@shrkcrft/mcp-server 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/tools/get-graph-impact-analysis.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getGraphImpactAnalysisTool: IToolDefinition;
+//# sourceMappingURL=get-graph-impact-analysis.tool.d.ts.map

package/dist/tools/get-graph-impact-analysis.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-impact-analysis.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-impact-analysis.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAWpE,eAAO,MAAM,0BAA0B,EAAE,eAoCxC,CAAC"}

package/dist/tools/get-graph-impact-analysis.tool.js

@@ -0,0 +1,44 @@
+import { analyzeGraphImpact } from '@shrkcrft/impact-engine';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+export const getGraphImpactAnalysisTool = {
+    name: 'get_graph_impact_analysis',
+    description: 'Rich graph-backed change analysis (schema sharkcraft.graph-impact-analysis/v3). Inputs: file list OR symbol OR git ref. Returns affected symbols/files/packages/rules/templates/tests/risk + recommended validation commands. Read-only.',
+    cliCommand: 'graph impact',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: { type: 'array', items: { type: 'string' } },
+            symbol: { type: 'string' },
+            gitref: { type: 'string' },
+            maxDepth: { type: 'number' },
+            limit: { type: 'number' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        let resolved;
+        if (args.files && args.files.length > 0)
+            resolved = { kind: 'files', files: args.files };
+        else if (args.symbol)
+            resolved = { kind: 'symbol', symbolId: args.symbol };
+        else if (args.gitref)
+            resolved = { kind: 'gitref', ref: args.gitref };
+        if (!resolved) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'One of `files`, `symbol`, or `gitref` is required.' },
+            };
+        }
+        const analysis = analyzeGraphImpact(resolved, {
+            projectRoot: ctx.inspection.projectRoot,
+            limit: clamp(args.limit ?? 200, 1, 2000),
+            maxDepth: clamp(args.maxDepth ?? 5, 1, 10),
+        });
+        return { data: formatObjectArrays(analysis, input) };
+    },
+};
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}

package/dist/tools/get-graph-impact.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getGraphImpactTool: IToolDefinition;
+//# sourceMappingURL=get-graph-impact.tool.d.ts.map

package/dist/tools/get-graph-impact.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-impact.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-impact.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAYpE,eAAO,MAAM,kBAAkB,EAAE,eA4EhC,CAAC"}

package/dist/tools/get-graph-impact.tool.js

