@shrkcrft/mcp-server 0.1.0-alpha.1 → 0.1.0-alpha.10

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

@@ -0,0 +1,127 @@
+import { GraphQueryApi, GraphStore } from '@shrkcrft/graph';
+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' },
+        },
+        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 = 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.id, maxDepth, limit);
+        const direct = closure.layer[1] ?? [];
+        const transitive = closure.all.filter((id) => id !== anchor.id && !direct.includes(id));
+        return {
+            data: {
+                schema: 'sharkcraft.graph-impact/v1',
+                anchor: summarise(anchor),
+                maxDepth,
+                limit,
+                truncated: closure.truncated,
+                directDependents: direct.map((id) => summarise(api.neighbours(id).node)),
+                transitiveDependents: transitive
+                    .slice(0, limit)
+                    .map((id) => summarise(api.neighbours(id).node)),
+                totalReached: closure.all.length - 1,
+            },
+        };
+    },
+};
+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, startId, maxDepth, limit) {
+    const seen = new Set([startId]);
+    const layer = {};
+    let frontier = [startId];
+    let depth = 1;
+    let truncated = false;
+    while (depth <= maxDepth && frontier.length > 0) {
+        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;
+        if (truncated)
+            break;
+    }
+    return { all: [...seen], layer, truncated };
+}
+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-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;AAWpE,eAAO,MAAM,kBAAkB,EAAE,eA6DhC,CAAC"}

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

@@ -0,0 +1,75 @@
+import { GraphQueryApi, GraphStore } from '@shrkcrft/graph';
+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' },
+        },
+        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 = GraphQueryApi.fromStore(ctx.inspection.projectRoot);
+        const matches = [];
+        if (!args.kind || args.kind === 'file') {
+            const f = api.findFile(query);
+            if (f)
+                matches.push(f);
+        }
+        if (!args.kind || args.kind === 'symbol') {
+            const exact = args.exact ?? false;
+            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);
+        }
+        return {
+            data: {
+                schema: 'sharkcraft.graph-search/v1',
+                query,
+                kind: args.kind ?? 'any',
+                total: Math.min(matches.length, limit),
+                matches: matches.slice(0, limit).map(summarise),
+            },
+        };
+    },
+};
+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,9 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only status for the on-disk code graph. Returns
+ * { state: 'fresh' | 'corrupt' | 'missing' } and counters.
+ * On 'missing', `isError` + `error.details.nextCommand` direct the
+ * caller (CLI or human) 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;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAqChC,CAAC"}

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

