@colbymchenry/codegraph 1.1.6 → 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/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/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);
@@ -222,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);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.1.6",
+  "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.6",
-    "@colbymchenry/codegraph-darwin-x64": "1.1.6",
-    "@colbymchenry/codegraph-linux-arm64": "1.1.6",
-    "@colbymchenry/codegraph-linux-x64": "1.1.6",
-    "@colbymchenry/codegraph-win32-arm64": "1.1.6",
-    "@colbymchenry/codegraph-win32-x64": "1.1.6"
+    "@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",