@shrkcrft/mcp-server 0.1.0-alpha.1

package/dist/tools/r33-agent-task-prep.tool.js

@@ -0,0 +1,34 @@
+/**
+ * Canonical agent task entrypoint (read-only).
+ *
+ * Recommended first MCP call for AI agents picking up a task. Returns a
+ * bundle of intent hints, recommended commands, relevant profiles /
+ * conventions / routing hints, and the next safe action.
+ */
+import { prepareAgentTask } from '@shrkcrft/inspector';
+export const prepareAgentTaskTool = {
+    name: 'prepare_agent_task',
+    description: 'Canonical agent task entrypoint — call this FIRST when an AI agent picks up a new task. Returns intent / confidence / recommended commands / relevant profiles & conventions / safety notes / next-safe-action. Read-only. Prefer this over `get_task_packet` or `get_relevant_context` for first task grounding. Recommended commands may include experimental verbs; consult `get_command_catalog` for per-command tier, or call `shrk surface enable <cmd>` on the host before invoking.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['task'],
+        properties: { task: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const task = typeof input.task === 'string' ? input.task : '';
+        if (!task)
+            return { isError: true, error: { code: 'invalid-input', message: 'task is required' } };
+        const packet = await prepareAgentTask(ctx.inspection, task);
+        // Agents need to know that recommend results may
+        // include experimental commands they cannot call directly. The
+        // surface tier system is the source of truth; the snapshot in
+        // `get_command_catalog` carries `tier` per command.
+        return {
+            data: {
+                ...packet,
+                gatingNotice: 'Some recommended commands may be experimental in this repo. Confirm via `get_command_catalog` (each entry has a `tier` field) before invoking; enable via `shrk surface enable <cmd> --write` if needed.',
+            },
+        };
+    },
+};

package/dist/tools/r33-conventions.tool.d.ts

@@ -0,0 +1,5 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listConventionsTool: IToolDefinition;
+export declare const getConventionTool: IToolDefinition;
+export declare const getConventionsDoctorTool: IToolDefinition;
+//# sourceMappingURL=r33-conventions.tool.d.ts.map

package/dist/tools/r33-conventions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-conventions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-conventions.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,mBAAmB,EAAE,eAcjC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eAgB/B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAOtC,CAAC"}

package/dist/tools/r33-conventions.tool.js

@@ -0,0 +1,48 @@
+/**
+ * Read-only MCP tools for the convention registry.
+ */
+import { findConvention, listConventions, listConventionIssues, } from '@shrkcrft/inspector';
+export const listConventionsTool = {
+    name: 'list_conventions',
+    description: 'List registered conventions (naming / path / barrel / layout / …). Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { kind: { type: 'string' }, source: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        let entries = await listConventions(ctx.inspection);
+        if (typeof input.kind === 'string')
+            entries = entries.filter((e) => e.convention.kind === input.kind);
+        if (typeof input.source === 'string')
+            entries = entries.filter((e) => e.source === input.source);
+        return { data: entries };
+    },
+};
+export const getConventionTool = {
+    name: 'get_convention',
+    description: 'Get one convention by id. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    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 entry = await findConvention(ctx.inspection, id);
+        if (!entry)
+            return { isError: true, error: { code: 'not-found', message: `Unknown convention "${id}".` } };
+        return { data: entry };
+    },
+};
+export const getConventionsDoctorTool = {
+    name: 'get_conventions_doctor',
+    description: 'Convention registry doctor — surface load/validation issues. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    async handler(_input, ctx) {
+        return { data: { issues: await listConventionIssues(ctx.inspection) } };
+    },
+};

package/dist/tools/r33-dev-cycle-ci-predict.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getDevCyclePlanTool: IToolDefinition;
+export declare const getCiPredictionTool: IToolDefinition;
+//# sourceMappingURL=r33-dev-cycle-ci-predict.tool.d.ts.map

package/dist/tools/r33-dev-cycle-ci-predict.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-dev-cycle-ci-predict.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-dev-cycle-ci-predict.tool.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,mBAAmB,EAAE,eAgBjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAsBjC,CAAC"}

package/dist/tools/r33-dev-cycle-ci-predict.tool.js