@@ -0,0 +1,150 @@
+import { GraphQueryApi, GraphStore, loadGraphApiCached } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+import { dropDeleted, graphResultStaleness } from "./graph-staleness.js";
+const NEXT = 'shrk graph index';
+export const getGraphImpactTool = {
+    name: 'get_graph_impact',
+    description: 'Compute reverse closure (importers + transitive) for a file or symbol. Returns direct and transitive dependents capped by limit. Read-only.',
+    cliCommand: 'graph impact',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            target: { type: 'string' },
+            maxDepth: { type: 'number' },
+            limit: { type: 'number' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        required: ['target'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const target = (args.target ?? '').trim();
+        if (!target) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'target is required' },
+            };
+        }
+        const maxDepth = clamp(args.maxDepth ?? 5, 1, 10);
+        const limit = clamp(args.limit ?? 200, 1, 2000);
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: `Code-intelligence index is missing. Run '${NEXT}'.`,
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        const api = loadGraphApiCached(ctx.inspection.projectRoot) ?? GraphQueryApi.fromStore(ctx.inspection.projectRoot);
+        const anchor = resolveAnchor(api, target);
+        if (!anchor) {
+            return {
+                isError: true,
+                error: {
+                    code: 'not-found',
+                    message: `No graph node matched "${target}".`,
+                    details: { target },
+                },
+            };
+        }
+        const closure = reverseClosure(api, anchor, maxDepth, limit);
+        const direct = closure.layer[1] ?? [];
+        const transitive = closure.all.filter((id) => id !== anchor.id && !direct.includes(id));
+        const directNodes = direct.map((id) => summarise(api.neighbours(id).node));
+        const transitiveNodes = transitive.slice(0, limit).map((id) => summarise(api.neighbours(id).node));
+        // Targeted staleness over the blast-radius files: drop dependents whose
+        // file was deleted (they can't break), flag those whose content changed —
+        // so a stale index never misroutes which tests/files the agent trusts.
+        const fresh = graphResultStaleness(api, ctx.inspection.projectRoot, [
+            anchor.path,
+            ...directNodes.map((n) => n.path),
+            ...transitiveNodes.map((n) => n.path),
+        ]);
+        const data = {
+            schema: 'sharkcraft.graph-impact/v1',
+            anchor: summarise(anchor),
+            maxDepth,
+            limit,
+            truncated: closure.truncated,
+            directDependents: dropDeleted(directNodes, fresh.deletedSet),
+            transitiveDependents: dropDeleted(transitiveNodes, fresh.deletedSet),
+            totalReached: closure.all.length - 1,
+            ...(fresh.field ?? {}),
+        };
+        return { data: formatObjectArrays(data, input) };
+    },
+};
+function resolveAnchor(api, target) {
+    const direct = api.neighbours(target);
+    if (direct)
+        return direct.node;
+    if (target.startsWith('file:') || target.startsWith('symbol:') || target.startsWith('package:')) {
+        return undefined;
+    }
+    const f = api.findFile(target);
+    if (f)
+        return f;
+    const syms = api.findSymbol(target, { exact: true, limit: 1 });
+    if (syms.length > 0)
+        return syms[0];
+    return undefined;
+}
+function reverseClosure(api, anchor, maxDepth, limit) {
+    const seen = new Set([anchor.id]);
+    const layer = {};
+    let truncated = false;
+    // Layer 1 uses the anchor-kind-aware direct dependents (importersOf alone
+    // returns NOTHING for a symbol anchor — symbols have no import edges).
+    let frontier = directDependents(api, anchor).filter((id) => !seen.has(id));
+    if (frontier.length > limit) {
+        frontier = frontier.slice(0, limit);
+        truncated = true;
+    }
+    for (const id of frontier)
+        seen.add(id);
+    if (frontier.length > 0)
+        layer[1] = frontier;
+    let depth = 2;
+    while (depth <= maxDepth && frontier.length > 0 && !truncated) {
+        const next = [];
+        for (const id of frontier) {
+            for (const imp of api.importersOf(id)) {
+                if (seen.has(imp.id))
+                    continue;
+                seen.add(imp.id);
+                next.push(imp.id);
+                if (seen.size - 1 >= limit) {
+                    truncated = true;
+                    break;
+                }
+            }
+            if (truncated)
+                break;
+        }
+        if (next.length > 0)
+            layer[depth] = next;
+        frontier = next;
+        depth += 1;
+    }
+    return { all: [...seen], layer, truncated };
+}
+/** Kind-aware direct dependents — the shared `GraphQueryApi` implementation. */
+function directDependents(api, anchor) {
+    return api.directDependentsOf(anchor).map((n) => n.id);
+}
+function summarise(n) {
+    return {
+        id: n.id,
+        kind: n.kind,
+        label: n.label,
+        ...(n.path ? { path: n.path } : {}),
+        ...(n.line ? { line: n.line } : {}),
+    };
+}
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}

package/dist/tools/get-graph-path.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getGraphPathTool: IToolDefinition;
+//# sourceMappingURL=get-graph-path.tool.d.ts.map

package/dist/tools/get-graph-path.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-path.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-path.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAYpE,eAAO,MAAM,gBAAgB,EAAE,eAgG9B,CAAC"}

package/dist/tools/get-graph-path.tool.js

