@shrkcrft/mcp-server 0.1.0-alpha.1

package/dist/tools/dashboard-summary.tool.d.ts

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

package/dist/tools/dashboard-summary.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-summary.tool.d.ts","sourceRoot":"","sources":["../../src/tools/dashboard-summary.tool.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,uBAAuB,EAAE,eA0LrC,CAAC"}

package/dist/tools/dashboard-summary.tool.js

@@ -0,0 +1,182 @@
+import { buildAreaMap, buildAiReadinessReport, buildCoverageReport, buildDriftReport, buildQualityReport, buildReleaseReadiness, buildSafetyAudit, evaluatePolicy, listConstructs, listDevSessionsDetailed, listFeatureBundles, listPlaybooks, } from '@shrkcrft/inspector';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+// DX#4 — derive audit view from ALL_TOOLS at runtime.
+import { ALL_TOOLS } from "./all-tools.js";
+export const getDashboardSummaryTool = {
+    name: 'get_dashboard_summary',
+    description: 'Compact dashboard summary aggregating quality, safety, readiness, coverage, drift, packs, sessions, bundles, command-safety totals, and recommended next commands. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            includeRecentSessions: { type: 'boolean' },
+            includeRecentBundles: { type: 'boolean' },
+            maxItems: { type: 'number' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const inspection = ctx.inspection;
+        const inp = input;
+        const maxItems = typeof inp.maxItems === 'number' ? inp.maxItems : 5;
+        const readiness = (() => {
+            try {
+                return buildAiReadinessReport(inspection);
+            }
+            catch {
+                return { score: 0, grade: 'unknown' };
+            }
+        })();
+        const coverage = (() => {
+            try {
+                return buildCoverageReport(inspection);
+            }
+            catch {
+                return { overall: 0, categories: [] };
+            }
+        })();
+        let drift;
+        try {
+            drift = buildDriftReport(inspection);
+        }
+        catch {
+            drift = { findings: [], counts: { error: 0, warning: 0, info: 0 } };
+        }
+        const areas = buildAreaMap(inspection);
+        const bundles = listFeatureBundles(ctx.cwd);
+        const sessions = listDevSessionsDetailed(ctx.cwd);
+        const constructs = listConstructs(inspection);
+        const playbooks = listPlaybooks(inspection);
+        let quality = null;
+        try {
+            const q = await buildQualityReport({ inspection, config: {} });
+            quality = {
+                score: q.score,
+                overall: q.overall,
+                blockers: q.blockers,
+                warnings: q.warnings,
+            };
+        }
+        catch {
+            quality = null;
+        }
+        let policySummary = null;
+        try {
+            const p = await evaluatePolicy(inspection);
+            policySummary = {
+                registrations: p.registrations.length,
+                checks: p.checks.length,
+                passed: p.summary.passed,
+            };
+        }
+        catch {
+            policySummary = null;
+        }
+        const safety = buildSafetyAudit({
+            inspection,
+            catalog: [],
+            mcpTools: ALL_TOOLS.map((t) => ({ name: t.name, description: t.description })),
+            planSecretEnv: 'SHARKCRAFT_PLAN_SECRET',
+            planSecretConfigured: typeof process.env['SHARKCRAFT_PLAN_SECRET'] === 'string' &&
+                process.env['SHARKCRAFT_PLAN_SECRET'].length > 0,
+        });
+        const reportSiteDir = nodePath.join(ctx.cwd, '.sharkcraft', 'reports', 'site');
+        const siteAvailable = existsSync(reportSiteDir);
+        // Include release-readiness verdict + smoke-report summary when available.
+        let releaseReadinessSummary = null;
+        try {
+            const rr = await buildReleaseReadiness(inspection, {});
+            releaseReadinessSummary = {
+                ready: rr.ready,
+                blockers: rr.blockers.length,
+                warnings: rr.warnings.length,
+            };
+        }
+        catch {
+            releaseReadinessSummary = null;
+        }
+        const smokeReportFile = nodePath.join(ctx.cwd, '.sharkcraft', 'reports', 'release-smoke.json');
+        let smokeSummary = null;
+        if (existsSync(smokeReportFile)) {
+            try {
+                const parsed = JSON.parse(readFileSync(smokeReportFile, 'utf8'));
+                const mtimeMs = statSync(smokeReportFile).mtimeMs;
+                const len = Array.isArray(parsed.scenarios)
+                    ? parsed.scenarios.length
+                    : Number(parsed.scenarios?.length ?? 0);
+                smokeSummary = {
+                    passed: parsed.passed === true,
+                    scenarios: len,
+                    ageMs: Date.now() - mtimeMs,
+                };
+            }
+            catch {
+                smokeSummary = null;
+            }
+        }
+        const next = [];
+        if (!quality || quality.overall === 'fail')
+            next.push('shrk quality');
+        if (drift.counts.error > 0)
+            next.push('shrk drift');
+        if (bundles.some((b) => b.status === 'planned' || b.status === 'partially-applied')) {
+            const id = bundles.find((b) => b.status !== 'applied' && b.status !== 'validated')?.id;
+            if (id)
+                next.push(`shrk bundle status ${id}`);
+        }
+        if (!siteAvailable)
+            next.push('shrk report site');
+        if (constructs.length === 0)
+            next.push('shrk constructs infer');
+        if (playbooks.length === 0)
+            next.push('shrk playbooks list');
+        const data = {
+            schema: 'sharkcraft.dashboard-summary/v2',
+            generatedAt: new Date().toISOString(),
+            quality,
+            safety: {
+                mcpAnyWritable: safety.mcp.anyWritable,
+                writesSource: safety.commands.writesSource.length,
+                writesDrafts: safety.commands.writesDrafts.length,
+                writesSession: safety.commands.writesSession.length,
+                runsShell: safety.commands.runsShell.length,
+                readOnly: safety.commands.readOnly.length,
+            },
+            readiness: { score: readiness.score, grade: readiness.grade },
+            coverage: { overall: coverage.overall, categories: coverage.categories.length },
+            drift: drift.counts,
+            areas: areas.areas.length,
+            bundles: bundles.length,
+            sessions: sessions.length,
+            constructs: constructs.length,
+            playbooks: playbooks.length,
+            packs: {
+                total: inspection.packs.validPacks.length,
+                invalid: inspection.packs.invalidPacks?.length ?? 0,
+            },
+            policy: policySummary,
+            mcpTools: { total: ALL_TOOLS.length, anyWritable: safety.mcp.anyWritable },
+            reportSite: { available: siteAvailable, dir: reportSiteDir },
+            releaseReadiness: releaseReadinessSummary,
+            releaseSmoke: smokeSummary,
+            nextCommands: next.slice(0, maxItems),
+        };
+        if (inp.includeRecentSessions) {
+            data['recentSessions'] = sessions.slice(0, maxItems).map((s) => ({
+                id: s.id,
+                phase: s.phase,
+                task: s.task,
+                nextAction: s.nextAction,
+            }));
+        }
+        if (inp.includeRecentBundles) {
+            data['recentBundles'] = bundles.slice(0, maxItems).map((b) => ({
+                id: b.id,
+                task: b.task,
+                status: b.status,
+                risk: b.riskLevel,
+            }));
+        }
+        return { data };
+    },
+};

