@colbymchenry/codegraph 1.3.0 → 1.3.1

package/dist/db/index.d.ts

@@ -73,8 +73,8 @@ export declare class DatabaseConnection {
      */
     optimize(): void;
     /**
-     * Lightweight, non-blocking maintenance to run after bulk writes
-     * (indexAll, sync). Two operations:
+     * Lightweight maintenance to run after bulk writes (indexAll, sync).
+     * Two operations:
      *
      *   - `PRAGMA optimize` — incremental ANALYZE; SQLite only re-analyzes
      *     tables whose row counts changed materially since the last
@@ -86,10 +86,22 @@ export declare class DatabaseConnection {
      *     unboundedly between automatic checkpoints (auto-fires at 1000
      *     pages by default; large indexAll runs blow past that).
      *
-     * Both operations are silently swallowed on failure — they're a
-     * best-effort optimization, never load-bearing for correctness.
+     * Runs on a WORKER THREAD with its own connection: on a multi-GB index
+     * these pragmas are minutes of synchronous IO (a 95k-file kernel index
+     * left a 593MB WAL whose checkpoint alone blew the #850 watchdog's 60s
+     * window and got a COMPLETED index SIGKILLed at the finish line). WAL
+     * checkpointing from a second connection is standard SQLite; `PRAGMA
+     * optimize` persists its statistics in sqlite_stat tables, so the main
+     * connection benefits the same. The main thread just awaits a message,
+     * so the event loop — and the watchdog heartbeat — keep turning.
+     *
+     * Everything is silently swallowed on failure — best-effort
+     * optimization, never load-bearing for correctness. If worker threads
+     * are unavailable, falls back to a bounded in-line `PRAGMA optimize`
+     * and SKIPS the checkpoint (the final close() checkpoints after the
+     * CLI has already disarmed its watchdog).
      */
-    runMaintenance(): void;
+    runMaintenance(): Promise<void>;
     /**
      * Close the database connection
      */

package/dist/db/queries.d.ts

@@ -4,7 +4,7 @@
  * Prepared statements for CRUD operations on the knowledge graph.
  */
 import { SqliteDatabase } from './sqlite-adapter';
-import { Node, Edge, FileRecord, UnresolvedReference, NodeKind, EdgeKind, GraphStats, SearchOptions, SearchResult } from '../types';
+import { Node, Edge, FileRecord, UnresolvedReference, NodeKind, EdgeKind, Language, GraphStats, SearchOptions, SearchResult } from '../types';
 /**
  * Query builder for the knowledge graph database
  */
@@ -198,6 +198,23 @@ export declare class QueryBuilder {
      * Get all nodes in the database
      */
     getAllNodes(): Node[];
+    /**
+     * Stream nodes of one language whose `decorators` JSON array contains
+     * `decorator`. The LIKE on the JSON text is a cheap index-free pre-filter
+     * (a decorator name can appear as a substring of another), so callers must
+     * still exact-check `node.decorators.includes(decorator)`. Exists so the
+     * kotlin expect/actual synthesizer never materializes the whole node table
+     * the way `getAllNodes().filter(...)` did — that array alone OOM'd Node's
+     * default heap on a 2M-node graph (#1212).
+     */
+    iterateNodesByLanguageWithDecorator(language: Language, decorator: string): IterableIterator<Node>;
+    /**
+     * Distinct languages present in the files table. One indexed aggregate —
+     * lets the dynamic-edge synthesizers skip passes for languages the project
+     * doesn't contain at all (a Kotlin pass has no work on a pure-C repo), so
+     * their cost is zero rather than a full-graph scan that finds nothing (#1212).
+     */
+    getDistinctFileLanguages(): Set<string>;
     /**
      * Get nodes by exact name match (uses idx_nodes_name index)
      */
@@ -395,6 +412,13 @@ export declare class QueryBuilder {
      * Get all distinct node names (lightweight — just name strings for pre-filtering)
      */
     getAllNodeNames(): string[];
+    /**
+     * Stream the distinct node names one row at a time — the incremental
+     * counterpart to {@link getAllNodeNames} for callers that need to yield
+     * to the event loop mid-scan (resolver cache warm-up on multi-million-node
+     * indexes). Fresh statement per call: the iterator holds an open cursor.
+     */
+    iterateNodeNames(): IterableIterator<string>;
     /**
      * Get unresolved references scoped to specific file paths.
      * Uses the idx_unresolved_file_path index for efficient lookup.

package/dist/mcp/query-pool.d.ts

@@ -81,6 +81,20 @@ export declare class QueryPool {
      * degrades to today's behavior instead of failing tool calls.
      */
     get healthy(): boolean;
+    /**
+     * True once at least one worker has completed its cold start (posted the
+     * 'ready' handshake). Until then the ToolHandler serves calls IN-PROCESS:
+     * a worker cold start is a full module load + DB open — seconds normally,
+     * tens of seconds on a loaded machine — and a call queued behind it gets
+     * nothing until the 45s busy backstop. The daemon's very first tool call
+     * hitting that window was the recurring #662 test flake (and a real
+     * first-call stall for agents). The pool exists for CONCURRENT load, which
+     * by definition arrives after warm-up; the pre-pool in-process path is
+     * strictly better while nothing is warm. Stays true for the pool's
+     * lifetime — later crash-respawn gaps are covered by retry + backstop.
+     */
+    get ready(): boolean;
+    private everReady;
     private spawnOne;
     private onMessage;
     private onWorkerGone;

package/dist/resolution/c-fnptr-synthesizer.d.ts

@@ -1,5 +1,6 @@
 import type { Edge } from '../types';
 import type { QueryBuilder } from '../db/queries';
 import type { ResolutionContext } from './types';
-export declare function cFnPointerDispatchEdges(queries: QueryBuilder, ctx: ResolutionContext): Edge[];
+import type { MaybeYield } from './cooperative-yield';
+export declare function cFnPointerDispatchEdges(_queries: QueryBuilder, ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]>;
 //# sourceMappingURL=c-fnptr-synthesizer.d.ts.map

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

@@ -24,5 +24,6 @@
  */
 import type { Edge } from '../types';
 import type { ResolutionContext } from './types';
-export declare function goframeRouteEdges(ctx: ResolutionContext): Edge[];
+import type { MaybeYield } from './cooperative-yield';
+export declare function goframeRouteEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]>;
 //# sourceMappingURL=goframe-synthesizer.d.ts.map

package/dist/resolution/index.d.ts

@@ -6,6 +6,7 @@
 import { UnresolvedReference, Edge } from '../types';
 import { QueryBuilder } from '../db/queries';
 import { UnresolvedRef, ResolvedRef, ResolutionResult } from './types';
+import { type MaybeYield } from './cooperative-yield';
 export * from './types';
 /**
  * Reference Resolver
@@ -57,6 +58,15 @@ export declare class ReferenceResolver {
      * We cache the set of known symbol names for fast pre-filtering.
      */
     warmCaches(): void;
+    /**
+     * warmCaches for the async resolution entry points: streams the distinct
+     * name set with periodic yields instead of one synchronous `.all()`. On a
+     * multi-million-node index the DISTINCT scan is a solid multi-second block
+     * (measured up to 28s inside `codegraph sync` on the Linux kernel index),
+     * long enough to matter to the #850 watchdog on slower hardware. Same
+     * result, same memory — only the event loop keeps turning.
+     */
+    warmCachesYielding(onYield: MaybeYield): Promise<void>;
     /**
      * Clear internal caches
      */

package/dist/resolution/types.d.ts

@@ -66,6 +66,15 @@ export interface ResolutionContext {
     getNodesByQualifiedName(qualifiedName: string): Node[];
     /** Get all nodes of a kind */
     getNodesByKind(kind: Node['kind']): Node[];
+    /**
+     * Stream nodes of a kind one at a time instead of materializing (and, unlike
+     * `getNodesByKind`, without populating the resolver's per-kind array cache).
+     * For unbounded kinds (`function`, `method`, `struct`) on a symbol-dense
+     * project the full array is gigabytes — the dynamic-edge synthesizers must
+     * use this so their memory stays O(1) in node count (#610, #1212). Optional
+     * so minimal test contexts compile; callers fall back to getNodesByKind.
+     */
+    iterateNodesByKind?(kind: Node['kind']): IterableIterator<Node>;
     /** Check if a file exists */
     fileExists(filePath: string): boolean;
     /** Read file content */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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.3.0",
-    "@colbymchenry/codegraph-darwin-x64": "1.3.0",
-    "@colbymchenry/codegraph-linux-arm64": "1.3.0",
-    "@colbymchenry/codegraph-linux-x64": "1.3.0",
-    "@colbymchenry/codegraph-win32-arm64": "1.3.0",
-    "@colbymchenry/codegraph-win32-x64": "1.3.0"
+    "@colbymchenry/codegraph-darwin-arm64": "1.3.1",
+    "@colbymchenry/codegraph-darwin-x64": "1.3.1",
+    "@colbymchenry/codegraph-linux-arm64": "1.3.1",
+    "@colbymchenry/codegraph-linux-x64": "1.3.1",
+    "@colbymchenry/codegraph-win32-arm64": "1.3.1",
+    "@colbymchenry/codegraph-win32-x64": "1.3.1"
   },
   "files": [
     "npm-shim.js",