@@ -0,0 +1,144 @@
+import { EdgeKind, GraphQueryApi, GraphStore, loadGraphApiCached, NodeKind, } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+import { callGraphLanguageNote, graphResultStaleness } from "./graph-staleness.js";
+const NEXT = 'shrk graph index';
+export const getGraphPathTool = {
+    name: 'get_graph_path',
+    description: 'Is code A actually wired to code B? Returns the shortest directed CODE path (import/call/reference/declare/re-export/extends/implements edges) from `from` to `to`, hop by hop with edge kind and call-site line — the deterministic answer to "is X wired to Y" that grep cannot give. If A does not reach B it also checks B→A and reports the direction. Each endpoint is a file path or a symbol name. Read-only; needs `shrk graph index`.',
+    cliCommand: 'graph path',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            from: { type: 'string' },
+            to: { type: 'string' },
+            maxDepth: { type: 'number' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        required: ['from', 'to'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const fromArg = (args.from ?? '').trim();
+        const toArg = (args.to ?? '').trim();
+        if (!fromArg || !toArg) {
+            return { isError: true, error: { code: 'invalid-input', message: 'from and to are required' } };
+        }
+        const maxDepth = clampDepth(args.maxDepth);
+        const cwd = ctx.inspection.projectRoot;
+        const store = new GraphStore(cwd);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: `Code-intelligence index is missing. Run '${NEXT}'.`,
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        const api = loadGraphApiCached(cwd) ?? GraphQueryApi.fromStore(cwd);
+        const from = resolveAnchor(api, fromArg);
+        const to = resolveAnchor(api, toArg);
+        if (!from || !to) {
+            const missing = !from ? fromArg : toArg;
+            return {
+                isError: true,
+                error: { code: 'not-found', message: `No graph node matched "${missing}".`, details: { target: missing } },
+            };
+        }
+        // A symbol has no OUTGOING code edges (references are recorded file→symbol),
+        // so trace from its declaring file. The target may stay a symbol.
+        const fromStart = bfsStartNode(api, from);
+        const toStart = bfsStartNode(api, to);
+        const forward = api.pathBetween(fromStart.id, to.id, { maxDepth });
+        const reverse = forward.found ? null : api.pathBetween(toStart.id, from.id, { maxDepth });
+        const direction = forward.found
+            ? 'forward'
+            : reverse?.found
+                ? 'reverse'
+                : 'none';
+        const chosen = forward.found ? forward : reverse?.found ? reverse : forward;
+        const startEndpoint = direction === 'reverse' ? to : from;
+        const startFile = direction === 'reverse' ? toStart : fromStart;
+        const startNote = direction !== 'none' && startFile.id !== startEndpoint.id && startEndpoint.kind === NodeKind.Symbol
+            ? `\`${startEndpoint.label}\` is declared in ${startFile.path ?? startFile.id}; path traced from that file (per-symbol out-edges are not tracked).`
+            : undefined;
+        const hops = chosen.hops.map((h) => ({
+            from: h.from.path ?? h.from.id,
+            to: h.to.path ?? h.to.id,
+            kind: h.kind,
+            label: h.to.label,
+            ...(h.line ? { line: h.line } : {}),
+        }));
+        const fresh = graphResultStaleness(api, cwd, [
+            from.path,
+            to.path,
+            ...chosen.hops.map((h) => h.from.path),
+            ...chosen.hops.map((h) => h.to.path),
+        ]);
+        // A no-path answer between non-TS endpoints may just be missing call edges.
+        const langNote = direction === 'none' ? callGraphLanguageNote(api, from) ?? callGraphLanguageNote(api, to) : undefined;
+        const data = {
+            schema: 'sharkcraft.graph-path/v1',
+            from: summarise(from),
+            to: summarise(to),
+            found: direction !== 'none',
+            direction,
+            ...(direction !== 'none' && startFile.id !== startEndpoint.id ? { tracedFrom: summarise(startFile) } : {}),
+            hops,
+            hopCount: hops.length,
+            explored: forward.found ? forward.explored : reverse?.explored ?? forward.explored,
+            ...(direction === 'none' && chosen.reason ? { reason: chosen.reason } : {}),
+            ...(startNote ?? langNote ? { note: startNote ?? langNote } : {}),
+            ...(fresh.field ?? {}),
+        };
+        return { data: formatObjectArrays(data, input) };
+    },
+};
+function clampDepth(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw))
+        return 16;
+    return Math.max(1, Math.min(32, Math.floor(raw)));
+}
+function resolveAnchor(api, target) {
+    const direct = api.neighbours(target);
+    if (direct)
+        return direct.node;
+    if (target.startsWith('file:') || target.startsWith('symbol:') || target.startsWith('package:')) {
+        return undefined;
+    }
+    const f = api.findFile(target);
+    if (f)
+        return f;
+    const syms = api.findSymbol(target, { exact: true, limit: 1 });
+    if (syms.length > 0)
+        return syms[0];
+    return undefined;
+}
+/** A file is its own BFS start; a symbol resolves to its declaring file. */
+function bfsStartNode(api, node) {
+    if (node.kind !== NodeKind.Symbol)
+        return node;
+    const neighbours = api.neighbours(node.id);
+    if (neighbours) {
+        for (const incoming of neighbours.in) {
+            if (incoming.edge.kind !== EdgeKind.DeclaresSymbol)
+                continue;
+            if ('resolved' in incoming.source)
+                continue;
+            if (incoming.source.kind === NodeKind.File)
+                return incoming.source;
+        }
+    }
+    return (node.path ? api.findFile(node.path) : undefined) ?? node;
+}
+function summarise(n) {
+    return {
+        id: n.id,
+        kind: n.kind,
+        label: n.label,
+        ...(n.path ? { path: n.path } : {}),
+        ...(n.line ? { line: n.line } : {}),
+    };
+}

