Skip to content

Latest commit

 

History

History
1748 lines (1287 loc) · 103 KB

CHANGELOG.md

File metadata and controls

1748 lines (1287 loc) · 103 KB

Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[0.17.1] - 2026-10-11

Dependency release: local embedding runs on ONNX Runtime 1.28 through fastembed 7.1.1, OpenSSL leaves the dependency graph on every platform, and the lockfile moves past the open advisories in the HTTP stack. No index or emission change; existing indexes keep working without a rebuild.

Changed

  • fastembed =7.1.1 and ort =2.0.0-rc.13 (ONNX Runtime 1.28). The thread cap from 0.17.0 now also applies per session: when the shared pool cannot be committed, each session runs embedding_threads intra-op threads with spin-waiting off instead of every CPU.
  • Every network path uses rustls: model downloads, the ONNX Runtime binary download at build time, and remote embedding. openssl-sys is absent from the dependency graph; building from source no longer needs libssl-dev.
  • Lockfile refreshed within semver: h2 0.4.20, quinn-proto 0.11.19, rustls-webpki 0.103.15 (past RUSTSEC-2026-0258, RUSTSEC-2026-0185, RUSTSEC-2026-0049 and their siblings), rmcp 3.5.1, tantivy 0.26.2, tokenizers 0.23.2.
  • Linux floor for cargo install: glibc 2.38+ and libstdc++ from GCC 13+, set by the prebuilt ONNX Runtime binaries (Ubuntu 24.04, Debian 13, Fedora 39 and later). The release binaries are built on Ubuntu 24.04 (glibc 2.39). README states both.
  • Search results on an index embedded by 0.17.0 or earlier are unchanged: the same ranking, scores within 1e-6. Indexing with semantic search uses about 40 percent less CPU on the reference machine than 0.17.0.

Added

  • contributing/scripts/brew-formula-check.sh: runs the homebrew-core formula through Homebrew's CI shape (brew style, from-source install with the fetch hook and cargo install --offline, brew test, brew audit --strict) in the ghcr.io/homebrew/brew image before a pull request.

Removed

  • macOS x86_64 (Intel) release binaries and the cargo-binstall override for that target. ONNX Runtime 1.28 has no Intel macOS build, in Microsoft's releases or in the ort crate's prebuilt binaries, so neither the release binary nor cargo install can target it. Release binaries are Apple Silicon only; 0.17.0 is the last release for Intel Macs.
  • The brew-update.yml workflow and the tap bartolli/homebrew-codanna. Homebrew installs come from homebrew-core (brew install codanna).

[0.17.0] - 2026-10-11

Watcher, indexing-pipeline, resolution, and local-embedding fixes from the contributor PR batch and reported issues. Emission semantics version 4: existing indexes are rebuilt once (see the note at the end of this section).