package/dist/tools/dev-session.tool.d.ts

@@ -0,0 +1,14 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * MCP tool: preview what a dev session would contain WITHOUT creating it.
+ * Returns the task packet + the exact CLI command the human should run.
+ *
+ * Read-only by contract — MCP never writes.
+ */
+export declare const startDevSessionPreviewTool: IToolDefinition;
+export declare const getDevSessionTool: IToolDefinition;
+export declare const getDevStatusTool: IToolDefinition;
+export declare const getDevNextActionTool: IToolDefinition;
+export declare const getDevReportTool: IToolDefinition;
+export declare const listDevSessionsTool: IToolDefinition;
+//# sourceMappingURL=dev-session.tool.d.ts.map

package/dist/tools/dev-session.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-session.tool.d.ts","sourceRoot":"","sources":["../../src/tools/dev-session.tool.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,eAsCxC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA+B/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAmC9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAkBlC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAsB9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAQjC,CAAC"}

package/dist/tools/dev-session.tool.js

@@ -0,0 +1,167 @@
+import { buildTaskPacket, computeDevNextAction, listDevSessions, renderDevSessionFinalReport, scanDevSession, } from '@shrkcrft/inspector';
+/**
+ * MCP tool: preview what a dev session would contain WITHOUT creating it.
+ * Returns the task packet + the exact CLI command the human should run.
+ *
+ * Read-only by contract — MCP never writes.
+ */
+export const startDevSessionPreviewTool = {
+    name: 'start_dev_session_preview',
+    description: 'Preview what `shrk dev start "<task>"` would produce, WITHOUT creating the session. ' +
+        'Returns the task packet (recommended pipeline + templates + rules + verification commands + ' +
+        'forbidden actions) and the exact CLI command the human should run. MCP never writes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            maxTokens: { type: 'number', minimum: 100, maximum: 20000 },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = String(input.task ?? '').trim();
+        if (!task)
+            return { isError: true, text: 'task is required' };
+        const maxTokens = Number(input.maxTokens ?? 3500);
+        const packet = buildTaskPacket(ctx.inspection, task, { maxTokens });
+        return {
+            data: {
+                task,
+                recommendedPipeline: packet.recommendedPipelines[0] ?? null,
+                recommendedPipelines: packet.recommendedPipelines,
+                selectedTemplates: packet.relevantTemplates.slice(0, 5).map((t) => ({ id: t.id, name: t.name })),
+                relevantRules: packet.relevantRules.slice(0, 5).map((r) => ({ id: r.id, title: r.title })),
+                forbiddenActions: packet.forbiddenActions,
+                verificationCommands: packet.verificationCommands,
+                humanReviewPoints: packet.humanReviewPoints,
+                suggestedGen: packet.suggestedGen ?? null,
+                cliCommand: `shrk dev start "${task.replace(/"/g, '\\"')}"`,
+                note: 'This preview does NOT create a session. Run the cliCommand above to create one ' +
+                    'under .sharkcraft/sessions/. MCP is read-only by contract.',
+            },
+        };
+    },
+};
+export const getDevSessionTool = {
+    name: 'get_dev_session',
+    description: 'Read one dev session by id. Returns task, phase, plans, applied plans, validations, ' +
+        'reports, and computed next action. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        if (!id)
+            return { isError: true, text: 'id is required' };
+        const load = scanDevSession(ctx.cwd, id);
+        if (!load)
+            return { isError: true, text: `No session "${id}".` };
+        const next = computeDevNextAction(load);
+        return {
+            data: {
+                id: load.id,
+                dir: load.dir,
+                task: load.task,
+                legacy: load.legacy,
+                state: load.state,
+                plansOnDisk: load.plansOnDisk,
+                reportsOnDisk: load.reportsOnDisk,
+                intentFiles: load.intentFiles,
+                nextAction: next,
+            },
+        };
+    },
+};
+export const getDevStatusTool = {
+    name: 'get_dev_status',
+    description: 'Get the high-level status of a dev session: phase, plan counts, validation status, ' +
+        'and the next recommended action. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        if (!id)
+            return { isError: true, text: 'id is required' };
+        const load = scanDevSession(ctx.cwd, id);
+        if (!load)
+            return { isError: true, text: `No session "${id}".` };
+        const next = computeDevNextAction(load);
+        return {
+            data: {
+                id: load.id,
+                task: load.task,
+                legacy: load.legacy,
+                phase: load.state?.phase ?? null,
+                plansCount: load.state?.plans.length ?? load.plansOnDisk.length,
+                intentsCount: load.intentFiles.length,
+                reviewedCount: load.state?.plans.filter((p) => p.status === 'reviewed').length ??
+                    load.reportsOnDisk.filter((r) => r.startsWith('plan-review-')).length,
+                validationsCount: load.state?.validations.length ?? 0,
+                appliedCount: load.state?.appliedPlans.length ?? 0,
+                warnings: load.state?.warnings ?? [],
+                nextAction: next,
+            },
+        };
+    },
+};
+export const getDevNextActionTool = {
+    name: 'get_dev_next_action',
+    description: 'Compute the safe next CLI command for an existing dev session: dev plan, plan review, ' +
+        'apply, dev validate, or dev report. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        if (!id)
+            return { isError: true, text: 'id is required' };
+        const load = scanDevSession(ctx.cwd, id);
+        if (!load)
+            return { isError: true, text: `No session "${id}".` };
+        return { data: computeDevNextAction(load) };
+    },
+};
+export const getDevReportTool = {
+    name: 'get_dev_report',
+    description: 'Render the dev session final report (Markdown) WITHOUT writing it. Use shrk dev report ' +
+        '<id> to persist. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        if (!id)
+            return { isError: true, text: 'id is required' };
+        const load = scanDevSession(ctx.cwd, id);
+        if (!load)
+            return { isError: true, text: `No session "${id}".` };
+        const next = computeDevNextAction(load);
+        const md = renderDevSessionFinalReport(load, {
+            nextActionLine: `${next.action} — \`${next.command}\``,
+        });
+        return { data: { id: load.id, markdown: md, nextAction: next } };
+    },
+};
+export const listDevSessionsTool = {
+    name: 'list_dev_sessions',
+    description: 'List all dev session ids under .sharkcraft/sessions/. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const ids = listDevSessions(ctx.cwd);
+        return { data: { sessions: ids.map((id) => ({ id })) } };
+    },
+};