package/dist/tools/get-graph-search.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getGraphSearchTool: IToolDefinition;
+//# sourceMappingURL=get-graph-search.tool.d.ts.map

package/dist/tools/get-graph-search.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-search.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-search.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAYpE,eAAO,MAAM,kBAAkB,EAAE,eA8EhC,CAAC"}

package/dist/tools/get-graph-search.tool.js

@@ -0,0 +1,95 @@
+import { GraphQueryApi, GraphStore, loadGraphApiCached } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+const NEXT = 'shrk graph index';
+export const getGraphSearchTool = {
+    name: 'get_graph_search',
+    description: 'Search the code graph by file path, symbol name, or package name. Returns ranked node summaries. Read-only.',
+    cliCommand: 'graph search',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string' },
+            kind: { type: 'string', enum: ['file', 'symbol', 'package'] },
+            limit: { type: 'number' },
+            exact: { type: 'boolean' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        required: ['query'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const query = (args.query ?? '').trim();
+        if (!query) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'query is required' },
+            };
+        }
+        const limit = Math.max(1, Math.min(200, args.limit ?? 20));
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: `Code-intelligence index is missing. Run '${NEXT}'.`,
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        const api = loadGraphApiCached(ctx.inspection.projectRoot) ?? GraphQueryApi.fromStore(ctx.inspection.projectRoot);
+        const exact = args.exact ?? false;
+        const matches = [];
+        if (!args.kind || args.kind === 'file') {
+            const f = api.findFile(query);
+            if (f)
+                matches.push(f);
+            // Fuzzy fallback (mirrors the CLI): substring match on path/basename so a
+            // bare name like `Foo` finds `packages/x/Foo.ts` without the full path —
+            // otherwise the MCP returned an empty list where the CLI found the file.
+            if (!exact && matches.length < limit) {
+                const q = query.toLowerCase();
+                const seen = new Set(matches.map((n) => n.id));
+                for (const node of api.allFiles()) {
+                    if (seen.has(node.id))
+                        continue;
+                    const p = node.path?.toLowerCase() ?? '';
+                    const base = p.includes('/') ? p.slice(p.lastIndexOf('/') + 1) : p;
+                    if (base.includes(q) || p.includes(q)) {
+                        matches.push(node);
+                        seen.add(node.id);
+                        if (matches.length >= limit)
+                            break;
+                    }
+                }
+            }
+        }
+        if (!args.kind || args.kind === 'symbol') {
+            for (const s of api.findSymbol(query, { exact, limit }))
+                matches.push(s);
+        }
+        if (!args.kind || args.kind === 'package') {
+            const p = api.neighbours(`package:${query}`);
+            if (p)
+                matches.push(p.node);
+        }
+        const data = {
+            schema: 'sharkcraft.graph-search/v1',
+            query,
+            kind: args.kind ?? 'any',
+            total: Math.min(matches.length, limit),
+            matches: matches.slice(0, limit).map(summarise),
+        };
+        return { data: formatObjectArrays(data, input) };
+    },
+};
+function summarise(n) {
+    return {
+        id: n.id,
+        kind: n.kind,
+        label: n.label,
+        ...(n.path ? { path: n.path } : {}),
+        ...(n.line ? { line: n.line } : {}),
+    };
+}

