@colbymchenry/codegraph 1.1.5 → 1.2.0

package/README.md

@@ -4,7 +4,7 @@
 
 ## 🎉 1.0 Released!
 
-Already installed? Run `codegraph upgrade` to update in place.
+Already installed? Run `codegraph upgrade`
 
 Follow [@getcodegraph](https://x.com/getcodegraph) on X for updates.
 

package/dist/db/index.d.ts

@@ -119,4 +119,24 @@ export declare const DATABASE_FILENAME = "codegraph.db";
  * Get the default database path for a project
  */
 export declare function getDatabasePath(projectRoot: string): string;
+/**
+ * Delete a database file and its WAL sidecars (`-wal`/`-shm`).
+ *
+ * This is how a FULL re-index discards an existing database — rather than
+ * opening the old graph and DELETE-ing every row. On a large or pre-fix
+ * poisoned index (e.g. an old graph that scanned an ignored gitlink corpus into
+ * ~1.6M nodes with a multi-GB WAL, #1065) the per-row `nodes_fts` delete-trigger
+ * churn blocks the main thread long enough to trip the #850 liveness watchdog
+ * before indexing even starts, so the rebuild could never recover the bad state
+ * (#1067). Unlinking is O(1) regardless of DB size and also reclaims the disk
+ * the bloated WAL would otherwise keep.
+ *
+ * POSIX removes the directory entry even while another process (a daemon/MCP
+ * server) still holds the file open; that holder heals via `reopenIfReplaced`
+ * (#925). On Windows a live holder can make the unlink fail with EBUSY/EPERM —
+ * that is thrown for the caller to surface ("stop the other process and retry").
+ * The `-wal`/`-shm` sidecars are best-effort: SQLite recreates them on the next
+ * open, so a leftover sidecar is harmless.
+ */
+export declare function removeDatabaseFiles(dbPath: string): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/extraction/languages/c-cpp.d.ts

@@ -47,5 +47,22 @@ export declare const cExtractor: LanguageExtractor;
  * so C's heavier use of `struct TAG var;` never reaches it.
  */
 export declare function blankCppExportMacros(source: string): string;
+export declare function blankCppInlineMacros(source: string): string;
+/**
+ * Universal fallback (any macro, no list) for a C/C++ function name still mangled
+ * because a macro we don't blank sat in front of the return type: `MACRO Ret
+ * name(…)` / `Ret MACRO name(…)` misparse so the return type is glued onto the
+ * name ("Ret name", "char_t* to_str(double v)"). Recover the real identifier —
+ * the token immediately before the parameter list (or the last token). This runs
+ * AFTER the curated pre-parse blank, so it only ever sees the residual tail that
+ * blanking didn't already fix cleanly (which also recovers the return type).
+ *
+ * Safe by construction: only touches an ALREADY-mangled name — one with an
+ * internal space that isn't a legit `operator …`/destructor — so a well-formed
+ * name is returned unchanged. Guarded against the two ways it could mis-pick:
+ * the `Ret (name)` parenthesized-name idiom (left as-is, ambiguous), and a token
+ * that is a bare primitive/keyword rather than a real identifier.
+ */
+export declare function recoverMangledCppName(name: string): string;
 export declare const cppExtractor: LanguageExtractor;
 //# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/tree-sitter-types.d.ts

@@ -114,6 +114,15 @@ export interface LanguageExtractor {
     returnField?: string;
     /** Override symbol name extraction (e.g. ObjC multi-part selectors). */
     resolveName?: (node: SyntaxNode, source: string) => string | undefined;
+    /**
+     * Post-process an already-extracted name to recover a real identifier from a
+     * name still mangled by a macro the pre-parse didn't blank (C/C++:
+     * `MACRO Ret name(` misparses to the name "Ret name"). Applied to every name
+     * this extractor produces, so it MUST be a no-op on a well-formed name — only
+     * C/C++ set it, because a mangled name there is unambiguous (an internal space),
+     * whereas e.g. Kotlin/Scala backtick identifiers legitimately contain spaces.
+     */
+    recoverMangledName?: (name: string) => string;
     /** Extract property name when the generic name walk fails (e.g. ObjC @property). */
     extractPropertyName?: (node: SyntaxNode, source: string) => string | null;
     /** Extract signature from node */
@@ -140,6 +149,14 @@ export interface LanguageExtractor {
     extraClassNodeTypes?: string[];
     /** Whether methods can be top-level without enclosing class (Go: true) */
     methodsAreTopLevel?: boolean;
+    /**
+     * Skip a bodiless class node as a forward declaration / elaborated type,
+     * mirroring the bodiless-struct/enum skip. Set only for languages where a
+     * bodiless `class` specifier is NOT a complete definition — C/C++
+     * (`class Foo;` is a forward decl). Leave unset for languages where a
+     * bodiless class IS complete (Kotlin `class Empty`, Scala `case object`). (#1093)
+     */
+    skipBodilessClass?: boolean;
     /** NodeKind to use for interface-like declarations (Rust: 'trait'). Default: 'interface' */
     interfaceKind?: NodeKind;
     /**

package/dist/index.d.ts

@@ -110,6 +110,23 @@ export declare class CodeGraph {
      * @returns A CodeGraph instance
      */
     static open(projectRoot: string, options?: OpenOptions): Promise<CodeGraph>;
+    /**
+     * Rebuild the project's database from scratch and return a fresh, empty
+     * instance — the "same result as a fresh init" semantics that `codegraph
+     * index` documents.
+     *
+     * Unlike `open()` followed by `clear()`, this DISCARDS the existing
+     * `.codegraph/codegraph.db` (and its `-wal`/`-shm` sidecars) before
+     * re-initializing, instead of opening the old database and DELETE-ing every
+     * row. On a large or pre-fix poisoned index — e.g. an old graph that scanned
+     * an ignored gitlink corpus (#1065) into ~1.6M nodes with a multi-GB WAL —
+     * the per-row `nodes_fts` delete-trigger churn blocks the main thread long
+     * enough to trip the #850 liveness watchdog before indexing even starts, so a
+     * full re-index could never recover the bad state (#1067). Discarding the
+     * files is O(1) regardless of size, reclaims the disk, and sidesteps opening
+     * (and running migrations against) the poisoned database entirely.
+     */
+    static recreate(projectRoot: string): Promise<CodeGraph>;
     /**
      * Open synchronously (without sync)
      */

package/dist/resolution/callback-synthesizer.d.ts

@@ -11,5 +11,5 @@ import type { ResolutionContext } from './types';
  * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
  * Returns the count added. Never throws into indexing — callers wrap in try/catch.
  */
-export declare function synthesizeCallbackEdges(queries: QueryBuilder, ctx: ResolutionContext): number;
+export declare function synthesizeCallbackEdges(queries: QueryBuilder, ctx: ResolutionContext): Promise<number>;
 //# sourceMappingURL=callback-synthesizer.d.ts.map

package/dist/resolution/cooperative-yield.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cooperative yielding for long synchronous resolution spans.
+ *
+ * Reference resolution and callback-edge synthesis run on the indexer's MAIN
+ * thread — unlike parsing, which is off-thread in the parse worker. The #850
+ * liveness watchdog (armed on `index`/`init` since #999) SIGKILLs the process
+ * when that thread doesn't turn its event loop for the timeout window (default
+ * 60s), because its heartbeat is a `setInterval` on that same thread. On a large
+ * repo, resolving refs + synthesizing dynamic-dispatch edges legitimately runs
+ * for minutes, so a span that never yields starves the heartbeat and the
+ * watchdog kills a VALID, in-progress index — the exact symptom of #1091 (the
+ * progress bar freezes at wherever it last rendered — 88% / 100% — then the
+ * process is killed).
+ *
+ * `createYielder` returns a `maybeYield()` that yields (via `setImmediate`) only
+ * once more than `budgetMs` of wall-clock has elapsed since the last yield, so
+ * fast repos pay essentially nothing while slow ones give the heartbeat a
+ * regular window to fire. Call it at natural boundaries in a long loop (between
+ * batches, between synthesis passes).
+ *
+ * This does NOT weaken the watchdog. A genuinely wedged loop — an infinite or
+ * non-terminating span, the case the watchdog exists to catch — never reaches a
+ * yield point, so the heartbeat still stops and the SIGKILL still fires. We only
+ * stop killing work that is demonstrably making progress.
+ */
+/** Yield when more than `budgetMs` of wall-clock has passed since the last yield. */
+export type MaybeYield = () => Promise<void>;
+/** Default budget: well under the watchdog's minimum heartbeat cadence (~1s), so
+ * a heartbeat byte always has a chance to land between yields. */
+export declare const DEFAULT_YIELD_BUDGET_MS = 250;
+export declare function createYielder(budgetMs?: number): MaybeYield;
+//# sourceMappingURL=cooperative-yield.d.ts.map

package/dist/resolution/index.d.ts

@@ -103,7 +103,16 @@ export declare class ReferenceResolver {
      * (re-resolving an already-resolved ref is a no-op since it's been deleted).
      * Returns the number of newly-created edges.
      */
-    resolveChainedCallsViaConformance(): number;
+    resolveChainedCallsViaConformance(): Promise<number>;
+    /**
+     * Resolve one batch in smaller sub-chunks, yielding to the event loop between
+     * them so the #850 liveness heartbeat can fire on a slow/dense batch (#1091).
+     * Behaviourally identical to a single `resolveAll(batch)`: `warmCaches()` is
+     * idempotent (guarded) and `resolveOne` is independent per ref, so splitting
+     * and re-merging changes only timing, never which edges get created. Falls
+     * through to a plain `resolveAll` when the batch is already small.
+     */
+    private resolveBatchYielding;
     /**
      * Resolve and persist in batches to keep memory bounded.
      * Processes unresolved references in chunks, persisting edges and cleaning
@@ -172,7 +181,7 @@ export declare class ReferenceResolver {
      * Mirrors resolveChainedCallsViaConformance's lifecycle. Returns the number
      * of newly-created edges.
      */
-    resolveDeferredThisMemberRefs(): number;
+    resolveDeferredThisMemberRefs(): Promise<number>;
     private gateLanguage;
     /**
      * Drop a FRAMEWORK-strategy resolution that crosses two *known* language

package/dist/resolution/name-matcher.d.ts

@@ -3,6 +3,7 @@
  *
  * Handles symbol name matching for reference resolution.
  */
+import { Node } from '../types';
 import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types';
 /**
  * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
@@ -47,6 +48,27 @@ export declare function matchByExactName(ref: UnresolvedRef, context: Resolution
  * Try to resolve by qualified name
  */
 export declare function matchByQualifiedName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * When a symbol name is ambiguous across files, prefer the candidate(s) declared
+ * in the call site's own file, keeping the rest in their original order (#1079).
+ * A same-file definition is the strongest language-agnostic signal for which of
+ * several same-named symbols a call means; without it, resolution collapses onto
+ * whichever was indexed first, so a call in `b/svc` wrongly targets `a/svc`.
+ * No-op when there are <2 candidates or none share the call site's file.
+ */
+export declare function preferCallSiteFile(nodes: Node[], callSiteFile: string): Node[];
+export declare function resolveMethodOnType(typeName: string, methodName: string, ref: UnresolvedRef, context: ResolutionContext, confidence: number, resolvedBy: ResolvedRef['resolvedBy'], 
+/**
+ * Optional FQN that identifies WHICH class declaration `typeName`
+ * refers to in the caller's file. When multiple candidates share
+ * the same qualifiedName (`FooConverter::convert` in both
+ * `dao/converter/` and `service/converter/`), the FQN's
+ * file-path-suffix picks the right one — the disambiguation
+ * signal Java imports carry but the call site doesn't (#314).
+ */
+preferredFqn?: string, 
+/** Recursion guard for the supertype/conformance walk. */
+depth?: number): ResolvedRef | null;
 /**
  * Resolve a C++ chained call whose receiver is itself a call — encoded by the
  * extractor as `<innerCallee>().<method>` (#645). The receiver's type is what

package/npm-shim.js

@@ -45,7 +45,7 @@ async function main() {
   // Happy path: the npm-installed optional dependency. Fall back to a download
   // when the registry didn't deliver it.
   var resolved = resolveInstalledBundle() || (await selfHealBundle());
-  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit' });
+  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit', windowsHide: true });
   if (res.error) {
     process.stderr.write('codegraph: ' + res.error.message + '\n');
     process.exit(1);
@@ -105,7 +105,7 @@ async function selfHealBundle() {
   // Already downloaded by a previous run? Use it even when downloads are
   // disabled — CODEGRAPH_NO_DOWNLOAD blocks fetching, not a cached bundle.
   var cached = launcherIn(dest);
-  if (cached) return cached;
+  if (cached) { pruneOldBundles(bundlesDir, dest); return cached; }
 
   if (process.env.CODEGRAPH_NO_DOWNLOAD) {
     fail('the network fallback is disabled (CODEGRAPH_NO_DOWNLOAD is set).');
@@ -149,6 +149,7 @@ async function selfHealBundle() {
 
   var ready = launcherIn(dest);
   if (!ready) fail('downloaded bundle is missing its launcher under ' + dest + '.');
+  pruneOldBundles(bundlesDir, dest);
   process.stderr.write('codegraph: bundle ready.\n');
   return ready;
 }
@@ -221,7 +222,7 @@ function extract(archive, destDir) {
   var args = isWindows
     ? ['-xf', archive, '-C', destDir, '--strip-components=1']
     : ['-xzf', archive, '-C', destDir, '--strip-components=1'];
-  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore' });
+  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore', windowsHide: true });
   if (res.error) throw new Error('tar unavailable: ' + res.error.message);
   if (res.status !== 0) throw new Error('tar exited ' + res.status);
 }
@@ -230,6 +231,27 @@ function rmrf(p) {
   try { fs.rmSync(p, { recursive: true, force: true }); } catch (e) { /* best effort */ }
 }
 
+// Drop sibling bundles for OTHER versions of this same platform target, keeping
+// only keepDir. The self-heal cache otherwise accumulates a full ~50 MB bundle
+// per version forever (issue #1074). Best-effort: a locked/busy dir (a
+// concurrent run still mapping an older node.exe on Windows) just stays — rmrf
+// already swallows its own errors, and the readdir is guarded — so cleanup can
+// never break a working command. Only this target's "<target>-<version>" dirs
+// are touched; other platforms' bundles and the ".dl-*" staging dirs are left
+// alone.
+function pruneOldBundles(bundlesDir, keepDir) {
+  var keep = path.basename(keepDir);
+  try {
+    var names = fs.readdirSync(bundlesDir);
+    for (var i = 0; i < names.length; i++) {
+      var name = names[i];
+      if (name === keep) continue;
+      if (name.indexOf(target + '-') !== 0) continue;
+      rmrf(path.join(bundlesDir, name));
+    }
+  } catch (e) { /* best effort — never break a working run over cleanup */ }
+}
+
 function fail(reason) {
   process.stderr.write(
     'codegraph: no prebuilt bundle for ' + target + '.\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
   "bin": {
     "codegraph": "npm-shim.js"
@@ -15,12 +15,12 @@
     "./package.json": "./package.json"
   },
   "optionalDependencies": {
-    "@colbymchenry/codegraph-darwin-arm64": "1.1.5",
-    "@colbymchenry/codegraph-darwin-x64": "1.1.5",
-    "@colbymchenry/codegraph-linux-arm64": "1.1.5",
-    "@colbymchenry/codegraph-linux-x64": "1.1.5",
-    "@colbymchenry/codegraph-win32-arm64": "1.1.5",
-    "@colbymchenry/codegraph-win32-x64": "1.1.5"
+    "@colbymchenry/codegraph-darwin-arm64": "1.2.0",
+    "@colbymchenry/codegraph-darwin-x64": "1.2.0",
+    "@colbymchenry/codegraph-linux-arm64": "1.2.0",
+    "@colbymchenry/codegraph-linux-x64": "1.2.0",
+    "@colbymchenry/codegraph-win32-arm64": "1.2.0",
+    "@colbymchenry/codegraph-win32-x64": "1.2.0"
   },
   "files": [
     "npm-shim.js",