package/dist/tools/diagnostics.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getDiagnosticForCodeTool: IToolDefinition;
+export declare const listDiagnosticsTool: IToolDefinition;
+//# sourceMappingURL=diagnostics.tool.d.ts.map

package/dist/tools/diagnostics.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.tool.d.ts","sourceRoot":"","sources":["../../src/tools/diagnostics.tool.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,wBAAwB,EAAE,eA+BtC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAOjC,CAAC"}

package/dist/tools/diagnostics.tool.js

@@ -0,0 +1,40 @@
+import { buildDiagnosticByCode, getDiagnosticEntry, listDiagnostics, } from '@shrkcrft/inspector';
+export const getDiagnosticForCodeTool = {
+    name: 'get_diagnostic_for_code',
+    description: 'Look up a structured SharkCraft failure diagnostic by code. Provide optional context for the placeholders. Returns problem / likelyCause / nextCommand / docsLink. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['code'],
+        properties: {
+            code: { type: 'string' },
+            context: { type: 'object' },
+        },
+        additionalProperties: false,
+    },
+    handler(input) {
+        const code = String(input['code'] ?? '');
+        const entry = getDiagnosticEntry(code);
+        if (!entry) {
+            return {
+                isError: true,
+                error: {
+                    code: 'unknown-diagnostic',
+                    message: `Unknown diagnostic code "${code}".`,
+                    details: { known: listDiagnostics().map((e) => e.code) },
+                },
+                data: { schema: 'sharkcraft.diagnostic-registry/v1', known: listDiagnostics() },
+            };
+        }
+        const ctx = input['context'] ?? {};
+        const diagnostic = buildDiagnosticByCode(entry.code, ctx);
+        return { data: diagnostic };
+    },
+};
+export const listDiagnosticsTool = {
+    name: 'list_diagnostics',
+    description: 'List every known SharkCraft failure diagnostic. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false },
+    handler() {
+        return { data: { schema: 'sharkcraft.diagnostic-registry/v1', entries: listDiagnostics() } };
+    },
+};