package/dist/tools/get-graph-status.tool.d.ts

@@ -0,0 +1,11 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only status for the on-disk code graph. Returns
+ * { state: 'fresh' | 'stale' | 'corrupt' | 'missing' } and counters.
+ * `corrupt` (store self-integrity) and `stale` (files changed on disk since
+ * indexing) are orthogonal — a store can be digest-valid yet stale — so
+ * precedence is corrupt > stale > fresh. On 'missing', `isError` +
+ * `nextCommand` direct the caller to refresh.
+ */
+export declare const getGraphStatusTool: IToolDefinition;
+//# sourceMappingURL=get-graph-status.tool.d.ts.map

package/dist/tools/get-graph-status.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-status.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-status.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAKpE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,eA4ChC,CAAC"}

package/dist/tools/get-graph-status.tool.js

@@ -0,0 +1,55 @@
+import { detectGraphFreshness, GraphStore } from '@shrkcrft/graph';
+const NEXT = 'shrk graph index';
+const STALE_HINT = `Code-intelligence index is missing or stale. Run '${NEXT}' to build it.`;
+/**
+ * Read-only status for the on-disk code graph. Returns
+ * { state: 'fresh' | 'stale' | 'corrupt' | 'missing' } and counters.
+ * `corrupt` (store self-integrity) and `stale` (files changed on disk since
+ * indexing) are orthogonal — a store can be digest-valid yet stale — so
+ * precedence is corrupt > stale > fresh. On 'missing', `isError` +
+ * `nextCommand` direct the caller to refresh.
+ */
+export const getGraphStatusTool = {
+    name: 'get_graph_status',
+    description: 'Read-only status of the SharkCraft code-intelligence graph: state (fresh/stale/corrupt/missing), file/node/edge counts, and how many files changed/added/deleted since indexing. Returns nextCommand when stale or missing so the agent knows to refresh before trusting graph answers.',
+    cliCommand: 'graph status',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: STALE_HINT,
+                    details: { nextCommand: NEXT, state: 'missing' },
+                },
+            };
+        }
+        const verify = store.verifyDigest();
+        const snap = store.loadSnapshot();
+        const fresh = detectGraphFreshness(ctx.inspection.projectRoot);
+        const behind = fresh.modified.length + fresh.added.length + fresh.deleted.length;
+        const state = !verify.ok ? 'corrupt' : behind > 0 ? 'stale' : 'fresh';
+        return {
+            data: {
+                schema: snap.manifest.schema,
+                state,
+                digestOk: verify.ok,
+                fileCount: snap.manifest.filesIndexed,
+                nodeCount: snap.nodes.size,
+                edgeCount: snap.edges.size,
+                nodesByKind: snap.manifest.nodesByKind,
+                edgesByKind: snap.manifest.edgesByKind,
+                workspacePackages: snap.manifest.workspacePackages,
+                lastIndexedAt: snap.manifest.lastIndexedAt,
+                lastIndexDurationMs: snap.manifest.lastIndexDurationMs,
+                modifiedSinceIndex: fresh.modified.length,
+                newSinceIndex: fresh.added.length,
+                deletedSinceIndex: fresh.deleted.length,
+                ...(behind > 0 ? { nextCommand: 'shrk graph index --changed' } : {}),
+                ...(verify.ok ? {} : { expectedDigest: verify.expected, actualDigest: verify.actual }),
+            },
+        };
+    },
+};

package/dist/tools/get-graph-unresolved.tool.d.ts

