@shrkcrft/mcp-server 0.1.0-alpha.1

package/dist/tools/r23-extras.tool.js

@@ -0,0 +1,239 @@
+/**
+ * Agent-contract MCP tools. All read-only.
+ */
+import { buildAgentContract, buildHealingPlanFromCommand, buildHealingPlanFromError, buildHealingPlanFromFile, buildHealingPlanFromReport, buildRepositoryMemory, buildTaskExecutionGraph, loadRepositoryMemory, memoryRiskForTask, simulatePlan, } from '@shrkcrft/inspector';
+export const createAgentContractTool = {
+    name: 'create_agent_contract',
+    description: 'Build a deterministic agent contract for a task (intent + risk + impact + ownership + boundaries + policies + playbooks). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            role: { type: 'string' },
+            mode: { type: 'string' },
+            files: { type: 'array', items: { type: 'string' } },
+            since: { type: 'string' },
+            staged: { type: 'boolean' },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const role = typeof input['role'] === 'string' ? input['role'] : undefined;
+        const mode = typeof input['mode'] === 'string' ? input['mode'] : undefined;
+        const since = typeof input['since'] === 'string' ? input['since'] : undefined;
+        const staged = input['staged'] === true;
+        const files = Array.isArray(input['files'])
+            ? input['files'].filter((x) => typeof x === 'string')
+            : undefined;
+        const contract = await buildAgentContract(task, ctx.inspection, {
+            ...(role ? { role } : {}),
+            ...(mode ? { mode } : {}),
+            ...(files ? { files } : {}),
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+        });
+        return { data: contract };
+    },
+};
+export const simulatePlanTool = {
+    name: 'simulate_plan',
+    description: 'Simulate a saved generation plan (v1 or v2): virtual final content, classified operations, boundary/policy/impact gates, apply readiness. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            planPath: { type: 'string' },
+            strict: { type: 'boolean' },
+            includeBoundaries: { type: 'boolean' },
+            includeImpact: { type: 'boolean' },
+            includeTests: { type: 'boolean' },
+            includePolicies: { type: 'boolean' },
+            includeOwnership: { type: 'boolean' },
+            includeMemory: { type: 'boolean' },
+        },
+        required: ['planPath'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const planPath = typeof input['planPath'] === 'string' ? input['planPath'] : '';
+        if (!planPath) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'planPath is required.' },
+            };
+        }
+        const report = await simulatePlan(ctx.inspection, planPath, {
+            strict: input['strict'] === true,
+            includeBoundaries: input['includeBoundaries'] !== false,
+            includeImpact: input['includeImpact'] !== false,
+            includeTests: input['includeTests'] !== false,
+            includePolicies: input['includePolicies'] !== false,
+            includeOwnership: input['includeOwnership'] !== false,
+            includeMemory: input['includeMemory'] === true,
+        });
+        return { data: report };
+    },
+};
+export const getMemoryReportTool = {
+    name: 'get_memory_report',
+    description: 'Get the local repository memory index (built by `shrk memory build`). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { rebuild: { type: 'boolean' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        if (input['rebuild'] === true) {
+            const built = await buildRepositoryMemory(ctx.inspection);
+            return { data: built };
+        }
+        const index = loadRepositoryMemory(ctx.inspection.projectRoot);
+        if (!index) {
+            return {
+                isError: true,
+                error: {
+                    code: 'no-memory-index',
+                    message: 'No memory index found. Run `shrk memory build` first (or call this tool with rebuild=true).',
+                },
+            };
+        }
+        return { data: index };
+    },
+};
+export const getMemoryRiskTool = {
+    name: 'get_memory_risk',
+    description: 'Compute memory-based risk overlap for a task. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { task: { type: 'string' } },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const index = loadRepositoryMemory(ctx.inspection.projectRoot);
+        return { data: memoryRiskForTask(index, task) };
+    },
+};
+export const listMemoryFilesTool = {
+    name: 'list_memory_files',
+    description: 'List historically risky files from the local memory index. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { limit: { type: 'number' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const index = loadRepositoryMemory(ctx.inspection.projectRoot);
+        if (!index) {
+            return {
+                isError: true,
+                error: {
+                    code: 'no-memory-index',
+                    message: 'No memory index found. Run `shrk memory build` first.',
+                },
+            };
+        }
+        const lim = typeof input['limit'] === 'number' ? input['limit'] : 50;
+        return { data: index.files.slice(0, lim) };
+    },
+};
+export const getMemoryDiagnosticsTool = {
+    name: 'get_memory_diagnostics',
+    description: 'List recurring diagnostics from the local memory index. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { limit: { type: 'number' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const index = loadRepositoryMemory(ctx.inspection.projectRoot);
+        if (!index) {
+            return {
+                isError: true,
+                error: {
+                    code: 'no-memory-index',
+                    message: 'No memory index found. Run `shrk memory build` first.',
+                },
+            };
+        }
+        const lim = typeof input['limit'] === 'number' ? input['limit'] : 50;
+        return { data: index.diagnostics.slice(0, lim) };
+    },
+};
+export const createHealingPlanTool = {
+    name: 'create_healing_plan',
+    description: 'Build a deterministic healing plan from a free-form error string, a log file, a JSON report, or a failed command. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            errorText: { type: 'string' },
+            filePath: { type: 'string' },
+            reportPath: { type: 'string' },
+            command: { type: 'string' },
+            exitCode: { type: 'number' },
+            stderrText: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input) {
+        if (typeof input['errorText'] === 'string' && input['errorText'].length > 0) {
+            return { data: buildHealingPlanFromError(input['errorText']) };
+        }
+        if (typeof input['filePath'] === 'string' && input['filePath'].length > 0) {
+            return { data: buildHealingPlanFromFile(input['filePath']) };
+        }
+        if (typeof input['reportPath'] === 'string' && input['reportPath'].length > 0) {
+            return { data: buildHealingPlanFromReport(input['reportPath']) };
+        }
+        if (typeof input['command'] === 'string' && input['command'].length > 0) {
+            const cmd = input['command'];
+            const code = typeof input['exitCode'] === 'number' ? input['exitCode'] : 1;
+            const stderr = typeof input['stderrText'] === 'string' ? input['stderrText'] : '';
+            return { data: buildHealingPlanFromCommand(cmd, code, stderr) };
+        }
+        return {
+            isError: true,
+            error: {
+                code: 'invalid-input',
+                message: 'Provide one of: errorText, filePath, reportPath, or command + exitCode + stderrText.',
+            },
+        };
+    },
+};
+export const createExecutionGraphTool = {
+    name: 'create_execution_graph',
+    description: 'Build a task execution graph (task → intent → risk → contract → constructs → plans → gates → validation → done). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            role: { type: 'string' },
+            mode: { type: 'string' },
+            files: { type: 'array', items: { type: 'string' } },
+            since: { type: 'string' },
+            staged: { type: 'boolean' },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const role = typeof input['role'] === 'string' ? input['role'] : undefined;
+        const mode = typeof input['mode'] === 'string' ? input['mode'] : undefined;
+        const since = typeof input['since'] === 'string' ? input['since'] : undefined;
+        const staged = input['staged'] === true;
+        const files = Array.isArray(input['files'])
+            ? input['files'].filter((x) => typeof x === 'string')
+            : undefined;
+        const graph = await buildTaskExecutionGraph(task, ctx.inspection, {
+            ...(role ? { role } : {}),
+            ...(mode ? { mode } : {}),
+            ...(files ? { files } : {}),
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+        });
+        return { data: graph };
+    },
+};