@@ -0,0 +1,44 @@
+/**
+ * Read-only MCP tools for dev cycle plan + CI predict.
+ */
+import { buildCiPredictReport, CiPredictProfileId, DevCycleProfileId, planDevCycle, } from '@shrkcrft/inspector';
+export const getDevCyclePlanTool = {
+    name: 'get_dev_cycle_plan',
+    description: 'Return the deterministic dev cycle plan for a profile. Read-only — never runs commands.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            profile: { type: 'string' },
+        },
+    },
+    async handler(input, _ctx) {
+        const profile = typeof input.profile === 'string' ? input.profile : DevCycleProfileId.SharkcraftSelf;
+        const plan = planDevCycle(profile);
+        if (!plan)
+            return { isError: true, error: { code: 'invalid-input', message: `Unknown dev cycle profile "${profile}".` } };
+        return { data: plan };
+    },
+};
+export const getCiPredictionTool = {
+    name: 'get_ci_prediction',
+    description: 'Predict likely CI gate outcomes from `.sharkcraft/reports/` JSON files. Read-only — does not run commands.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            profile: { type: 'string' },
+            reportsDir: { type: 'string' },
+        },
+    },
+    async handler(input, ctx) {
+        const profile = typeof input.profile === 'string' ? input.profile : CiPredictProfileId.GithubPr;
+        const reportsDir = typeof input.reportsDir === 'string' ? input.reportsDir : undefined;
+        const report = buildCiPredictReport({
+            projectRoot: ctx.cwd,
+            profileId: profile,
+            ...(reportsDir ? { reportsDir } : {}),
+        });
+        return { data: report };
+    },
+};

package/dist/tools/r33-pack-contributions.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getPackContributionsTool: IToolDefinition;
+export declare const getPackConflictsTool: IToolDefinition;
+//# sourceMappingURL=r33-pack-contributions.tool.d.ts.map

package/dist/tools/r33-pack-contributions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-pack-contributions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-pack-contributions.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,wBAAwB,EAAE,eAmBtC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAgBlC,CAAC"}

package/dist/tools/r33-pack-contributions.tool.js

@@ -0,0 +1,42 @@
+/**
+ * Read-only MCP tools for pack contributions inventory + conflicts.
+ */
+import { buildPackContributionsInventory, selectConflicts } from '@shrkcrft/inspector';
+export const getPackContributionsTool = {
+    name: 'get_pack_contributions',
+    description: 'Inventory of every pack/local contribution across every supported kind, with source attribution + conflict list. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            pack: { type: 'string' },
+            kind: { type: 'string' },
+        },
+    },
+    async handler(input, ctx) {
+        const inv = buildPackContributionsInventory(ctx.inspection);
+        let entries = inv.entries;
+        if (typeof input.pack === 'string')
+            entries = entries.filter((e) => e.packageName === input.pack);
+        if (typeof input.kind === 'string')
+            entries = entries.filter((e) => e.kind === input.kind);
+        return { data: { ...inv, entries } };
+    },
+};
+export const getPackConflictsTool = {
+    name: 'get_pack_conflicts',
+    description: 'Pack contribution conflicts (duplicate ids / shadowed / stale signature, …). Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { severity: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const inv = buildPackContributionsInventory(ctx.inspection);
+        let conflicts = selectConflicts(inv);
+        const sev = typeof input.severity === 'string' ? input.severity : undefined;
+        if (sev)
+            conflicts = conflicts.filter((c) => c.severity === sev);
+        return { data: { conflicts, totals: inv.totals } };
+    },
+};

package/dist/tools/r33-pack-signature.tool.d.ts

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

package/dist/tools/r33-pack-signature.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-pack-signature.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-pack-signature.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,0BAA0B,EAAE,eAOxC,CAAC"}

package/dist/tools/r33-pack-signature.tool.js

@@ -0,0 +1,12 @@
+/**
+ * Read-only MCP tool for pack signature freshness.
+ */
+import { buildPackSignatureStatusReport } from '@shrkcrft/inspector';
+export const getPackSignatureStatusTool = {
+    name: 'get_pack_signature_status',
+    description: 'Pack signature freshness across discovered packs. Never fake-signs. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    async handler(_input, ctx) {
+        return { data: buildPackSignatureStatusReport(ctx.inspection) };
+    },
+};

package/dist/tools/r33-routing-helpers.tool.d.ts

