CodeJinn — AI Code Assistant for Angular + Spring Boot Projects

Language: The extension UI is available in French (default) and English, selectable from the Settings page.

CodeJinn is a VS Code extension built for Angular / Spring Boot full-stack teams. It brings AI-powered code generation, quality analysis, and developer tooling tailored to the Java backend and Angular frontend stack.

Features

Code Generation

• Java Unit Tests — Generate JUnit 5 / Mockito tests from any Java class with smart dependency scanning
• TypeScript/Angular Unit Tests — Generate Jasmine/Karma tests from Angular components, services, and pipes
• Angular Components from REST — Generate full Angular components (component + service + model) from Spring @RestController classes
• Angular Services — Generate typed Angular services with HTTP client integration
• REST Mocks — Generate mock JSON responses from REST controller signatures
• HTML Template Adaptation — Adapt HTML templates to match your Angular components

Code Quality

• Test Quality Analysis — Grade your tests A–D with detection of weak patterns (empty tests, no assertions, generic names)
• AI Auto-fix — Automatically fix and improve existing unit tests through iterative AI correction
• Code Optimizer — AI-powered refactoring suggestions for readability, performance, and maintainability
• Dead Code Detection — Find unused code statically (no AI) across the whole project: unused imports, private members, and local variables; project-wide unused exports and Angular components/directives/pipes; and — full-stack cross-check — Spring REST endpoints never called by any Angular service. Confidence-tiered results biased to never report false positives.

Developer Tools

• Log Viewer — Analyze terminal logs: detect Java exceptions, stack traces, and JSON objects with clickable links
• JSON Viewer — Capture and inspect JSON from the clipboard, editor selection, or terminal output
• Accessibility Checker (a11y) — Scan HTML for WCAG violations and get AI-powered fix suggestions
• Diagnostics Manager — Review VS Code diagnostics with AI-suggested corrections
• Spell Checker — Detect and fix spelling errors in labels across Java, TypeScript, and HTML files
• Code Snippets Favorites — Save, organize, and reuse your favorite code snippets across a project
• Project Statistics — View coverage metrics and project health at a glance
• Familier-Chat — An interactive AI tamagotchi companion that evolves as you use CodeJinn

Requirements

• VS Code 1.75.0 or higher
• An OpenAI-compatible API key (OpenAI, Azure OpenAI, or any compatible endpoint)
• Java projects: JDK installed, Maven or Gradle
• Angular projects: Node.js, Angular CLI

Getting Started

1. Install CodeJinn from the VS Code Marketplace
2. Open the CodeJinn panel from the Activity Bar (left sidebar)
3. Go to Settings and enter your API key and endpoint
4. Right-click a .java or .ts file and select CodeJinn from the context menu

Configuration

Configure CodeJinn in the Settings page of the extension panel:

Custom Prompts

Override default AI prompts per project by creating files in .codejinn/:

.codejinn/
├── tests/
│   ├── java-prompt.md          # Custom prompt for Java test generation
│   └── typescript-prompt.md   # Custom prompt for TypeScript test generation
└── rest-to-angular/
    └── rest-to-angular-prompt.md

Example Files

Place example test files in .codejinn/tests/ to guide the AI generation style:

• Java: .codejinn/tests/*.java
• TypeScript: .codejinn/tests/*.ts

Commands

Via Context Menu (right-click on a file)

Via Command Palette

Via Keyboard Shortcuts

Extension Settings

CodeJinn stores all settings in VS Code's globalState — no workspace files are modified except the optional .codejinn/ folder for project-specific customization.

Known Issues

Release Notes

0.0.62

• Stub "from a captured JSON": captures were indistinguishable. The JSON viewer's label only describes the SHAPE of the payload, so two responses from different endpoints — and above all two successive calls to the SAME request — looked exactly alike. The REST client now files its response with its origin (GET /notifications?statut=NEW, resolved path), a strictly identical capture replaces the previous one instead of piling up, and the picker also de-duplicates on read — origin, date, size, with the most recent one flagged
• The page-request indicator was too easy to miss: the 2px bar at the top of the panel sat too far from where the eye is looking. It becomes a centered spinner, still with no dimming and no pointer capture — the page stays clickable underneath

0.0.61

• REST generation from Word: the layering no longer varies. The facade was dropped as soon as a SINGLE service was called — the controller then delegated straight to the service, and the layering changed from one generation to the next. It is now always generated; the "Facade" checkbox only declines to (re)generate the file, it no longer changes the layering
• Conversions are assigned to the facade, and to it alone. The plan said WHAT to convert, never WHO converts: the mapper call ended up in the service, in the controller, or nowhere. The rule is stated positively to the facade and negatively to the service and controller. A mapper no facade method invokes now triggers a corrective pass instead of a plain end-of-pipeline warning
• A response mapping is guaranteed. Without one, the Mapping step was skipped entirely and the facade returned the service's object as-is. It is added when the source type follows unambiguously from the planned signatures, and reported in the review otherwise — where it can still be added by hand
• Stubs: "Restore all" had no safeguard, while PLACING a stub does — yet it is the least reversible action on the screen, rewriting every stubbed file in the workspace at once. A modal confirmation now states how many stubs and files are involved
• Stubs: "no active stub" read like "the command did nothing." The positive outcome shows up in the middle of the screen while the negative one went to a corner and faded away — the two outcomes of the same gesture had nothing like the same visibility
• Dashboard: the "Test coverage" and "Test quality" cards open the matching page in one click
• REST controller generator: the rule panels (analyzed and custom) are collapsed by default
• Online help updated (FR/EN)

0.0.60

• Stub "from a pinned response": pinning a REST client request now carries its last successful response along as a reference response (.codejinn/rest-client/responses.json, versioned and therefore shared by the team). A new stub variant replays it verbatim — zero cost, real data, and the stub a teammate places returns exactly what mine returns. Responses belonging to the endpoint being stubbed are offered first. Unpinning clears the reference; replacing it stays an explicit action (badge when a more recent call succeeded)
• The panel waited 15s on EVERY open. The panel's ready handler was silently overwritten by an application handler of the same type: the promise never resolved, so every command waited out its timeout before pushing its navigation and busy overlay — which therefore showed up after the work was already done, making it invisible. Handler collisions are now logged
• What the PAGE itself is waiting for is finally shown: a thin, non-blocking progress bar appears while the webview has requests in flight (config, history, controller scan) — until now the screen just sat empty with nothing to explain it. The busy state is also polled by the webview at startup and after every navigation, since a pushed message is lost when the page isn't mounted yet
• Activity bar: "Reactive Forms from models" (removed in 0.0.57) left a dead entry behind, replaced by "REST mocks from controllers"; "AI code optimization" was missing from the list
• Online help updated (FR/EN)

0.0.59

• A panel opened from a context menu now gives NATIVE feedback first. The webview's own busy overlay always arrived too late — we were asking the very thing that isn't loaded yet to announce that it is loading. A VSCode progress notification is now raised on the command's first instruction, before the panel even opens (extension.adaptTemplate, extension.generateRestMocks, codeJinn.showCodeJinn and extension.generateAngularFromRest benefit too). The webview's boot screen carries the extension's own label instead of a mute "Loading…"
• Panel opens noticeably faster. Preloading of every route fired at the exact moment the target page painted: 2.69 MB of JavaScript across 85 files downloaded AND executed on the UI thread, competing with what the user is waiting for. Mermaid is now a dynamic import (reverse-engineering route chunk: 743 KB → 116 KB) and preloading is deferred until after startup, on an idle thread, held back while any work or navigation is in progress, and serialized
• REST client: the response of a call was invisible. The "Response" tab appeared but stayed closed — the screen didn't move a pixel after sending, making it look like the request never went out. It now opens on its own, backed by a notification (status, duration, size). A replay from the table, with the request screen closed, shows the response in its own window
• REST client: reopening a request went to the wrong URL. A hand-edited base URL wasn't kept (the screen reopened on the resolved address — the very one the user had just corrected), and an endpoint with several paths or verbs reopened on whichever combination came first rather than the one actually called

0.0.58

• One project configuration, one wizard. .codejinn/project.json absorbs dead-code.json, rest-client/config.json and controleur-rest/rest-conventions.json: the same facts were written in several places with nothing keeping them in sync. Six sections — server, spring, angular, deadCode, restClient, restConventions. The former files are migrated automatically on first access, then renamed to .migre; finding exclusions (dead-code-excluded.json) stay separate
• A single wizard, laid out as a rail of sections rather than a linear stepper, reachable from the Settings → General tab and from the button on the "REST client", "Dead code" and "REST controller generator" pages — each opening its own section. Saving a section preserves all the others
• REST client: the called URL was missing its first segment. A controller declaring the start of its URI on a custom class annotation (@MonApiController(uri = "/mandataires")) instead of @RequestMapping had the REST client call /{id} rather than /mandataires/{id} — no error, no message, just an address that doesn't exist. The setting was only declared on the dead-code side, and the REST client never read it
• Class annotations carrying a URI fragment (spring.classUriAnnotations): annotation name plus the attribute holding the value. The attribute is read explicitly — on @MonApi(uri = "/x", produces = "…"), taking the first literal would yield a plausible, wrong path. The pre-analysis suggests them at no extra scan cost: they are the custom annotations whose value starts with /
• Spring API keys now available for both front-end call styles (in-house service and lookup map), which are the same mechanism: the front end quotes a key, only the way it passes it differs
• Dead code: Spring annotations were only asked for in one case out of three — the wizard tied the Spring side (how to READ controllers) to the front end's call style. The two are independent, and the Spring side is now always offered
• Dead code: a lookup map key was never matched by key — the index (mapApi['USR.LIST']) was always read as a PATH, so it never matched an endpoint declaring its key through an annotation, and those endpoints were reported as never called. A key containing a / is still read as a path, so projects whose map really is indexed by URIs keep working
• A panel opened from a context menu no longer looks frozen: the target page used to sit empty while the extension kept working for several seconds (controller scan, type resolution, port probe). The panel now opens BEFORE the work starts, with a busy overlay driven by the extension and lifted as soon as the page takes over with its own progress
• REST client: a pre-filled request is no longer lost on a cold start — a message pushed to a page that isn't mounted yet went nowhere; it is now staged and claimed by the page when it mounts. The webview ready timeout goes from 5s to 15s
• The codeJinn.configureRestConventions command is gone along with the file it opened — it would have opened the very same project.json as codeJinn.configureProject, under a name suggesting a second configuration
• Online help and CLAUDE.md updated (FR/EN)

0.0.57

• AI settings moved into VSCode settings (codejinn.ai.token, apiBase, model, requestMethod): globalState is isolated per profile, so switching profiles meant re-entering everything — settings, on the other hand, are shared across profiles and carried by Settings Sync. The token is application-scoped (so it can never be committed in a project), the other three can be overridden per project; the former storage is still written as a fallback and existing configuration is migrated automatically
• Shared PROJECT configuration .codejinn/project.json (local server + the REST URI prefix the framework injects): two facts no code analysis can establish, now written once and read by both the REST client and dead-code detection. A unified wizard is offered when the panel opens, pre-filled from the front end's environment.ts, plus a codeJinn.configureProject command
• Dead code: the configuration wizard now accepts several API services and several URL maps — a project with two services had the second one's calls ignored, so its endpoints were wrongly reported as never called. It also reuses the existing configuration instead of overwriting it, and preserves hand-edited settings
• REST client: the base URL from project.json takes precedence over the whole port-resolution cascade, for in-house frameworks that impose their port
• Online help updated (FR/EN)
• Removed: the Reactive Forms generator (command, page and related scanners)

0.0.56

• Spring endpoint stubs: a controller mapping method (@GetMapping, @RequestMapping…) can now be stubbed too, not just a method calling a REST service — the front end stays workable while the back end's business logic isn't ready. The mapping annotation alone qualifies it, including when carried by an interface
• REST client: a controller exposing its endpoints behind a custom composed annotation (@MonApiController) is finally recognized — no more "open a REST controller" on a file holding ten of them; outbound HTTP clients (@FeignClient, @HttpExchange…) stay excluded. On the dead-code side the custom annotation is opt-in via restCrossCheck.controllerAnnotations
• Stubs: transport wrappers (ResponseEntity<T>, Mono<T>, Optional<T>, CompletableFuture<T>…) are now unwrapped — the "bulk" variant is offered on a ResponseEntity<List<Compte>> or a Mono<List<Compte>>, and the generated stub re-wraps the collection instead of returning a bare list that wouldn't compile
• Stubs: an annotation spread over several lines is now picked up correctly — the CodeLens was misplaced and the endpoint unrecognizable
• Stubs: an unexpected error goes to the CodeJinn output channel (full stack, with a button to open it) instead of an unreadable technical notification

0.0.55

• REST client: server status is now re-probed continuously (on open, every 5s, after each send, and on demand) instead of being frozen when the request was built — a server that was shut down is no longer reported as "listening"; outside the local machine the banner reads "Remote server"
• REST client: the controller inventory is no longer limited to *Controller — *Resource, *Ressource, *Api, *Endpoint, *Rest, *Controleur and *Facade are scanned too; whole projects used to be invisible
• REST client: the end of each endpoint method is now known — a cursor sitting in a private method below no longer silently targets the mapping above it; from the context menu a QuickPick lists the file's endpoints instead of reporting "no endpoint detected"
• Stubs: the marker records the original code's line count; if a formatter re-wrapped it, restoring now warns instead of silently returning recomposed code

0.0.54

• Built-in REST client: call a project endpoint straight from its controller (a "Call" CodeLens), the server is started when needed, path/query params and request body are pre-filled, and the history is deduplicated and replayable — with a configuration wizard (environments, discriminant header, secrets)
• Dead code: findings can now be excluded (multi-selection, per file or per kind) into .codejinn/dead-code-excluded.json, versionable and shared across the team
• Log analysis: several file paths can now be given to the log parser
• Stubs: AI generation mechanism optimized
• Test quality: the tab holding an actual report is now selected by default
• CodeJinn panel refreshed

0.0.53

• Stubs: the types injected into the AI prompt are now resolved transitively (nested objects up to 3 levels deep) — the model no longer invents the fields of a databean's sub-objects
• Stubs: a stub whose marker contained a Java generic import (java.util.List<Compte>) became invisible — no gutter icon, no "Restore" button; marker values are now sanitized and parsed correctly
• Stubs: safety net — a stub not covered by any detected method still gets its "Restore" CodeLens, anchored on the marker
• Stubs: the offer to install the git guard is now a modal dialog explaining what the hook does, instead of a notification that went unnoticed

0.0.52

• Method stubs: replace the body of a method calling a REST service with a stub, so you can keep working while the backend is down — a "Stub it" / "Restore the real code" CodeLens above the signature (Java and TypeScript)
• The original code stays in the file, commented out below the stub: the stub survives a git stash, a branch switch and disabling the extension, and restoring it is lossless
• Six variants: empty, error, slow and "from a captured JSON" with no AI call at all, "realistic nominal" and "large payload" generated by AI; the cost is shown before you click
• Optional pre-commit git hook that rejects any commit carrying a stub, plus a status bar counter and an inventory of the workspace's active stubs

0.0.51

• Left menu reorganized into collapsible sections (Generate, Analyze, Tools, Settings, Help & support), with the expanded/collapsed state remembered
• Activity bar view redesigned: features are grouped by theme (Unit tests, Generate, Analyze, Tools) and fully translated
• Test generation: running the command from a test file now resolves the class under test automatically; if it cannot be found, an explicit warning is shown before proceeding
• Test quality: table columns are finally aligned with their headers, plus various visual tweaks (settings, REST controller generator, dead-code wizard)

0.0.50

• Coverage: new directory tree view (switchable with the flat list), each folder carrying the aggregate of its descendants; empty folder levels are collapsed and the tree expands while searching
• Coverage: a "re-run" button on every row — a single test is executed then merged into the last full run's coverage instead of paying for a whole run again; a banner flags a partially dated percentage
• Coverage: files with no executable line at all (interfaces, types) are no longer counted at 0%, matching Sonar — the estimator now tracks the enclosing type, body-less signatures and multi-line annotations
• Coverage: the "estimated" badge and its summary panel have been removed from the page; a re-added file now reads like any other

0.0.49

• Coverage: percentage now aligned with SonarQube — source files with no coverage report (e.g. a module without tests) are counted at 0% over an estimated executable line count, flagged with an "estimated" badge
• Coverage: the formula matches Sonar's (lines + conditions); plain line coverage is still displayed separately
• Coverage: conditions are read from all three formats (JaCoCo, LCOV, Istanbul), jacocoTestReport.xml (Gradle) is recognized, the 20-report scan limit is lifted and reports covering the same file are merged

0.0.48

• Test generation: project examples are now injected into the pass that actually writes the code (instead of the analysis pass), so the existing test style is finally followed
• Test generation: fix loops no longer round-trip the whole file — only the modified members are returned and merged locally, cutting cost and leaving untouched tests untouched
• Test generation: new quality filter — a generated test graded C or D triggers a single assertion-strengthening pass, kept only if the grade improves without breaking compilation; the grade is reported to the user
• Coverage: sonar.coverage.exclusions / sonar.exclusions declared in pom.xml files are now excluded from the computation (multi-module, Maven per-property inheritance), so the percentage matches SonarQube

0.0.47

• Test generation: a truncated AI response (unclosed braces) no longer overwrites the existing test — nothing is written and a message suggests raising "Max tokens"
• Auto-fix (verify & fix): a truncated fix is discarded, the file is left untouched
• Custom endpoints: the guard timeout now watches server INACTIVITY instead of total duration — a long but progressing generation is never cut off, a silent server is
• Custom endpoints: the Cancel button now also works while the stream is being read
• Responses cut off by max_tokens are detected on both providers (OpenAI and custom)

0.0.46

• Dashboard: the "Files without tests" scan is now cached per project (result reloaded on open, last scan date, "Update" button)
• Files without tests: files carrying no testable logic (databeans, exceptions, constant classes, configuration, interfaces/enums/records) are filtered out, by path, name and then content
• Terminal JSON: detection of escaped JSON (body="{\"id\":1}"), of JSON nested inside a Java toString(), and reassembly of multi-line JSON
• Log analysis: escaped JSON inside a logged string is now recognized
• Service generator: analyzed rules panel collapsed by default

0.0.45

• Architecture plan review: mappings (field-by-field), orchestration, nominal/alternative scenarios and reused services are now editable
• REST generation: the Mapping step now knows the types actually returned by services (generated or already present in the project)
• REST generation: mapping cardinality derived automatically (collections), with the iteration idiom given to calling layers
• REST generation: check that the facade actually calls the planned services, with a corrective pass
• REST generation: review warning when a reused service is absent from the specification
• REST controller generator: rule panels collapsed by default
• Dead code: import resolution delegated to the TypeScript compiler (paths aliases, index.ts, dynamic imports), fewer false positives on components loaded via loadComponent

0.0.44

• Project REST conventions: first-run setup wizard (per-layer packages, databean suffix, cross-cutting parameter) pre-filled from the existing code
• REST generation: detailed progress modal with steps checked off as generation proceeds
• REST generation: additive merge into existing files (only missing members are added, reviewed code is never rewritten)
• REST generation: nominal and alternative scenarios from the spec now passed to the facade/service prompts
• REST generation: unit services from the Word spec become methods named after the document
• REST generation: each created service is written in the package of ITS own business domain
• Conventions file moved to .codejinn/controleur-rest/ (automatic migration)
• Fixed business rules moved during review being implemented by the wrong layer
• Fixed duplicate files by reusing the real existing class name instead of the theoretical one

0.0.43

• Unit test generation: test execution report displayed in a modal
• REST generation from Word: configurable and auto-detected per-layer packages, cross-cutting parameter (call context) propagated to signatures
• REST generation from Word: existing project code taken into account (services/facades/controllers/mappers reused instead of recreated)
• Generated controllers: project input checks reproduced, custom rules applied at every stage
• Truncated AI responses (token limit reached) now raise an error instead of writing an incomplete file
• package declaration of generated Java files automatically fixed when it diverges from the target layer

0.0.42

• AI response token cap raised to 150,000 by default (configurable up to 500,000)
• REST controller generator: warning before leaving the page with unsaved prompts
• Fixed architecture plan review not displaying the received plan (including after regeneration)

0.0.41

• Project REST conventions (.codejinn/rest-conventions.json): databean naming enforced across all Spring generations
• Dead code detection: path-indexed URL maps (angularUrlMaps) in the REST ↔ Angular cross-check
• REST generation from Word: scope closed to the spec, required validations actually enforced, no facade for a single service
• More reliable Word spec parsing (tables, endpoints, required fields)
• Unified and more robust AI response parsing
• Fixed Windows compatibility for Java test paths and build execution

0.0.40

• Added a CodeJinn features panel to the dashboard

0.0.39

• Dead code detection: TypeScript/Angular circular dependencies
• Real-time recap of unit test generation steps (Java/TS) with progress checkmarks
• More reliable AI generation cancellation (REST controller, reactive forms, services, tests)
• Optimized parsing for REST ↔ Angular cross-check (dead code)
• Removed team statistics

0.0.38

• Full UI internationalization (French/English)
• Spec-driven generation: markdown contract validated before generation (REST controller / Spring service)
• Dead code detection: API-key matching + first-time configuration wizard
• "Guaranteed" test generation: compilation / execution / coverage filters
• Spell checker: choice of git scan scope (workspace / last commit / uncommitted)
• Unified empty/loading states (shared components) + cascading animations on result lists
• More reliable AI pipeline: generalized retry, prompt budget, real cancellation
• Structured outputs (JSON schema) generalized to all generators
• Fixed loading/content overlap in the log viewer
• Fixed overflow of the + button on numeric settings fields
• Fixed infinite spinner with no timeout on test coverage

0.0.37

• Dead code detection: unused public Java methods (cross-module)
• Fixed detection of lazily-loaded Angular components

0.0.36

• Dead Code Detection — new static analyzer (no AI): unused imports/private members/locals, project-wide unused exports and Angular components/directives/pipes, and Spring REST endpoints never called by the Angular front (full-stack cross-check)

0.0.35

• Utility class methods are now preserved during dependency scanning (Java/TS)
• Tests are no longer generated on technical code defects
• Fixed the initial route flash on webview load

0.0.34

• More reliable REST generation: follows project conventions
• Improved semantic example selection
• Context-adaptive prompts

0.0.33

• Generation process optimizations and bug fixes

0.0.32

• More reliable AI generations: structured outputs (JSON schema)
• Generalized auto-correction (verify-fix loop)
• Semantic example selection (local lexical RAG)

0.0.31

• Revamped REST controller generator and Angular-from-REST generation
• Redesigned dashboard with consumed tokens display
• Prompt history grouped by action

0.0.30

• Optimized CodeJinn loading (loading screen + preloading)

0.0.29

• Multi-file support for jinx
• Code defect detection before test generation

0.0.28

• Angular components from REST generator: full revamp (per-artifact generation)
• Test patterns configuration: shared typed examples via test-patterns.json
• Pinned REST-to-Angular reference files to guide generation

0.0.27

• Unit test generator (Java/TypeScript): full revamp
• REST examples now injected into the modern generation pipeline
• Java unit test generator: further optimizations
• Prompt history: richer details and metadata
• Help and FAQ updates
• Reactive service visualizer: fix
• Miscellaneous corrections

0.0.26

• REST controller generator: full revamp
• Angular components from REST generator: full revamp
• Visual Reverse Engineering: Mermaid diagram optimization
• Settings: simplified UI

0.0.25

• Code generation: automatic selection of examples similar to the current generation

0.0.24

• Tamagotchi: behavior and display improvements
• Label extractor: added exclusion filtering for unwanted labels

0.0.23

• Visual Reverse Engineering: additional fixes
• Settings save optimization
• Label extractor: fixes and improved quote handling

0.0.22

• Token usage: display token count consumed per AI call
• Configurable temperature parameter for AI calls
• Visual Reverse Engineering: further improvements
• Prompt generation: simplification and optimization
• Various VSCode bug fixes

0.0.21

• Settings: added connection button on the AI tab — tests the provider connection and validates that the SSE streaming parameter is working correctly
• AI Streaming (SSE): enabled globally across all providers (OpenAI + Custom fetch) — reduces timeout risks on long generations
• Visual Reverse Engineering: zoom support + Mermaid diagram visual improvements
• Prompt history: minor fix + display line and character counts

0.0.20

• AI context management: context is now taken into account in AI calls
• Visual Reverse Engineering: additional bug fix

0.0.19

• Prompt history: AI responses are now stored in the history
• Visual Reverse Engineering: bug fix

0.0.18

• Visual Reverse Engineering: generate Mermaid.js diagrams from reactive code blocks (Spring Reactor / RxJS)
• Prompt generation improvements
• CDN calls internalized (no external CDN dependencies)

0.0.17

• Prompt history: display fix

0.0.16

• Unit test generator logs: enriched displayed info + option to exclude the first call
• Project stats: further metric enrichments

0.0.15

• Project stats: enriched displayed metrics
• Bundle analyzer: re-trigger analysis by clicking the button again
• Unit test generator: fixed dependency search
• Spell checker: bug fix

0.0.14

• Prompt history: improvements
• REST controller generator: enriched features
• Word document reader: bug fix

0.0.13

• Spell checker: further optimizations
• Companion: fixed XP calculation
• Added /package Claude Code command for release workflow

0.0.12

• Spell checker: optimized label extractors (HTML, Java, TypeScript)
• Bundle analyzer: additional fix

0.0.11

• Bundle analyzer: fixed "spawn npm ENOENT" error

0.0.10

• Test Quality: file rows in the "Coverage per file" table are now clickable to open the file in the VSCode editor
• Bundle analyzer fix

0.0.9

• Fixed bundle analyzer: project build command is now used first, falling back to global ng if unavailable
• Fixed bundle analysis: added support for esbuild stats.json format (Angular 17+) alongside webpack format
• Companion chat UI: swapped input area and chat display positions
• Improved marketplace logo (removed white background)
• Updated guided tour
• Renamed "Project stats" menu entry to "Statistiques du projet"

0.0.7

• Fixed CodeJinn panel icon not showing in the deployed extension

0.0.6

• Correction packaging

0.0.5

• Added Familier-Chat (interactive AI tamagotchi)
• Added Code Optimizer with AI refactoring review
• Added Spell Checker for Java/Angular/HTML labels
• Added Test Quality Analysis with A–D grading
• Added Diagnostics Manager with AI fix suggestions
• Added Accessibility Checker (a11y) with AI fix suggestions
• Improved Log Viewer with clickable stack trace links
• Improved JSON Viewer with bracket-balanced detection

License

GPL-3.0