package/dist/tools/docs-check.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getDocsCheckTool: IToolDefinition;
+export declare const getExamplesCheckTool: IToolDefinition;
+//# sourceMappingURL=docs-check.tool.d.ts.map

package/dist/tools/docs-check.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-check.tool.d.ts","sourceRoot":"","sources":["../../src/tools/docs-check.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAO9B,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAOlC,CAAC"}

package/dist/tools/docs-check.tool.js

@@ -0,0 +1,17 @@
+import { buildDocsCheck, buildExamplesCheck } from '@shrkcrft/inspector';
+export const getDocsCheckTool = {
+    name: 'get_docs_check',
+    description: 'Verify docs/ and README content. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false },
+    handler(_input, ctx) {
+        return { data: buildDocsCheck(ctx.cwd) };
+    },
+};
+export const getExamplesCheckTool = {
+    name: 'get_examples_check',
+    description: 'Verify examples/ tree. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false },
+    handler(_input, ctx) {
+        return { data: buildExamplesCheck(ctx.cwd) };
+    },
+};

package/dist/tools/doctor-packs.tool.d.ts

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

package/dist/tools/doctor-packs.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-packs.tool.d.ts","sourceRoot":"","sources":["../../src/tools/doctor-packs.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,eAAe,EAAE,eA6B7B,CAAC"}

