@bharanidev/bhgraph-darwin-x64 1.0.0

package/lib/dist/db/migrations.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Database Migrations
+ *
+ * Schema versioning and migration support.
+ */
+import { SqliteDatabase } from './sqlite-adapter';
+/**
+ * Current schema version
+ */
+export declare const CURRENT_SCHEMA_VERSION = 7;
+/**
+ * Migration definition
+ */
+interface Migration {
+    version: number;
+    description: string;
+    up: (db: SqliteDatabase) => void;
+}
+/**
+ * Get the current schema version from the database
+ */
+export declare function getCurrentVersion(db: SqliteDatabase): number;
+/**
+ * Run all pending migrations
+ */
+export declare function runMigrations(db: SqliteDatabase, fromVersion: number): void;
+/**
+ * Check if the database needs migration
+ */
+export declare function needsMigration(db: SqliteDatabase): boolean;
+/**
+ * Get list of pending migrations
+ */
+export declare function getPendingMigrations(db: SqliteDatabase): Migration[];
+/**
+ * Get migration history from database
+ */
+export declare function getMigrationHistory(db: SqliteDatabase): Array<{
+    version: number;
+    appliedAt: number;
+    description: string | null;
+}>;
+export {};
+//# sourceMappingURL=migrations.d.ts.map

package/lib/dist/db/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/db/migrations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;GAEG;AACH,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,CAAC;CAClC;AAuGD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,CAU5D;AAWD;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAiB3E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAG1D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,cAAc,GAAG,SAAS,EAAE,CAKpE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,cAAc,GACjB,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAU3E"}

