@shrkcrft/graph 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/indexer/resolve-reexports.d.ts

@@ -0,0 +1,32 @@
+import type { IEdge } from '../schema/edge.js';
+import type { INode } from '../schema/node.js';
+/**
+ * Resolve barrel re-export chains so a reference/call edge that targets a
+ * symbol re-exported through a package barrel points at the REAL declaring
+ * symbol instead of a phantom `symbol:<barrel>#<name>` that never existed.
+ *
+ * Why this matters: cross-package consumers import from a package barrel
+ * (`import { X } from '@scope/pkg'`), which the resolver maps to the barrel
+ * `index.ts`. The binder then targets `symbol:<barrel>#X` — but `X` is
+ * declared in a sub-file the barrel re-exports (`export * from './x'` /
+ * `export { X } from './x'`), so `callersOf(<real X>)` misses every one of
+ * those consumers and `graph callers` returns a confidently-wrong all-clear.
+ * This pass rewrites those edges to the real symbol id.
+ *
+ * Conservative + deterministic:
+ *   - Only edges whose target symbol does NOT exist (a phantom) are
+ *     considered; every valid edge is returned untouched.
+ *   - Re-export chains are followed with a visited-set cycle guard, so a
+ *     re-export cycle terminates instead of looping.
+ *   - Renamed re-exports (`export { a as b } from './x'`) are intentionally
+ *     left unresolved — the exposed name differs from the declaration, so
+ *     there is no safe deterministic match.
+ *
+ * Target file paths come from the `ImportsFile` edges the barrel already
+ * emits for its `export … from` specifiers, so this is a pure pass over
+ * `(nodes, edges)` with no extra resolver state — it runs identically in the
+ * full and incremental builders. The caller is responsible for de-duping
+ * (a rewrite can collide a rewritten edge id with an existing one).
+ */
+export declare function resolveReExportedReferenceEdges(nodes: readonly INode[], edges: readonly IEdge[]): IEdge[];
+//# sourceMappingURL=resolve-reexports.d.ts.map

package/dist/indexer/resolve-reexports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-reexports.d.ts","sourceRoot":"","sources":["../../src/indexer/resolve-reexports.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAS/C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,KAAK,EAAE,SAAS,KAAK,EAAE,GACtB,KAAK,EAAE,CA4ET"}

package/dist/indexer/resolve-reexports.js