@@ -0,0 +1,6 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listTaskRoutingHintsTool: IToolDefinition;
+export declare const explainTaskRoutingTool: IToolDefinition;
+export declare const listHelpersTool: IToolDefinition;
+export declare const getHelperTool: IToolDefinition;
+//# sourceMappingURL=r33-routing-helpers.tool.d.ts.map

package/dist/tools/r33-routing-helpers.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-routing-helpers.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-routing-helpers.tool.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,wBAAwB,EAAE,eAOtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAcpC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAgB7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,eAgB3B,CAAC"}

package/dist/tools/r33-routing-helpers.tool.js

@@ -0,0 +1,63 @@
+/**
+ * Read-only MCP tools for task routing hints + pack helpers.
+ */
+import { explainTaskRouting, findPackHelper, listPackHelpers, listTaskRoutingHints, } from '@shrkcrft/inspector';
+export const listTaskRoutingHintsTool = {
+    name: 'list_task_routing_hints',
+    description: 'List pack/local task routing hints. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    async handler(_input, ctx) {
+        return { data: await listTaskRoutingHints(ctx.inspection) };
+    },
+};
+export const explainTaskRoutingTool = {
+    name: 'explain_task_routing',
+    description: 'Explain which routing hints fire for a task. **For agent first-task grounding prefer `prepare_agent_task`**; use this when you only need the routing trace. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['task'],
+        properties: { task: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const task = typeof input.task === 'string' ? input.task : '';
+        return { data: { task, matches: await explainTaskRouting(ctx.inspection, task) } };
+    },
+};
+export const listHelpersTool = {
+    // Renamed from `list_helpers` to dedup with the helper-registry tool;
+    // both used to register under the same name. The alias on the import side
+    // (`listPackHelpersTool`) was already pointing here.
+    name: 'list_pack_helpers',
+    description: 'List pack/local-contributed helpers. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { source: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        let entries = await listPackHelpers(ctx.inspection);
+        if (typeof input.source === 'string')
+            entries = entries.filter((e) => e.source === input.source);
+        return { data: entries };
+    },
+};
+export const getHelperTool = {
+    name: 'get_helper',
+    description: 'Get one pack/local-contributed helper by id. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = typeof input.id === 'string' ? input.id : '';
+        if (!id)
+            return { isError: true, error: { code: 'invalid-input', message: 'id required' } };
+        const entry = await findPackHelper(ctx.inspection, id);
+        if (!entry)
+            return { isError: true, error: { code: 'not-found', message: `Unknown helper "${id}".` } };
+        return { data: entry };
+    },
+};

package/dist/tools/r33-self-config.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getSelfConfigDoctorTool: IToolDefinition;
+export declare const getSelfConfigGraphTool: IToolDefinition;
+//# sourceMappingURL=r33-self-config.tool.d.ts.map

package/dist/tools/r33-self-config.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r33-self-config.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r33-self-config.tool.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,eAQrC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAOpC,CAAC"}

package/dist/tools/r33-self-config.tool.js

@@ -0,0 +1,20 @@
+/**
+ * Read-only MCP tools for self-config doctor + graph.
+ */
+import { buildSelfConfigDoctorReport, buildSelfConfigGraph, } from '@shrkcrft/inspector';
+export const getSelfConfigDoctorTool = {
+    name: 'get_self_config_doctor',
+    description: 'Run the self-config cross-reference doctor. Validates that knowledge/templates/playbooks/agent-tests/search-tuning/etc. references resolve. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    async handler(_input, ctx) {
+        return { data: await buildSelfConfigDoctorReport(ctx.inspection) };
+    },
+};
+export const getSelfConfigGraphTool = {
+    name: 'get_self_config_graph',
+    description: 'Return the self-config reference graph (nodes + edges + brokenEdges). Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    async handler(_input, ctx) {
+        return { data: await buildSelfConfigGraph(ctx.inspection) };
+    },
+};

package/dist/tools/r34-search-unified.tool.d.ts

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

package/dist/tools/r34-search-unified.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r34-search-unified.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r34-search-unified.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,iBAAiB,EAAE,eA4B/B,CAAC"}

package/dist/tools/r34-search-unified.tool.js