@@ -0,0 +1,46 @@
+import { 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' | 'corrupt' | 'missing' } and counters.
+ * On 'missing', `isError` + `error.details.nextCommand` direct the
+ * caller (CLI or human) to refresh.
+ */
+export const getGraphStatusTool = {
+    name: 'get_graph_status',
+    description: 'Read-only status of the SharkCraft code-intelligence graph: file/node/edge counts, schema, last indexed time, digest verification. Returns nextCommand when missing.',
+    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();
+        return {
+            data: {
+                schema: snap.manifest.schema,
+                state: verify.ok ? 'fresh' : 'corrupt',
+                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,
+                ...(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;AASpE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAsEpC,CAAC"}

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

@@ -0,0 +1,81 @@
+import { EdgeKind, GraphStore } from '@shrkcrft/graph';
+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. Read-only.',
+    cliCommand: 'graph unresolved',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            limit: { type: 'number' },
+        },
+        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);
+        return {
+            data: {
+                schema: 'sharkcraft.graph-unresolved/v1',
+                totalEdges,
+                totalFiles: list.length,
+                truncated: list.length > limit,
+                files: list.slice(0, limit),
+            },
+        };
+    },
+};

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"}

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

@@ -0,0 +1,65 @@
+import { diffImpactReports, ImpactReportStore, } from '@shrkcrft/impact-engine';
+/**
+ * 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 const getImpactBaselineTool = {
+    name: 'get_impact_baseline',
+    description: 'Return the impact baseline + latest impact run + delta. Read-only mirror of `shrk impact baseline show`.',
+    cliCommand: 'impact baseline show',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+    },
+    handler(_input, ctx) {
+        const store = new ImpactReportStore(ctx.inspection.projectRoot);
+        const baseline = store.readBaseline();
+        const last = store.read();
+        if (!baseline && !last) {
+            return {
+                data: {
+                    schema: 'sharkcraft.impact-baseline/v1',
+                    state: 'missing-both',
+                    baseline: null,
+                    last: null,
+                    nextCommands: ['shrk impact --via-graph <target>', 'shrk impact baseline write'],
+                },
+            };
+        }
+        if (!baseline) {
+            return {
+                data: {
+                    schema: 'sharkcraft.impact-baseline/v1',
+                    state: 'missing-baseline',
+                    baseline: null,
+                    last,
+                    nextCommands: ['shrk impact baseline write'],
+                },
+            };
+        }
+        if (!last) {
+            return {
+                data: {
+                    schema: 'sharkcraft.impact-baseline/v1',
+                    state: 'missing-last',
+                    baseline,
+                    last: null,
+                    nextCommands: ['shrk impact --via-graph <target>'],
+                },
+            };
+        }
+        const delta = diffImpactReports(baseline, last);
+        return {
+            data: {
+                schema: 'sharkcraft.impact-baseline/v1',
+                state: 'present',
+                baseline,
+                last,
+                delta,
+            },
+        };
+    },
+};

package/dist/tools/get-intent-benchmark-run.tool.d.ts

@@ -0,0 +1,12 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only MCP surface for the intent-classifier benchmark. Returns
+ * the latest persisted run + a hint about the source fixture so the
+ * agent can correlate misses against the labelled cases.
+ *
+ * When no run is on disk but a fixture is present, the tool reports
+ * `state: 'fixture-only'` and points at `shrk context benchmark` so
+ * the run can be created without an additional turn of guessing.
+ */
+export declare const getIntentBenchmarkRunTool: IToolDefinition;
+//# sourceMappingURL=get-intent-benchmark-run.tool.d.ts.map

package/dist/tools/get-intent-benchmark-run.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-intent-benchmark-run.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-intent-benchmark-run.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,eA6CvC,CAAC"}

package/dist/tools/get-intent-benchmark-run.tool.js

@@ -0,0 +1,55 @@
+import { loadIntentBenchmark, readBenchmarkRun, } from '@shrkcrft/context-planner';
+/**
+ * Read-only MCP surface for the intent-classifier benchmark. Returns
+ * the latest persisted run + a hint about the source fixture so the
+ * agent can correlate misses against the labelled cases.
+ *
+ * When no run is on disk but a fixture is present, the tool reports
+ * `state: 'fixture-only'` and points at `shrk context benchmark` so
+ * the run can be created without an additional turn of guessing.
+ */
+export const getIntentBenchmarkRunTool = {
+    name: 'get_intent_benchmark_run',
+    description: 'Return the most recent intent-classifier benchmark run. Read-only mirror of `shrk context benchmark`.',
+    cliCommand: 'context benchmark',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+    },
+    handler(_input, ctx) {
+        const root = ctx.inspection.projectRoot;
+        const fixture = loadIntentBenchmark(root);
+        const run = readBenchmarkRun(root);
+        if (!fixture && !run) {
+            return {
+                data: {
+                    schema: 'sharkcraft.intent-benchmark/v1',
+                    state: 'missing',
+                    fixture: null,
+                    run: null,
+                    nextCommands: ['shrk context benchmark seed', 'shrk context benchmark'],
+                },
+            };
+        }
+        if (!run) {
+            return {
+                data: {
+                    schema: 'sharkcraft.intent-benchmark/v1',
+                    state: 'fixture-only',
+                    fixtureCaseCount: fixture?.cases.length ?? 0,
+                    run: null,
+                    nextCommands: ['shrk context benchmark'],
+                },
+            };
+        }
+        return {
+            data: {
+                schema: 'sharkcraft.intent-benchmark/v1',
+                state: 'present',
+                fixtureCaseCount: fixture?.cases.length ?? run.total,
+                run,
+            },
+        };
+    },
+};

