@huanlin/dsh-plugin-codegraph-sqlite 0.1.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CC ZHAO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @huanlin/dsh-plugin-codegraph-sqlite
+
+Read-only SQLite store for the code-graph seam. Serves structural queries from the graph at `.codegraph/codegraph.db` — the same on-disk format the `codegraph` CLI writes — opening it read-only and gating on its recorded format version. Reads schema v4 (what `@huanlin/dsh-plugin-codegraph-tree-sitter` builds) and schema v8 (what the `codegraph` CLI ≥1.5 writes); the queries touch only the tables both versions share.
+
+Part of **[dsh-plugin-codegraph](https://github.com/CC19990113/dsh-plugin-codegraph)** — structural code intelligence for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness).
+
+Most users should install the bundle instead, which mounts this package and its siblings in one layer:
+
+```sh
+dsh plugin --profile <name> add dsh-plugin-codegraph
+```
+
+See the [project README](https://github.com/CC19990113/dsh-plugin-codegraph#readme) for setup, configuration, and the full tool reference.
+
+## License
+
+[MIT](LICENSE)

package/lib/database.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Connection ownership for the on-disk knowledge graph: where a project root's database lives, the
+ * format-version gate every connection passes before serving a query, and the bounded pool that
+ * keeps recently queried projects open.
+ *
+ * Databases open READ-ONLY. The external indexer may be writing through its own daemon while the
+ * harness reads, so this store never takes a write lock, never recovers a journal, and never repairs
+ * an index it does not own.
+ * @module @huanlin/dsh-plugin-codegraph-sqlite/database
+ */
+import { DatabaseSync } from 'node:sqlite';
+/**
+ * Where the external indexer keeps a project's graph, relative to the project root. Fixed by that
+ * tool's on-disk layout rather than configurable: pointing this store at another path would not make
+ * a different file readable, it would only fail later and less clearly.
+ */
+export declare const DATABASE_RELATIVE_PATH = ".codegraph/codegraph.db";
+/**
+ * The on-disk format versions this store reads. The format is an external specification, so support
+ * is a fixed fact rather than a deployment choice; a database at any other version fails loud
+ * instead of being read through assumptions that no longer hold.
+ *
+ * Two writers share this file, one per version: `@huanlin/dsh-plugin-codegraph-tree-sitter` builds schema v4,
+ * and the `@colbymchenry/codegraph` CLI (≥1.5, whose daemon may own the same index) stamps schema
+ * v8 — its `nodes`/`edges`/`files`/`nodes_fts` tables keep every column the store reads and only add
+ * ones the store never touches (`unresolved_refs` is reshaped, `project_metadata` and
+ * `name_segment_vocab` are new, and no store query reads any of the three).
+ */
+export declare const SUPPORTED_FORMAT_VERSIONS: readonly number[];
+/**
+ * The absolute path of a project root's graph database.
+ * @param projectRoot - absolute path of the indexed project root.
+ * @returns the database path, whether or not it exists.
+ */
+export declare function databasePath(projectRoot: string): string;
+/**
+ * Open one project's graph read-only and verify its format version.
+ * @param projectRoot - absolute path of the indexed project root.
+ * @returns the open, version-checked connection.
+ */
+export declare function openGraph(projectRoot: string): DatabaseSync;
+/**
+ * A bounded set of open graph connections keyed by project root, evicting the least recently used
+ * one when full. Every connection the pool hands out stays valid until {@link close}: eviction and
+ * disposal both close connections, so a caller holds a connection only for the duration of one
+ * synchronous query.
+ *
+ * A connection is opened against one specific on-disk file. An indexing run replaces that file
+ * wholesale (rename over the old path), and POSIX unlink semantics mean an already-open read-only
+ * connection keeps serving the REPLACED file's bytes indefinitely — reopening is the only way to see
+ * the new graph. `acquire` detects that swap by comparing the device/inode recorded at open time
+ * against the path's current identity, so a cache hit never silently serves a graph an indexing run
+ * has already superseded.
+ */
+export declare class GraphPool {
+    private readonly capacity;
+    private readonly open;
+    private disposed;
+    /**
+     * @param capacity - largest number of simultaneously open databases; at least 1.
+     */
+    constructor(capacity: number);
+    /**
+     * The connection for a project root, opening and caching it on first use. Reopens automatically
+     * when the file on disk is no longer the one the cached connection was opened against.
+     * @param projectRoot - absolute path of the indexed project root.
+     * @returns the open, version-checked connection, current as of this call.
+     */
+    acquire(projectRoot: string): DatabaseSync;
+    /** Close every open connection; further {@link acquire} calls fail as `CODEGRAPH_DISPOSED`. */
+    close(): void;
+    /** Close least-recently-used connections until the pool fits its capacity. */
+    private evictOverflow;
+}
+//# sourceMappingURL=database.d.ts.map

package/lib/database.js

@@ -0,0 +1,180 @@
+/**
+ * Connection ownership for the on-disk knowledge graph: where a project root's database lives, the
+ * format-version gate every connection passes before serving a query, and the bounded pool that
+ * keeps recently queried projects open.
+ *
+ * Databases open READ-ONLY. The external indexer may be writing through its own daemon while the
+ * harness reads, so this store never takes a write lock, never recovers a journal, and never repairs
+ * an index it does not own.
+ * @module @huanlin/dsh-plugin-codegraph-sqlite/database
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { CodegraphError } from '@huanlin/dsh-plugin-codegraph-service';
+/**
+ * Where the external indexer keeps a project's graph, relative to the project root. Fixed by that
+ * tool's on-disk layout rather than configurable: pointing this store at another path would not make
+ * a different file readable, it would only fail later and less clearly.
+ */
+export const DATABASE_RELATIVE_PATH = '.codegraph/codegraph.db';
+/**
+ * The on-disk format versions this store reads. The format is an external specification, so support
+ * is a fixed fact rather than a deployment choice; a database at any other version fails loud
+ * instead of being read through assumptions that no longer hold.
+ *
+ * Two writers share this file, one per version: `@huanlin/dsh-plugin-codegraph-tree-sitter` builds schema v4,
+ * and the `@colbymchenry/codegraph` CLI (≥1.5, whose daemon may own the same index) stamps schema
+ * v8 — its `nodes`/`edges`/`files`/`nodes_fts` tables keep every column the store reads and only add
+ * ones the store never touches (`unresolved_refs` is reshaped, `project_metadata` and
+ * `name_segment_vocab` are new, and no store query reads any of the three).
+ */
+export const SUPPORTED_FORMAT_VERSIONS = [4, 8];
+/**
+ * The absolute path of a project root's graph database.
+ * @param projectRoot - absolute path of the indexed project root.
+ * @returns the database path, whether or not it exists.
+ */
+export function databasePath(projectRoot) {
+    return join(projectRoot, DATABASE_RELATIVE_PATH);
+}
+/**
+ * The format version recorded in an open database.
+ * @param db - an open connection.
+ * @returns the highest applied schema version.
+ */
+function readFormatVersion(db) {
+    const row = db.prepare('SELECT MAX(version) AS version FROM schema_versions').get();
+    const version = row?.version;
+    if (version === null || version === undefined) {
+        throw new CodegraphError('the code graph records no schema version', 'CODEGRAPH_MALFORMED_INDEX');
+    }
+    return Number(version);
+}
+/**
+ * A path's current on-disk identity, or `undefined` when it cannot be stat'd (most commonly: an
+ * indexing run's atomic replace is between removing the old file and renaming the new one into place).
+ * That absence is treated as "unknown, not gone" by every caller — a transient rebuild window must
+ * never look like a missing graph.
+ * @param path - the file to identify.
+ */
+function identify(path) {
+    try {
+        const stats = statSync(path);
+        return { dev: stats.dev, ino: stats.ino };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether two identities name the same underlying file. */
+function sameIdentity(a, b) {
+    return a.dev === b.dev && a.ino === b.ino;
+}
+/**
+ * Open one project's graph read-only and verify its format version.
+ * @param projectRoot - absolute path of the indexed project root.
+ * @returns the open, version-checked connection.
+ */
+export function openGraph(projectRoot) {
+    const path = databasePath(projectRoot);
+    let db;
+    try {
+        db = new DatabaseSync(path, { readOnly: true });
+    }
+    catch (cause) {
+        throw new CodegraphError(`cannot open the code graph at "${path}"`, 'CODEGRAPH_UNAVAILABLE', { cause });
+    }
+    let version;
+    try {
+        version = readFormatVersion(db);
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+    if (!SUPPORTED_FORMAT_VERSIONS.includes(version)) {
+        db.close();
+        throw new CodegraphError(`the code graph at "${path}" is format version ${version}; this store reads version ${SUPPORTED_FORMAT_VERSIONS.join(' or ')}`, 'CODEGRAPH_UNSUPPORTED_FORMAT');
+    }
+    return db;
+}
+/**
+ * A bounded set of open graph connections keyed by project root, evicting the least recently used
+ * one when full. Every connection the pool hands out stays valid until {@link close}: eviction and
+ * disposal both close connections, so a caller holds a connection only for the duration of one
+ * synchronous query.
+ *
+ * A connection is opened against one specific on-disk file. An indexing run replaces that file
+ * wholesale (rename over the old path), and POSIX unlink semantics mean an already-open read-only
+ * connection keeps serving the REPLACED file's bytes indefinitely — reopening is the only way to see
+ * the new graph. `acquire` detects that swap by comparing the device/inode recorded at open time
+ * against the path's current identity, so a cache hit never silently serves a graph an indexing run
+ * has already superseded.
+ */
+export class GraphPool {
+    capacity;
+    open = new Map();
+    disposed = false;
+    /**
+     * @param capacity - largest number of simultaneously open databases; at least 1.
+     */
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    /**
+     * The connection for a project root, opening and caching it on first use. Reopens automatically
+     * when the file on disk is no longer the one the cached connection was opened against.
+     * @param projectRoot - absolute path of the indexed project root.
+     * @returns the open, version-checked connection, current as of this call.
+     */
+    acquire(projectRoot) {
+        if (this.disposed) {
+            throw new CodegraphError('the code-graph store is disposed', 'CODEGRAPH_DISPOSED');
+        }
+        const cached = this.open.get(projectRoot);
+        if (cached !== undefined) {
+            const current = identify(databasePath(projectRoot));
+            // `undefined` means the path is transiently unstatable — most likely an indexing run's replace
+            // is mid-flight between removing the old file and renaming the new one into place. Keep serving
+            // the connection we have rather than treating a rebuild-in-progress as a missing graph.
+            if (current === undefined || sameIdentity(current, cached.identity)) {
+                // Re-insert to mark most recently used; Map iteration order is insertion order.
+                this.open.delete(projectRoot);
+                this.open.set(projectRoot, cached);
+                return cached.db;
+            }
+            cached.db.close();
+            this.open.delete(projectRoot);
+        }
+        const db = openGraph(projectRoot);
+        const identity = identify(databasePath(projectRoot));
+        // Only `undefined` when the file vanishes in the instant between opening it and this stat — an
+        // unprovokable race in tests. The sentinel never matches a real identity, so the next acquire()
+        // is forced to re-verify rather than trusting an unconfirmed connection indefinitely.
+        /* v8 ignore next */
+        this.open.set(projectRoot, { db, identity: identity ?? { dev: -1, ino: -1 } });
+        this.evictOverflow();
+        return db;
+    }
+    /** Close every open connection; further {@link acquire} calls fail as `CODEGRAPH_DISPOSED`. */
+    close() {
+        this.disposed = true;
+        for (const { db } of this.open.values())
+            db.close();
+        this.open.clear();
+    }
+    /** Close least-recently-used connections until the pool fits its capacity. */
+    evictOverflow() {
+        while (this.open.size > this.capacity) {
+            // Map iteration starts at the least recently used entry, and `acquire` re-inserts on a hit,
+            // so the first entry is always the eviction candidate.
+            for (const [root, entry] of this.open) {
+                entry.db.close();
+                this.open.delete(root);
+                break;
+            }
+        }
+    }
+}
+//# sourceMappingURL=database.js.map

package/lib/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * SQLite graph store for `ctx.codegraph`. One plugin instance registers one store that answers every
+ * seam operation from the on-disk knowledge graph an external `codegraph` indexer writes to
+ * `<projectRoot>/.codegraph/codegraph.db`, opening each project read-only and keeping a bounded set
+ * of connections warm.
+ *
+ * The store is host-local by construction: `node:sqlite` opens a path on the machine running the
+ * harness, so availability is decided against the host filesystem rather than `ctx.fs`. A workspace
+ * that lives in a remote sandbox is not served by this store even when `ctx.fs` can read its files —
+ * reporting availability from `ctx.fs` would claim a root the store then fails to open.
+ *
+ * Namespace plugin (named exports, no default export). Lifecycle is effect-scoped: disposal
+ * unregisters from `ctx.codegraph` first, then closes every open connection.
+ * @module @huanlin/dsh-plugin-codegraph-sqlite
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export { DATABASE_RELATIVE_PATH, GraphPool, SUPPORTED_FORMAT_VERSIONS, databasePath, openGraph, } from './database.ts';
+export { toEdge, toFile, toNode } from './rows.ts';
+export { ftsPhrase, likeAnywhere } from './sql.ts';
+export { walkImpact, walkTrace, type ImpactHit, type ImpactWalk, type Step, type TraceWalk } from './traverse.ts';
+/** Cordis plugin name for loader diagnostics. */
+export declare const name = "codegraph-sqlite";
+/** Services required by this plugin. */
+export declare const inject: string[];
+/** Default branded identity this store reserves on the seam. */
+export declare const DEFAULT_STORE_ID = "codegraph-sqlite";
+/** Default number of project databases kept open at once. */
+export declare const DEFAULT_MAX_OPEN_DATABASES = 4;
+/** Default ceiling on distinct nodes one `impact` or `trace` walk may visit. */
+export declare const DEFAULT_MAX_TRAVERSAL_NODES = 20000;
+/** Default ceiling on indexed files one `status` call stats on the host filesystem for freshness. */
+export declare const DEFAULT_MAX_STALENESS_CHECKS = 2000;
+/** Plugin configuration: store identity and the bounds the seam's requests cannot express. */
+export interface Config {
+    /**
+     * Branded identity to reserve on `ctx.codegraph`. Give each instance its own id when mounting
+     * more than one, so a duplicate registration fails at load instead of shadowing the first store.
+     */
+    storeId?: string;
+    /**
+     * Largest number of project databases held open at once (default 4). The least recently queried
+     * connection closes when the limit is exceeded; a project queried again simply reopens.
+     */
+    maxOpenDatabases?: number;
+    /**
+     * Largest number of distinct nodes one `impact` or `trace` walk may visit (default 20000). A
+     * request's `depth`, `limit`, and `maxPaths` bound the answer; this bounds the work, so a query
+     * against a large monorepo returns a truncated answer instead of running unboundedly.
+     */
+    maxTraversalNodes?: number;
+    /**
+     * Largest number of indexed files one `status` call stats on the host filesystem to detect
+     * staleness (default 2000). A repository indexing more files than this gets a lower-bound stale
+     * count instead of a `status` call that stats every file it ever indexed.
+     */
+    maxStalenessChecks?: number;
+}
+export declare const Config: z<Config>;
+/**
+ * Register the SQLite graph store.
+ * @param ctx - the plugin context (must inject `codegraph`).
+ * @param config - the resolved plugin configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,119 @@
+/**
+ * SQLite graph store for `ctx.codegraph`. One plugin instance registers one store that answers every
+ * seam operation from the on-disk knowledge graph an external `codegraph` indexer writes to
+ * `<projectRoot>/.codegraph/codegraph.db`, opening each project read-only and keeping a bounded set
+ * of connections warm.
+ *
+ * The store is host-local by construction: `node:sqlite` opens a path on the machine running the
+ * harness, so availability is decided against the host filesystem rather than `ctx.fs`. A workspace
+ * that lives in a remote sandbox is not served by this store even when `ctx.fs` can read its files —
+ * reporting availability from `ctx.fs` would claim a root the store then fails to open.
+ *
+ * Namespace plugin (named exports, no default export). Lifecycle is effect-scoped: disposal
+ * unregisters from `ctx.codegraph` first, then closes every open connection.
+ * @module @huanlin/dsh-plugin-codegraph-sqlite
+ */
+import { access } from 'node:fs/promises';
+import z from '@deepseek-ai/schemastery';
+import { CodegraphStoreId } from '@huanlin/dsh-plugin-codegraph-service';
+import { assertNever } from '@deepseek-ai/dsh-util-values';
+import { GraphPool, databasePath } from "./database.js";
+import { files, impact, node, relations, search, status, trace } from "./queries.js";
+import { walkImpact, walkTrace } from "./traverse.js";
+export { DATABASE_RELATIVE_PATH, GraphPool, SUPPORTED_FORMAT_VERSIONS, databasePath, openGraph, } from "./database.js";
+export { toEdge, toFile, toNode } from "./rows.js";
+export { ftsPhrase, likeAnywhere } from "./sql.js";
+export { walkImpact, walkTrace } from "./traverse.js";
+/** Cordis plugin name for loader diagnostics. */
+export const name = 'codegraph-sqlite';
+/** Services required by this plugin. */
+export const inject = ['codegraph'];
+/** Default branded identity this store reserves on the seam. */
+export const DEFAULT_STORE_ID = 'codegraph-sqlite';
+/** Default number of project databases kept open at once. */
+export const DEFAULT_MAX_OPEN_DATABASES = 4;
+/** Default ceiling on distinct nodes one `impact` or `trace` walk may visit. */
+export const DEFAULT_MAX_TRAVERSAL_NODES = 20_000;
+/** Default ceiling on indexed files one `status` call stats on the host filesystem for freshness. */
+export const DEFAULT_MAX_STALENESS_CHECKS = 2_000;
+export const Config = z.object({
+    storeId: z.string().default(DEFAULT_STORE_ID),
+    maxOpenDatabases: z.number().default(DEFAULT_MAX_OPEN_DATABASES),
+    maxTraversalNodes: z.number().default(DEFAULT_MAX_TRAVERSAL_NODES),
+    maxStalenessChecks: z.number().default(DEFAULT_MAX_STALENESS_CHECKS),
+});
+/**
+ * Register the SQLite graph store.
+ * @param ctx - the plugin context (must inject `codegraph`).
+ * @param config - the resolved plugin configuration.
+ */
+export function apply(ctx, config) {
+    const resolved = config;
+    assertPositiveInteger('maxOpenDatabases', resolved.maxOpenDatabases);
+    assertPositiveInteger('maxTraversalNodes', resolved.maxTraversalNodes);
+    assertPositiveInteger('maxStalenessChecks', resolved.maxStalenessChecks);
+    const pool = new GraphPool(resolved.maxOpenDatabases);
+    const store = {
+        id: CodegraphStoreId(resolved.storeId),
+        async indexes(projectRoot) {
+            try {
+                await access(databasePath(projectRoot));
+                return true;
+            }
+            catch {
+                // Only the existence probe runs in the try. Any rejection — missing file, missing
+                // directory, or no permission to look — means this store cannot serve the root, which is
+                // the answer the seam asked for rather than a failure to report.
+                return false;
+            }
+        },
+        query(request) {
+            return Promise.resolve(run(pool, resolved, request));
+        },
+    };
+    ctx.effect(function* () {
+        // Registered first, so it disposes LAST: the store unregisters before its connections close,
+        // and no query can be routed to a pool that is already shut.
+        yield () => {
+            pool.close();
+        };
+        yield ctx.codegraph.registerStore(store);
+    }, 'codegraph-sqlite');
+}
+/**
+ * Answer one request from the pooled connection for its project root.
+ * @param pool - the store's connection pool.
+ * @param config - the resolved plugin configuration.
+ * @param request - the normalized seam request.
+ * @returns the result member matching `request.operation`.
+ */
+function run(pool, config, request) {
+    const db = pool.acquire(request.projectRoot);
+    switch (request.operation) {
+        case 'search':
+            return search(db, request);
+        case 'node':
+            return node(db, request);
+        case 'callers':
+        case 'callees':
+            return relations(db, request);
+        case 'impact':
+            return impact(db, request, (origin, depth) => walkImpact(db, origin, depth, config.maxTraversalNodes));
+        case 'trace':
+            return trace(db, request, (from, to, maxDepth, maxPaths) => walkTrace(db, from, to, maxDepth, maxPaths, config.maxTraversalNodes));
+        case 'files':
+            return files(db, request);
+        case 'status':
+            return status(db, request.projectRoot, config.maxStalenessChecks);
+        /* v8 ignore next -- exhaustive over the seam's closed operation union; unreachable. */
+        default:
+            return assertNever(request, 'codegraph-sqlite request');
+    }
+}
+/** Reject a non-positive-integer config value at load, so misconfiguration fails loud. */
+function assertPositiveInteger(field, value) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`codegraph-sqlite: ${field} must be a positive integer`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `dsh-plugin-codegraph-sqlite`.
+ * @module dsh-plugin-codegraph-sqlite/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "codegraph-sqlite-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/invariant.js

@@ -0,0 +1,23 @@
+/**
+ * Package-owned invariant companion for `dsh-plugin-codegraph-sqlite`.
+ * @module dsh-plugin-codegraph-sqlite/invariant
+ */
+const PACKAGE_NAME = 'dsh-plugin-codegraph-sqlite';
+/** Cordis companion plugin name. */
+export const name = 'codegraph-sqlite-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant: the store owns no mutable harness data and emits no event. Its connection
+ * pool is private, and the graph it reads is a file another tool writes, so there is no owned
+ * relation between two harness-visible values to compare.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/lib/queries.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The eight seam operations against one open graph database. Every function here is synchronous:
+ * `node:sqlite` is a synchronous binding, so a query either completes within one turn or throws,
+ * and the store's async surface exists for the seam's contract rather than for I/O interleaving.
+ * @module @huanlin/dsh-plugin-codegraph-sqlite/queries
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { CodegraphCalleesRequest, CodegraphCallersRequest, CodegraphFilesRequest, CodegraphFilesResult, CodegraphImpactRequest, CodegraphImpactResult, CodegraphNodeRequest, CodegraphNodeResult, CodegraphRelationsResult, CodegraphSearchRequest, CodegraphSearchResult, CodegraphStatusResult, CodegraphTraceRequest, CodegraphTraceResult } from '@huanlin/dsh-plugin-codegraph-service';
+import type { ImpactWalk, TraceWalk } from './traverse.ts';
+/**
+ * Find declarations matching a free-text query.
+ * @param db - the open graph connection.
+ * @param request - the search query with its resolved bounds.
+ * @returns the matching declarations, most relevant first, with the pre-limit total.
+ */
+export declare function search(db: DatabaseSync, request: CodegraphSearchRequest): CodegraphSearchResult;
+/**
+ * Resolve one symbol and read its immediate neighbourhood.
+ * @param db - the open graph connection.
+ * @param request - the node query with its resolved bounds.
+ * @returns the resolved declaration with its one-hop relations, or a null subject when the name
+ * matches nothing.
+ */
+export declare function node(db: DatabaseSync, request: CodegraphNodeRequest): CodegraphNodeResult;
+/**
+ * Find the declarations that call, or are called by, one symbol.
+ * @param db - the open graph connection.
+ * @param request - the callers or callees query; its operation picks the direction walked.
+ * @returns the distinct related declarations with their earliest call sites and repeat counts.
+ */
+export declare function relations(db: DatabaseSync, request: CodegraphCallersRequest | CodegraphCalleesRequest): CodegraphRelationsResult;
+/**
+ * Walk dependents transitively.
+ * @param db - the open graph connection.
+ * @param request - the impact query.
+ * @param walk - the reverse-reachability walk, injected so the traversal budget stays with the
+ * plugin that configures it.
+ * @returns the affected declarations, nearest first.
+ */
+export declare function impact(db: DatabaseSync, request: CodegraphImpactRequest, walk: ImpactWalk): CodegraphImpactResult;
+/**
+ * Find shortest directed paths between two symbols.
+ * @param db - the open graph connection.
+ * @param request - the trace query.
+ * @param walk - the shortest-path sweep, injected so the traversal budget stays with the plugin that
+ * configures it.
+ * @returns the paths, each as ordered hops from origin to destination.
+ */
+export declare function trace(db: DatabaseSync, request: CodegraphTraceRequest, walk: TraceWalk): CodegraphTraceResult;
+/**
+ * List indexed files under an optional subtree and glob.
+ * @param db - the open graph connection.
+ * @param request - the files query with its resolved bounds.
+ * @returns the matching files ordered by path, with the pre-limit total.
+ */
+export declare function files(db: DatabaseSync, request: CodegraphFilesRequest): CodegraphFilesResult;
+/**
+ * Report index size, language coverage, and freshness.
+ * @param db - the open graph connection.
+ * @param projectRoot - the project root the result echoes back, since the graph does not record it.
+ * @param maxStalenessChecks - largest number of indexed files to stat on the host filesystem when
+ * looking for drift, so a call against a very large index stays cheap.
+ * @returns the index summary.
+ */
+export declare function status(db: DatabaseSync, projectRoot: string, maxStalenessChecks: number): CodegraphStatusResult;
+//# sourceMappingURL=queries.d.ts.map