package/dist/tools/r24-extras.tool.d.ts

@@ -0,0 +1,9 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getContractStatusTool: IToolDefinition;
+/**
+ * MCP preview only — never writes a file. The human runs
+ * `shrk contract approve … --output …` to actually persist an approval.
+ */
+export declare const createContractApprovalPreviewTool: IToolDefinition;
+export declare const queryExecutionGraphTool: IToolDefinition;
+//# sourceMappingURL=r24-extras.tool.d.ts.map

package/dist/tools/r24-extras.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r24-extras.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r24-extras.tool.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,qBAAqB,EAAE,eAoCnC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iCAAiC,EAAE,eAyD/C,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqCrC,CAAC"}

package/dist/tools/r24-extras.tool.js

@@ -0,0 +1,144 @@
+/**
+ * Memory MCP tools. All read-only.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { AGENT_CONTRACT_APPROVAL_SCHEMA, buildApproval, buildTaskExecutionGraph, checkAgentContract, computeContractHash, queryExecutionGraph, } from '@shrkcrft/inspector';
+function resolveAgainstInspection(planPath, projectRoot) {
+    return nodePath.isAbsolute(planPath) ? planPath : nodePath.resolve(projectRoot, planPath);
+}
+export const getContractStatusTool = {
+    name: 'get_contract_status',
+    description: 'Validate an agent contract (optionally against a plan + approval). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            contractPath: { type: 'string' },
+            planPath: { type: 'string' },
+            approvalPath: { type: 'string' },
+        },
+        required: ['contractPath'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const contractPath = typeof input['contractPath'] === 'string' ? input['contractPath'] : '';
+        if (!contractPath) {
+            return { isError: true, error: { code: 'invalid-input', message: 'contractPath is required.' } };
+        }
+        const abs = resolveAgainstInspection(contractPath, ctx.inspection.projectRoot);
+        if (!existsSync(abs)) {
+            return { isError: true, error: { code: 'not-found', message: `Contract not found: ${abs}` } };
+        }
+        let contract;
+        try {
+            contract = JSON.parse(readFileSync(abs, 'utf8'));
+        }
+        catch (e) {
+            return { isError: true, error: { code: 'invalid-input', message: `Failed to parse contract: ${e.message}` } };
+        }
+        const planPath = typeof input['planPath'] === 'string' ? input['planPath'] : undefined;
+        const approvalPath = typeof input['approvalPath'] === 'string' ? input['approvalPath'] : undefined;
+        const report = await checkAgentContract(ctx.inspection, contract, {
+            ...(planPath ? { planPath: resolveAgainstInspection(planPath, ctx.inspection.projectRoot) } : {}),
+            ...(approvalPath ? { approvalPath: resolveAgainstInspection(approvalPath, ctx.inspection.projectRoot) } : {}),
+        });
+        return { data: report };
+    },
+};
+/**
+ * MCP preview only — never writes a file. The human runs
+ * `shrk contract approve … --output …` to actually persist an approval.
+ */
+export const createContractApprovalPreviewTool = {
+    name: 'create_contract_approval_preview',
+    description: 'Preview a contract approval (does NOT write anything). The human runs `shrk contract approve … --output <file>` to persist. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            contractPath: { type: 'string' },
+            approvedBy: { type: 'string' },
+            reason: { type: 'string' },
+            approvedGates: { type: 'array', items: { type: 'string' } },
+            expiresAt: { type: 'string' },
+        },
+        required: ['contractPath', 'approvedBy', 'reason'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const contractPath = typeof input['contractPath'] === 'string' ? input['contractPath'] : '';
+        const approvedBy = typeof input['approvedBy'] === 'string' ? input['approvedBy'] : '';
+        const reason = typeof input['reason'] === 'string' ? input['reason'] : '';
+        if (!contractPath || !approvedBy || !reason) {
+            return { isError: true, error: { code: 'invalid-input', message: 'contractPath, approvedBy, reason are all required.' } };
+        }
+        const abs = resolveAgainstInspection(contractPath, ctx.inspection.projectRoot);
+        if (!existsSync(abs)) {
+            return { isError: true, error: { code: 'not-found', message: `Contract not found: ${abs}` } };
+        }
+        let contract;
+        try {
+            contract = JSON.parse(readFileSync(abs, 'utf8'));
+        }
+        catch (e) {
+            return { isError: true, error: { code: 'invalid-input', message: `Failed to parse contract: ${e.message}` } };
+        }
+        const hash = computeContractHash(contract);
+        const approval = buildApproval({
+            contractHash: hash,
+            approvedBy,
+            reason,
+            ...(Array.isArray(input['approvedGates'])
+                ? {
+                    approvedGates: input['approvedGates'].filter((x) => typeof x === 'string'),
+                }
+                : {}),
+            ...(typeof input['expiresAt'] === 'string' ? { expiresAt: input['expiresAt'] } : {}),
+        });
+        return {
+            data: {
+                schema: AGENT_CONTRACT_APPROVAL_SCHEMA,
+                approvalPreview: approval,
+                contractHash: hash,
+                nextCommand: `shrk contract approve <contract.json> --by "${approvedBy}" --reason "${reason}" --output <approval.json>`,
+                note: 'Preview only — MCP does not write. The human must run the CLI to persist the approval.',
+            },
+        };
+    },
+};
+export const queryExecutionGraphTool = {
+    name: 'query_execution_graph',
+    description: 'Query a saved execution graph (by JSON path) or rebuild for a task, then return matching nodes/edges. Supported queries: blocks:done, kind:<x>, edge:<x>, text:<x>. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            graphPath: { type: 'string' },
+            task: { type: 'string' },
+            role: { type: 'string' },
+            query: { type: 'string' },
+        },
+        required: ['query'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const query = typeof input['query'] === 'string' ? input['query'] : '';
+        if (!query) {
+            return { isError: true, error: { code: 'invalid-input', message: 'query is required.' } };
+        }
+        const graphPath = typeof input['graphPath'] === 'string' ? input['graphPath'] : undefined;
+        if (graphPath) {
+            const abs = resolveAgainstInspection(graphPath, ctx.inspection.projectRoot);
+            if (!existsSync(abs)) {
+                return { isError: true, error: { code: 'not-found', message: `Graph not found: ${abs}` } };
+            }
+            const graph = JSON.parse(readFileSync(abs, 'utf8'));
+            return { data: queryExecutionGraph(graph, query) };
+        }
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        if (!task) {
+            return { isError: true, error: { code: 'invalid-input', message: 'graphPath or task is required.' } };
+        }
+        const role = typeof input['role'] === 'string' ? input['role'] : undefined;
+        const graph = await buildTaskExecutionGraph(task, ctx.inspection, role ? { role } : {});
+        return { data: queryExecutionGraph(graph, query) };
+    },
+};

