v0.15.0

Full Changelog: v0.14.0...v0.15.0

v0.14.0

Full Changelog: v0.13.0...v0.14.0

v0.13.0

A curated sync with upstream DeusData/codebase-memory-mcp, plus the store-integrity cluster the previous pass deferred.

Correctness

• Corruption is no longer silent. Every store row-scan loop discarded the terminal sqlite3_step code, so SQLITE_CORRUPT mid-scan was indistinguishable from a clean end of results. Counts answered from covering indexes stayed correct while row fetches died at the first corrupt page — so search returned total=379 with results=[], Cypher counts diverged from schema counts, and BM25 returned total=0, all with no error anywhere. All 31 scan loops now fail loudly with CBM_STORE_ERR.
• Cypher variable-length paths use shortest-path semantics. The BFS recursive CTE deduped (node, hop) pairs, so a single self-loop minted every hop level for every node it could reach — *k..k matched fabricated walks of arbitrary length and the row set exploded to nodes × depth. MIN(hop) GROUP BY now returns each node once at its minimal distance.
• A clamped hop range is advertised. Exceeding the engine ceiling used to be indistinguishable from "no such path"; it now surfaces as a warning on the result.

Data safety

• Stale WAL sidecars can no longer corrupt a fresh database. Three paths installed a new DB generation without removing the destination's -wal/-shm. SQLite validates a WAL against the sidecar's own header, not the main file, so a crashed session's leftover WAL was replayed on top of the newly installed file.
• The page writer publishes atomically. It now builds into a sibling temp generation and installs it by fsync + atomic replace, so the live database stays intact through every error path.
• Artifact export snapshots consistently. The fast path (watcher / incremental auto-update) read the raw bytes of a live WAL-mode store — committed rows still in the -wal were missing and mid-checkpoint reads produced torn snapshots that imported as corrupt caches. Both quality levels now snapshot via VACUUM INTO, and import refuses page-corrupted artifacts via PRAGMA quick_check. The fast path pays a full consistent copy: a deliberate speed-for-correctness trade, since teammates pull these.

Features

• get_architecture gains an opt-in cycles aspect — circular call dependencies via iterative Tarjan SCC condensation (heap stacks, no recursion overflow). Opt-in only, never via all or overview, because it scans the whole call graph.
• detect_changes now performs real blast-radius analysis. It previously parsed and echoed depth without ever traversing — "impacted" was just the symbols defined in the changed files. It now resolves the diff to those symbols and runs one multi-source traversal to the transitive impact set, with a module rollup and an exact impacted_total. Seeds are excluded, so a changed file reached from another changed file is not counted as extra impact.
• get_code_snippet caps whole-file spans at 500 lines with source_clipped. A structural Module/File node spans its entire file, so an unclipped read could return hundreds of KB in a single call.

Robustness

• GLR stack-merge recursion bounded at 512 frames, preventing a native stack overflow during parsing of deeply nested ambiguous input.
• Windows thread heaps released via a TLS detach callback — a static MinGW link has no DllMain, so every thread previously leaked its allocator heap.

Verification

5641 tests passing; clang-format, cppcheck and the NOLINT gate clean; the 7-layer security audit, smoke test, and an index-determinism check all green. The corruption fix was additionally proven RED-on-revert: neutralising all 31 guards reproduces the exact reported symptom.

Full changelog: v0.12.0...v0.13.0

v0.12.0

v0.12.0 — graph-correctness sync with upstream

A curated port of 17 upstream commits from DeusData/codebase-memory-mcp
(8d00f4b..97ce23f), scoped to C++, Python and Go indexing correctness, plus one
fork-specific regression found while porting. Every fix below is verified by tests and by
indexing real fixtures with the release binary.

Full test suite: 5626 passed / 0 failed (+11 ported regression guards).

If you index anything larger than 50 files, re-index after upgrading

Several of these fixes change the graph the indexer produces. The parallel pipeline (the
default above 50 files) was dropping edges that the sequential one kept, so existing graphs
are incomplete rather than wrong-but-consistent. delete_project + re-index to pick up the
corrected edges.

Call-graph completeness

• Parallel-path CALLS edges restored — the registry fallback ran only when no LSP
  resolution existed, so an LSP resolution whose target wasn't a graph node dropped the edge
  outright. Upstream measured ~21% of a Next.js call graph lost this way. Parallel is the
  default above 50 files, so the default index was the affected one. (upstream 8c39465)
• Reason-keyed LSP strategies restored on the default path — a fork-only regression: this
  fork had made the per-file O(1) LSP index authoritative and dropped the linear rescan that
  reason-keyed strategies join through. lsp_func_ptr, lsp_dll_resolve, lsp_destructor,
  lsp_dict_dispatch, lsp_method_ref_ctor{,_synth} and php_method_dynamic were all
  silently dropped whenever the parallel path ran. Measured on a 61-file project: 1096
  edges with the fix, 1036 without.
• Python aliased imports — from m import f as g; g() produced no CALLS edge at all.
  Now resolved via a new lsp_import_alias strategy. (upstream d322548)
• imported.method() no longer collapses to the imported symbol — the aliased
  direct-symbol import shortcut fired before suffix handling and bound the call to the
  symbol's own node. Upstream measured this degrading Django by ~11K edges (CALLS
  74,685→72,175, TESTS 38,032→29,236). (upstream 89e1c47 + afcce2d)

IMPLEMENTS / INHERITS / OVERRIDE

• IMPLEMENTS vs INHERITS is now one decision in both pipelines, keyed off the resolved
  base node's label. The parallel path hardcoded INHERITS and demoted every explicit
  implements at scale — upstream measured elasticsearch going from 3 to 11,182 IMPLEMENTS.
