@shrkcrft/mcp-server 0.1.0-alpha.2

package/dist/tools/runtime-reports.tool.js

@@ -0,0 +1,175 @@
+/**
+ * Read-only MCP tools that mirror `shrk report ...`. Each returns the rendered
+ * body (or structured JSON) without writing to disk and without running shell
+ * commands. SharkCraft's MCP contract: data only, plus a `nextCommand` hint.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAdoptionReport, buildCoverageReport, buildDriftReport, buildOnboardingAdoptionPlan, buildOnboardingPlan, buildQualityReport, buildSafetyAudit, readAdoptionState, renderAdoptionReportHtml, renderAdoptionReportMarkdown, renderAdoptionReportText, renderDevSessionHtml, renderDevSessionFinalReport, renderReviewComment, renderReviewHtml, renderQualityHtml, renderSafetyHtml, scanDevSession, } from '@shrkcrft/inspector';
+// DX#4 — derive audit view from ALL_TOOLS at runtime.
+import { ALL_TOOLS } from "./all-tools.js";
+function pickFormat(input, fallback = 'json') {
+    const f = String(input.format ?? fallback).toLowerCase();
+    if (f === 'text' || f === 'markdown' || f === 'html' || f === 'json')
+        return f;
+    return fallback;
+}
+const READ_ONLY_NOTE = 'MCP cannot write — adoption / session / quality / safety / review outputs are returned as data only. Run the corresponding `shrk report ...` to persist.';
+export const getAdoptionReportTool = {
+    name: 'get_adoption_report',
+    description: 'Render the onboarding adoption report (text / markdown / html / json). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', description: 'text|markdown|html|json (default: json)' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const plan = buildOnboardingPlan(ctx.inspection, {});
+        const adoption = buildOnboardingAdoptionPlan({ inspection: ctx.inspection, plan });
+        const state = readAdoptionState(ctx.cwd);
+        const report = buildAdoptionReport({ projectRoot: ctx.cwd, plan: adoption, state });
+        const format = pickFormat(input);
+        if (format === 'html')
+            return { text: renderAdoptionReportHtml(report), data: { format, schema: 'sharkcraft.adoption-report/v1', nextCommand: 'shrk report adoption --format html --output adoption.html', note: READ_ONLY_NOTE } };
+        if (format === 'markdown')
+            return { text: renderAdoptionReportMarkdown(report), data: { format, nextCommand: 'shrk report adoption --format markdown' } };
+        if (format === 'text')
+            return { text: renderAdoptionReportText(report), data: { format } };
+        return { data: { format: 'json', report, nextCommand: 'shrk report adoption --format json', note: READ_ONLY_NOTE } };
+    },
+};
+export const getSessionHtmlReportTool = {
+    name: 'get_session_html_report',
+    description: 'Render an HTML / markdown / json report for a dev session. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+            format: { type: 'string', description: 'html|markdown|json (default: html)' },
+        },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        const load = scanDevSession(ctx.cwd, id);
+        if (!load || !load.state)
+            return { isError: true, data: { error: `no session "${id}"` } };
+        const format = pickFormat(input, 'html');
+        if (format === 'json')
+            return { data: { id, format: 'json', state: load.state, nextCommand: 'shrk report session ' + id + ' --format json', note: READ_ONLY_NOTE } };
+        if (format === 'markdown')
+            return { text: renderDevSessionFinalReport(load, {}), data: { format } };
+        return { text: renderDevSessionHtml(load), data: { format, schema: 'sharkcraft.dev-session/v1', nextCommand: `shrk dev open ${id} --html` } };
+    },
+};
+export const getQualityHtmlReportTool = {
+    name: 'get_quality_html_report',
+    description: 'Render the quality report (html / markdown / json / text). Gates that would run shell commands are recorded as skipped. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { format: { type: 'string' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const report = await buildQualityReport({ inspection: ctx.inspection, config: {}, skipShell: true });
+        const format = pickFormat(input, 'html');
+        if (format === 'json')
+            return { data: { format, report, nextCommand: 'shrk report quality --format json' } };
+        if (format === 'markdown' || format === 'text')
+            return { text: JSON.stringify(report, null, 2) };
+        return { text: renderQualityHtml(report), data: { format, schema: 'sharkcraft.quality-report/v1', nextCommand: 'shrk report quality --format html --output quality.html', note: READ_ONLY_NOTE } };
+    },
+};
+export const getSafetyHtmlReportTool = {
+    name: 'get_safety_html_report',
+    description: 'Render the safety audit (html / markdown / json / text). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { format: { type: 'string' } },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const audit = buildSafetyAudit({
+            inspection: ctx.inspection,
+            catalog: [],
+            mcpTools: ALL_TOOLS.map((t) => ({ name: t.name, description: t.description, canWrite: false })),
+            planSecretEnv: 'SHARKCRAFT_PLAN_SECRET',
+            planSecretConfigured: typeof process.env.SHARKCRAFT_PLAN_SECRET === 'string' && process.env.SHARKCRAFT_PLAN_SECRET.length > 0,
+        });
+        const format = pickFormat(input, 'html');
+        if (format === 'json')
+            return { data: { format, audit, nextCommand: 'shrk report safety --format json' } };
+        if (format === 'markdown' || format === 'text')
+            return { text: JSON.stringify(audit, null, 2) };
+        return { text: renderSafetyHtml(audit), data: { format, schema: 'sharkcraft.safety-audit/v1', nextCommand: 'shrk report safety --format html --output safety.html', note: READ_ONLY_NOTE } };
+    },
+};
+export const getReviewHtmlReportTool = {
+    name: 'get_review_html_report',
+    description: 'Render a review packet as HTML / markdown / json. Pass `packetPath` (relative to cwd) or `packet` (inline object).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            packetPath: { type: 'string' },
+            packet: { type: 'object' },
+            format: { type: 'string' },
+            collapseLongSections: { type: 'boolean' },
+            maxItems: { type: 'integer' },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        let packet = null;
+        if (typeof input.packetPath === 'string') {
+            const abs = nodePath.isAbsolute(input.packetPath) ? input.packetPath : nodePath.resolve(ctx.cwd, input.packetPath);
+            if (!existsSync(abs))
+                return { isError: true, data: { error: `packet not found: ${abs}` } };
+            packet = JSON.parse(readFileSync(abs, 'utf8'));
+        }
+        else if (input.packet && typeof input.packet === 'object') {
+            packet = input.packet;
+        }
+        else {
+            return { isError: true, data: { error: 'provide packetPath or packet' } };
+        }
+        const format = pickFormat(input, 'html');
+        if (format === 'json')
+            return { data: { format, packet, nextCommand: 'shrk report review <packet.json> --format json' } };
+        if (format === 'markdown' || format === 'text')
+            return { text: renderReviewComment(packet, {}), data: { format } };
+        return {
+            text: renderReviewHtml(packet, {
+                ...(input.collapseLongSections ? { collapseLongSections: true } : {}),
+                ...(typeof input.maxItems === 'number' ? { maxItems: input.maxItems } : {}),
+            }),
+            data: { format, schema: 'sharkcraft.review-packet/v1', nextCommand: 'shrk report review <packet.json> --format html' },
+        };
+    },
+};
+export const getCoverageReportRenderedTool = {
+    name: 'get_coverage_report_rendered',
+    description: 'Render the coverage report as JSON (default) or markdown. Read-only.',
+    inputSchema: { type: 'object', properties: { format: { type: 'string' } }, additionalProperties: false },
+    handler(input, ctx) {
+        const r = buildCoverageReport(ctx.inspection);
+        const format = pickFormat(input, 'json');
+        if (format === 'markdown' || format === 'text')
+            return { text: JSON.stringify(r, null, 2) };
+        return { data: { format, report: r, nextCommand: 'shrk report coverage --format json' } };
+    },
+};
+export const getDriftReportRenderedTool = {
+    name: 'get_drift_report_rendered',
+    description: 'Render the drift report as JSON (default) or markdown. Read-only.',
+    inputSchema: { type: 'object', properties: { format: { type: 'string' } }, additionalProperties: false },
+    handler(input, ctx) {
+        const r = buildDriftReport(ctx.inspection);
+        const format = pickFormat(input, 'json');
+        if (format === 'markdown' || format === 'text')
+            return { text: JSON.stringify(r, null, 2) };
+        return { data: { format, report: r, nextCommand: 'shrk report drift --format json' } };
+    },
+};

package/dist/tools/safety-audit.tool.d.ts

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

package/dist/tools/safety-audit.tool.d.ts.map

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

package/dist/tools/safety-audit.tool.js

@@ -0,0 +1,42 @@
+import { buildSafetyAudit } from '@shrkcrft/inspector';
+// DX#4 — derive the audit list at runtime from ALL_TOOLS instead of
+// maintaining a parallel static list.
+import { ALL_TOOLS } from "./all-tools.js";
+import { COMMAND_CATALOG_EXPORT } from "./command-catalog.tool.js";
+const PLAN_SECRET_ENV = 'SHARKCRAFT_PLAN_SECRET';
+export const getSafetyAuditTool = {
+    name: 'get_safety_audit',
+    description: 'Return the SharkCraft safety audit: command safety levels, MCP read-only invariant, pack signature status, verification command trust, plan-signing status, recommendations. READ-ONLY.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+    },
+    async handler(_input, ctx) {
+        const planSecretConfigured = typeof process !== 'undefined' && process.env[PLAN_SECRET_ENV] !== undefined;
+        // Translate the catalog into the audit-input shape (already aligned).
+        const catalog = COMMAND_CATALOG_EXPORT.map((e) => ({
+            command: e.command,
+            description: e.description,
+            category: e.category,
+            safetyLevel: e.safetyLevel,
+            writesFiles: e.writesFiles,
+            writesSource: e.writesSource,
+            runsShell: e.runsShell,
+            requiresReview: e.requiresReview,
+            mcpAvailable: e.mcpAvailable,
+        }));
+        const mcpTools = ALL_TOOLS.map((t) => ({
+            name: t.name,
+            description: t.description,
+        }));
+        const report = buildSafetyAudit({
+            inspection: ctx.inspection,
+            catalog,
+            mcpTools,
+            planSecretEnv: PLAN_SECRET_ENV,
+            planSecretConfigured,
+        });
+        return { data: report };
+    },
+};

package/dist/tools/scaffold-patterns.tool.d.ts

@@ -0,0 +1,5 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listScaffoldPatternsTool: IToolDefinition;
+export declare const getScaffoldPatternTool: IToolDefinition;
+export declare const getScaffoldPatternDoctorTool: IToolDefinition;
+//# sourceMappingURL=scaffold-patterns.tool.d.ts.map

package/dist/tools/scaffold-patterns.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold-patterns.tool.d.ts","sourceRoot":"","sources":["../../src/tools/scaffold-patterns.tool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,wBAAwB,EAAE,eAsBtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAgBpC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,eAkB1C,CAAC"}

package/dist/tools/scaffold-patterns.tool.js

@@ -0,0 +1,59 @@
+import { loadScaffoldPatternsFromInspection, doctorScaffoldPatterns, } from '@shrkcrft/inspector';
+export const listScaffoldPatternsTool = {
+    name: 'list_scaffold_patterns',
+    description: 'List every scaffold pattern contributed by an installed pack. Read-only. Inputs: none.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const r = await loadScaffoldPatternsFromInspection(ctx.inspection);
+        return {
+            data: {
+                patterns: r.patterns.map((p) => ({
+                    id: p.pattern.id,
+                    title: p.pattern.title,
+                    templateId: p.pattern.templateId,
+                    matchPaths: p.pattern.matchPaths,
+                    appliesWhen: p.pattern.appliesWhen,
+                    confidence: p.pattern.confidence,
+                    source: p.source,
+                })),
+                warnings: r.warnings,
+            },
+        };
+    },
+};
+export const getScaffoldPatternTool = {
+    name: 'get_scaffold_pattern',
+    description: 'Get one scaffold pattern by id (full content). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const id = String(input.id ?? '');
+        const r = await loadScaffoldPatternsFromInspection(ctx.inspection);
+        const match = r.patterns.find((p) => p.pattern.id === id);
+        if (!match)
+            return { isError: true, data: { error: `unknown scaffold pattern: ${id}` } };
+        return { data: match };
+    },
+};
+export const getScaffoldPatternDoctorTool = {
+    name: 'get_scaffold_pattern_doctor',
+    description: 'Validate every loaded scaffold pattern (templates exist, strategies recognized, confidence valid). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const r = await loadScaffoldPatternsFromInspection(ctx.inspection);
+        const issues = doctorScaffoldPatterns(r.patterns, ctx.inspection);
+        return {
+            data: {
+                patterns: r.patterns.length,
+                errors: issues.filter((i) => i.severity === 'error').length,
+                warnings: issues.filter((i) => i.severity === 'warning').length,
+                issues,
+                nextCommand: 'shrk scaffolds doctor',
+            },
+        };
+    },
+};

package/dist/tools/schema-inventory.tool.d.ts

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

package/dist/tools/schema-inventory.tool.d.ts.map

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

package/dist/tools/schema-inventory.tool.js

@@ -0,0 +1,23 @@
+import { buildSchemaInventory, findSchemaInventoryEntry } from '@shrkcrft/inspector';
+export const getSchemaInventoryTool = {
+    name: 'get_schema_inventory',
+    description: 'Engine schema-id inventory: known versions, current version, deprecation/back-compat status. Pass `id` for one schema only. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Optional schema id (e.g. "sharkcraft.self-config-doctor").' },
+        },
+        additionalProperties: false,
+    },
+    handler(input) {
+        const id = typeof input.id === 'string' ? input.id : null;
+        if (id) {
+            const entry = findSchemaInventoryEntry(id);
+            if (!entry) {
+                return { data: { found: false, id } };
+            }
+            return { data: { found: true, entry } };
+        }
+        return { data: buildSchemaInventory() };
+    },
+};

package/dist/tools/search-knowledge.tool.d.ts

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

package/dist/tools/search-knowledge.tool.d.ts.map

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

package/dist/tools/search-knowledge.tool.js

@@ -0,0 +1,42 @@
+import { searchKnowledge } from '@shrkcrft/knowledge';
+export const searchKnowledgeTool = {
+    name: 'search_knowledge',
+    description: 'Search knowledge entries by query/tags/types/scope/appliesWhen.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string' },
+            types: { type: 'array', items: { type: 'string' } },
+            scope: { type: 'array', items: { type: 'string' } },
+            tags: { type: 'array', items: { type: 'string' } },
+            appliesWhen: { type: 'array', items: { type: 'string' } },
+            minPriority: { type: 'string' },
+            limit: { type: 'integer', minimum: 1 },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const limit = typeof input.limit === 'number' ? input.limit : 20;
+        const results = searchKnowledge(ctx.inspection.knowledgeEntries, {
+            query: typeof input.query === 'string' ? input.query : undefined,
+            types: input.types,
+            scope: input.scope,
+            tags: input.tags,
+            appliesWhen: input.appliesWhen,
+            minPriority: typeof input.minPriority === 'string' ? input.minPriority : undefined,
+            limit,
+        });
+        return {
+            data: results.map((r) => ({
+                id: r.entry.id,
+                title: r.entry.title,
+                score: r.score,
+                type: r.entry.type,
+                priority: r.entry.priority,
+                tags: r.entry.tags,
+                scope: r.entry.scope,
+                reasons: r.reasons,
+            })),
+        };
+    },
+};

package/dist/tools/search-path-conventions.tool.d.ts

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

package/dist/tools/search-path-conventions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-path-conventions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/search-path-conventions.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,yBAAyB,EAAE,eA6BvC,CAAC"}

package/dist/tools/search-path-conventions.tool.js

@@ -0,0 +1,30 @@
+export const searchPathConventionsTool = {
+    name: 'search_path_conventions',
+    description: 'Search path conventions by query/scope/tags.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string' },
+            scope: { type: 'array', items: { type: 'string' } },
+            tags: { type: 'array', items: { type: 'string' } },
+            limit: { type: 'integer', minimum: 1 },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const results = ctx.inspection.pathService.search({
+            query: typeof input.query === 'string' ? input.query : undefined,
+            scope: input.scope,
+            tags: input.tags,
+            limit: typeof input.limit === 'number' ? input.limit : 20,
+        });
+        return {
+            data: results.map((p) => ({
+                id: p.id,
+                title: p.title,
+                path: p.metadata?.path ?? '',
+                priority: p.priority,
+            })),
+        };
+    },
+};

package/dist/tools/search-templates.tool.d.ts

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

package/dist/tools/search-templates.tool.d.ts.map

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

package/dist/tools/search-templates.tool.js

@@ -0,0 +1,21 @@
+export const searchTemplatesTool = {
+    name: 'search_templates',
+    description: 'Search templates by free-text query.',
+    inputSchema: {
+        type: 'object',
+        properties: { query: { type: 'string' } },
+        required: ['query'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const results = ctx.inspection.templateRegistry.search(String(input.query ?? ''));
+        return {
+            data: results.map((t) => ({
+                id: t.id,
+                name: t.name,
+                description: t.description,
+                tags: t.tags,
+            })),
+        };
+    },
+};

package/dist/tools/search-tuning-explain.tool.d.ts

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

package/dist/tools/search-tuning-explain.tool.d.ts.map

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

package/dist/tools/search-tuning-explain.tool.js

@@ -0,0 +1,17 @@
+import { explainSearchTuning, loadSearchTuning } from '@shrkcrft/inspector';
+export const explainSearchTuningTool = {
+    name: 'explain_search_tuning',
+    description: 'Return a structured explainer for how tuning would influence a given query. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['query'],
+        properties: { query: { type: 'string' }, topN: { type: 'number' } },
+    },
+    async handler(input, ctx) {
+        const query = String(input['query'] ?? '');
+        const topN = typeof input['topN'] === 'number' ? input['topN'] : undefined;
+        await loadSearchTuning(ctx.inspection);
+        const report = await explainSearchTuning(ctx.inspection, query, topN ? { topN } : {});
+        return { data: report };
+    },
+};

package/dist/tools/search-tuning.tool.d.ts

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

package/dist/tools/search-tuning.tool.d.ts.map

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

package/dist/tools/search-tuning.tool.js

@@ -0,0 +1,10 @@
+import { loadSearchTuning } from '@shrkcrft/inspector';
+export const listSearchTuningTool = {
+    name: 'list_search_tuning',
+    description: 'List search-tuning entries contributed by local config and packs. Read-only.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler(_input, ctx) {
+        const { entries, issues } = await loadSearchTuning(ctx.inspection);
+        return { data: { entries, issues } };
+    },
+};

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

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

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

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

package/dist/tools/search.tool.js

@@ -0,0 +1,45 @@
+import { buildSearchIndex, loadConstructs, loadPlaybooks, searchIndex, SearchKind, SearchSource, } from '@shrkcrft/inspector';
+export const searchAllTool = {
+    name: 'search_all',
+    description: 'Unified, deterministic search across knowledge, rules, paths, templates, pipelines, presets, packs, boundaries, docs, sessions, bundles, constructs, and playbooks. No AI / embeddings — pure ranking. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['query'],
+        properties: {
+            query: { type: 'string' },
+            kinds: { type: 'array', items: { type: 'string' } },
+            sources: { type: 'array', items: { type: 'string' } },
+            limit: { type: 'number' },
+            explain: { type: 'boolean' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const query = typeof input['query'] === 'string' ? input['query'] : '';
+        const limit = typeof input['limit'] === 'number' ? input['limit'] : 30;
+        const explain = Boolean(input['explain']);
+        const rawKinds = Array.isArray(input['kinds']) ? input['kinds'] : [];
+        const rawSources = Array.isArray(input['sources']) ? input['sources'] : [];
+        const validKinds = new Set(Object.values(SearchKind));
+        const validSources = new Set(Object.values(SearchSource));
+        const kinds = rawKinds.filter((k) => validKinds.has(k));
+        const sources = rawSources.filter((s) => validSources.has(s));
+        await loadConstructs(ctx.inspection);
+        await loadPlaybooks(ctx.inspection);
+        const index = buildSearchIndex(ctx.inspection);
+        const opts = { query, limit, explain };
+        if (kinds.length > 0)
+            opts.kinds = kinds;
+        if (sources.length > 0)
+            opts.sources = sources;
+        const result = searchIndex(index, opts);
+        return {
+            data: {
+                query: result.query,
+                total: result.total,
+                truncated: result.truncated,
+                hits: result.hits,
+            },
+        };
+    },
+};

package/dist/tools/self-audit.tool.d.ts

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

package/dist/tools/self-audit.tool.d.ts.map

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

package/dist/tools/self-audit.tool.js

@@ -0,0 +1,28 @@
+import { buildSelfAudit, detectSharkcraftRepo, buildReleaseReadiness, buildDocsCheck, buildExamplesCheck } from '@shrkcrft/inspector';
+export const getSelfAuditTool = {
+    name: 'get_self_audit',
+    description: 'Run the SharkCraft self-dogfood audit. Returns a single verdict aggregating release readiness, docs/examples checks, and MCP safety. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false },
+    async handler(_input, ctx) {
+        const isRepo = detectSharkcraftRepo(ctx.cwd);
+        if (!isRepo) {
+            return { data: buildSelfAudit(ctx.cwd) };
+        }
+        const readiness = await buildReleaseReadiness(ctx.inspection, {
+            includeDocsCheck: true,
+            includeExamplesCheck: true,
+        });
+        const docs = buildDocsCheck(ctx.cwd);
+        const examples = buildExamplesCheck(ctx.cwd);
+        return {
+            data: buildSelfAudit(ctx.cwd, {
+                releaseReadinessReady: readiness.ready,
+                releaseReadinessBlockers: readiness.blockers.length,
+                releaseReadinessWarnings: readiness.warnings.length,
+                mcpAuditWriteToolCount: 0,
+                docsCheckOk: docs.ok,
+                examplesCheckOk: examples.ok,
+            }),
+        };
+    },
+};

package/dist/tools/start-here.tool.d.ts

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

package/dist/tools/start-here.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-here.tool.d.ts","sourceRoot":"","sources":["../../src/tools/start-here.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAkB9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAOpC,CAAC"}

package/dist/tools/start-here.tool.js

@@ -0,0 +1,27 @@
+import { buildStartHereReport, buildPrimaryCommandsReport, } from '@shrkcrft/inspector';
+export const getStartHereTool = {
+    name: 'get_start_here',
+    description: 'Return the SharkCraft start-here flow list (30-second explanation + 5 primary flows + safety pledge). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            flow: {
+                type: 'string',
+                enum: ['onboard', 'brief', 'dev', 'review', 'governance', 'packs', 'release'],
+            },
+        },
+        additionalProperties: false,
+    },
+    handler(input) {
+        const flow = typeof input['flow'] === 'string' ? input['flow'] : null;
+        return { data: buildStartHereReport(flow) };
+    },
+};
+export const getPrimaryCommandsTool = {
+    name: 'get_primary_commands',
+    description: 'Return the curated primary SharkCraft command list. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false },
+    handler() {
+        return { data: buildPrimaryCommandsReport() };
+    },
+};

package/dist/tools/test-impact.tool.d.ts

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

package/dist/tools/test-impact.tool.d.ts.map

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