package/dist/tools/r25-extras.tool.d.ts

@@ -0,0 +1,11 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getLanguageProfilesTool: IToolDefinition;
+export declare const getLanguageCommandsTool: IToolDefinition;
+export declare const getPolyglotDependencyGraphTool: IToolDefinition;
+export declare const getPolyglotTestImpactTool: IToolDefinition;
+export declare const getLanguageReportTool: IToolDefinition;
+export declare const getMemoryDiffTool: IToolDefinition;
+export declare const getMemoryDriftTool: IToolDefinition;
+export declare const listContractTemplatesTool: IToolDefinition;
+export declare const getContractTemplateTool: IToolDefinition;
+//# sourceMappingURL=r25-extras.tool.d.ts.map

package/dist/tools/r25-extras.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r25-extras.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r25-extras.tool.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,uBAAuB,EAAE,eAQrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAQrC,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eAuB5C,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eAoBvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAenC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA2C/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eA0BhC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eAOvC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqBrC,CAAC"}

package/dist/tools/r25-extras.tool.js

@@ -0,0 +1,186 @@
+/**
+ * Polyglot language MCP tools. All read-only.
+ *
+ * Adds: language profiles + commands + dependency graph + test impact +
+ * language report, memory diff/drift, contract template list/get.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildLanguageCommandReport, computePolyglotTestImpact, detectLanguageProfiles, diffMemoryIndex, getContractTemplate, latestMemorySnapshot, listAllContractTemplates, loadMemorySnapshot, loadRepositoryMemory, scanPolyglotDependencies, } from '@shrkcrft/inspector';
+function resolveAgainst(path, root) {
+    return nodePath.isAbsolute(path) ? path : nodePath.resolve(root, path);
+}
+export const getLanguageProfilesTool = {
+    name: 'get_language_profiles',
+    description: 'Detect language profiles (TS/JS/Java/C#/Python/Go/Rust) and return source/test roots, build tools, and likely commands. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: detectLanguageProfiles(ctx.inspection.projectRoot) };
+    },
+};
+export const getLanguageCommandsTool = {
+    name: 'get_language_commands',
+    description: 'Return per-language install/test/typecheck/lint/build commands derived from the detected language profiles. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: buildLanguageCommandReport(ctx.inspection.projectRoot) };
+    },
+};
+export const getPolyglotDependencyGraphTool = {
+    name: 'get_polyglot_dependency_graph',
+    description: 'Scan Java / C# / Python / Go / Rust imports and return the polyglot dependency graph. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            language: { type: 'string', description: 'all | java | csharp | python | go | rust' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const langRaw = typeof input['language'] === 'string' ? input['language'].toLowerCase() : 'all';
+        const languages = langRaw === 'all'
+            ? undefined
+            : [langRaw];
+        return {
+            data: scanPolyglotDependencies(ctx.inspection.projectRoot, languages ? { languages } : {}),
+        };
+    },
+};
+export const getPolyglotTestImpactTool = {
+    name: 'get_polyglot_test_impact',
+    description: 'Predict per-language test files impacted by a set of changed source files. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: { type: 'array', items: { type: 'string' } },
+        },
+        required: ['files'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const files = Array.isArray(input['files'])
+            ? input['files'].filter((x) => typeof x === 'string')
+            : [];
+        if (files.length === 0) {
+            return { isError: true, error: { code: 'invalid-input', message: 'files[] is required.' } };
+        }
+        return { data: computePolyglotTestImpact(ctx.inspection.projectRoot, files) };
+    },
+};
+export const getLanguageReportTool = {
+    name: 'get_language_report',
+    description: 'One-shot polyglot summary: language profiles + commands + dependency graph + missing-tests hints. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const profiles = detectLanguageProfiles(ctx.inspection.projectRoot);
+        return {
+            data: {
+                profiles,
+                commands: buildLanguageCommandReport(ctx.inspection.projectRoot, profiles),
+                dependencies: scanPolyglotDependencies(ctx.inspection.projectRoot),
+            },
+        };
+    },
+};
+export const getMemoryDiffTool = {
+    name: 'get_memory_diff',
+    description: 'Compare two memory snapshots (or one snapshot + the current index). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            oldPath: { type: 'string' },
+            newPath: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const root = ctx.inspection.projectRoot;
+        const oldPath = typeof input['oldPath'] === 'string' ? input['oldPath'] : '';
+        if (!oldPath) {
+            return { isError: true, error: { code: 'invalid-input', message: 'oldPath is required.' } };
+        }
+        const absOld = resolveAgainst(oldPath, root);
+        if (!existsSync(absOld)) {
+            return { isError: true, error: { code: 'not-found', message: `Snapshot not found: ${absOld}` } };
+        }
+        let before;
+        try {
+            before = JSON.parse(readFileSync(absOld, 'utf8'));
+        }
+        catch (e) {
+            return { isError: true, error: { code: 'invalid-input', message: `Failed to parse snapshot: ${e.message}` } };
+        }
+        const newPath = typeof input['newPath'] === 'string' ? input['newPath'] : '';
+        let after;
+        if (newPath) {
+            const absNew = resolveAgainst(newPath, root);
+            if (!existsSync(absNew)) {
+                return { isError: true, error: { code: 'not-found', message: `Snapshot not found: ${absNew}` } };
+            }
+            after = JSON.parse(readFileSync(absNew, 'utf8'));
+        }
+        else {
+            after = loadRepositoryMemory(root);
+            if (!after) {
+                return { isError: true, error: { code: 'not-found', message: 'No current memory index — run `shrk memory build` first.' } };
+            }
+        }
+        return { data: diffMemoryIndex(before, after) };
+    },
+};
+export const getMemoryDriftTool = {
+    name: 'get_memory_drift',
+    description: 'Compare the current memory index against the latest snapshot under .sharkcraft/memory/history/. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            previousPath: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const root = ctx.inspection.projectRoot;
+        const current = loadRepositoryMemory(root);
+        if (!current) {
+            return { isError: true, error: { code: 'not-found', message: 'No current memory index. Run `shrk memory build` first.' } };
+        }
+        let previous;
+        const prevPath = typeof input['previousPath'] === 'string' ? input['previousPath'] : '';
+        if (prevPath) {
+            previous = loadMemorySnapshot(resolveAgainst(prevPath, root));
+        }
+        else {
+            previous = latestMemorySnapshot(root);
+        }
+        return { data: diffMemoryIndex(previous, current) };
+    },
+};
+export const listContractTemplatesTool = {
+    name: 'list_contract_templates',
+    description: 'List contract templates (built-ins + pack-contributed). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: await listAllContractTemplates(ctx.inspection) };
+    },
+};
+export const getContractTemplateTool = {
+    name: 'get_contract_template',
+    description: 'Get a single contract template by id (built-in + pack-contributed). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const id = typeof input['id'] === 'string' ? input['id'] : '';
+        if (!id) {
+            return { isError: true, error: { code: 'invalid-input', message: 'id is required.' } };
+        }
+        const tpl = getContractTemplate(id) ?? (await listAllContractTemplates(ctx.inspection)).find((t) => t.id === id) ?? null;
+        if (!tpl) {
+            return { isError: true, error: { code: 'not-found', message: `Unknown template id: ${id}` } };
+        }
+        return { data: tpl };
+    },
+};

package/dist/tools/r26-ingest.tool.d.ts

@@ -0,0 +1,10 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createRepositoryIngestionPlanTool: IToolDefinition;
+export declare const getRepositoryKnowledgeModelTool: IToolDefinition;
+export declare const getRepositoryIngestionStatusTool: IToolDefinition;
+export declare const getRepositoryIngestionReportTool: IToolDefinition;
+export declare const getContradictionReportTool: IToolDefinition;
+export declare const getGeneratedCodeReportTool: IToolDefinition;
+export declare const getStabilityMapTool: IToolDefinition;
+export declare const getIngestAdoptionPreviewTool: IToolDefinition;
+//# sourceMappingURL=r26-ingest.tool.d.ts.map

package/dist/tools/r26-ingest.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r26-ingest.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r26-ingest.tool.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAyBpE,eAAO,MAAM,iCAAiC,EAAE,eA4B/C,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,eAyB7C,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,eAiB9C,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,eAiB9C,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAWxC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAWxC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAejC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,eAY1C,CAAC"}