@@ -0,0 +1,11 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only MCP mirror of `shrk graph unresolved`. Returns every
+ * `unresolved:<spec>` ImportsFile edge grouped by source file.
+ * Sorted by unresolved-count desc so the worst offenders surface first.
+ *
+ * Same safety contract as the other graph tools: structured
+ * `graph-missing` error when the index isn't built yet.
+ */
+export declare const getGraphUnresolvedTool: IToolDefinition;
+//# sourceMappingURL=get-graph-unresolved.tool.d.ts.map

package/dist/tools/get-graph-unresolved.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-graph-unresolved.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-graph-unresolved.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAyEpC,CAAC"}

package/dist/tools/get-graph-unresolved.tool.js

@@ -0,0 +1,85 @@
+import { EdgeKind, GraphStore } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+const NEXT = 'shrk graph index';
+/**
+ * Read-only MCP mirror of `shrk graph unresolved`. Returns every
+ * `unresolved:<spec>` ImportsFile edge grouped by source file.
+ * Sorted by unresolved-count desc so the worst offenders surface first.
+ *
+ * Same safety contract as the other graph tools: structured
+ * `graph-missing` error when the index isn't built yet.
+ */
+export const getGraphUnresolvedTool = {
+    name: 'get_graph_unresolved',
+    description: 'List every unresolved import in the code graph, grouped by source file. Sorted by unresolved-count desc. Pass `format:"table"` for a token-efficient columnar encoding of the file list. Read-only.',
+    cliCommand: 'graph unresolved',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            limit: { type: 'number' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const limit = typeof args.limit === 'number' && Number.isFinite(args.limit) && args.limit > 0
+            ? args.limit
+            : 200;
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: `Code-intelligence index is missing. Run '${NEXT}'.`,
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        const snap = store.loadSnapshot();
+        const groups = new Map();
+        for (const e of snap.edges.values()) {
+            if (e.kind !== EdgeKind.ImportsFile)
+                continue;
+            if (!e.to.startsWith('unresolved:'))
+                continue;
+            const fromNode = snap.nodes.get(e.from);
+            const spec = e.to.slice('unresolved:'.length);
+            const existing = groups.get(e.from);
+            if (existing) {
+                existing.specifiers.add(spec);
+            }
+            else {
+                groups.set(e.from, {
+                    from: e.from,
+                    ...(fromNode?.path ? { path: fromNode.path } : {}),
+                    specifiers: new Set([spec]),
+                });
+            }
+        }
+        const list = [...groups.values()]
+            .map((g) => ({
+            path: g.path ?? g.from.replace(/^file:/, ''),
+            unresolved: [...g.specifiers].sort(),
+        }))
+            .sort((a, b) => {
+            if (b.unresolved.length !== a.unresolved.length) {
+                return b.unresolved.length - a.unresolved.length;
+            }
+            return a.path.localeCompare(b.path);
+        });
+        const totalEdges = list.reduce((n, g) => n + g.unresolved.length, 0);
+        const data = {
+            schema: 'sharkcraft.graph-unresolved/v1',
+            totalEdges,
+            totalFiles: list.length,
+            truncated: list.length > limit,
+            files: list.slice(0, limit),
+        };
+        // `format:"table"` columnar-encodes the top-level `files` array (one row per
+        // source file); scalars (schema/totalEdges/…) and each row's inner
+        // `unresolved` string array are left untouched by the helper.
+        return { data: formatObjectArrays(data, input) };
+    },
+};

package/dist/tools/get-impact-baseline.tool.d.ts

@@ -0,0 +1,9 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only MCP mirror of `shrk impact baseline show`. Returns the
+ * frozen baseline + the most recent run + the delta between them.
+ * When either side is missing the response carries a structured hint
+ * pointing at the command that fills the gap.
+ */
+export declare const getImpactBaselineTool: IToolDefinition;
+//# sourceMappingURL=get-impact-baseline.tool.d.ts.map

package/dist/tools/get-impact-baseline.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-impact-baseline.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-impact-baseline.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,eA0DnC,CAAC"}