package/dist/tools/doctor-packs.tool.js

@@ -0,0 +1,30 @@
+import { buildPackDoctorReport } from '@shrkcrft/inspector';
+export const doctorPacksTool = {
+    name: 'doctor_packs',
+    description: 'Validate pack discovery: invalid manifests, missing contribution files, empty contributions, duplicate ids, template/pipeline quality, action-hint coverage, and (optionally) signatures. Mirrors `shrk packs doctor`.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            requireSignatures: {
+                type: 'boolean',
+                description: 'If true, treat unsigned packs as warnings.',
+            },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const requireSignatures = input.requireSignatures === true;
+        const report = buildPackDoctorReport(ctx.inspection, { requireSignatures });
+        return {
+            data: {
+                passed: report.passed,
+                packsChecked: report.packsChecked,
+                summary: report.summary,
+                discoveredPackCount: ctx.inspection.packs.discoveredPacks.length,
+                validPackCount: ctx.inspection.packs.validPacks.length,
+                invalidPackCount: ctx.inspection.packs.invalidPacks.length,
+                issues: report.issues,
+            },
+        };
+    },
+};

package/dist/tools/explain-generation-target.tool.d.ts

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

package/dist/tools/explain-generation-target.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain-generation-target.tool.d.ts","sourceRoot":"","sources":["../../src/tools/explain-generation-target.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,eAAO,MAAM,2BAA2B,EAAE,eAgDzC,CAAC"}

package/dist/tools/explain-generation-target.tool.js

@@ -0,0 +1,49 @@
+import { resolveTargetPath } from '@shrkcrft/templates';
+import { buildNameVariables } from '@shrkcrft/generator';
+export const explainGenerationTargetTool = {
+    name: 'explain_generation_target',
+    description: 'Explain where a generated file would go and why (based on the template and the closest path convention).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            templateId: { type: 'string' },
+            name: { type: 'string' },
+            variables: { type: 'object', additionalProperties: { type: 'string' } },
+            task: { type: 'string' },
+        },
+        required: ['templateId'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const t = ctx.inspection.templateRegistry.get(String(input.templateId));
+        if (!t)
+            return { isError: true, text: `No template with id "${input.templateId}"` };
+        const nameVars = typeof input.name === 'string' ? buildNameVariables(input.name) : {};
+        const values = { ...nameVars, ...(input.variables ?? {}) };
+        const resolved = resolveTargetPath(t, values, ctx.inspection.projectRoot);
+        const task = typeof input.task === 'string' ? input.task : `generate ${t.id}`;
+        const bestPath = ctx.inspection.pathService.findBestForTask(task);
+        return {
+            data: {
+                template: { id: t.id, name: t.name, description: t.description },
+                resolved: resolved
+                    ? {
+                        rawPath: resolved.rawPath,
+                        absolutePath: resolved.absolutePath,
+                        isInsideProject: resolved.isInsideProject,
+                    }
+                    : null,
+                bestPathConvention: bestPath
+                    ? {
+                        id: bestPath.convention.id,
+                        title: bestPath.convention.title,
+                        path: bestPath.convention.metadata?.path ?? '',
+                        reason: bestPath.reason,
+                        score: bestPath.score,
+                    }
+                    : null,
+                notes: t.postGenerationNotes ?? [],
+            },
+        };
+    },
+};