• New OVERRIDE edges for explicit-inheritance languages (Java, TypeScript, C#, Kotlin,
  PHP): a class method is linked to the base method it redefines, for both interfaces and
  superclasses. Go keeps its implicit-satisfaction path and is excluded so it isn't
  double-covered. (both upstream 4a3aac6)

C/C++

• Definitions split across #ifdef/#else braces are recovered. A function whose body
  braces open in each branch with one shared close is unparseable in raw form, and was
  silently dropped while its callers stayed unresolved. Recovered from the preprocessed pass
  and remapped to original lines, with every line verified to belong to the main file so
  header-inlined definitions and macro-generated callables fail closed. (upstream 65a176e,
  99d3919)
• Headers get their own File node. Extension stripping applied to File QNs too, so
  NodeController.h and NodeController.cpp collided and the header ended up with no node.
  Also fixes .env / .env.local / .env.production collapsing to one node. (upstream
  751752b)
• #include resolves to the header rather than a same-stem source or module node.
  (upstream 632fd08)
• No more false parse gaps from macro calls — ALLOC(int, n)-style function-like macro
  invocations make the grammar emit an ERROR node, which was reported as a parse_partial
  coverage gap even though nothing was missing. Top-level invocations that expand to
  definitions stay flagged. (upstream a75f4b6)

Go / Java

• Directory-module collision guard — a class-level env access or throws in a
  package-per-directory language falls back to the module QN, which collides with the shared
  Folder node and conflated every such edge. (upstream 6b2cd08)

Reliability

• Wide repositories index completely. A directory with more than 512 immediate
  subdirectories silently dropped every subdirectory past the walk-stack cap — the fan-out
  just vanished from the index with no error. dotnet/runtime has 855 sibling dirs in one
  folder. The stack now grows on demand. (upstream 03dc9c9)
• Runaway Cypher queries abort instead of hanging. An unbounded OPTIONAL MATCH or a
  whole-graph GROUP BY produces no rows, so the 100k row ceiling never fired and
  query_graph hung indefinitely. Now bounded by a 30s wall-clock deadline with an
  actionable error. (upstream 6bd11ff)
• Second-index crash fixed — a SIGABRT (free of a non-libmalloc pointer in
  ts_stack_delete) when a sequential index run preceded a parallel one in the same process.
  (upstream 2f7befb)
• Incremental re-index no longer diverges from a full index — the incremental path named
  File nodes by relative path while the full pipeline used the basename, so an incremental
  re-index renamed the node in place and name-based traversal dead-ended at every touched
  file. (upstream 2833ef5)

Extraction

• UTF-8 docstring truncation no longer cuts mid-codepoint. (upstream 3ebcf48)
• body_tokens are populated before the MinHash gate, so short functions still get
  semantic-search tokens; token buffer and identifier caps widened. (upstream b9797ec)

Not included

This is a deliberately scoped sync. The upstream shared-coordination daemon, the MCP
tree-format output migration, ObjectScript and Perl language support, the Windows
launcher/install-transaction work, and the store-integrity cluster were not ported — see
UPSTREAM_SYNC.md
for the full ported/skipped breakdown and the fork-side deviations.

Upstream credit: the original engine and design are by
DeusData/codebase-memory-mcp.

v0.11.0

Full Changelog: v0.10.0...v0.11.0

v0.10.0

Highlights

• Deterministic indexing is now a release guarantee: repeated full indexes now produce byte-identical graphs across redis, rocksdb, and etcd. This closes the remaining worker-order leaks in graph-buffer indexes, import fallback resolution, semantic edge budgeting, and SIMILAR_TO direction selection.
• C++ indexing is substantially faster. This release adds hash-indexed Rust/Python/Go LSP registry lookups, removes redundant per-miss LSP rescans, adds a 4-gram config-key index, and speeds graph-buffer integer keys. The README benchmark table was refreshed with current measurements: rocksdb ~6s, django ~4s, redis ~2s, etcd ~1.3s.
• Cypher correctness is improved for real graph queries: bound-variable joins now behave as joins instead of cross products, OPTIONAL MATCH preserves input rows correctly, COUNT skips nulls, all-null MIN/MAX/AVG return null, dynamic binding growth avoids fixed preallocation OOMs, and intermediate caps now warn instead of silently truncating.
• C/C++ resolver stability improved by stopping resolve workers from mutating the shared Tier-2 cross registry, eliminating a class of use-after-free crashes and dangling arena pointers.

Validation

• Release workflow run 28751569769 passed: lint, static security, CodeQL gate, full test matrix, all platform builds, smoke, quick soak, binary verification, and publish.
• Published artifacts include SHA-256 checksums, SBOM, and cosign provenance/signature bundles.
• The registry manifest was synced in main at 4f28633 using the actual v0.10.0 artifact checksums.

Artifacts

Standard MCP packages are published for:

• macOS arm64 and amd64
• Linux amd64 and arm64 portable
• Windows amd64

UI-enabled artifacts are also published for macOS, Linux, and Windows.

Full Changelog: v0.9.0...v0.10.0

v0.9.0

Full Changelog: v0.8.3...v0.9.0

v0.8.3

Full Changelog: v0.8.2...v0.8.3

v0.8.2

Full Changelog: v0.7.0...v0.8.2

v0.7.0

C++23 build of the codebase-memory-mcp fork, synced to upstream DeusData/codebase-memory-mcp@d0e1e77 (post-v0.7.0).

Standard binaries for darwin (arm64/amd64), linux (arm64/amd64), and windows (amd64), built by CI from main. Integrity: verify against checksums.txt.

Install:

curl -fsSL https://raw.githubusercontent.com/tigercosmos/cpp-codebase-memory-mcp/main/install.sh | bash

Note: these binaries report --version dev (the push-CI build is not version-stamped); the code is the v0.7.0 fork (main).