@@ -0,0 +1,38 @@
+/**
+ * Read-only MCP tool for unified search.
+ */
+import { buildUniversalSearch } from '@shrkcrft/inspector';
+export const searchUnifiedTool = {
+    name: 'search_unified',
+    description: 'Universal search palette across every contribution kind. Returns the 7-section unified output + uncertainty footer. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query'],
+        properties: {
+            query: { type: 'string' },
+            kind: { type: 'string' },
+            source: { type: 'string' },
+            limit: { type: 'number' },
+            commandsOnly: { type: 'boolean' },
+            actionsOnly: { type: 'boolean' },
+        },
+    },
+    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 opts = {};
+        if (typeof input.kind === 'string')
+            opts.kind = input.kind;
+        if (typeof input.source === 'string')
+            opts.source = input.source;
+        if (typeof input.limit === 'number')
+            opts.limit = input.limit;
+        if (input.commandsOnly === true)
+            opts.commandsOnly = true;
+        if (input.actionsOnly === true)
+            opts.actionsOnly = true;
+        return { data: await buildUniversalSearch(ctx.inspection, query, opts) };
+    },
+};

package/dist/tools/r35-registration-hints.tool.d.ts

@@ -0,0 +1,5 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listRegistrationHintsTool: IToolDefinition;
+export declare const getRegistrationHintTool: IToolDefinition;
+export declare const previewRegistrationHintTool: IToolDefinition;
+//# sourceMappingURL=r35-registration-hints.tool.d.ts.map

package/dist/tools/r35-registration-hints.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r35-registration-hints.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r35-registration-hints.tool.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,yBAAyB,EAAE,eAavC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAgBrC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,eAwBzC,CAAC"}

package/dist/tools/r35-registration-hints.tool.js

@@ -0,0 +1,69 @@
+/**
+ * Read-only MCP tools for registration hints.
+ *
+ *   list_registration_hints     — enumerate registered hints (filter by source).
+ *   get_registration_hint       — fetch a hint by id.
+ *   preview_registration_hint   — render a preview against the live file system.
+ *
+ * All tools are strictly read-only.
+ */
+import { listRegistrationHints, getRegistrationHint, previewRegistrationHint, } from '@shrkcrft/inspector';
+export const listRegistrationHintsTool = {
+    name: 'list_registration_hints',
+    description: 'List pack/local registration hints. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { source: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        let entries = await listRegistrationHints(ctx.inspection);
+        if (typeof input.source === 'string')
+            entries = entries.filter((e) => e.source === input.source);
+        return { data: entries };
+    },
+};
+export const getRegistrationHintTool = {
+    name: 'get_registration_hint',
+    description: 'Fetch a registration hint by id. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = typeof input.id === 'string' ? input.id : '';
+        if (!id)
+            return { isError: true, error: { code: 'invalid-input', message: 'id required' } };
+        const entry = await getRegistrationHint(ctx.inspection, id);
+        if (!entry)
+            return { isError: true, error: { code: 'not-found', message: `Unknown hint "${id}".` } };
+        return { data: entry };
+    },
+};
+export const previewRegistrationHintTool = {
+    name: 'preview_registration_hint',
+    description: 'Preview a registration hint against the live file system. Read-only — no edits are made; ambiguous discovery is reported, not guessed.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: {
+            id: { type: 'string' },
+            variables: { type: 'object', additionalProperties: { type: 'string' } },
+        },
+    },
+    async handler(input, ctx) {
+        const id = typeof input.id === 'string' ? input.id : '';
+        if (!id)
+            return { isError: true, error: { code: 'invalid-input', message: 'id required' } };
+        const variables = input.variables && typeof input.variables === 'object'
+            ? input.variables
+            : {};
+        const preview = await previewRegistrationHint(ctx.inspection, id, { variables });
+        if (!preview)
+            return { isError: true, error: { code: 'not-found', message: `Unknown hint "${id}".` } };
+        return { data: preview };
+    },
+};

package/dist/tools/r57-specs.tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read-only MCP tools for spec discovery.
+ *
+ * NONE of these tools write. Spec mutation (create / implement / verify)
+ * is CLI-only by design (the safety contract: MCP is read-only).
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listSpecsTool: IToolDefinition;
+export declare const getSpecTool: IToolDefinition;
+export declare const getSpecReviewTool: IToolDefinition;
+export declare const getSpecVerificationTool: IToolDefinition;
+//# sourceMappingURL=r57-specs.tool.d.ts.map