@@ -0,0 +1,123 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+/**
+ * Resolve barrel re-export chains so a reference/call edge that targets a
+ * symbol re-exported through a package barrel points at the REAL declaring
+ * symbol instead of a phantom `symbol:<barrel>#<name>` that never existed.
+ *
+ * Why this matters: cross-package consumers import from a package barrel
+ * (`import { X } from '@scope/pkg'`), which the resolver maps to the barrel
+ * `index.ts`. The binder then targets `symbol:<barrel>#X` — but `X` is
+ * declared in a sub-file the barrel re-exports (`export * from './x'` /
+ * `export { X } from './x'`), so `callersOf(<real X>)` misses every one of
+ * those consumers and `graph callers` returns a confidently-wrong all-clear.
+ * This pass rewrites those edges to the real symbol id.
+ *
+ * Conservative + deterministic:
+ *   - Only edges whose target symbol does NOT exist (a phantom) are
+ *     considered; every valid edge is returned untouched.
+ *   - Re-export chains are followed with a visited-set cycle guard, so a
+ *     re-export cycle terminates instead of looping.
+ *   - Renamed re-exports (`export { a as b } from './x'`) are intentionally
+ *     left unresolved — the exposed name differs from the declaration, so
+ *     there is no safe deterministic match.
+ *
+ * Target file paths come from the `ImportsFile` edges the barrel already
+ * emits for its `export … from` specifiers, so this is a pure pass over
+ * `(nodes, edges)` with no extra resolver state — it runs identically in the
+ * full and incremental builders. The caller is responsible for de-duping
+ * (a rewrite can collide a rewritten edge id with an existing one).
+ */
+export function resolveReExportedReferenceEdges(nodes, edges) {
+    const symbolIds = new Set();
+    for (const n of nodes)
+        if (n.kind === NodeKind.Symbol)
+            symbolIds.add(n.id);
+    // file path → (re-export specifier → resolved target file path).
+    const importTargets = new Map();
+    // file path → its re-exports.
+    const reExportsByFile = new Map();
+    for (const e of edges) {
+        if (e.kind === EdgeKind.ImportsFile) {
+            if (!e.from.startsWith('file:') || !e.to.startsWith('file:'))
+                continue;
+            const spec = e.data?.['specifier'];
+            if (typeof spec !== 'string')
+                continue;
+            const from = e.from.slice('file:'.length);
+            let m = importTargets.get(from);
+            if (!m) {
+                m = new Map();
+                importTargets.set(from, m);
+            }
+            if (!m.has(spec))
+                m.set(spec, e.to.slice('file:'.length));
+        }
+        else if (e.kind === EdgeKind.ReExportsSymbol) {
+            if (!e.from.startsWith('file:'))
+                continue;
+            const name = e.data?.['name'];
+            const specifier = e.data?.['specifier'];
+            if (typeof name !== 'string' || typeof specifier !== 'string')
+                continue;
+            const from = e.from.slice('file:'.length);
+            let arr = reExportsByFile.get(from);
+            if (!arr) {
+                arr = [];
+                reExportsByFile.set(from, arr);
+            }
+            arr.push({ name, star: e.data?.['star'] === true, specifier });
+        }
+    }
+    const resolve = (file, name, visited) => {
+        const key = `${file}#${name}`;
+        if (visited.has(key))
+            return undefined;
+        visited.add(key);
+        const direct = `symbol:${file}#${name}`;
+        if (symbolIds.has(direct))
+            return direct;
+        const reExports = reExportsByFile.get(file);
+        const specMap = importTargets.get(file);
+        if (!reExports || !specMap)
+            return undefined;
+        for (const re of reExports) {
+            if (!re.star && re.name !== name)
+                continue;
+            const targetPath = specMap.get(re.specifier);
+            if (!targetPath)
+                continue;
+            const r = resolve(targetPath, name, visited);
+            if (r)
+                return r;
+        }
+        return undefined;
+    };
+    return edges.map((e) => {
+        // Re-target the same symbol-pointing edges that cross a package barrel:
+        // references/calls AND the typed heritage edges. Without heritage here, a
+        // `class X implements I` where `I` is imported from a package barrel would
+        // point at the unresolved barrel placeholder and `subtypesOf(I)` would
+        // silently return nothing cross-package.
+        if (e.kind !== EdgeKind.CallsSymbol &&
+            e.kind !== EdgeKind.ReferencesSymbol &&
+            e.kind !== EdgeKind.ExtendsSymbol &&
+            e.kind !== EdgeKind.ImplementsSymbol) {
+            return e;
+        }
+        if (!e.to.startsWith('symbol:') || symbolIds.has(e.to))
+            return e;
+        const body = e.to.slice('symbol:'.length);
+        const hash = body.lastIndexOf('#');
+        if (hash <= 0)
+            return e;
+        const resolved = resolve(body.slice(0, hash), body.slice(hash + 1), new Set());
+        if (!resolved || resolved === e.to)
+            return e;
+        return { ...e, to: resolved, id: edgeId(e.from, resolved, e.kind) };
+    });
+}
+function edgeId(from, to, kind) {
+    return createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex');
+}

package/dist/query/graph-api-cache.d.ts

@@ -0,0 +1,21 @@
+import { GraphQueryApi } from './query-api.js';
+/**
+ * Load the graph query API for a project, cached across calls keyed by the
+ * store's `meta.json` mtime+size.
+ *
+ * The MCP server is long-lived and every graph tool used to re-read + re-parse
+ * the ~12MB on-disk store and rebuild four in-memory indexes on EVERY request
+ * (~30–165ms). The store only changes when the index is rebuilt
+ * (`graph index` / `updateChanged` rewrite `meta.json`, bumping its mtime), so
+ * keying the cache on that stat reloads only when it genuinely changed —
+ * including when a SEPARATE process (a CLI `graph index`) rebuilt it. The query
+ * API is read-only, so sharing one instance across calls is safe.
+ *
+ * Returns `null` when no index exists. NOTE: this caches the STORE, not
+ * working-tree freshness — source-file edits are still detected per-query via
+ * {@link GraphQueryApi.staleFilesAmong}; the two are orthogonal.
+ */
+export declare function loadGraphApiCached(projectRoot: string): GraphQueryApi | null;
+/** Drop all cached snapshots (tests / explicit invalidation). */
+export declare function clearGraphApiCache(): void;
+//# sourceMappingURL=graph-api-cache.d.ts.map

package/dist/query/graph-api-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-api-cache.d.ts","sourceRoot":"","sources":["../../src/query/graph-api-cache.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAW/C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAyB5E;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/query/graph-api-cache.js