package/lib/dist/db/migrations.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Database Migrations
+ *
+ * Schema versioning and migration support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_SCHEMA_VERSION = void 0;
+exports.getCurrentVersion = getCurrentVersion;
+exports.runMigrations = runMigrations;
+exports.needsMigration = needsMigration;
+exports.getPendingMigrations = getPendingMigrations;
+exports.getMigrationHistory = getMigrationHistory;
+/**
+ * Current schema version
+ */
+exports.CURRENT_SCHEMA_VERSION = 7;
+/**
+ * All migrations in order
+ *
+ * Note: Version 1 is the initial schema, handled by schema.sql
+ * Future migrations go here.
+ */
+const migrations = [
+    {
+        version: 2,
+        description: 'Add project metadata, provenance tracking, and unresolved ref context',
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS project_metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+        ALTER TABLE unresolved_refs ADD COLUMN file_path TEXT NOT NULL DEFAULT '';
+        ALTER TABLE unresolved_refs ADD COLUMN language TEXT NOT NULL DEFAULT 'unknown';
+        ALTER TABLE edges ADD COLUMN provenance TEXT DEFAULT NULL;
+        CREATE INDEX IF NOT EXISTS idx_unresolved_file_path ON unresolved_refs(file_path);
+        CREATE INDEX IF NOT EXISTS idx_edges_provenance ON edges(provenance);
+      `);
+        },
+    },
+    {
+        version: 3,
+        description: 'Add lower(name) expression index for memory-efficient case-insensitive lookups',
+        up: (db) => {
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_nodes_lower_name ON nodes(lower(name));
+      `);
+        },
+    },
+    {
+        version: 4,
+        description: 'Drop redundant idx_edges_source / idx_edges_target (covered by source_kind / target_kind composites)',
+        up: (db) => {
+            db.exec(`
+        DROP INDEX IF EXISTS idx_edges_source;
+        DROP INDEX IF EXISTS idx_edges_target;
+      `);
+        },
+    },
+    {
+        version: 5,
+        description: 'Add nodes.return_type — normalized return/result type for receiver-type inference (C++ singletons/factories, #645)',
+        up: (db) => {
+            db.exec(`
+        ALTER TABLE nodes ADD COLUMN return_type TEXT;
+      `);
+        },
+    },
+    {
+        version: 6,
+        description: 'Dedup duplicate edge rows and add a UNIQUE identity index so INSERT OR IGNORE actually dedups (#1034)',
+        up: (db) => {
+            // `insertEdge` has always used `INSERT OR IGNORE`, but the edges table had
+            // no UNIQUE constraint, so nothing conflicted and byte-identical rows
+            // accumulated whenever two passes emitted the same edge. Collapse each
+            // identity group to its lowest id, then add the constraint that makes
+            // `OR IGNORE` keep its promise. IFNULL folds nullable line/col so
+            // coordinate-less edges dedup too (SQLite treats each NULL as distinct) —
+            // and it MUST match the GROUP BY exactly, or the index creation would
+            // fail on a pair the DELETE left behind. Idempotent: the index is
+            // `IF NOT EXISTS` and the DELETE is a no-op once the table is unique.
+            db.exec(`
+        DELETE FROM edges
+        WHERE id NOT IN (
+          SELECT MIN(id) FROM edges
+          GROUP BY source, target, kind, IFNULL(line, -1), IFNULL(col, -1)
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_edges_identity
+          ON edges(source, target, kind, IFNULL(line, -1), IFNULL(col, -1));
+      `);
+        },
+    },
+    {
+        version: 7,
+        description: 'Add name_segment_vocab — prose-word → symbol-name lookup for the prompt hook’s graph-derived gate',
+        up: (db) => {
+            // DDL only — instant on any size database (the row-churn hazards of #1067
+            // don't apply). The table starts EMPTY on migrated databases; `sync`
+            // detects that over a populated graph and backfills batched+yielding
+            // (BHGraph.rebuildNameSegmentVocab), and any full index rebuilds it
+            // from scratch. Keep the definition in lockstep with schema.sql.
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS name_segment_vocab (
+          segment TEXT NOT NULL,
+          name TEXT NOT NULL,
+          PRIMARY KEY (segment, name)
+        ) WITHOUT ROWID;
+      `);
+        },
+    },
+];
+/**
+ * Get the current schema version from the database
+ */
+function getCurrentVersion(db) {
+    try {
+        const row = db
+            .prepare('SELECT MAX(version) as version FROM schema_versions')
+            .get();
+        return row?.version ?? 0;
+    }
+    catch {
+        // Table doesn't exist yet
+        return 0;
+    }
+}
+/**
+ * Record a migration as applied
+ */
+function recordMigration(db, version, description) {
+    db.prepare('INSERT INTO schema_versions (version, applied_at, description) VALUES (?, ?, ?)').run(version, Date.now(), description);
+}
+/**
+ * Run all pending migrations
+ */
+function runMigrations(db, fromVersion) {
+    const pending = migrations.filter((m) => m.version > fromVersion);
+    if (pending.length === 0) {
+        return;
+    }
+    // Sort by version
+    pending.sort((a, b) => a.version - b.version);
+    // Run each migration in a transaction
+    for (const migration of pending) {
+        db.transaction(() => {
+            migration.up(db);
+            recordMigration(db, migration.version, migration.description);
+        })();
+    }
+}
+/**
+ * Check if the database needs migration
+ */
+function needsMigration(db) {
+    const current = getCurrentVersion(db);
+    return current < exports.CURRENT_SCHEMA_VERSION;
+}
+/**
+ * Get list of pending migrations
+ */
+function getPendingMigrations(db) {
+    const current = getCurrentVersion(db);
+    return migrations
+        .filter((m) => m.version > current)
+        .sort((a, b) => a.version - b.version);
+}
+/**
+ * Get migration history from database
+ */
+function getMigrationHistory(db) {
+    const rows = db
+        .prepare('SELECT version, applied_at, description FROM schema_versions ORDER BY version')
+        .all();
+    return rows.map((row) => ({
+        version: row.version,
+        appliedAt: row.applied_at,
+        description: row.description,
+    }));
+}
+//# sourceMappingURL=migrations.js.map

package/lib/dist/db/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.js","sourceRoot":"","sources":["../../src/db/migrations.ts"],"names":[],"mappings":"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"}

package/lib/dist/db/queries.d.ts

@@ -0,0 +1,452 @@
+/**
+ * Database Queries
+ *
+ * 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';
+/**
+ * Query builder for the knowledge graph database
+ */
+export declare class QueryBuilder {
+    private db;
+    private projectNameTokens;
+    private nodeCache;
+    private readonly maxCacheSize;
+    private stmts;
+    private segmentedNames;
+    private static readonly MAX_SEGMENTED_NAMES;
+    constructor(db: SqliteDatabase);
+    /** Set the normalized project-name tokens used to down-weight non-discriminative
+     * query words in path scoring (#720). Called once when the project opens. */
+    setProjectNameTokens(tokens: Set<string>): void;
+    /** The normalized project-name tokens (#720); empty if none were derived. */
+    getProjectNameTokens(): Set<string>;
+    /**
+     * Insert a new node
+     */
+    insertNode(node: Node): void;
+    /** Which node kinds contribute their name to the segment vocabulary — the
+     *  single gate shared by insertNode, updateNode, and the rebuild page query
+     *  (getDistinctNodeNames), so the write paths can't drift apart. */
+    private isSegmentableKind;
+    /** Write `name`'s segments into name_segment_vocab (idempotent). */
+    private insertNameSegments;
+    /**
+     * Insert multiple nodes in a transaction
+     */
+    insertNodes(nodes: Node[]): void;
+    /**
+     * Update an existing node
+     */
+    updateNode(node: Node): void;
+    /**
+     * Delete a node by ID
+     */
+    deleteNode(id: string): void;
+    /**
+     * Delete all nodes for a file
+     */
+    deleteNodesByFile(filePath: string): void;
+    /** Wipe the segment vocabulary. A full index calls this at its start; the
+     *  node write path repopulates it as files (re-)index, so the end state is
+     *  exactly the current names with no orphan rows. */
+    clearNameSegmentVocab(): void;
+    /** True when the vocab has no rows — an index built before the table existed.
+     *  `sync` uses this to heal such databases (see rebuildNameSegmentVocabFrom). */
+    isNameSegmentVocabEmpty(): boolean;
+    /** One page of distinct segmentable node names, for batched vocab rebuilds
+     *  (file basenames and import specifiers are excluded from the vocab — see
+     *  insertNode). */
+    getDistinctNodeNames(limit: number, offset: number): string[];
+    /** Insert segments for a batch of names in one transaction (vocab heal path). */
+    insertNameSegmentsBatch(names: string[]): void;
+    /**
+     * Names whose segments cover at least `minWords` distinct PROMPT WORDS —
+     * the co-occurrence probe behind the prompt hook's medium tier: the words
+     * "state" and "machine" both being segments of `OrderStateMachine` is strong
+     * evidence the prompt names that symbol in prose. Ordered by coverage.
+     *
+     * Takes (segment variant → original word) pairs and folds variants back to
+     * their word INSIDE the SQL: a name matching both `service` and `services`
+     * counts ONE word, not two. Counting raw variants let plural-variant pairs
+     * of a single word tie with genuine two-word matches and — because ORDER
+     * BY/LIMIT run here, before any JS-side re-check — crowd a real match past
+     * the LIMIT on vocab-heavy repos (#1146).
+     */
+    getSegmentCoOccurrence(variants: Array<{
+        segment: string;
+        word: string;
+    }>, minWords: number, limit: number): Array<{
+        name: string;
+        matches: number;
+    }>;
+    /** How many distinct names each segment appears in — the rarity signal that
+     *  separates a discriminative word ("checkout") from a ubiquitous one ("state"). */
+    getSegmentNameCounts(segments: string[]): Map<string, number>;
+    /** Names containing the given segment (rare-single-word tier). */
+    getNamesForSegment(segment: string, limit: number): string[];
+    /**
+     * Get a node by ID
+     */
+    getNodeById(id: string): Node | null;
+    /**
+     * Batch lookup: fetch many nodes by ID in a single SQL round-trip.
+     *
+     * Replaces the N+1 pattern in graph traversal where every edge would
+     * trigger its own `getNodeById` call. For a function with 50 callers
+     * this collapses 50 point reads into one IN-list query (~10-50x
+     * faster end-to-end).
+     *
+     * Returns a Map keyed by id so callers can preserve their own ordering
+     * (typically the order edges were returned from the graph). Missing IDs
+     * are simply absent from the map.
+     *
+     * Cache-aware: ids already in the LRU cache are served from memory and
+     * the SQL query only touches the misses.
+     */
+    getNodesByIds(ids: readonly string[]): Map<string, Node>;
+    private getExistingNodeIds;
+    /**
+     * Add a node to the cache, evicting oldest if needed
+     */
+    private cacheNode;
+    /**
+     * Clear the node cache
+     */
+    clearCache(): void;
+    /**
+     * Get all nodes in a file
+     */
+    getNodesByFile(filePath: string): Node[];
+    /**
+     * Find the file that holds the densest concentration of the project's
+     * internal call graph — the "core" file. Used by context-builder to
+     * boost ranking of symbols in that file's directory (so e.g. sinatra
+     * queries surface `lib/sinatra/base.rb`'s `route!` instead of
+     * `sinatra-contrib/lib/sinatra/multi_route.rb`'s `route` extension).
+     *
+     * Returns null if no file has a meaningful concentration (e.g. spread
+     * evenly across many files, or empty index).
+     *
+     * "Internal" = source and target are in the same file. Cross-file
+     * edges aren't useful here — they don't tell us which file is the
+     * functional center.
+     *
+     * Excludes test/spec files from candidacy via path-pattern. The agent's
+     * typical question is "how does X work", not "how is X tested", so
+     * boosting a test file's directory would be a misfire.
+     */
+    getDominantFile(): {
+        filePath: string;
+        edgeCount: number;
+        nextEdgeCount: number;
+    } | null;
+    /**
+     * Find the file that holds the densest concentration of the project's
+     * `route` nodes (framework-emitted: Express/Gin/Flask/Rails/Drupal/etc.).
+     * Used by handleContext on small repos to inline the project's routing
+     * config when the agent's query is about request flow — eliminating the
+     * "Glob + Read routes.rb" pattern that beats bhgraph on tiny realworld
+     * template repos.
+     *
+     * Excludes test/generated files from candidacy. Returns null if there
+     * are fewer than 3 non-test routes total, or if no file holds at least
+     * 30% of them (diffuse routing → no single answer file).
+     */
+    getTopRouteFile(): {
+        filePath: string;
+        routeCount: number;
+        totalRoutes: number;
+    } | null;
+    /**
+     * Build a URL → handler manifest from the index. Each route node's
+     * `references` edge points at the function/method that handles the
+     * request. We join them in one pass; the agent gets the canonical
+     * routing answer ("POST /users/login → AuthController#login") without
+     * having to parse the framework's route DSL itself.
+     *
+     * Also returns the file with the most handler endpoints — used as the
+     * "top handler file" to inline source for, so the agent has both the
+     * mapping AND the handler implementations.
+     */
+    getRoutingManifest(limit?: number): {
+        entries: Array<{
+            url: string;
+            handler: string;
+            handlerFile: string;
+            handlerLine: number;
+            handlerKind: string;
+        }>;
+        topHandlerFile: string | null;
+        topHandlerFileCount: number;
+        totalRoutes: number;
+    } | null;
+    /**
+     * Get all nodes of a specific kind
+     */
+    getNodesByKind(kind: NodeKind): Node[];
+    /**
+     * Stream every node of a kind one at a time (lazy) instead of materializing
+     * them all like {@link getNodesByKind}. For unbounded kinds (`function`,
+     * `method`) on a symbol-dense project the full array is gigabytes; the
+     * dynamic-edge synthesizers only scan-and-filter, so they iterate to keep
+     * memory O(1) in the node count rather than O(nodes) (#610).
+     */
+    iterateNodesByKind(kind: NodeKind): IterableIterator<Node>;
+    /**
+     * Get all nodes in the database
+     */
+    getAllNodes(): Node[];
+    /**
+     * Get nodes by exact name match (uses idx_nodes_name index)
+     */
+    getNodesByName(name: string): Node[];
+    /**
+     * Nodes whose name starts with `prefix`, by index range scan (a LIKE would
+     * skip idx_nodes_name under SQLite's default case-insensitive LIKE).
+     */
+    getNodesByNamePrefix(prefix: string, limit?: number): Node[];
+    /**
+     * Get nodes by exact qualified name match (uses idx_nodes_qualified_name index)
+     */
+    getNodesByQualifiedNameExact(qualifiedName: string): Node[];
+    /**
+     * Get nodes by lowercase name match (uses idx_nodes_lower_name expression index)
+     */
+    getNodesByLowerName(lowerName: string): Node[];
+    /**
+     * Search nodes by name using FTS with fallback to LIKE for better matching
+     *
+     * Search strategy:
+     * 1. Try FTS5 prefix match (query*) for word-start matching
+     * 2. If no results, try LIKE for substring matching (e.g., "signIn" finds "signInWithGoogle")
+     * 3. Score results based on match quality
+     */
+    searchNodes(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Match-everything path used when the user supplied only field
+     * filters (`kind:function lang:typescript`) with no text. Returns
+     * candidates ordered by name; the caller's filter pass narrows to
+     * what was asked for.
+     */
+    private searchAllByFilters;
+    /**
+     * Fuzzy fallback: when zero FTS/LIKE hits, try an edit-distance
+     * sweep over the distinct symbol-name set. Caps `maxDist` at 2 so
+     * `getUssr` finds `getUser` but `process` doesn't match `prosody`.
+     * Bounded edit distance keeps each comparison cheap; the per-query
+     * scan is O(distinct-name-count) which is far smaller than total
+     * node count on any real codebase.
+     */
+    private searchNodesFuzzy;
+    /**
+     * FTS5 search with prefix matching
+     */
+    private searchNodesFTS;
+    /**
+     * LIKE-based substring search for cases where FTS doesn't match
+     * Useful for camelCase matching (e.g., "signIn" finds "signInWithGoogle")
+     */
+    private searchNodesLike;
+    /**
+     * Find nodes by exact name match
+     *
+     * Used for hybrid search - looks up symbols by exact name or case-insensitive match.
+     * Returns high-confidence matches for known symbol names extracted from query.
+     *
+     * @param names - Array of symbol names to look up
+     * @param options - Search options (kinds, languages, limit)
+     * @returns SearchResult array with exact matches scored at 1.0
+     */
+    findNodesByExactName(names: string[], options?: SearchOptions): SearchResult[];
+    /**
+     * Find nodes whose name contains a substring (LIKE-based).
+     * Useful for CamelCase-part matching where FTS fails because
+     * e.g. "TransportSearchAction" is one FTS token, not matchable by "Search"*.
+     *
+     * Results are ordered by name length (shorter = more likely to be the core type).
+     */
+    findNodesByNameSubstring(substring: string, options?: SearchOptions & {
+        excludePrefix?: boolean;
+    }): SearchResult[];
+    /**
+     * Insert a new edge
+     */
+    insertEdge(edge: Edge): void;
+    /**
+     * Insert multiple edges in a transaction
+     */
+    insertEdges(edges: Edge[]): void;
+    /**
+     * Delete all edges from a source node
+     */
+    deleteEdgesBySource(sourceId: string): void;
+    /**
+     * Get outgoing edges from a node
+     */
+    getOutgoingEdges(sourceId: string, kinds?: EdgeKind[], provenance?: string): Edge[];
+    /**
+     * Get incoming edges to a node
+     */
+    getIncomingEdges(targetId: string, kinds?: EdgeKind[]): Edge[];
+    /**
+     * Find all edges where both source and target are in the given node set.
+     * Useful for recovering inter-node connectivity after BFS.
+     */
+    findEdgesBetweenNodes(nodeIds: string[], kinds?: EdgeKind[]): Edge[];
+    /**
+     * Distinct file paths that DEPEND ON `filePath`: every file containing a
+     * symbol with a cross-file edge (any kind except `contains`) into a symbol
+     * of this file. This is the file-level projection of the symbol dependency
+     * graph and the basis for blast-radius / `affected` test selection.
+     *
+     * It deliberately does NOT restrict to `imports` edges. In this graph an
+     * `imports` edge connects a file to its own local import declarations
+     * (it is always same-file), so an imports-only lookup returns zero
+     * cross-file dependents for every file. The real cross-file dependency
+     * signal is the resolved call/reference graph — calls, references,
+     * instantiates, extends, implements, overrides, type_of, returns,
+     * decorates — exactly what {@link GraphTraverser.getImpactRadius} traverses.
+     * `contains` is excluded: a parent containing a symbol does not *depend* on
+     * it. One indexed query (idx_nodes_file_path + idx_edges_target_kind).
+     */
+    getDependentFilePaths(filePath: string): string[];
+    /**
+     * Distinct file paths that `filePath` DEPENDS ON — the inverse of
+     * {@link getDependentFilePaths}: every file containing a symbol that a
+     * symbol of this file has a cross-file edge into. Same edge-kind rules
+     * (all kinds except `contains`); same reason imports-only is insufficient.
+     */
+    getDependencyFilePaths(filePath: string): string[];
+    /**
+     * Cross-file edges whose TARGET is a node in `filePath` and whose SOURCE is a
+     * node in a *different* file, paired with the target node's (name, kind) so a
+     * caller can re-resolve the edge to the re-indexed target's new ID (node IDs
+     * are `sha256(filePath:kind:name:line)`, so any line shift in the callee file
+     * changes target IDs and a naive re-insert by old ID silently drops them).
+     * Used by `storeExtractionResult` to preserve incoming edges across a file
+     * re-index (issue #899). Same edge-kind rules as
+     * {@link getDependentFilePaths}: all kinds except `contains`.
+     */
+    getCrossFileIncomingEdgesWithTarget(filePath: string): Array<Edge & {
+        targetName: string;
+        targetKind: NodeKind;
+    }>;
+    /**
+     * Insert or update a file record
+     */
+    upsertFile(file: FileRecord): void;
+    /**
+     * Delete a file record and its nodes
+     */
+    deleteFile(filePath: string): void;
+    /**
+     * Get a file record by path
+     */
+    getFileByPath(filePath: string): FileRecord | null;
+    /**
+     * Get all tracked files
+     */
+    getAllFiles(): FileRecord[];
+    /**
+     * Most recent index timestamp (ms since epoch) across all tracked files, or
+     * null when nothing is indexed yet. One indexed aggregate, no per-row scan. (#329)
+     */
+    getLastIndexedAt(): number | null;
+    /**
+     * Get files that need re-indexing (hash changed)
+     */
+    getStaleFiles(currentHashes: Map<string, string>): FileRecord[];
+    /**
+     * Insert an unresolved reference
+     */
+    insertUnresolvedRef(ref: UnresolvedReference): void;
+    /**
+     * Insert multiple unresolved references in a transaction
+     */
+    insertUnresolvedRefsBatch(refs: UnresolvedReference[]): void;
+    /**
+     * Delete unresolved references from a node
+     */
+    deleteUnresolvedByNode(nodeId: string): void;
+    /**
+     * Get unresolved references by name (for resolution)
+     */
+    getUnresolvedByName(name: string): UnresolvedReference[];
+    /**
+     * Get all unresolved references
+     */
+    getUnresolvedReferences(): UnresolvedReference[];
+    /**
+     * Get the count of unresolved references without loading them into memory
+     */
+    getUnresolvedReferencesCount(): number;
+    /**
+     * Get a batch of unresolved references using LIMIT/OFFSET pagination.
+     * Used to process references in bounded memory chunks.
+     */
+    getUnresolvedReferencesBatch(offset: number, limit: number): UnresolvedReference[];
+    /**
+     * Get all tracked file paths (lightweight — no full FileRecord objects)
+     */
+    getAllFilePaths(): string[];
+    /**
+     * Get all distinct node names (lightweight — just name strings for pre-filtering)
+     */
+    getAllNodeNames(): string[];
+    /**
+     * Get unresolved references scoped to specific file paths.
+     * Uses the idx_unresolved_file_path index for efficient lookup.
+     */
+    getUnresolvedReferencesByFiles(filePaths: string[]): UnresolvedReference[];
+    /**
+     * Delete all unresolved references (after resolution)
+     */
+    clearUnresolvedReferences(): void;
+    /**
+     * Delete resolved references by their IDs
+     */
+    deleteResolvedReferences(fromNodeIds: string[]): void;
+    /**
+     * Delete specific resolved references by (fromNodeId, referenceName, referenceKind) tuples.
+     * More precise than deleteResolvedReferences — only removes refs that were actually resolved.
+     */
+    deleteSpecificResolvedReferences(refs: Array<{
+        fromNodeId: string;
+        referenceName: string;
+        referenceKind: string;
+    }>): void;
+    /**
+     * Lightweight (nodes, edges) count snapshot. Used around an index/sync
+     * run to compute true additions across extraction + resolution +
+     * synthesis — the per-phase counter in the orchestrator only sees
+     * extraction's contribution, which is why the CLI summary under-reported
+     * the edge count (resolution + synthesizer edges were invisible).
+     */
+    getNodeAndEdgeCount(): {
+        nodes: number;
+        edges: number;
+    };
+    /**
+     * Get graph statistics
+     */
+    getStats(): GraphStats;
+    /**
+     * Get a metadata value by key
+     */
+    getMetadata(key: string): string | null;
+    /**
+     * Set a metadata key-value pair (upsert)
+     */
+    setMetadata(key: string, value: string): void;
+    /**
+     * Get all metadata as a key-value record
+     */
+    getAllMetadata(): Record<string, string>;
+    /**
+     * Clear all data from the database
+     */
+    clear(): void;
+}
+//# sourceMappingURL=queries.d.ts.map