package/dist/tools/feature-bundle.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listFeatureBundlesTool: IToolDefinition;
+export declare const getFeatureBundleTool: IToolDefinition;
+//# sourceMappingURL=feature-bundle.tool.d.ts.map

package/dist/tools/feature-bundle.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-bundle.tool.d.ts","sourceRoot":"","sources":["../../src/tools/feature-bundle.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,sBAAsB,EAAE,eAiBpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAelC,CAAC"}

package/dist/tools/feature-bundle.tool.js

@@ -0,0 +1,36 @@
+import { listFeatureBundles, readFeatureBundle, } from '@shrkcrft/inspector';
+export const listFeatureBundlesTool = {
+    name: 'list_feature_bundles',
+    description: 'List feature workflow bundles stored under .sharkcraft/bundles. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const all = listFeatureBundles(ctx.cwd);
+        return {
+            data: all.map((b) => ({
+                id: b.id,
+                task: b.task,
+                status: b.status,
+                risk: b.riskLevel,
+                plans: b.plans.length,
+                nextAction: b.nextAction,
+            })),
+        };
+    },
+};
+export const getFeatureBundleTool = {
+    name: 'get_feature_bundle',
+    description: 'Read a feature workflow bundle by id. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input['id'] ?? '');
+        const b = readFeatureBundle(ctx.cwd, id);
+        if (!b)
+            return { isError: true, text: `No bundle "${id}".` };
+        return { data: b };
+    },
+};

package/dist/tools/get-action-hints.tool.d.ts

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

package/dist/tools/get-action-hints.tool.d.ts.map

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

package/dist/tools/get-action-hints.tool.js

@@ -0,0 +1,43 @@
+import { aggregateActionHints, aggregatedHintsToText, KnowledgeIndex, } from '@shrkcrft/knowledge';
+export const getActionHintsTool = {
+    name: 'get_action_hints',
+    description: 'Aggregate action hints (CLI commands, MCP tools, preferred flow, forbidden actions, verification commands, related templates / path conventions, human review markers) from knowledge entries relevant to a task. Use this when you need a single answer to "what should I do next?".',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Natural-language task description.' },
+            entryIds: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional explicit list of knowledge entry ids to aggregate from. Skips the relevance search.',
+            },
+            limit: { type: 'integer', minimum: 1, default: 10 },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const explicitIds = input.entryIds ?? [];
+        let entries = [];
+        if (explicitIds.length) {
+            for (const id of explicitIds) {
+                const entry = ctx.inspection.index.get(id);
+                if (entry)
+                    entries.push(entry);
+            }
+        }
+        else if (typeof input.task === 'string' && input.task.length > 0) {
+            const limit = typeof input.limit === 'number' ? input.limit : 10;
+            const idx = new KnowledgeIndex(ctx.inspection.knowledgeEntries);
+            const results = idx.search({ query: input.task, limit });
+            entries = results.map((r) => r.entry);
+        }
+        else {
+            entries = ctx.inspection.knowledgeEntries.slice();
+        }
+        const hints = aggregateActionHints(entries);
+        return {
+            data: hints,
+            text: aggregatedHintsToText(hints),
+        };
+    },
+};

package/dist/tools/get-agent-instructions.tool.d.ts

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

package/dist/tools/get-agent-instructions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-agent-instructions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-agent-instructions.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,wBAAwB,EAAE,eAOtC,CAAC"}