Changed

  • semantic_search.embedding_threads also sizes one process-wide ONNX Runtime thread pool shared by every local embedding session: about 2N-1 busy threads at peak, clamped to 1..=logical CPUs, fixed at the first embedding in a process. Before, each of the N sessions ran its own pool sized to every logical CPU with spin-waiting on, so a reindex kept N x CPUs threads busy whatever indexing.parallelism said. Embedding batches are length-sorted and 8 texts per call (was 64, unsorted) in symbol indexing and in the document store, which bounds the ONNX arena by the batch instead of the corpus mix. Embeddings and search scores are unchanged. (GH #138)
  • TypeScript and JavaScript import { member as local } records the imported member name; calls through the alias resolve to the member. Emission semantics version 4.
  • macOS watcher: each handler root registers one recursive FSEvents watch, once per process, instead of one watch per directory; FSEvents stopped delivering events above 4,096 registered paths. Other platforms keep one non-recursive watch per directory, registered in one batch per site.

Fixed

  • TypeScript and JavaScript relative imports whose target file is absent from the index are negative evidence: a name imported through such a path no longer resolves by name to an unrelated symbol, including symbols in other languages. Files governed by a tsconfig or jsconfig with moduleSuffixes or rootDirs are exempt.
  • The resolution cache loaded at most 1,000,000 symbols; larger indexes lost cross-file edges. Every symbol loads. (PR #125)
  • A watch event for an unchanged file rewrote the semantic snapshot and sent a notification; the cached result is preserved. (PR #137)
  • Vector payload writes are buffered; one write syscall per f32 before. (PR #131)
  • Watcher event delivery never blocks the FSEvents thread; a full channel could wedge the watcher and keep a stdio server from exiting.
  • serve --watch: a settings reload watches the roots it adds and records them in index metadata, so the next command does not re-index them (GH #129); hot reload holds the facade write guard across the load, so a commit cannot land between the load and the swap.
  • codanna index beside a busy index writer fails with the error instead of reporting success with zero relationships; the watcher reports the affected roots and the heal.
  • A failed relationship store or commit in Phase 2 is an error and nothing from that batch is reported written. Phase 2 releases the Tantivy writer when it returns; a reindex that resolved only definitions used to hold the lockfile, and codanna index beside serve --watch failed with LockBusy.

Added

  • contributing/scripts/resource-profile.py: wall, CPU, peak RSS, and running-thread profile of one codanna index run in a fresh workspace.

Indexes written by 0.16.0 or earlier carry emission version 3. Every command except codanna index refuses them with exit code 7 and the rebuild instruction; an MCP server started on one serves no tools and names the rebuild. Run codanna index once per workspace: it rebuilds from scratch, and workspaces with semantic search enabled re-embed.

[0.16.0] - 2026-08-29

Receiver-typed call resolution reaches seven more languages: local and parameter declarations now supply receiver types for PHP, Java, Kotlin, Go, Swift, GDScript, and C#. Index format and emission semantics are unchanged (v3); receiver bindings are resolved in memory and never persisted.

Added

  • Variable-binding channels (find_variable_types / extract_parameter_type) for PHP (typed and promoted parameters, constructor-assigned locals, typed properties), Java (local declarations, var with constructor initializer), Kotlin (annotated properties and parameters), Go (composite literals, var declarations, &T{}), Swift (annotation- and initializer-typed let/var, labeled and inout parameters, Type.init), GDScript (var x: Type, X.new() on = and :=, typed parameters), and C# (parameters with ref/out/in, generics reduced to the base identifier, nullable and qualified types). Member calls on receivers bound by these declarations now resolve; factory-call initializers (makeThing(), NewT()) stay unbound by design.
  • resolution_precision example: per-edge precision verdicts (class-match / inherited / implementor / mismatch) for receiver-typed call edges against corpus source, with tree-sitter extraction for PHP, Java, Kotlin, Go, and Swift alongside the original JS-family heuristics.

Fixed

  • A resolution tier that rejected its own candidate ended resolution for that call; rejected picks now fall through to the typed-receiver arm.
  • PHP binding names carry the $ sigil, matching the receiver form on call rows; the join between the two previously dropped every PHP variable receiver.
  • C# annotation-typed locals bound raw type text (List<Item>, Session?, Foo.Bar) that could never match a member's class; both capture arms now reduce to the same base-identifier form.

Indexes built at 0.15.0 or earlier lack the new receiver-typed edges until one codanna index --force with this version; incremental re-index adopts them per file as files change.

[0.15.0] - 2026-08-28

Fixes Rust call resolution for module-anchored qualified calls and updates the bundled Claude Code plugin skills and README demos. Index format and emission semantics are unchanged (v3).

Fixed

  • Rust free-function calls qualified with crate::, super::, or self:: resolve on the static-call path. The anchor resolves against the calling file's module identity; a candidate matches in the resolved module or a segment-aware descendant (definitions re-exported one level down, as in the six-file parser layout). Multiple surviving candidates pass through the existing disambiguation gate; unresolvable anchors fail closed. These calls previously resolved to nothing, so crate::-style call edges were missing from call graphs.

Added

  • Demo recordings: committed scenes under contributing/demos/ regenerate the README's animated loops; the README embeds them by absolute raw URLs so surfaces that ship the README without the repository (crates.io) render them.

Changed

  • codanna-toolset 0.18.0: the graph skill's disc renderer builds on vault-graph 1.8.0; detail-panel signature blocks are syntax-highlighted via vendored highlight.js themes (dark and light); disc relation rows carry the same-name qualifier shared with the x-ray skill; both skills share the detail-panel mechanics.
  • The crates.io package additionally excludes assets/ (demo media).

Indexes built at 0.14.0 or earlier under-report module-anchored call edges until one codanna index --force with this version. This is separate from v0.14.0's multi-root adoption note, which covered cross-root edges.

[0.14.0] - 2026-08-25

Adds codanna dump for bulk graph export and fixes silent cross-root edge loss in multi-root workspaces. Index format and emission semantics are unchanged (v3); single-root indexes need no rebuild.

Added

  • codanna dump streams the whole index as JSON Lines in the envelope's streaming mode: a begin envelope, one result envelope per symbol and per relationship, and a terminal summary envelope with totals and index provenance (emission version, builder commit). Row ordering is unspecified. Design discussion in #119.
  • codanna dump filters: --symbols / --edges select row types; --relation <kind> keeps one relationship kind (calls, defines, uses, implements, extends); --kind <kind> keeps one symbol kind. Unknown values are rejected before any line is written (exit 2); a stale index refuses with exit 7.
  • Claude Code plugin marketplace served from the repository: /plugin marketplace add bartolli/codanna installs codanna-toolset@codanna (codebase graph and x-ray skills built on codanna dump).

Fixed

  • Multi-root workspaces (more than one codanna add-dir root) silently dropped cross-root call edges: resolution ran once per root against only that root's symbols, so edges such as tests/ into src/ survived only under one registration order and were lost on codanna index --force, on reversed add-dir order, and when a newly added directory was indexed by the startup sync or a running server. Resolution now runs once after every root has been walked, seeded from the persisted index, on every lane: codanna index, codanna index --force, startup config sync, watcher batch sync, and the MCP reindex tool. Reported with an eight-configuration repro by @mmeyer (#121).

Changed

  • The crates.io package excludes agents/ and .claude-plugin/ (Claude Code marketplace payloads; not part of the library or binary).

Multi-root indexes built by earlier versions under-report cross-root edges until one codanna index --force with this version.

[0.13.3] - 2026-08-21

Index-maintenance patch release. Segment merges that Tantivy schedules on each commit now complete before the index writer is released; previously the writer closed first and cancelled them, so every commit left one more segment behind and a long-running serve --watch grew without bound in segments, open files, disk, and memory. Batch incremental indexing also closes a one-second change-detection gap. Index format, emission semantics, and settings are unchanged; no rebuild is required.

An index built by an earlier version compacts on its first commit after upgrading: one merge of the accumulated segments. On a long-served large index that single commit can take seconds, during which queries wait; no codanna index --force is needed.

Fixed

  • Committing a batch waits for the merges the commit scheduled, then reloads the reader over the merged segments. The segment count under repeated commits stays within the merge policy's level width instead of growing by one per commit; every index compacts, including full builds. Contributed by @aniravi24 (#120).
  • Batch incremental indexing (codanna index over registered roots, watcher batch sync) detects a file rewritten within the same second as its indexed version. The modification-time fast path applies only to files whose modification time is older than the current second; per-file watcher events were unaffected.

Changed

  • codanna --version and -V append the build commit: codanna 0.13.3 (e7dbb76), with a -dirty suffix when built from a modified tree. Binaries built without a .git directory (brew source builds, crates.io installs) print the bare version.
  • Dependencies: clap 4.6.6, ignore 0.4.33, rmcp 3.1.4, tree-sitter 0.26.12, thiserror 2.0.20, rcgen 0.14.9, async-trait 0.1.92, testcontainers 0.28.0.

[0.13.2] - 2026-08-04

Windows path-handling and resolution-correctness patch release. Module identity, stored-path emission, notification URIs, and rendered paths now use one path-component contract on every platform, closing the 0.13.1 known limitation "on Windows, path handling degrades symbol resolution": the Windows test suite runs the same ten targets as Linux and macOS with zero failures. Two resolver fixes restore relationships that earlier binaries never recorded. Index format, emission semantics, and settings are unchanged; no automatic rebuild.

The resolver fixes apply when files are indexed: an index built by an earlier binary under-reports the affected relationships until the referencing files are re-indexed. codanna index --force heals the whole index at once.

Fixed

  • Indexing a project from outside its directory resolves the same relationships as indexing from inside it. Module identity now comes from the parse; it was previously re-derived against the invoking directory, which silently unbound cross-file imports for out-of-tree runs.
  • Relative imports between files with dots in their stems (bundled or generated artifacts such as three.core.js) resolve by file identity. These imports previously never bound: the dot was indistinguishable from a module separator in the text-based derivation.
  • Module paths derive from path components on every platform. On Windows, the previous text-based derivation produced module identities that matched nothing, which starved import resolution.
  • Relative file paths in tool results, CLI output, and resource-update notifications carry / separators on every platform; notification URIs byte-match subscription URIs on Windows.
  • Absolute paths in CLI output, MCP diagnostics, logs, and error messages render without the Windows verbatim prefix (\\?\C:\... renders as C:\...). Stored index data is unchanged.
  • codanna index --force validates its rebuild sources before clearing the index. A nonexistent path argument, or a configuration whose indexed paths no longer exist, refuses with exit 1 and leaves the index untouched; both cases previously cleared the index and rebuilt nothing.

Known Limitations

  • A symbol moved between two files that are both edited in one change set can lose its callers' relationships until those callers are next re-indexed; under-report only, heals on edit or codanna index --force.
  • In large bundled-JavaScript codebases, a rename wave can drop a small number of relationships that a fresh re-index restores; under-report only.
  • Windows testing covers in-tree indexing (the project indexed from its own directory); out-of-tree indexing on Windows is untested.

[0.13.1] - 2026-08-02

Incremental-refactor and watcher-notification patch release. Renames, renames combined with edits, and deletions now converge the incremental index to the same relationship set as a fresh index: files that reference a moved or deleted target are re-analyzed in the same run, so each relationship follows the current source evidence. Applies across batch indexing, serve --watch, and mcp <TOOL> --watch. Resource subscribers receive list-change notifications when watched files are created and one list-change notification when they are deleted. Index format, emission semantics, and settings are unchanged; no automatic rebuild.

If an earlier version processed a rename or deletion, relationships already lost from that index restore on the next edit of the referencing files, or all at once with codanna index --force.

Fixed

  • Byte-identical file and directory renames preserve inbound relationships; incremental discovery pairs deleted and new paths by content hash when the pairing is unique in both directions.
  • Files referencing a renamed, edited-and-renamed, or deleted target are re-analyzed in the same incremental run. A relationship survives only where the referencing file's imports and calls still support it: a rename plus content edit recovers the relationships its callers' evidence supports, and a stale import that still names the old path no longer retains its relationship.
  • serve --watch settles removal waves through the shared incremental lane. Directory events route by disk truth, so a directory rename reported as modify events with no per-file events still converges; genuine directory deletion still removes the subtree.
  • Watched file creation emits notifications/resources/list_changed; modification of a known file remains a URI-filtered notifications/resources/updated. Deleting a watched file emits one list-change notification, including when the file was created during the same watch session.
  • serve --watch no longer livelocks on Linux. inotify reports an open event for every directory read, including the watcher's own catch-up walks, so each walk triggered the next; the storm also starved the debounced-change drain, silencing reindexing and notifications. Access-class events are now ignored (they observe state, never change it), and the drain runs on a fixed cadence that sustained event streams cannot defer. The test suite now runs on Linux ahead of every release.

Known Limitations

  • A symbol moved between two files that are both edited in one change set can lose its callers' relationships until those callers are next re-indexed; under-report only, heals on edit or codanna index --force.
  • Re-indexing after a rename or deletion re-analyzes every file that referenced the target; incremental latency scales with the number of referencing files.
  • On Windows, path handling degrades symbol resolution: some relationships that resolve on Linux and macOS are under-reported. Windows now runs in the test pipeline as a non-blocking witness; fixes are tracked for a later release.
  • A delete followed by recreation inside one debounce-and-refresh window can omit the recreation's second list-change notification.

[0.13.0] - 2026-08-01

MCP 2026-07-28 migration release. All transports serve the new generation — the spec revision that removes protocol-level sessions and the initialize handshake — alongside the legacy generation through its deprecation window: dispatch is per-session on stdio, per-request on HTTP/HTTPS. Index format, emission semantics, and settings are unchanged; no rebuild.

Added

  • MCP 2026-07-28 stateless generation on stdio, HTTP, and HTTPS (rmcp 3.1.0): server/discover answered as the required RPC and stdio back-compat probe; HTTP requests with 2026-07-28 _meta are served per-request without minting a session (MCP-Protocol-Version header required; Mcp-Name header required on name-bearing methods); tool results carry resultType: "complete" on the stateless wire and omit it for legacy peers per spec.
  • subscriptions/listen: stateless clients opt in to resource-change notifications with per-category and per-URI filters; notifications are tagged with the subscription id. Sessions without opt-in receive nothing unsolicited.
  • Tool and prompt list results carry the cache contract: ttlMs 3600000, cacheScope "private" (the stale server serves ttlMs 0).
  • Protocol conformance matrix instrument for contributors: contributing/scripts/mcp-conformance-matrix.sh runs the release binary across {stdio, http} x {legacy, stateless} x {fresh, stale index} plus TLS and probe-death cells in scratch workspaces.

Changed

  • codanna mcp-test connects Discover-only (2026-07-28). Against a server that dies on the probe — every shipped release up to 0.12.0 — it fails with a diagnostic naming the probe death instead of a raw connection error; the legacy initialize fallback is removed because no shipped server survives the probe to trigger it.

Fixed

  • Stdio serve no longer dies on a pre-handshake server/discover probe: the probe is answered with a full discover result on both the live and the stale-index server. Previously any 2026-07-28 client's first contact killed the process before serving anyone. Reported with a working fix by Vinicios Lugli (#117); both fixes carry co-author credit.
  • A fresh, never-indexed workspace serves all tools on every serve start: the emission gate reads only real indexes (index.meta present). Previously the skeleton directory that serve itself created on first start was refused as stale on the second start — zero tools, permanently, for any directory resolving to a shared unindexed .codanna.
  • Multiple serve processes watching one workspace: the losing watcher of the Tantivy writer logs the hot-reload convergence path at info instead of an error per edit burst, and semantic search saves stage in per-save directories — concurrent savers (a second serve, codanna index under a live serve) could previously destroy each other's in-flight save or promote a partially written vector file.

Removed

  • The notifications/codanna/* custom wire notifications (file-reindexed, file-created, file-deleted, index-reloaded). No wire consumer existed; standard MCP notifications carry the watch lane on both protocol generations.

[0.12.0] - 2026-07-26

Pick-discipline and lane-parity release. Every bare-name resolution pick is evidence-gated: import bindings resolve exact-first then exactly-one at every surface, member picks require containment or kind evidence, and candidate order never decides an edge — insertion-order dependence is gone. Incremental re-indexing keeps the edges pointing into a changed file: cleanup captures inbound edges and rebinds them to the replacement symbols by containing type, then peer ordinal, then line, so re-indexing a file no longer sheds its callers' edges (previously up to 8.8% of a corpus call graph after two file touches). serve --watch indexes newly created files and directories.

Breaking Changes

  • Emission-semantics version 3 (was 1): indexes built by earlier binaries refuse before any tool runs — read commands exit 7 with the heal command; codanna index rebuilds from scratch automatically with a message. One rebuild per workspace crosses the gap.
  • indexing.ignore_patterns setting removed. No code path ever consumed it; exclusion is .gitignore + .codannaignore (gitignore syntax, per-directory chains), honored identically by batch indexing and the watcher. Settings files still carrying the key load clean.
  • module_path round-trips absent-vs-empty faithfully: a symbol without module identity persists the field absent instead of "". JSON consumers treating the empty string as the no-module sentinel must read absence; Java rows are the main visible surface.
  • Resolved-relationship counts drop where the new gates refuse unevidenced picks: ktor 22132 -> 20451 composed (-7.6%), MediatR 267 -> 139 (-48%), three.js -892 in the import-binding class. Stratified source reads of the dropped masses: the three.js src-side sample is 20/20 wrong cross-bundle picks; the ktor sample is 4/20 wrong (stdlib and cross-module captures) and 16/20 correct-by-luck single-candidate picks the resolver could not evidence. Dropped recall returns through evidence supply (receiver inference), not through restored guessing.

Added

  • Self-form and bare calls in a class body resolve to inherited members, and self-form calls resolve to cross-file members of the same type (split definitions), extending the class-membership evidence channel.
  • builder_commit in index.meta and get_index_info --json: the commit the building binary was compiled from, suffixed -dirty when built from a modified tree. Descriptive only; absent for tarball builds and indexes written before the stamp existed.

Fixed

  • Incremental re-index preserves cross-file edges into the changed files across all three entry points (codanna index, serve --watch, mcp <tool> --watch), including under range-shifting edits. Indexes built by earlier versions heal the accumulated loss at the forced rebuild. File renames are outside this guarantee: a renamed file's inbound edges still drop until a force re-index.
  • serve --watch indexes created files and directories: registered roots are watched directly, a directory created under one extends the watch set to its traversable subtree with catch-up, and eligibility is decided by the batch walker itself, so .gitignore/.codannaignore bind identically on both lanes. Previously a file created during a watch session stayed out of the index until a manual re-index.
  • Recorded workspace paths load canonicalized: a symlink component in a hand-edited or copied settings.toml no longer disables the workspace-root module-path tier or forks single-file re-index identity from the batch lane.
  • PHP enum declarations are containers with class evidence and enum cases are Constant members; calls resolve through enum receivers.
  • self in Python nested defs binds to the lexical enclosing method's class, recovering calls the 0.11.1 veto refused.
  • Defines cards count members of every kind, not methods only.
  • codanna index on an already-registered path reports registration state instead of a claim about index contents.

0.11.1 - 2026-07-24

Fixed

  • this.name() inside an arrow function resolves to the enclosing method's class member instead of a same-named local or the arrow's own symbol. A self-alias receiver (this, self, $this) on a caller carrying no class-member evidence no longer falls through to scope lookup in JavaScript, TypeScript, Python, PHP, Kotlin, and Java; JavaScript and TypeScript recover the call site through its innermost non-arrow enclosing callable, and a site with no such evidence produces no edge. Resolved-relationship counts move down where the resolver refuses picks it cannot prove: three.js 33695 -> 33491, laravel -6, ktor -2, pydantic -9. Python nested functions and PHP closures capturing self/$this fall into the refused class — their calls are dropped rather than resolved by scope proximity. Existing indexes converge through incremental re-index; codanna index --force adopts the change across every file at once.

0.11.0 - 2026-07-24

Added

  • function_wrappers parser option for TypeScript ([languages.typescript.parser_options]): functions declared through named wrapper calls are extracted with their inner call edges. A declared name matches the call's full dotted text (Effect.gen matches Effect.gen(...) only) or its final property name (memo matches both memo(...) and React.memo(...)); curried forms (wrap("name")(fn)) descend. Emission is unchanged when the option is absent. Closes #115; dotted-text matching adopted from PR #116. The generated codanna init settings carry a commented example.

Changed

  • --fields projects dotted paths (symbols.name,symbols.range.start_line) with output nesting preserved. An unknown first segment rejects with an INVALID_QUERY envelope listing the available fields (exit 2); unknown names previously dropped silently, returning output that looked complete. Scripts passing misspelled field names now fail the call.

Fixed

  • A language whose parser cannot construct (for example a malformed parser_options value) fails the indexing run with an error naming the language and cause, on every entry path: codanna index exits 2 before touching the index, watch-triggered re-index and MCP force-reindex surface the error on stderr. Previously the run reported success while every file of the language was silently skipped.
  • A failed re-index leaves the file's existing rows in place. Single-file re-index parses the new content before removing old rows; directory re-index validates parser construction for the change-set's languages before cleanup. Previously a parser-construction failure durably removed the changed files' rows until the next successful index run.
  • codanna index after deleting .codanna/index runs a single indexing pass in the command phase. Previously the pre-command config sync re-indexed every configured root against the freshly created empty index and the command phase then reported "Index up to date".

0.10.1 - 2026-07-23

Fixed

  • codanna serve (stdio) on a gate-refused index completes the MCP handshake instead of exiting before it: the instructions field carries the heal command and the semantic re-embed cost note, tools/list is empty, and the process exits 7 when the session ends. MCP clients that spawn the server and discard stderr previously showed only a generic connection failure with no heal instruction. HTTP/HTTPS serve and all read commands keep the immediate exit-7 refusal.

0.10.0 - 2026-07-23

Evidence-gated resolution release. Resolved-relationship counts move in both directions and both movements are fixes: recall rises where new evidence channels resolve calls that previously returned nothing (pydantic +3904, codanna self-index +937, gin +616), and counts drop where the resolver now refuses picks it cannot prove (ktor -46%, nlohmann -12%), with witnessed pick-corrections as the precision counterpart. Every call edge now carries its exact call site. An emission-semantics gate makes binary upgrades safe: an index built by a different-semantics binary can no longer be silently mixed with new rows.

Breaking Changes

  • codanna mcp process exit codes use the envelope vocabulary: not-found exits 1 (was 3), blocking errors exit 2. Automation keying on exit 3 must update.
  • Unknown key:value arguments reject on every surface — positional, --args, and serve-mode tools/call (serve rejects via isError: true; tool schemas advertise additionalProperties: false). Misspelled argument keys previously ignored now fail the call.
  • JS/TS/Go call_line values shift -1 to true 1-indexed source lines (a stored-range pre-increment double-counted with the JSON boundary's own shift), and every plain-call edge gains call_line/call_column. Consumers caching old call-site values must re-read.
  • Out-of-tree indexes emit file_path relative to the file's indexed root, matching in-tree shape and the schema's documented contract. Consumers of absolute out-of-tree paths must resolve against their indexed root. Existing indexes serve the corrected shape without a rebuild.
  • Emission-semantics gate: an index built by a binary with different output semantics is refused before any tool runs — read commands exit 7 with the heal command; codanna index rebuilds from scratch automatically with a message. Existing indexes heal on first codanna index after upgrade; no manual rm -rf required.
  • Resolved-relationship counts change across the board (see lead paragraph); cached counts will not match.

Added

  • Call-site metadata on every Calls edge: call_line (1-indexed editor coordinate) and call_column (0-indexed machine coordinate) on get_calls/find_callers JSON rows; text output names the callee definition and the call site separately. Exactness is fixture-locked for Rust, Python, JS, TS, and Go across call forms.
  • Emission-semantics version stamp in index.meta with a load-time gate (see Breaking Changes). The stamp is ignored by older binaries; downgrades parse cleanly.
  • Variable-binding receiver inference: constructor-shaped assignments feed an in-memory binding channel, resolving typed-receiver method calls (largest single recall source; bindings are never persisted).
  • Self-form member resolution through the caller's own class-membership evidence, with super() parent-chain resolution and identity-anchored inheritance walks; instance calls with multiple surviving candidates fail closed instead of guessing.
  • Kotlin module paths are package-true and package-grained in both provider and fallback modes; the import matcher compares packages.
  • Go methods carry class-membership scope from their receiver, feeding self-form and receiver resolution (previously Go methods were scope-blind).
  • Rust Defines edges rescue out-of-line impl members by site identity: a same-file candidate at the edge's exact definition line resolves outright, disambiguating same-name members that share one definer (a field and its accessor).
  • Receiver-type identity anchoring: when a receiver's type name denotes a specific class in the caller's file, copy selection uses that identity instead of failing closed on name ties in multi-copy corpora.
  • parser_census example binary: per-language audit of parser evidence emission (caller identity, receivers, static flags, scope, Defines/Extends, binding emission) — companion to dump_edges.
  • search_symbols rows carry 1-indexed line and language_id.
  • find_symbol symbol_id:<id> resolves identically on CLI JSON, one-shot MCP, and serve.
  • get_index_info reports the full symbol_kinds map (unsampled; values partition symbol_count) and a semantic_search status object; relationship queries return complete edge sets (hub answers are no longer capped).
  • Java methods and constructors emit Method kind (was Function); Swift protocol conformance emits Implements (was Extends).

Changed

  • Resolution is evidence-gated at three layers: per-language scope serves only file-local and internal-import identities; the post-scope ladder resolves only an exactly-one same-module survivor that is not a class member; a file-scoped-private veto applies where the language vouches for it. Fallback guessing paths are removed.
  • rmcp 2.1 -> 2.2; tree-sitter 0.26.11; tree-sitter-clojure-orchard 0.2.8 (parser emission verified unchanged across all 15 languages); tokio 1.53; patch bumps across serde, serde_json, clap, regex, thiserror, toml, rustls, tokio-util, async-trait, glob, sysinfo, bitflags, anyhow, crossbeam-channel, ignore. fastembed stays pinned at 5.6.0 (ONNX Runtime glibc floor) and reqwest at 0.12.

Fixed

  • Windows: forced re-indexing of a large repository no longer fails to save semantic vectors. Contributed by Fan Chen (#112).
  • Path-form variants (codanna index src, ./src, absolute) canonicalize to one identity before indexing — the same directory indexed under two spellings no longer double-indexes.
  • JS/TS: inline default-export declarations (export default function Foo() {}, export default class Foo {}) extract as Public symbols; previously only the split function Foo(){}; export default Foo; form indexed. Anonymous default exports still produce no symbol.
  • C, Lua, and PHP method calls attribute to their real enclosing caller instead of an empty caller identity.
  • Qualified static calls (Type::method) no longer emit a duplicate bare-name edge — the twin absorbs into one metadata-carrying edge per call site.
  • GDScript/Kotlin import scope serves only internal identities; external-import names no longer leak into resolution.
  • Call edges in minified or vendored single-line files attribute to the true enclosing caller.
  • codanna mcp coordinates are self-consistent across text and JSON: range objects 0-indexed, scalar line fields 1-indexed, one convention on every surface.
  • Serve-mode and CLI text output are byte-identical for the non-semantic tool set on both stdio and HTTP transports.

0.9.23 - 2026-07-03

Resolver precision release. Resolved-relationship counts drop across the board, and the drop is the fix: method-call edges that resolve now target the call site's actual receiver, method calls whose receiver type cannot be named return nothing instead of a guess, and resolution output is deterministic run to run. On the recall side, Python imports resolve across package boundaries and re-exports, and super() calls resolve to the parent's method instead of the caller's own override.

Breaking Changes

  • Resolved-relationship counts drop across indexed codebases. The resolver previously picked the first same-name candidate for method calls with unknown receiver types; those calls now return unresolved. Import, inheritance, and function-call edges keep their semantics. Cached counts will not match.
  • Full rebuild required (rm -rf .codanna && codanna init && codanna index <root>, or --force). Mandatory for watcher-served indexes: through 0.9.22 the watcher's single-file path never persisted id counters, so each watch-triggered reindex could mint duplicate symbol_ids. Rebuilding with 0.9.23 corrects existing duplicate ids; the atomic counter commit prevents recurrence. Also rebuild-not-migrate: scope_context values written by older versions read as no-scope-info, and Python imports and method names index differently (see Added).
  • CLI --json: ambiguous symbol names return an INVALID_QUERY envelope with the candidate list and exit 2, replacing aggregation across same-named symbols; backend query failures return INDEX_ERROR and exit 2 instead of an empty result.
  • LanguageBehavior::resolve_method_call removed (no remaining call path). External implementors drop their overrides.
  • indexing.project_root config field removed; it was never read.

Added

  • Python package-level import graph: relative imports normalize to absolute form at parse time; re-exports (explicit, aliased, import *) resolve through __init__ to the definition site; class inheritance emits Extends edges (previously mis-emitted as Implements); methods index under bare names, with Class.method dotted lookup now a query-layer feature across all languages.
  • super() calls resolve to the parent class's directly-declared member: single hop through the Extends edge in base-list order; no parent declaring the member yields no edge rather than a guess.
  • dump_edges example binary: full edge dumps for run-to-run diffing; --dups lists every symbol_id with more than one indexed doc.
  • Deletion-only indexing runs report Removed N deleted file(s), M symbol(s) from index; Index up to date now means no changes in either direction.

Changed

  • Symbol cards request one context set on every surface (implementations, definitions, callers, extends, uses): CLI find_symbol --json, semantic_search_with_context, MCP find_symbol, retrieve_symbol, retrieve_search. extends/extended_by/uses previously rendered null on the CLI and retrieve paths.
  • Resolution is order-independent: candidate lists sort by identity (file path, line, id), not session insertion order; repeated runs over the same tree produce identical edge sets.
  • One resolution policy for MCP text and CLI JSON: symbol lookup (refuse-and-list on ambiguity), the SymbolKind vocabulary, and receiver formatting are a shared service (src/mcp/service.rs).
  • Module decomposition: src/indexing/pipeline/ split by responsibility with run_phase1 as the single Phase 1 orchestrator; tantivy.rs split into schema/codec/writer/query; config.rs and mcp/mod.rs split likewise.
  • Hot paths move and borrow instead of cloning; CompactString backs its alias with Arc<str>.
  • rmcp 1.7 -> 2.1: model types align with the MCP 2025-11-25 spec revision; tool results carry spec ContentBlock values (wire format for text content unchanged; MCP text and CLI outputs byte-identical). Logging notifications keep emitting for client compatibility; the spec deprecates them under SEP-2577.
  • tower-http 0.6 -> 0.7; patch/minor bumps across anyhow, bitflags, chrono, console, ignore, indicatif, memmap2, rand, regex, rustls, sysinfo, tree-sitter, tree-sitter-swift.

Fixed

  • Method calls on receivers whose type is neither inferred nor indexed fail closed instead of resolving by insertion order.
  • Call sites attribute to the enclosing same-name symbol, so a test stub no longer absorbs the real function's callers.
  • Import-path matching respects segment boundaries (crate::widgets no longer matches crate::widget); same-module checks bound their prefix match to the caller language's separator, closing private-symbol leaks across string-prefix sibling modules.
  • Batch-incremental indexing resolves against the persisted index; edges through an unchanged re-export survive consumer-only changes.
  • Module paths resolve for out-of-tree indexed roots; TS/JS resolver-provider config lookup keys on absolute file path.
  • Id counters commit atomically with their docs on rolling commits, final commits, and the watcher single-file path.
  • find_symbol and analyze_impact headers render from the name-matched doc, keeping each row self-consistent even against an index carrying duplicate ids.
  • scope_context persists as JSON via serde, replacing a Debug-string scrape that silently decoded most parent kinds to none.
  • Embedding pool acquire is bounded (60s, then a PoolExhausted error) instead of blocking forever; checked-out instances release on drop, panic-safe; the embed fan-out runs on a dedicated rayon pool.
  • Semantic saves stage to a temp path and rename into place; vector storage drops its mmap before writing the backing file; Tantivy rolls back on cleanup errors instead of half-committing.
  • codanna serve lock acquisition race closed; the lock releases before process::exit.
  • Panicked read workers and failed symbol writes surface as indexing errors instead of being swallowed.
  • Profile rollback failures propagate instead of being discarded.
  • Config guidance templates and variables serialize in insertion order.

Removed

  • Dead code with no callers: SymbolStore, IndexTransaction, ResolutionMemo, unused vector wiring.

0.9.22 - 2026-05-19

Method-call resolution accuracy: static calls disambiguate by receiver type, instance calls infer the receiver from caller-parameter types, and inheritance-aware resolution lands for PHP.

Breaking Changes

  • Method-call resolution is stricter. Calls that previously resolved to a wrong-class same-name method now return unresolved. Downstream consumers of find_callers, analyze_impact, and get_calls will see fewer (but more accurate) edges; cached resolution counts will not match.
  • Re-index recommended. The new Tantivy fields relation_receiver and relation_static_call drive receiver disambiguation; existing indexes load with defaults (receiver=none, static=false) and skip the new filtering until re-indexed. The on-disk format itself is additive — no migration step required.

Added

  • Static method calls disambiguate by receiver type. Foo::bar() (Rust), Foo.bar() (Python/TS/Java/Go), and equivalents now resolve to the candidate whose containing type matches the receiver. No-match returns unresolved instead of silently selecting an unrelated same-name method.
  • Instance method calls resolve via caller-parameter type inference for Rust, Python, TypeScript, Go, Java. In fn f(x: Foo) { x.bar() }, bar resolves against Foo's methods.
  • PHP parent::method() resolves cross-file via per-language inheritance resolver built from Extends relationships; self:: and static:: resolve to the caller's class.
  • Method calls across 12 parsers (TypeScript, JavaScript, Java, Go, Kotlin, Swift, C++, PHP, C, Lua, GDScript, Python) carry receiver name and static-call flag; per-language is_static heuristics (Pascal-leading receiver, imported-package match, :: token, etc.).
  • Clojure interop: (.method obj) resolves as instance call; (Class/staticMethod) resolves as static call.
  • Kind-compatibility filter rejects resolutions where the (source-kind, target-kind, relationship-kind) triple is invalid - e.g. a method-call relationship cannot resolve to a field.
  • MCP server: allowed_hosts and allowed_origins config; unset flows to rmcp defaults.

Changed

  • Tantivy relationship schema gains relation_receiver and relation_static_call fields (additive; see Breaking Changes).
  • tantivy 0.24 -> 0.26, sha2 0.10 -> 0.11 (hex = "0.4" added as runtime dep), rmcp -> 1.7 (consume-self StreamableHttpServerConfig builder).
  • reqwest pinned to 0.12 / rustls-tls -> ring (0.13's rustls feature pulls aws-lc-rs + bindgen).

Fixed

  • Receiver-compatibility suffix matching now uses each language's module separator (Python ., Go /, Java .) instead of hardcoded ::. Previously matched only Rust and PHP path conventions.
  • Broken compare links in CHANGELOG.md.

0.9.21 - 2026-05-15

Fixed

  • documents stats <collection> returns per-collection file count. collection_stats filters file_states by state.collection == name; prior count summed all collections (#103).

Removed

  • gpu-* feature scaffolding (gpu-cuda, gpu-tensorrt, gpu-coreml, gpu-directml, gpu-openvino, gpu-rocm): commented Cargo.toml entries, matching [lints.rust] unexpected_cfgs check-cfg, tests/semantic/gpu_*.rs, tests/semantic_tests.rs gateway. Upstream fastembed = "=5.6.0" exposes none of these features.
  • [lints.clippy] table. CI runs cargo clippy --all-targets --all-features -- -D warnings; uninlined_format_args is a default clippy lint at warn, so -D warnings denies it without a table entry. clippy.toml header references the CI command.

0.9.20 - 2026-05-01

Fixed

  • documents index --collection X no longer wipes chunks belonging to other collections in the same index. detect_changes scopes its removed-files scan by state.collection so cross-collection paths in file_states are not classified as removed (#100).
  • codanna serve (stdio) acquires .codanna/index/serve.lock on startup; a duplicate invocation against the same index exits 1 with guidance to use HTTP mode for shared access. Stale lockfiles are reclaimed via sysinfo PID-liveness check (#101).

Changed

  • Clippy lint pass: unnecessary_sort_by to sort_by_key with Reverse (php behavior, vector engine), explicit_counter_loop to (1..).zip (python parser), collapsible_match arm guards (kotlin/php/typescript parsers), redundant .into_iter() after .zip() removed (embed pipeline, embedding pool).

0.9.19 - 2026-04-03

Fixed

  • mcp get_index_info reports persisted remote semantic metadata in lite facade loads (PR #98)
  • Remote embedding model name shown instead of local default in status messages (PR #98)
  • index-parallel persists index.meta so MCP status reads do not trigger unnecessary sync (PR #98)
  • Windows test portability: Java, Lua, and path tests use TempDir instead of hardcoded Unix paths (PR #98)

Changed

  • index-parallel command retired; index uses the same pipeline path
  • format_semantic_status() shared helper for remote/local status formatting
  • GitHub Actions upgraded to Node 24: checkout v6, upload-artifact v7, download-artifact v8, github-script v8
  • softprops/action-gh-release v1 to v2 (Node 20, no Node 24 release yet)
  • Swatinem/rust-cache@v2 in full-test, quick-check, and autofix workflows
  • full-test.yml: redundant build steps removed, release build conditional on tags only
  • Local CI scripts synced with updated workflows

Removed

  • index-parallel CLI command and save_document_index_metadata from IndexPersistence

0.9.18 - 2026-03-25

Added

  • Remote embedding backend: OpenAI-compatible HTTP endpoint as alternative to local fastembed (PR #97)
  • CODANNA_EMBED_API_KEY env var for Bearer auth on remote embedding servers
  • CODANNA_EMBED_URL, CODANNA_EMBED_MODEL, CODANNA_EMBED_DIM env var overrides
  • Remote embedding config documentation in codanna init output
  • Nix flake for reproducible builds and nix run support (PR #94)
  • GetIndexInfoRequest manual JsonSchema impl for OpenAI function-calling compatibility (PR #96)

Fixed

  • Dimension mismatch detection: enable_semantic_search no longer overrides semantic_incompatible flag
  • --force with CLI paths warns about configured roots that will not be rebuilt
  • --force suppresses misleading "Already indexed" message
  • process::exit removed from create_semantic_search in index_parallel (returns gracefully)
  • Highlight range overlap panic in document search
  • DimensionMismatch propagated through persistence and hot-reload paths

Changed

  • EmbeddingBackend enum wraps local fastembed pool and remote HTTP embedder
  • Shared load_symbol_languages helper (deduplicated load/load_remote)
  • API keys env-var only: secrets not stored in config files

0.9.17 - 2026-03-15

Added

  • Clojure language support: parser, behavior, definition, resolution modules (PR #80)
  • Clojure test fixtures, examples, grammar analysis, and audit report

Changed

  • Grammar audit tests split into per-language modules under abi15_grammar_audit/

0.9.16 - 2026-03-15

Fixed

  • Embedding pool initialized on incremental index when loaded from disk (#88)
  • Semantic save errors logged instead of silently discarded
  • get_index_info reports live embedding count instead of stale metadata
  • Debug printlns removed from semantic search

0.9.15 - 2026-03-15

Changed

  • rmcp 1.2.0, rand 0.10.0, and 18 other dependency updates

Fixed

  • System git backend for SSH config support
  • Profile install for symlinked directories
  • Windows installer script and rustls enablement

Removed

  • git2 crate (system git backend)

0.9.14 - 2026-01-29

Added

  • Lua language support: parser, behavior, definition, resolution modules
  • Lua test fixtures and comprehensive examples
  • Lua grammar analysis and audit report documentation

Changed

  • Updated rmcp to 0.14.0 (CallToolRequestParams, InitializeRequestParams, StreamableHttpServerConfig API)
  • Updated clap to 4.5.56, chrono to 0.4.43, thiserror to 2.0.18, rcgen to 0.14.7, sysinfo to 0.38.0

Fixed

  • Vector storage clippy panicking_unwrap false positive

0.9.13 - 2026-01-16

Added

  • Go project resolver provider for go.mod parsing and module path resolution
  • Python project resolver with multi-backend support (Poetry, Hatch, Maturin, Setuptools, PDM, Flit)
  • Kotlin project resolver with source layout config (jvm, standard-kmp, flat-kmp)
  • PHP PSR-4 provider for composer.json autoload namespace resolution
  • C# project resolver for .csproj SDK-style projects (RootNamespace, AssemblyName extraction)
  • Shared helper functions in helpers.rs for provider implementations
  • [[languages.X.projects]] config block for per-project source layout override
  • PHP method call tracking (member_call_expression, scoped_call_expression)
  • Animated spinner during pipeline warmup phase (DISCOVER/READ/PARSE/COLLECT)

Changed

  • Settings.languages uses IndexMap for alphabetical ordering in init output
  • LoggingConfig.modules uses IndexMap for consistent ordering
  • Empty indexes now auto-trigger force mode for dual EMBED+INDEX progress bars
  • DualProgressBar shows preparing spinner when both bars at 0%

Fixed

  • Languages without providers no longer show empty config_files in settings.toml
  • Rustdoc invalid-html-tags error in C# provider doc comments

0.9.12 - 2026-01-14

Added

  • Unified JSON envelope format (Envelope type) with schema_version, status, code, exit_code, message, hint, data, meta
  • --fields flag for JSON field filtering on data payload (mcp and retrieve commands)
  • QueryContext abstraction for symbol resolution and error handling in retrieve commands
  • lang field to Meta struct with with_lang() builder method
  • paths.rs module with normalize_for_module_path, strip_source_root, strip_extension helpers
  • format_path_as_module as required trait method for language-specific path formatting
  • Document collections info to get_index_info output

Changed

  • Migrated all 9 MCP tool commands to unified Envelope format for --json output
  • Migrated retrieve symbol/callers/calls/describe/search/implementations to Envelope format
  • Lazy load ML model for embedding generation (deferred until first semantic search)
  • Flattened tuple output in get_calls/find_callers to avoid nested array waste
  • Standardized search_symbols output with nested symbol object
  • Unified logging to stderr for all commands
  • Skip embedding pool loading for retrieve commands via load_facade_lite()
  • module_path_from_file now accepts extensions: &[&str] parameter (fixes deadlock when registry lock held)

Removed

  • file_extensions() method from LanguageBehavior trait (duplicated LanguageDefinition::extensions())
  • file_extensions() implementations from all 12 language behaviors
  • init_with_config_stderr function (replaced by unified init_with_config)
  • Tantivy-based resolution methods from trait: resolve_import, build_resolution_context, resolve_import_path, classify_import_origin, resolve_import_path_with_context
  • Dead Go behavior methods: get_current_package_path_for_file, get_project_root_for_file
  • store_file_info from DocumentIndex (replaced by store_file_registration)

Breaking

  • --json output format changed for mcp and retrieve commands (now uses Envelope schema)

0.9.11 - 2026-01-12

Fixed

  • MCP servers now load document store on all transports (stdio, HTTP, HTTPS)
  • Consolidated document store loading into reusable helper

Documentation

  • Added transport notes to MCP Persistent and MCP Network docs

0.9.10 - 2026-01-07

Changed

  • Bump version to 0.9.10
  • Update serde_json from 1.0.148 to 1.0.149
  • Disable ort dev-dependency (commented out)

Fixed

  • Pipeline wall_time tracking (aa01269)
  • Add EMBED to pipeline metrics (aa01269)

Documentation

  • Fix JSON examples in MCP tools
  • Add lang parameter to tools documentation
  • Update architecture for v0.9.0
  • Add install methods documentation

CI

  • Add standalone brew-update workflow

0.9.0 - 2026-01-05

Added

  • Parallel indexing pipeline with 5-stage architecture (DISCOVER, READ, PARSE, COLLECT, INDEX)
  • SemanticEmbedStage for parallel embedding generation
  • EmbeddingPool with configurable model instances for parallel embedding
  • Progress bars for Phase 1 and Phase 2 indexing with dual progress bar support
  • Pipeline metrics with stage timing, memory tracking, and bottleneck detection
  • GPU execution provider feature flags (CUDA, TensorRT, CoreML, DirectML, OpenVINO, ROCm)
  • GPU embedding benchmarks for CPU vs accelerator comparison
  • Incremental file-level change detection with mtime fast path
  • Document search auto-sync with mtime-based change detection
  • Install scripts for curl-based installation (install.sh, install.ps1)
  • IndexFacade as unified interface wrapping DocumentIndex, Pipeline, and SemanticSearch
  • --watch flag to mcp command for pre-tool reindex
  • --no-progress flag (progress enabled by default)

Changed

  • Replaced SimpleIndexer with IndexFacade across codebase
  • Consolidated thread settings into single parallelism value (derives stage threads)
  • Batch embeddings in groups of 64 for throughput
  • DocumentIndex.writer uses RwLock instead of Mutex for concurrent writes
  • Release workflow: removed slim variants (8 builds to 4 builds)
  • Release workflow: use macos-latest for both macOS targets
  • Manifest format simplified (removed variant field)

Removed

  • SimpleIndexer (6000+ lines, replaced by IndexFacade)
  • SymbolCache and related cache methods
  • Slim build variants from release pipeline
  • Unused retrieve commands: Uses, Defines, Dependencies

Fixed

  • Multi-directory symbol ID collisions by querying IDs before spawning threads
  • Pipeline metrics logging race with StatusLine
  • Child paths incorrectly processed when parent already indexed

0.8.9 - 2025-12-30

Changed

  • Extracted 14 CLI command handlers from main.rs to src/cli/commands/
  • Moved Clap argument definitions to src/cli/args.rs
  • Replaced unreachable!() arms with single exhaustive match pattern
  • Made indexer optional for commands that don't require index access

Removed

  • Unused rkyv dependency
  • Unused bincode dependency

Fixed

  • Parse command tests failing without index directory
  • Added index.db and index.scip to .gitignore

0.8.8 - 2025-12-30

Added

  • language_id() method to LanguageBehavior trait for cross-language resolution filtering
  • RelationRole enum for relationship disambiguation (From/To)
  • resolve_instance_method() and resolve_method_call() methods to LanguageBehavior
  • MethodCallResolver struct for per-file variable types and method call storage
  • CapturedIncomingRelationship for relationship preservation during file reindex
  • get_implemented_traits() query for symmetric trait display
  • Bidirectional relationship display in MCP (implements/implemented_by, extends/extended_by)
  • symbol_id:XXX format support in find_symbol for direct lookup
  • Calculator example files for method call resolution testing

Changed

  • Replaced variable_types + method_calls_by_file with unified method_call_resolvers
  • Simplified resolve_symbol_for_relationship() - kind filtering moved to behavior layer
  • Language filtering added to build_resolution_context_with_cache candidate verification
  • find_symbol MCP tool includes all ContextIncludes flags
  • Upgraded serde_json from 1.0.145 to 1.0.148
  • Upgraded tempfile from 3.23.0 to 3.24.0
  • Upgraded testcontainers from 0.26.2 to 0.26.3

Removed

  • Legacy conversion methods from MethodCall (to_simple_call, from_legacy_format)

0.8.7 - 2025-12-20

Added

  • Custom MCP requests: requests/codanna/index-stats, requests/codanna/force-reindex
  • Custom MCP notifications: file-reindexed, file-deleted, index-reloaded
  • HotReloadWatcher for external index changes (CI/CD, other processes)
  • Debug logging for unmatched file watcher events

Changed

  • Renamed IndexWatcher to HotReloadWatcher with clearer purpose
  • Moved hot reload watcher from mcp/watcher.rs to watcher/hot_reload.rs
  • Removed source file polling from HotReloadWatcher (UnifiedWatcher handles this)
  • Notification listener now spawned in HTTPS server for client notifications
  • Simplified async fn signature for on_custom_request

Removed

  • check_and_reindex_source_files() from hot reload watcher (redundant with UnifiedWatcher)
  • with_mcp_server() method (notifications now use broadcaster pattern)

0.8.6 - 2025-12-20

Added

  • Unified watcher module replacing three separate implementations
  • Path registry for tracking monitored files across multiple watchers
  • Debouncer module to prevent duplicate event processing
  • Handler trait with code, config, and document implementations
  • Logging module with tracing-subscriber and per-module level support
  • RUST_LOG environment variable support for runtime log level control
  • Documents command documentation in CLI reference
  • Logging configuration section in configuration guide

Changed

  • Replaced debug_print macros with tracing calls across indexer and parsers
  • MCP servers now use unified watcher and structured logging
  • Language parsers updated to use tracing
  • README restructured with Quick Start moved to top
  • Features presented as table with documentation links
  • Advanced features (Profiles, Documents) moved to collapsible sections

Removed

  • documents/watcher.rs (replaced by unified watcher)
  • indexing/fs_watcher.rs (replaced by unified watcher)
  • indexing/config_watcher.rs (replaced by unified watcher)

0.8.5 - 2025-12-18

Added

  • Document embedding system for RAG (Retrieval-Augmented Generation)
  • Document chunking with hybrid strategy (paragraph-based sizing with merge/split)
  • DocumentStore with tantivy metadata index and mmap vector storage
  • Semantic search for documents filtered by collection and path
  • File watcher for automatic document re-indexing on changes
  • CLI commands: documents add-collection, remove-collection, index, search, list, stats
  • MCP tool search_documents for AI assistant integration
  • Settings section [documents] with chunking and search configuration
  • Documentation in docs/user-guide/documents.md
  • KWIC (Keyword In Context) preview mode with highlighting

Changed

  • Upgraded rmcp from 0.11.0 to 0.12.0
  • Upgraded fastembed from 5.4.0 to 5.5.0
  • Upgraded tree-sitter from 0.26.2 to 0.26.3
  • Upgraded console from 0.16.1 to 0.16.2
  • Upgraded rcgen from 0.14.5 to 0.14.6
  • Settings save now preserves inline comments via add_config_comments

Fixed

  • add-dir command now handles already-indexed paths gracefully (shows message instead of error)
  • add-dir/remove-dir/list-dirs skip index loading and semantic search initialization
  • -c short flag conflict resolved (removed from --collection in documents commands)
  • documents index now syncs stale collections even when no collections configured

0.8.4 - 2025-12-12

Changed

  • Migrated from rmcp 0.9.1 to 0.11.0
  • Replaced SSE transport with streamable HTTP transport
  • Updated MCP HTTP/HTTPS server to use StreamableHttpService
  • Updated tree-sitter from 0.25.10 to 0.26.2
  • Fixed tree-sitter Node API calls to use u32 instead of usize
  • Updated fastembed from 5.3.1 to 5.4.0
  • Updated axum-server from 0.7.3 to 0.8.0
  • Updated tower-http from 0.6.7 to 0.6.8
  • Updated git2 from 0.20.2 to 0.20.3
  • Updated criterion from 0.8.0 to 0.8.1
  • Updated testcontainers from 0.25.2 to 0.26.0
  • MCP endpoint changed from /mcp/sse to /mcp
  • MCP client config type changed from "sse" to "http"
  • Updated HTTP server documentation with new transport configuration

Removed

  • Removed transport-sse-server feature from rmcp
  • Removed SSE-specific transport code
  • Removed early address parsing in HTTPS server

Fixed

  • Fixed clippy unnecessary_unwrap warnings in Swift test files

0.8.3 - 2025-11-30

Added

  • Swift language support with tree-sitter-swift parser
  • SwiftParser with class, struct, enum, protocol, function, property extraction
  • SwiftBehavior with Swift module path formatting
  • SwiftResolutionContext with Swift scope order
  • SwiftProvider for project structure handling
  • Swift ERROR recovery for @unchecked Sendable syntax
  • Nested type extraction in ERROR-recovered Swift classes
  • TypeScript ERROR recovery for export type * pattern
  • Kotlin context receiver function detection from infix_expression pattern
  • Test suite for Swift error recovery, relationships, visibility, nested types
  • Test suite for TypeScript error recovery
  • Test suite for Kotlin context receivers, value classes
  • Test suite for PHP readonly classes
  • Swift grammar documentation and audit reports
  • Example Swift files for testing
  • tree-sitter-swift dependency

Fixed

  • Swift nested types now extracted when parent class has ERROR nodes
  • TypeScript export type * as Name now resolves as Module symbol
  • Kotlin context(...) receiver functions now extracted as Function symbols
  • Swift recursive helper functions converted to static methods for clippy compliance

Changed

  • Swift parser handles both regular and ERROR-recovered class declarations
  • Kotlin audit.rs includes infix_expression in key_nodes tracking
  • Updated grammar-versions.lock with Swift grammar info

0.8.2 - 2025-11-28

Added

  • JavaScript language support
  • JavaScriptProvider for jsconfig.json parsing and path alias resolution
  • JavaScriptParser with class, function, method, arrow function, export extraction, etc
  • JavaScriptBehavior with ES module path formatting and .js extension handling
  • JavaScriptResolutionContext with JavaScript scope order (local → module → imported → global)
  • Example JavaScript projects: React app, Next.js app, vanilla JavaScript
  • JavaScript inheritance resolution with extends/extended_by relationships
  • Test suite for JavaScript nested functions
  • Project resolution documentation in docs/advanced/project-resolution.md

Fixed

  • JavaScript module path normalization now strips .js/.jsx/.mjs/.cjs extensions
  • JavaScript class inheritance resolution (extends relationships now resolve correctly)

Changed

  • Refactored JavaScript behavior to use shared normalize_js_import helper
  • Updated all language documentation to include JavaScript
  • JavaScript audit reports regenerated with current timestamps

Documentation

  • Added docs/advanced/project-resolution.md explaining tsconfig.json/jsconfig.json resolution
  • Added JavaScript to supported languages list across all documentation

0.8.1 - 2025-11-25

Fixed

  • Added AllMpnetBaseV2 support for fastembed 5.3.0 compatibility

Changed

  • Updated fastembed from 5.2.1 to 5.3.0
  • Updated tower-http from 0.6.6 to 0.6.7

0.8.0 - 2025-11-19

Added

  • Resolution pipeline: Multi-symbol disambiguation with relationship-aware resolution
  • Java language support with complete six-file architecture
  • JavaProvider for Maven pom.xml parsing and dependency resolution
  • Storage: find_symbols_by_module() for package-scoped resolution
  • Symbol relationships: extends, extended_by, uses, used_by
  • Symbol context: ClassMember now tracks class_name
  • JavaParser with class, interface, method, field, enum extraction
  • JavaBehavior with package-based module path formatting
  • JavaResolutionContext with Java scope order (local → class → imported → package)
  • JavaInheritanceResolver for interface and class hierarchy tracking
  • Reranking comparison integration test
  • Java audit test in abi15_grammar_audit.rs
  • Java-specific inheritance test in tantivy.rs

Changed

  • Symbol map: HashMap<String, SymbolId> → HashMap<String, Vec<(SymbolId, SymbolKind)>>
  • ClassMember: unit variant → struct with class_name field
  • Relationship flags: expanded from 4 to 6 bits (added EXTENDS | USES)
  • Version: 0.7.0 → 0.8.0
  • Updated 15 dependencies (anyhow, bitflags, clap, crossbeam-channel, etc)
  • Commented out release profile optimizations for faster dev builds

Fixed

  • MCP protocol: Added peer info registration in initialize handler
  • mcp-test command: Moved to early execution before index loading
  • stdout corruption: Changed diagnostic output to stderr
  • Security: Replaced unmaintained json5 with serde_json5 (RUSTSEC-2025-0120)

Enhanced

  • Kotlin parser: More granular relationship tracking
  • C# resolution: Better namespace handling
  • Project resolver: Improved glob matching for multi-extension support
  • All parser audit reports regenerated with current timestamps

Documentation

  • Updated README.md with Java in multi-language feature list
  • Updated language support tables across docs/ and contributing/ (7 files updated)
  • Added Java to implementation status table with Maven integration details
  • Synchronized language lists across architecture, getting-started, and reference docs

0.7.0 - 2025-11-08

Added

  • Kotlin generic type flow with parameter inference and substitution
  • Kotlin extension function resolution with receiver type tracking
  • Cow-based type substitution for zero-copy simple types and owned complex types
  • Trait method find_variable_types_with_substitution for opt-in owned type inference
  • Regex word-boundary type parameter replacement to prevent partial matches
  • Expression type registration in behavior layer for cross-component access
  • Kotlin resolution context with expression type injection
  • Test suite for generic inference (simple, nested, multi-param, complex substitution)
  • Test suite for extension function resolution with receiver tracking
  • Example demonstrating generic + extension resolution
  • Debug test for tracking function and method call collection

Fixed

  • Function call deduplication now includes line and column to track each call site separately

Changed

  • Indexer prefers complex type substitution when available, falls back to zero-copy
  • Function call deduplication key changed from (caller, callee, kind) to (caller, callee, kind, line, column)

0.6.9 - 2025-11-05

Added

  • TypeScript JSX component usage tracking with find_uses extraction
  • Symbol name to ID mapping during extraction phase for TypeScript
  • Test suite for JSX component relationship tracking (test_jsx_uses.rs)
  • Indexed paths cache in Settings for O(1) ancestor checks
  • Path deduplication in Settings to skip children when parent exists and replace children when adding parent
  • Path deduplication in SimpleIndexer to remove descendant paths when adding ancestor

Fixed

  • Sync operation now respects --progress flag when indexing new directories
  • Sync no longer shows "Index already up to date" after successfully indexing new directories
  • Sync failures now route through error handling system with proper exit codes and recovery suggestions
  • Metadata load failures during sync now show recovery steps instead of silent fallback
  • Debug output (DEBUG: prefix) now only appears when debug mode is enabled

Changed

  • Sync state tracking changed from boolean to Option<bool> to distinguish metadata unavailable (None), no changes (Some(false)), and changes applied (Some(true))
  • Single-file paths in codanna index are now skipped with clear message instead of attempting to add to settings
  • File removal during sync now shows progress bar for multiple files
  • Settings::add_indexed_path now deduplicates paths and manages parent-child relationships
  • add_relationships_by_name now accepts optional from_id parameter to skip lookups when symbol ID is known
  • resolve_relationships skips lookups when from_id exists in TypeScript parser
  • Index command now reuses cached results and prints skip messages for already-indexed paths

Documentation

  • Added profiles feature documentation with examples
  • Updated README with profiles configuration details
  • Updated cli-reference.md with idempotent indexing behavior and skip messages

0.6.8 - 2025-11-03

Added

  • Kotlin language support with symbol extraction for classes, objects, functions, properties, and interfaces
  • Context save/restore pattern in Kotlin parser for handle_class_declaration, handle_object_declaration, and handle_function_declaration
  • Test suite for Kotlin nested scope handling (test_nested_scopes.rs with 3 tests)
  • Pinned tree-sitter-kotlin dependency to commit 57fb4560 for reproducible builds
  • Kotlin to supported languages list in README.md
  • Kotlin implementation status in language-support.md

Fixed

  • Nested scope context loss in Kotlin parser where methods after nested classes would lose parent class context
  • Clippy len_zero warning in test_interfaces_and_enums.rs
  • Clippy uninlined_format_args warning in test_kotlin_semantic_search.rs

0.6.7 - 2025-11-01

Fixed

  • MCP commands now support symbol_id:N syntax with JSON output
  • Added symbol_id parameter handling to find_callers JSON data collection
  • Added symbol_id parameter handling to get_calls JSON data collection
  • Added symbol_id parameter handling to analyze_impact JSON data collection
  • Updated error messages to show correct parameter (symbol_id vs name) when symbol not found
  • Fixed empty impact result to handle symbol_id in identifier string

Closes #63

0.6.6 - 2025-10-31

Added

Documentation

  • Created language-architecture.md with design principles and resolution patterns
  • Created language-patterns.md with implementation patterns from TypeScript/Rust
  • Created development README.md as documentation index
  • Updated language-support.md with accurate resolution implementation status

Grammar Version Tracking

  • Added grammar-versions.lock to track tree-sitter grammar commits and ABI versions
  • Added update-grammar-lock.sh to generate/update lockfile automatically
  • Added check-grammar-updates.sh to detect remote grammar updates
  • Lockfile tracks commit hash, timestamp, ABI version, and repo URL for each grammar

GDScript Enhancement

  • Added relationship tracking for GDScript (#62)

MCP Enhancement

  • Added guidance messages to all MCP tool responses (find_symbol, get_calls, find_callers, analyze_impact, search_symbols, semantic_search_docs, semantic_search_with_context)

Changed

  • Renamed grammar-node-types.json to node-types.json across all languages
  • Updated setup.sh to copy node-types.json and update lockfile
  • Updated abi15_grammar_audit.rs to use new node-types.json filename
  • Moved generate_mcp_guidance() function to top of module for clarity

Fixed

  • Resolved clippy warning in method_call test data (changed vec![] to array)
  • Prevented CI model downloads by marking gdscript semantic search test as ignored

Removed

  • Removed unused from_persistence() method from MCP server
  • Removed IndexPersistence import from MCP module
  • Removed outdated parsers_api.md (superseded by new docs)

0.6.5 - 2025-10-29

Added

GDScript Language Support

  • Added GDScript parser with tree-sitter integration for Godot game engine projects
  • Implemented StatefulBehavior architecture for cross-file symbol tracking
  • Added relative path resolution for GDScript imports (./file.gd, ../dir/file.gd)
  • Implemented res:// protocol handling for GDScript module paths
  • Added class hierarchy, export variables, and signal extraction
  • Created example files and audit reports for GDScript grammar
  • Added test suite with 850+ lines covering parser, behavior, imports, and resolution

Retrieve Command Enhancement

  • Added symbol_id parameter support to retrieve symbol command
  • Enabled direct symbol lookup by ID without name ambiguity

Fixed

Index Command Workflow

  • Fixed force flag to trigger complete re-index regardless of path source
  • Added automatic path persistence when CLI paths provided to index command
  • Prevented redundant auto-sync when force flag is present
  • Added indexed_paths cleanup in remove_paths() to maintain tracking state
  • Extracted add_paths_to_settings() helper for shared logic between index and add-dir

Test Infrastructure

  • Fixed Windows file URL handling in marketplace resolution tests
  • Resolved path normalization issues for cross-platform compatibility

Configuration

  • Updated settings file references to remove non-existent commands
  • Enabled GDScript in default language configuration

Technical Details

  • Total additions: 6,870 lines across 58 files
  • GDScript implementation: 2,000+ lines of parser and behavior code
  • Test coverage: 850+ lines of language-specific tests
  • Co-authored-by: nguyenchiencong (GDScript foundation)

0.6.4 - 2025-10-29

Profile System

Share workspace configurations (gitignore, hooks, documentation) across projects with version control.

Commands:

  • codanna profile sync - Register providers and install team profiles
  • codanna profile install <profile> - Install individual profile from provider
  • codanna profile remove <profile> - Uninstall with directory cleanup
  • codanna profile status/list/verify - Inspection and validation
  • codanna profile provider add/list/remove - Provider registry management

Features:

  • Three-tier configuration: global registry, team config, local lockfile
  • Atomic transactional installation with pre-flight validation and rollback
  • Provider registry supports GitHub, Git URL, and local directory sources
  • File ownership tracking with conflict resolution via sidecars
  • SHA-256 integrity verification
  • Team sync from .codanna/profiles.json with extraKnownProviders

Multi-Directory Indexing

Index multiple directories with automatic sync mechanism.

Commands:

  • codanna add-dir <path> - Add directory to indexed paths
  • codanna remove-dir <path> - Remove directory from indexed paths
  • codanna list-dirs - Display configured indexed directories
  • codanna index [paths...] - Accept multiple paths, use config when none provided

Features:

  • Automatic sync on every command compares settings.toml with index metadata
  • settings.toml is source of truth, index metadata is derived state
  • New directories in config automatically indexed
  • Removed directories automatically cleaned (symbols, embeddings, metadata)
  • ConfigFileWatcher monitors settings.toml for changes in HTTP/HTTPS modes
  • FileWatcher tracks both config file and source file changes

Fixed:

  • Batch management in remove_file now self-contained (calls start_batch before operations)

Documentation

  • CLI reference
  • Configuration documentation simplified

0.6.3 - 2025-10-24

Changed

  • Simplified CLAUDE.md with focused code intelligence workflow
  • Removed multi-hop agent instructions in favor of direct workflow
  • Streamlined query optimization and exploration patterns

Fixed

  • Symbol location display now includes line ranges in semantic search results
  • Symbol context formatting shows symbol_id in location output

0.6.2 - 2025-10-23

Added

  • Binary release workflow with dual variants
    • Tag-triggered automated releases
    • 8 pre-built binaries (4 platforms × 2 variants)
    • Full variant includes MCP server support (--all-features)
    • Slim variant is CLI only
    • SHA256/SHA512 checksums for verification
    • Dist manifest with download URLs for universal installer
    • Preparation for https://setup.codanna.sh installer
  • C# benchmark command for performance testing
  • C# documentation examples (file-scoped namespaces, comprehensive.cs)

Fixed

  • C# import extraction fallback for using directives
  • Stats display showing accurate symbol counts and timing
  • Windows test compatibility (platform-agnostic path assertions)

0.6.1 - 2025-10-21

Added

  • Symbol ID parameter support for unambiguous queries
    • symbol_id parameter for retrieve commands (calls, callers, describe)
    • symbol_id parameter for MCP tools (get_calls, find_callers, analyze_impact)
    • CLI help text with symbol_id examples
    • Token-efficient workflow: search returns [symbol_id:123], use symbol_id:123 for precise follow-up
    • Eliminates disambiguation prompts, reduces token usage
  • Import binding system for external dependency detection
    • Tracks import statements and their bindings
    • Foundation for external dependency resolution
  • Documentation updates
    • Symbol_id workflows in User Guide, CLI Reference, and Search Guide
    • Advanced section with unambiguous query patterns
    • Plugin documentation with Node.js wrapper examples
    • Slash command updates with <relationship_symbol_name|symbol_id:ID> pattern

Changed

  • Plugin scripts updated to display and accept symbol_id
    • Formatters show [symbol_id:123] in headers and relationships
    • Context provider accepts symbol_id for all relationship queries
    • Applied to Claude Code plugin, codanna-cc, and codanna-base
  • Dependency updates
    • clap 4.5.41 → 4.5.50
    • memmap2 0.9.7 → 0.9.9
    • indicatif 0.18.0 → 0.18.1
    • rmcp 0.7.0 → 0.8.2

0.6.0 - 2025-10-18

Added

  • Plugin Management System: Install, remove, and manage plugins
    • Transactional installs with automatic rollback on failure
    • Smart update detection skips I/O when no changes needed
    • Marketplace resolution for external plugin sources
  • Documentation Hub: Centralized navigation at docs/README.md
    • Organized sections: Getting Started, User Guide, Integrations, Architecture, Advanced, Contributing, Plugins, Reference
    • Navigation footers across all documentation pages

Changed

  • Symbol display now includes file paths with line numbers for precise navigation
  • Enhanced relationship formatting for better readability
  • Improved plugins documentation with marketplace and MCP setup details

Fixed

  • TypeScript call tracking from object property functions
  • Documentation cross-references updated for new structure

0.5.26 - 2025-10-09

Added

  • Configurable Tantivy heap size via tantivy_heap_mb setting (default 50MB)
  • Configurable retry attempts via max_retry_attempts setting (default 3)
  • Universal defaults work across all platforms without cfg checks

Changed

  • Tantivy heap size now user-configurable instead of hardcoded
  • Retry logic moved to helper function with configurable attempts
  • DocumentIndex constructor accepts Settings parameter

Fixed

  • Error detection uses ErrorKind instead of locale-dependent strings
  • Transient permission errors handled with exponential backoff (100ms, 200ms, 400ms)
  • Tests updated to use Settings parameter

0.5.25 - 2025-10-08

Fixed

  • C++ parser: Member function call detection for method invocations
    • Extract method names from field_expression nodes (obj->method, obj.method)
    • Extract method names from qualified_identifier in function context (Class::method)
    • Function context tracking now handles qualified method implementations
    • Register call_expression, field_expression, qualified_identifier in audit system
  • MCP analyze_impact: Handle all symbols with same name instead of first match only
    • Changed from find_symbol (single) to find_symbols_by_name (all matches)
    • Aggregate impact across all symbols with same name
    • Show locations and direct caller counts for each symbol variant

0.5.24 - 2025-10-07

Fixed

  • C++ parser: Extract class methods from declarations and implementations
    • Method declarations inside classes now extracted as SymbolKind::Method
    • Out-of-class implementations (Class::method) identified as methods
    • Qualified_identifier pattern (Class::method) detection in function_definition
    • Class_specifier enters class scope and processes children recursively
    • Field_declaration extracts methods from function_declarator nodes
    • Tested with Qt QWindow: 144 methods extracted (was 0 before)

0.5.23 - 2025-10-07

Changed

  • Bump rmcp from 0.7.0 to 0.8.0

0.5.22 - 2025-10-07

Added

  • C++ parser: Doxygen doc comment extraction (/** */ and ///)
  • C++ parser: Recursive call tracking with function context
  • C++ parser: Scope context tracking via ParserContext

Fixed

  • MCP get_index_info now displays all symbol kinds dynamically
  • C++ Audit system uses proper tree-sitter node names to generate the report

0.5.21 - 2025-10-03

Added

  • Recursion depth guards across all language parsers
    • check_recursion_depth() prevents stack overflow on deeply nested AST structures
    • All parsers (TypeScript, Python, Rust, Go, PHP, C++, C#) now track depth in extract_symbols_from_node()
    • Safely handles pathological code with excessive nesting (tested on Qt keyboard at depth 3521)

Changed

  • PERFORMANCE: Optimized resolution pipeline for large codebases
    • Indexed method calls as HashMap for O(1) lookup instead of linear search
    • Added symbol lookup cache to eliminate duplicate Tantivy queries
    • Qt qtbase (8,508 files, 413K symbols): 7m38s total, relationship resolution processes 4.68M relationships with 4,778 resolved, 4.39M skipped
    • Skipped relationships: external symbols not in index (Qt framework dependencies, system libraries)
  • Parser method signatures updated to accept depth parameter
  • Audit reports and grammar analysis regenerated for all languages

0.5.20 - 2025-10-02

Added

  • C# language support with full parser implementation (PR#39)
    • Symbol extraction for classes, interfaces, structs, enums, methods, properties, fields
    • Relationship tracking for inheritance, interface implementation, and method calls
    • XML documentation comment extraction
    • File extensions: .cs, .csx, .cshtml
  • Fuzzy search on non-tokenized name field for whole-word typo tolerance
    • Handles missing character typos in full symbol names (e.g., "ArchivService" finds "ArchiveService")
    • Dual fuzzy strategy: ngram tokens for partial matches + whole words for full name typos

Changed

  • BREAKING: Tantivy schema name field changed from TEXT to STRING
    • Enables exact matching without tokenization for fuzzy search
    • Requires full reindex: codanna index --force
  • PERFORMANCE: Batch commits every 100 files instead of per-file commits
    • 10-50x faster indexing (varies by platform and file count)
    • macOS: ~10x improvement on typical projects
    • Windows: 25-50x improvement (1-2 files/s → 46 files/s on 4,453 file project)
    • Reduces disk I/O, segment creation, and cache rebuilds
  • Automatic reverse relationship creation for bidirectional graph navigation
    • Implements ↔ ImplementedBy, Extends ↔ ExtendedBy, Calls ↔ CalledBy, Uses ↔ UsedBy

Fixed

  • File ID counter race condition during batch operations
    • Pending counter prevents stale committed values from causing duplicate IDs
  • Windows file locking issues with proper retry logic and error logging
    • Symbol cache and persistence layer handle OS error 1224 and permission denied

0.5.19 - 2025-10-01

Added

  • Full symbol boundary tracking for precise editor navigation
    • create_symbol() accepts full_node parameter for complete range extraction
    • Tantivy schema extended with end_line and end_column fields
    • MCP tools now return precise symbol ranges (start_line, start_column, end_line, end_column)

Changed

  • C parser: Functions, structs, unions, enums, fields, and macros now use full boundaries
  • Rust parser: Functions, structs, enums, traits, and modules now use full boundaries
  • README: Added documentation for precise symbol boundary support

0.5.18 - 2025-09-30

Added

  • JSX component usage tracking in TypeScript parser
    • New component_usages field tracks function → component relationships
    • extract_jsx_uses_recursive() traverses AST to find JSX elements
    • track_jsx_component_usage() filters components by uppercase naming convention
    • Supports jsx_element and jsx_self_closing_element nodes
    • Generator functions (generator_function_declaration) included in function context
  • Test fixtures for JSX usage patterns
    • Profile.tsx: React component with JSX
    • test_documented_jsx.tsx: JSX with documentation
    • test_jsx_same_file.tsx: JSX defined and used in same file
    • test_jsx_usage.tsx: Multiple components using shared JSX

Changed

  • Audit reports regenerated to reflect JSX and generator function support
  • All language parser audit reports updated with latest node counts

0.5.17 - 2025-09-29

Changed

  • Refactored relationship compatibility logic from indexer to language behaviors
    • Moved is_compatible_relationship from SimpleIndexer to ResolutionScope trait
    • Each language now controls its own relationship validation rules
    • Cleaner separation between orchestration and language-specific logic

Fixed

  • UTF-8 character boundary parsing error when encountering Unicode characters
    • Added safe_substring_window() utility for UTF-8-safe string slicing
    • TypeScript parser now handles box-drawing characters and emojis correctly
    • Prevents panic when checking for export modifiers before symbols
    • Fixes Issue #38

0.5.16 - 2025-09-28

Added

  • TypeScript path alias resolution with full cross-module support
    • Aliases like @/* resolved to actual paths (./src/*)
    • Symbols added by module_path for cross-module resolution
    • Import paths enhanced at storage time for correct resolution
  • Default export visibility tracking for TypeScript
    • export default symbols now marked as Public
    • Enables proper cross-module access to default exports
  • React component relationship support
    • Constants and Variables now callable (React functional components)
    • Proper relationship tracking for component hierarchies

Changed

  • BREAKING: External stub symbols no longer created for unresolved imports
    • Cleaner index without placeholder symbols
    • Requires full project reindex: codanna index --force
  • TypeScript behavior enhanced with module_path resolution
  • Relationship validation extended for JavaScript/TypeScript patterns

Fixed

  • TypeScript imports using path aliases not resolving across modules
  • Default exported symbols incorrectly marked as Private
  • React components (Constants) not creating proper call relationships
  • Cross-module visibility checks for exported symbols

Migration Required

To benefit from improved TypeScript resolution:

codanna index --force

0.5.15 - 2025-09-27

Added

  • Cross-module resolution: Full qualified path resolution for all languages
    • Symbols now resolvable by both simple name and full module path
    • Example: crate::init::init_global_dirs, app.utils.helper.process_data
  • Python parser: Methods now use qualified names (e.g., Calculator.__init__)
  • Resolution tests for Rust and Python cross-module calls
  • Architectural documentation: Universal vs language-specific concepts

Changed

  • BREAKING: Python method naming convention - requires reindexing Python codebases
  • Resolution context: Module paths added during symbol population

Fixed

  • Cross-module function calls not being resolved (e.g., crate::module::function)
  • Python parser tests updated for new qualified naming convention

0.5.14 - 2025-09-25

Added

  • Global model cache system at ~/.codanna/models for shared FastEmbed models across projects
  • Project registry tracking all indexed projects with unique IDs
  • codanna init command to initialize project structure and create model symlinks
  • Test isolation with separate directories (~/.codanna-test) for development

Changed

  • BREAKING: Existing .fastembed_cache directories must be deleted before running init --force
  • Model storage moved from per-project directories to global cache via symlinks
  • Settings validation now checks for proper initialization on startup

Migration Required

To upgrade existing projects:

rm -rf .fastembed_cache
codanna init --force

0.5.13 - 2025-09-13

Fixed

  • Python parser: Module-level function calls and class instantiations now tracked (fixes #32)
    • Module symbol created for each Python file to represent module scope
    • Module-level calls tracked with <module> as caller, mapped to actual module path for queries
    • normalize_caller_name() maps synthetic names to searchable module paths
    • configure_symbol() renames module symbols for searchability
    • Module type accepted as valid caller in relationship validation
    • External symbol resolution handles unresolved import targets
    • Method call resolution normalizes caller names for consistent matching

Added

  • Python parser: Module-level execution tracking for better code analysis
  • Tests: Module-level class instantiation detection verification

0.5.12 - 2025-09-12

Fixed

  • MCP server: Fixed tool discovery issue after rmcp 0.6.4 upgrade (fixes #31)
    • Tools without parameters now generate proper {"type": "object"} schema
  • Parser safety: Fixed UTF-8 string truncation panic when encountering emojis or multi-byte characters (fixes #29)
    • Added safe_truncate_str and truncate_for_display utilities that respect UTF-8 boundaries
    • Applied fix to Python and PHP parsers where manual truncation was used
    • Zero-cost implementation returning string slices without allocation

Improved

  • MCP server instructions: Updated workflow guidance to emphasize semantic search first approach for better code exploration

0.5.11 - 2025-09-11

Added

  • React example app under examples/typescript/react demonstrating call tracking for React hooks and component methods.

Fixed

  • TypeScript parser/indexer: Function call relationships correctly tracked in React projects (fixes #23)
    • React hooks (useState, useEffect) and component methods properly detected
    • Call relationships preserved during full project indexing
    • External module symbols correctly resolved with unique IDs

[0.5.10] - 2025-09-11

Added

  • Parse command: output AST nodes in JSONL format for debugging
  • Parse command flags: --max-depth, --all-nodes, --output
  • Tree-sitter CLI detection in development scripts

Fixed

  • TypeScript parser: improved nested node extraction in arrow functions and JSDoc blocks (123/182 coverage)
  • Test parallel execution race conditions with unique temp files
  • CLI startup performance for non-index commands (parse, config, benchmark)

Changed

  • Parser audit reports now include timestamps
  • Parse command integration tests moved to proper test structure

0.5.9 - 2025-09-07

Enhanced

  • codanna-navigator agent: Improved code research reports with quantified findings, investigation paths, and actionable insights

Added

  • C/C++ language support with tree-sitter parsing
  • Dynamic NodeTracker system for zero-maintenance parser auditing across all languages
  • TypeScript tsconfig.json path resolution infrastructure with persistence (.codanna/index/resolvers/)
  • Project-agnostic resolution foundation (ProjectResolutionProvider trait, not yet integrated)
  • Python parser extensions: assignment, decorated_definition, type_alias extraction
  • Parser API documentation for consistent resolution patterns across languages

Fixed

  • Semantic search: SymbolId persistence between embeddings and symbol index (addresses #23)
  • CI: clippy --all-targets --all-features compliance across all parsers

Changed

  • Test infrastructure: enable subfolder organization, removed 20k LOC obsolete tests, added ABI-15 audit (supports #20)
  • Memory optimization: symbol-cache candidate lookup with relationship deduplication

Breaking Changes

  • Existing codebases need reindexing with --force or clean new index

0.5.8 - 2025-09-01

Security

  • Fixed critical slab vulnerability (RUSTSEC-2025-0047) by updating to v0.4.11
  • Replaced unmaintained atty (0.2.14) with is-terminal (0.4.16)
  • Resolved RUSTSEC-2024-0375 (atty unmaintained warning)
  • Resolved RUSTSEC-2021-0145 (atty potential unaligned read)

Documentation (internal)

  • Added security maintenance documentation
  • Created paste dependency analysis and monitoring strategy
  • Updated security sprint tracking and procedures

Changed

  • Terminal detection now uses is-terminal crate instead of atty

0.5.7 - 2025-09-01

Fixed

  • rmcp 0.6.1 compatibility for cargo install codanna --locked
  • Symbol counts showing as 0 in get_index_info

0.5.6 - 2025-08-22

Fixed

  • Clippy warnings in Go resolution (unnecessary unwrap, unused parentheses)
  • Documentation build errors with escaped bracket syntax in Go parser
  • CI timeouts by ignoring hanging regression tests pending investigation

0.5.5 - 2025-08-22

Added

  • Go language support with complete parser implementation
  • Go-specific symbol extraction: structs, interfaces, methods, functions, constants, variables
  • Go generics support (Go 1.18+) with type parameter parsing
  • Go package-level visibility handling (exported vs unexported symbols)
  • Go import statement parsing and relationship tracking
  • Performance benchmark: 74,545 symbols/sec (7.4x above 10k/s target)

Fixed

  • Retrieve commands relationship data parity with MCP tools
  • All 6 retrieve functions now use proper SymbolContext with complete relationship data
  • retrieve_describe aggregates relationships from all symbols with same name
  • JSON output field population for all retrieve commands

Changed

  • Language registry: Go parser integrated with self-registration architecture
  • README: Updated supported languages list to include Go (5 production languages)
  • Dependencies: Added tree-sitter-go for Go language parsing

0.5.4 - 2025-08-22

Added

  • ResolutionScope::resolve_relationship with default + language-specific overrides
  • Support for Defines, Calls, Implements, and qualified name resolution (e.g. Config::new, self::method)
  • TDD integration tests for Rust, Python, TypeScript, PHP with real parser validation
  • Structured, extensible abstractions for relationship resolution

Fixed

  • Replace ordering hack in SimpleIndexer with ResolutionContext delegation
  • Update retrieve describe to aggregate relationships across symbols with same name
  • Clean ~40 lines of hack code with professional architecture patterns

Changed

  • Architecture: SimpleIndexer = orchestration only; ResolutionContext = owns logic; per-language behaviors encapsulated
  • Maintains <10ms resolution via memory-mapped symbol cache

0.5.3 - 2025-08-22

Added

  • Function call tracking for all language parsers via PR #17
  • Automatic detection and storage of function calls during indexing
  • Call relationships now tracked alongside existing symbol relationships

Fixed

  • MCP schema validation: Changed non-standard uint format to uint32
  • Python parser: Exclude method calls from function call tracking (only track function calls)
  • PHP parser: Exclude method calls from function call tracking (only track function calls)
  • Test deduplication for function call relationships from multiple analysis passes

Changed

  • CI workflow: Switched to PR-triggered CI with concurrency control for better resource management

0.5.2 - 2025-08-21

Added

  • Language filtering for semantic search in mixed-language codebases
  • lang parameter for semantic_search_docs and semantic_search_with_context MCP tools
  • Language mappings persistence in .codanna/index/semantic/languages.json
  • similarity_score_analysis.sh script demonstrating score consistency
  • File paths with line numbers in JSON output for all retrieve commands
  • Unified output schema with zero-cost abstractions (OutputManager)
  • Dual format support for all retrieve commands (positional and key:value)

New slash commands:

  • /find: Smart semantic search with natural language query optimization
  • /deps: Dependency analysis with coupling metrics and refactoring insights

Fixed

  • TypeScript JSDoc extraction for exported functions
  • TypeScript parser now correctly finds JSDoc comments above export function declarations

Changed

  • Semantic search filters embeddings by language before computing similarity
  • Search performance improved in mixed-language projects (up to 75% noise reduction)
  • All retrieve commands migrated to OutputManager infrastructure
  • Deprecated impact command in favor of analyze_impact MCP tool

0.5.1 - 2025-08-17

Added

  • Comprehensive signature extraction across all language parsers
  • Parent context tracking for nested symbols
  • PHP Resolution API with namespace resolution and PSR-4 support
  • Python Resolution API with LEGB scoping and MRO
  • TypeScript type tracking and call graph analysis
  • TypeScript re-export and barrel file support

Fixed

  • All scope tests and language behavior doctests
  • TypeScript import parsing foundation

[0.5.0] - Unreleased

Note: v0.5.0 was an internal milestone, not a public release. Changes were included in v0.5.1.

Added

  • Language registry architecture for modular parser system
  • PHP language support with full parser implementation
  • TypeScript support with type annotations and interfaces
  • Language-agnostic module resolution system

Changed

  • Parser directory reorganization into language-specific subdirectories
  • Core systems migrated to registry-based language detection
  • ParserFactory integrated with language registry

Fixed

  • Rust symbol extraction for enums, types, and constants
  • Inherent methods trait signature handling

0.4.0 - 2025-08-13

Added

  • Language registry system for self-registering parsers
  • Comprehensive SimpleIndexer refactoring
  • Language-specific behavior traits

Changed

  • Major refactor of parsing architecture to support modular languages
  • Migration from hard-coded language support to registry pattern

0.3.0 - 2025-08-11

Added

  • Unix interface with positional arguments
  • JSON output support for all commands
  • MCP notifications support
  • Optimized CI/CD workflow for rapid development

Changed

  • Improved quick-check workflow for faster feedback

Performance

  • Significant CI pipeline optimization