package/dist/tools/r57-specs.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r57-specs.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r57-specs.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,aAAa,EAAE,eAkB3B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,eA8BzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA4B/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eA4BrC,CAAC"}

package/dist/tools/r57-specs.tool.js

@@ -0,0 +1,115 @@
+/**
+ * Read-only MCP tools for spec discovery.
+ *
+ * NONE of these tools write. Spec mutation (create / implement / verify)
+ * is CLI-only by design (the safety contract: MCP is read-only).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { buildSpecList, buildSpecReview, } from '@shrkcrft/inspector';
+import { loadSpec, specMdPath, specVerificationPath, } from '@shrkcrft/generator';
+export const listSpecsTool = {
+    name: 'list_specs',
+    description: 'List every spec under .sharkcraft/specs/. Returns id, slug, title, status, timestamps, hasPlan, hasVerification.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            status: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    cliCommand: 'spec list',
+    handler(input, ctx) {
+        const report = buildSpecList(ctx.cwd);
+        const status = typeof input.status === 'string' ? input.status : undefined;
+        const entries = status ? report.entries.filter((e) => e.status === status) : report.entries;
+        return { data: { ...report, entries } };
+    },
+};
+export const getSpecTool = {
+    name: 'get_spec',
+    description: 'Return a spec\'s canonical view (spec.json) with optionally resolved registry pointers (rule titles / template names).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Spec id (directory name under .sharkcraft/specs/).' },
+            includeBody: { type: 'boolean' },
+        },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    cliCommand: 'spec show',
+    handler(input, ctx) {
+        const id = String(input.id);
+        const loaded = loadSpec(ctx.cwd, id);
+        if (!loaded.ok) {
+            return {
+                isError: true,
+                error: { code: 'spec-not-found', message: `Spec not found: ${id}` },
+            };
+        }
+        const includeBody = input.includeBody === true;
+        return {
+            data: includeBody
+                ? { ...loaded.value.spec, body: loaded.value.body }
+                : loaded.value.spec,
+        };
+    },
+};
+export const getSpecReviewTool = {
+    name: 'get_spec_review',
+    description: 'Run a read-only spec review and return the sharkcraft.spec-review/v1 packet. Does NOT mutate spec.md.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    cliCommand: 'spec review',
+    handler(input, ctx) {
+        const id = String(input.id);
+        const loaded = loadSpec(ctx.cwd, id);
+        if (!loaded.ok) {
+            return {
+                isError: true,
+                error: { code: 'spec-not-found', message: `Spec not found: ${id}` },
+            };
+        }
+        const review = buildSpecReview({
+            spec: loaded.value.spec,
+            specPath: specMdPath(ctx.cwd, id),
+            body: loaded.value.body,
+            inspection: ctx.inspection,
+        });
+        return { data: review };
+    },
+};
+export const getSpecVerificationTool = {
+    name: 'get_spec_verification',
+    description: 'Return the most recent spec verification report (the cached verification.json) or null if `spec verify` has not yet run.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    cliCommand: 'spec verify',
+    handler(input, ctx) {
+        const id = String(input.id);
+        const p = specVerificationPath(ctx.cwd, id);
+        if (!existsSync(p))
+            return { data: null };
+        try {
+            return { data: JSON.parse(readFileSync(p, 'utf8')) };
+        }
+        catch (e) {
+            return {
+                isError: true,
+                error: {
+                    code: 'invalid-verification-json',
+                    message: `Verification report at ${p} is not valid JSON`,
+                    details: { error: e.message },
+                },
+            };
+        }
+    },
+};

package/dist/tools/r58-grounding.tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Two read-only MCP tools for the additive grounding surface.
+ *
+ *   - `get_grounding(task)` — what shrk knows that's relevant to <task>.
+ *   - `check_external_plan(path | content, extractorId?)` — validate an
+ *     external plan file against the live workspace.
+ *
+ * Both are read-only. The CLI is the only write path (matching the
+ * safety contract). No write tools for spec/plan mutation.
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getGroundingTool: IToolDefinition;
+export declare const checkExternalPlanTool: IToolDefinition;
+//# sourceMappingURL=r58-grounding.tool.d.ts.map

package/dist/tools/r58-grounding.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r58-grounding.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r58-grounding.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAeH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAsB9B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAuGnC,CAAC"}