@@ -0,0 +1,54 @@
+import { statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { GraphStore } from "../store/graph-store.js";
+import { GraphQueryApi } from "./query-api.js";
+const CACHE = new Map();
+const MAX_ENTRIES = 4;
+/**
+ * Load the graph query API for a project, cached across calls keyed by the
+ * store's `meta.json` mtime+size.
+ *
+ * The MCP server is long-lived and every graph tool used to re-read + re-parse
+ * the ~12MB on-disk store and rebuild four in-memory indexes on EVERY request
+ * (~30–165ms). The store only changes when the index is rebuilt
+ * (`graph index` / `updateChanged` rewrite `meta.json`, bumping its mtime), so
+ * keying the cache on that stat reloads only when it genuinely changed —
+ * including when a SEPARATE process (a CLI `graph index`) rebuilt it. The query
+ * API is read-only, so sharing one instance across calls is safe.
+ *
+ * Returns `null` when no index exists. NOTE: this caches the STORE, not
+ * working-tree freshness — source-file edits are still detected per-query via
+ * {@link GraphQueryApi.staleFilesAmong}; the two are orthogonal.
+ */
+export function loadGraphApiCached(projectRoot) {
+    const metaPath = nodePath.join(projectRoot, '.sharkcraft', 'graph', 'meta.json');
+    let st;
+    try {
+        st = statSync(metaPath);
+    }
+    catch {
+        CACHE.delete(projectRoot);
+        return null;
+    }
+    const key = `${Math.floor(st.mtimeMs)}:${st.size}`;
+    const hit = CACHE.get(projectRoot);
+    if (hit && hit.key === key)
+        return hit.api;
+    const store = new GraphStore(projectRoot);
+    if (!store.exists()) {
+        CACHE.delete(projectRoot);
+        return null;
+    }
+    const api = new GraphQueryApi(store.loadSnapshot());
+    if (!CACHE.has(projectRoot) && CACHE.size >= MAX_ENTRIES) {
+        const oldest = CACHE.keys().next().value;
+        if (oldest !== undefined)
+            CACHE.delete(oldest);
+    }
+    CACHE.set(projectRoot, { key, api });
+    return api;
+}
+/** Drop all cached snapshots (tests / explicit invalidation). */
+export function clearGraphApiCache() {
+    CACHE.clear();
+}

package/dist/query/query-api.d.ts

@@ -1,4 +1,5 @@
 import type { IEdge } from '../schema/edge.js';
+import { EdgeKind } from '../schema/edge-kind.js';
 import type { IGraphSnapshot } from '../schema/graph-snapshot.js';
 import type { INode } from '../schema/node.js';
 import { type IFileCycle } from './cycle-detection.js';
@@ -38,6 +39,57 @@ export interface IFindSymbolOptions {
     /** Exact match required (no case-insensitive / prefix matching). */
     exact?: boolean;
 }
+export interface IStaleResultFiles {
+    /** Result files whose on-disk content changed since indexing (line numbers / membership may be stale). */
+    modified: readonly string[];
+    /** Result files that no longer exist on disk (should be dropped from results). */
+    deleted: readonly string[];
+}
+export interface ICallSite {
+    /** The file node that calls / references the symbol. */
+    node: INode;
+    /**
+     * Representative source line of the use. The indexer de-dupes reference
+     * edges by (target, kind), so this is the FIRST recorded call/reference
+     * site in that file — enough for an agent to jump straight to, not an
+     * exhaustive list of every occurrence.
+     */
+    line?: number;
+}
+/** A single hop along a directed code path: `from` uses `to` via `kind`. */
+export interface IGraphPathHop {
+    from: INode;
+    to: INode;
+    kind: EdgeKind;
+    /** Representative source line of the use (call/reference edges carry one). */
+    line?: number;
+}
+/** Result of a directed reachability query between two code nodes. */
+export interface IGraphPath {
+    /** True when a directed `from → … → to` path exists within the depth cap. */
+    found: boolean;
+    from?: INode;
+    to?: INode;
+    /** The shortest path, hop by hop. Empty when `from === to` or not found. */
+    hops: readonly IGraphPathHop[];
+    /** Nodes visited before answering — context for a "no path" result. */
+    explored: number;
+    /** Why the query could not run / find a path (endpoint missing, depth cap). */
+    reason?: string;
+}
+/** A load-bearing node and how many distinct files depend on it. */
+export interface IGraphHub {
+    node: INode;
+    /** Distinct dependents: referencing files for a symbol, importers for a file. */
+    inDegree: number;
+}
+/** The most-depended-on code in the snapshot — what to change carefully. */
+export interface IGraphHubs {
+    /** Most-referenced symbols (functions / classes / types). */
+    symbols: readonly IGraphHub[];
+    /** Most-imported files. */
+    files: readonly IGraphHub[];
+}
 /**
  * Read-only query layer over an in-memory graph snapshot.
  *
@@ -76,6 +128,37 @@ export declare class GraphQueryApi {
     callersOf(symbolNodeId: string): readonly INode[];
     /** Files that *reference* the given symbol (any use, including calls). */
     referencesOf(symbolNodeId: string): readonly INode[];
+    /**
+     * Symbols that EXTEND or IMPLEMENT the given symbol — the precise "who
+     * implements this interface / who subclasses this" answer that a generic
+     * reference cannot give (a reference might be a call, a type annotation, or
+     * a heritage clause; these are typed `extends-symbol`/`implements-symbol`
+     * edges only). Returns the subtype symbol nodes.
+     */
+    subtypesOf(symbolNodeId: string): readonly INode[];
+    /** Symbols the given symbol EXTENDS or IMPLEMENTS (its supertypes). */
+    supertypesOf(symbolNodeId: string): readonly INode[];
+    /**
+     * Like {@link callersOf}, but keeps the call-site line carried on each
+     * edge so a caller can render `path:line` (jump-straight-to-source)
+     * instead of just the file path — the difference between "grep, then grep
+     * again inside each file" and a direct hit.
+     */
+    callerSitesOf(symbolNodeId: string): readonly ICallSite[];
+    /** Like {@link referencesOf}, but keeps the representative use-site line. */
+    referenceSitesOf(symbolNodeId: string): readonly ICallSite[];
+    /**
+     * Targeted, cheap staleness check over a handful of RESULT file paths (the
+     * declaring file + caller/dependent files of a query) — NOT a full tree
+     * walk. For each project-relative path that the index knows about: stat it
+     * (mtime+size gate, sha1 only on mismatch) and classify as `modified`
+     * (content changed → results may be wrong: stale lines / a removed caller
+     * still listed) or `deleted` (gone from disk → drop it). Lets a query flag
+     * or prune a silently-stale answer for a file the agent just edited without
+     * paying for a whole-repo freshness walk. `cwd` is passed explicitly: the
+     * snapshot's index-time absolute root is wrong if the repo moved.
+     */
+    staleFilesAmong(cwd: string, paths: readonly string[]): IStaleResultFiles;
     /** Packages that this package depends on (PackageDependsOn). */
     packageDeps(packageName: string): readonly INode[];
     /** Packages that depend on this package (reverse PackageDependsOn). */
@@ -91,5 +174,48 @@ export declare class GraphQueryApi {
     cycles(): readonly IFileCycle[];
     /** 1-hop neighbours of a node, both in + out. */
     neighbours(nodeId: string): IGraphNeighbours | undefined;
+    /**
+     * Shortest directed code path from `fromId` to `toId` over the
+     * "code uses code" edges (imports / calls / references / declares /
+     * re-exports / extends / implements). Answers "is A actually wired to B?"
+     * deterministically: a found path lists every hop with its edge kind (and
+     * call-site line where the edge carries one) so a caller sees HOW they are
+     * wired — a chain of `imports-file` hops reads very differently from a
+     * `calls-symbol` one. Breadth-first, so the returned path is minimal-hop;
+     * `explored` reports how many nodes were visited so a "no path" answer is
+     * honestly bounded rather than read as "definitely unrelated".
+     */
+    pathBetween(fromId: string, toId: string, opts?: {
+        maxDepth?: number;
+    }): IGraphPath;
+    /** Walk the BFS `parent` map back from `toId` to `fromId` into ordered hops. */
+    private reconstructPath;
+    /**
+     * The most-depended-on code in the snapshot: symbols ranked by how many
+     * distinct files reference/call them and files ranked by how many distinct
+     * files import them. This is the "load-bearing code" view — the surface an
+     * agent should change most carefully and a human should understand first.
+     * In-degree counts DISTINCT dependent files (a file that calls a symbol
+     * ten times counts once), so the rank reflects blast radius, not call volume.
+     */
+    /**
+     * The DIRECT dependents of a node — what breaks if you change it, one hop out.
+     * Kind-aware, because the edge that carries "depends on" differs by kind:
+     *   - Symbol: the files that reference/call it, PLUS the files declaring its
+     *     subtypes (a class that `import type`s an interface has no value-reference
+     *     edge, so subtypes must be added explicitly or implementers are missed).
+     *     Falls back to the importers of its declaring file when nothing references
+     *     the symbol directly.
+     *   - File: its importers (`imports-file`).
+     *   - Package: the packages that depend on it.
+     * The shared building block for impact reverse-closures (CLI + MCP) — keep this
+     * the ONE source of truth so the two surfaces never disagree on a symbol's
+     * blast radius (they once did: an importers-only closure returned NOTHING for a
+     * symbol, a confidently-wrong "nothing breaks").
+     */
+    directDependentsOf(anchor: INode): readonly INode[];
+    /** The file that declares a symbol (the `declares-symbol` source), if known. */
+    declaringFileOf(symbolId: string): INode | undefined;
+    topHubs(limit?: number, pathPrefix?: string): IGraphHubs;
 }
 //# sourceMappingURL=query-api.d.ts.map

package/dist/query/query-api.d.ts.map

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