package/dist/tools/get-migrations.tool.d.ts

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

package/dist/tools/get-migrations.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-migrations.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-migrations.tool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AA0BpE,eAAO,MAAM,iBAAiB,EAAE,eA+D/B,CAAC"}

package/dist/tools/get-migrations.tool.js

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { findResumePoint } from '@shrkcrft/migrate';
+export const getMigrationsTool = {
+    name: 'get_migrations',
+    description: 'Read-only: list `@shrkcrft/migrate` run state from `.sharkcraft/migrations/*.state.json`. Mirrors the dashboard Migrations panel. Pass `id` to fetch a single run; otherwise returns every saved state newest-first.',
+    cliCommand: 'migrate',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const projectRoot = ctx.inspection.projectRoot;
+        const dir = nodePath.join(projectRoot, '.sharkcraft', 'migrations');
+        if (!existsSync(dir)) {
+            const payload = {
+                schema: 'sharkcraft.mcp-migrations/v1',
+                available: false,
+                total: 0,
+                migrations: [],
+                hint: 'no migrations have been run yet',
+            };
+            return { data: payload };
+        }
+        const rows = [];
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            /* ignore */
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith('.state.json'))
+                continue;
+            const abs = nodePath.join(dir, entry);
+            try {
+                const report = JSON.parse(readFileSync(abs, 'utf8'));
+                if (args.id && report.migration.id !== args.id)
+                    continue;
+                const resumePoint = findResumePoint(report);
+                rows.push({
+                    id: report.migration.id,
+                    title: report.migration.title,
+                    overall: report.overall,
+                    dryRun: report.dryRun,
+                    startedAt: report.startedAt,
+                    totalDurationMs: report.totalDurationMs,
+                    steps: report.steps,
+                    ...(resumePoint !== undefined ? { resumePoint } : {}),
+                });
+            }
+            catch {
+                /* skip corrupt state */
+            }
+        }
+        rows.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+        const payload = {
+            schema: 'sharkcraft.mcp-migrations/v1',
+            available: true,
+            total: rows.length,
+            migrations: rows,
+        };
+        return { data: payload };
+    },
+};

package/dist/tools/get-pattern-registry.tool.d.ts

@@ -0,0 +1,8 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only MCP mirror of `shrk search-structural registry list`.
+ * Returns the full registry payload — the agent can pick a pattern by
+ * id and reference it in subsequent `get_structural_search` calls.
+ */
+export declare const getPatternRegistryTool: IToolDefinition;
+//# sourceMappingURL=get-pattern-registry.tool.d.ts.map

package/dist/tools/get-pattern-registry.tool.d.ts.map

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

package/dist/tools/get-pattern-registry.tool.js

@@ -0,0 +1,40 @@
+import { PatternRegistryStore } from '@shrkcrft/structural-search';
+/**
+ * Read-only MCP mirror of `shrk search-structural registry list`.
+ * Returns the full registry payload — the agent can pick a pattern by
+ * id and reference it in subsequent `get_structural_search` calls.
+ */
+export const getPatternRegistryTool = {
+    name: 'get_pattern_registry',
+    description: 'Return the persistent registry of reusable structural-search patterns. Read-only.',
+    cliCommand: 'search-structural registry list',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+    },
+    handler(_input, ctx) {
+        const store = new PatternRegistryStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                data: {
+                    schema: 'sharkcraft.structural-pattern-registry/v1',
+                    present: false,
+                    path: store.absPath,
+                    patterns: [],
+                    nextCommands: ['shrk search-structural registry seed', 'shrk search-structural registry add'],
+                },
+            };
+        }
+        const reg = store.read();
+        return {
+            data: {
+                schema: reg.schema,
+                present: true,
+                path: store.absPath,
+                patterns: reg.patterns,
+                total: reg.patterns.length,
+            },
+        };
+    },
+};

package/dist/tools/get-quality-gate.tool.d.ts

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

package/dist/tools/get-quality-gate.tool.d.ts.map

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