@shrkcrft/mcp-server 0.1.0-alpha.2

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

@@ -0,0 +1,209 @@
+/**
+ * API + boundaries MCP tools. All read-only.
+ */
+import { buildApiReport, buildReposetMap, buildSafetyAuditDeep, buildUpgradeAdvice, computeReleaseTrainReadiness, generatePackDocs, getReleaseTrain, getRoleView, getTaskAwareRoleView, listReleaseTrains, listRoleViews, loadReposetConfig, recommendCommands, scorePack, suggestDiagnostic, } from '@shrkcrft/inspector';
+export const getRoleViewTool = {
+    name: 'get_role_view',
+    description: 'Get a role-specific view (developer/reviewer/architect/release-manager/security/ai-agent). When `task` is supplied, the view is personalised with intent + per-task risk + role-appropriate commands.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            role: { type: 'string' },
+            task: { type: 'string' },
+            riskAware: { type: 'boolean' },
+        },
+        required: ['role'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const role = typeof input['role'] === 'string' ? input['role'] : '';
+        const task = typeof input['task'] === 'string' ? input['task'].trim() : '';
+        if (task.length > 0) {
+            const v = await getTaskAwareRoleView(role, task, ctx.inspection);
+            if (!v) {
+                return {
+                    isError: true,
+                    error: { code: 'role-not-found', message: `Unknown role "${role}".`, details: { role, available: listRoleViews().map((x) => x.role) } },
+                };
+            }
+            return { data: v };
+        }
+        const v = getRoleView(role);
+        if (!v) {
+            return {
+                isError: true,
+                error: { code: 'role-not-found', message: `Unknown role "${role}".`, details: { role, available: listRoleViews().map((x) => x.role) } },
+            };
+        }
+        return { data: v };
+    },
+};
+export const recommendCommandsTool = {
+    name: 'recommend_commands',
+    description: 'Recommend SharkCraft commands for a free-form query or stderr blob. Deterministic — no AI. **For agent first-task grounding prefer `prepare_agent_task`**; this tool is the underlying ranker exposed for ad-hoc lookups.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string' },
+            fromError: { type: 'string' },
+            role: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const query = typeof input['query'] === 'string' ? input['query'] : '';
+        const fromError = typeof input['fromError'] === 'string' ? input['fromError'] : undefined;
+        const role = typeof input['role'] === 'string' ? input['role'] : undefined;
+        const r = await recommendCommands(ctx.inspection, query, {
+            ...(fromError ? { fromError } : {}),
+            ...(role ? { role } : {}),
+        });
+        return { data: r };
+    },
+};
+export const suggestDiagnosticTool = {
+    name: 'suggest_diagnostic',
+    description: 'Suggest the most likely diagnostic for a stderr blob.',
+    inputSchema: {
+        type: 'object',
+        properties: { input: { type: 'string' } },
+        required: ['input'],
+        additionalProperties: false,
+    },
+    async handler(input) {
+        const s = typeof input['input'] === 'string' ? input['input'] : '';
+        return { data: suggestDiagnostic(s) };
+    },
+};
+export const getDashboardExportPreviewTool = {
+    name: 'get_dashboard_export_preview',
+    description: 'Preview what `shrk dashboard export` would write. Read-only — does NOT touch disk.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return {
+            data: {
+                sections: ['repository-map', 'architecture-map', 'intelligence-graph', 'role-views', 'packs', 'commands', 'safety', 'sessions', 'bundles', 'recent-reports', 'index.json'],
+                nextCommand: 'shrk dashboard export --output .sharkcraft/dashboard-data',
+                targetDir: '.sharkcraft/dashboard-data',
+            },
+        };
+    },
+};
+export const getPackQualityReportTool = {
+    name: 'get_pack_quality_report',
+    description: 'Pack quality score for a specific pack name or path. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { pack: { type: 'string' } },
+        required: ['pack'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const target = typeof input['pack'] === 'string' ? input['pack'] : '';
+        const pack = ctx.inspection.packs.validPacks.find((p) => p.packageName === target || p.packageRoot === target);
+        if (!pack) {
+            return {
+                isError: true,
+                error: { code: 'pack-not-found', message: `Pack "${target}" not found.`, details: { target } },
+            };
+        }
+        return { data: scorePack(ctx.inspection, pack) };
+    },
+};
+export const getPackDocsPreviewTool = {
+    name: 'get_pack_docs_preview',
+    description: 'Preview README-style markdown for a pack at the given path. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path'],
+        additionalProperties: false,
+    },
+    async handler(input) {
+        const p = typeof input['path'] === 'string' ? input['path'] : '';
+        return { data: generatePackDocs(p) };
+    },
+};
+export const listReposetTool = {
+    name: 'list_reposet',
+    description: 'List repos in the local reposet config (read-only).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const cfg = loadReposetConfig(ctx.inspection.projectRoot);
+        return { data: cfg ?? { schema: 'sharkcraft.reposet/v1', repos: [] } };
+    },
+};
+export const getReposetMapTool = {
+    name: 'get_reposet_map',
+    description: 'Aggregate map across the reposet (read-only).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const cfg = loadReposetConfig(ctx.inspection.projectRoot);
+        if (!cfg)
+            return { data: { schema: 'sharkcraft.reposet-map/v1', repos: [], note: 'no reposet config' } };
+        const map = await buildReposetMap(cfg);
+        return { data: map };
+    },
+};
+export const listReleaseTrainsTool = {
+    name: 'list_release_trains',
+    description: 'List local release trains.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: listReleaseTrains(ctx.inspection.projectRoot) };
+    },
+};
+export const getReleaseTrainTool = {
+    name: 'get_release_train',
+    description: 'Get a release train by id, with readiness.',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const id = typeof input['id'] === 'string' ? input['id'] : '';
+        const train = getReleaseTrain(ctx.inspection.projectRoot, id);
+        if (!train) {
+            return { isError: true, error: { code: 'release-train-not-found', message: `Train ${id} not found.`, details: { id } } };
+        }
+        const readiness = computeReleaseTrainReadiness(ctx.inspection.projectRoot, train);
+        return { data: { train, readiness } };
+    },
+};
+export const getUpgradeAdviceTool = {
+    name: 'get_upgrade_advice',
+    description: 'Read-only SharkCraft upgrade advice (schema-version detection).',
+    inputSchema: {
+        type: 'object',
+        properties: { from: { type: 'string' }, to: { type: 'string' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const from = typeof input['from'] === 'string' ? input['from'] : undefined;
+        const to = typeof input['to'] === 'string' ? input['to'] : undefined;
+        return { data: buildUpgradeAdvice(ctx.inspection, { ...(from ? { from } : {}), ...(to ? { to } : {}) }) };
+    },
+};
+export const getSafetyAuditDeepTool = {
+    name: 'get_safety_audit_deep',
+    description: 'Deep safety audit: report-site external JS, demo destructive lines, CI permissions.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: await buildSafetyAuditDeep(ctx.inspection) };
+    },
+};
+export const getPackageApiReportTool = {
+    name: 'get_package_api_report',
+    description: 'Public API report for SharkCraft packages.',
+    inputSchema: {
+        type: 'object',
+        properties: { package: { type: 'string' } },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const pkg = typeof input['package'] === 'string' ? input['package'] : undefined;
+        return { data: buildApiReport(ctx.inspection, pkg ? { packageFilter: pkg } : {}) };
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const queryRepositoryIntelligenceTool: IToolDefinition;
+export declare const getArchitectureViolationsTool: IToolDefinition;
+export declare const getArchitectureAreaTool: IToolDefinition;
+export declare const getRiskSignalsTool: IToolDefinition;
+export declare const previewComplianceEvidencePacketTool: IToolDefinition;
+export declare const getPolicyOverrideAuditTool: IToolDefinition;
+export declare const getCommandTaxonomyTool: IToolDefinition;
+export declare const getProductCoherenceTool: IToolDefinition;
+//# sourceMappingURL=r19-extras.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"r19-extras.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r19-extras.tool.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,+BAA+B,EAAE,eAkC7C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAO3C,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAarC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAOhC,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,eAajD,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAOxC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAmBpC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAOrC,CAAC"}

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

@@ -0,0 +1,117 @@
+/**
+ * Repository intelligence MCP tools. All read-only.
+ */
+import { buildArchitectureArea, buildArchitectureViolations, buildProductCoherenceReport, buildRepositoryIntelligenceGraph, computeRiskSignals, parseRepositoryGraphExpression, previewComplianceEvidencePacket, queryRepositoryIntelligence, readPolicyOverrideAudit, } from '@shrkcrft/inspector';
+export const queryRepositoryIntelligenceTool = {
+    name: 'query_repository_intelligence',
+    description: 'Filter the repository intelligence graph by kind/edge/imports/depends-on/text/tag/package/construct. DSL: AND (space, default), OR (literal), not:<filter>. Opt-in alias-resolved imports.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string' },
+            includeImports: { type: 'boolean' },
+            resolveAliases: { type: 'boolean' },
+        },
+        required: ['query'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const raw = typeof input['query'] === 'string' ? input['query'] : '';
+        const resolveAliases = input['resolveAliases'] === true;
+        const includeImports = input['includeImports'] === true || resolveAliases || /imports:|depends-on:/i.test(raw);
+        const graph = await buildRepositoryIntelligenceGraph(ctx.inspection, { includeImports, resolveAliases });
+        const { expression, errors } = parseRepositoryGraphExpression(raw);
+        const r = queryRepositoryIntelligence(graph, expression);
+        return {
+            data: {
+                expression,
+                errors,
+                nodeCount: r.nodes.length,
+                edgeCount: r.edges.length,
+                reasons: r.reasons,
+                nodes: r.nodes.slice(0, 100),
+                edges: r.edges.slice(0, 100),
+            },
+        };
+    },
+};
+export const getArchitectureViolationsTool = {
+    name: 'get_architecture_violations',
+    description: 'Boundary violations report (read-only).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: await buildArchitectureViolations(ctx.inspection) };
+    },
+};
+export const getArchitectureAreaTool = {
+    name: 'get_architecture_area',
+    description: 'Members of an architecture area (layer id).',
+    inputSchema: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const id = typeof input['id'] === 'string' ? input['id'] : '';
+        return { data: await buildArchitectureArea(ctx.inspection, id) };
+    },
+};
+export const getRiskSignalsTool = {
+    name: 'get_risk_signals',
+    description: 'Compute deterministic risk signals (boundary violations, architecture risks, pack signatures, tests).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: await computeRiskSignals(ctx.inspection) };
+    },
+};
+export const previewComplianceEvidencePacketTool = {
+    name: 'preview_compliance_evidence_packet',
+    description: 'Preview what `shrk compliance evidence <profileId>` would write (read-only, does NOT write).',
+    inputSchema: {
+        type: 'object',
+        properties: { profileId: { type: 'string' } },
+        required: ['profileId'],
+        additionalProperties: false,
+    },
+    async handler(input) {
+        const profileId = typeof input['profileId'] === 'string' ? input['profileId'] : '';
+        return { data: previewComplianceEvidencePacket(profileId) };
+    },
+};
+export const getPolicyOverrideAuditTool = {
+    name: 'get_policy_override_audit',
+    description: 'Read the policy override audit trail (read-only).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: { schema: 'sharkcraft.policy-override-audit/v1', entries: readPolicyOverrideAudit(ctx.inspection) } };
+    },
+};
+export const getCommandTaxonomyTool = {
+    name: 'get_command_taxonomy',
+    description: 'Command taxonomy report (read-only).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler() {
+        // The CLI carries the canonical catalog; here we describe the surface
+        // without importing it (no inspector → CLI dependency). Adopters can
+        // run `shrk commands taxonomy` for the full grouped output.
+        return {
+            data: {
+                note: 'Run `shrk commands taxonomy --json` for the live grouped output.',
+                groups: [
+                    'start-here', 'daily-development', 'ai-agent-context', 'review-impact',
+                    'architecture', 'governance-compliance', 'packs', 'ci-reports',
+                    'release-readiness', 'diagnostics', 'advanced',
+                ],
+            },
+        };
+    },
+};
+export const getProductCoherenceTool = {
+    name: 'get_product_coherence',
+    description: 'Verify the SharkCraft product narrative is coherent.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return { data: buildProductCoherenceReport(ctx.inspection) };
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"r20-extras.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r20-extras.tool.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,iCAAiC,EAAE,eA8B/C,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAgCnC,CAAC"}

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

@@ -0,0 +1,65 @@
+/**
+ * Architecture-diff / risk MCP tools. All read-only.
+ */
+import { buildArchitectureViolationsDiff, buildTaskRiskReport, } from '@shrkcrft/inspector';
+export const getArchitectureViolationsDiffTool = {
+    name: 'get_architecture_violations_diff',
+    description: 'Architecture violations diff (read-only). Scope/compare by `since`, `staged`, `files`, `baselineFile`.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            since: { type: 'string' },
+            staged: { type: 'boolean' },
+            files: { type: 'array', items: { type: 'string' } },
+            baselineFile: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const since = typeof input['since'] === 'string' ? input['since'] : undefined;
+        const staged = input['staged'] === true;
+        const baselineFile = typeof input['baselineFile'] === 'string' ? input['baselineFile'] : undefined;
+        const files = Array.isArray(input['files'])
+            ? input['files'].filter((x) => typeof x === 'string')
+            : undefined;
+        const report = await buildArchitectureViolationsDiff(ctx.inspection, {
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+            ...(baselineFile ? { baselineFile } : {}),
+            ...(files ? { files } : {}),
+        });
+        return { data: report };
+    },
+};
+export const getTaskRiskReportTool = {
+    name: 'get_task_risk_report',
+    description: 'Compute a per-task risk report (intent + impact + boundaries + ownership + tests + architecture signals). Read-only. `includeMemory` folds memory-weighted signals into the score.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            files: { type: 'array', items: { type: 'string' } },
+            since: { type: 'string' },
+            staged: { type: 'boolean' },
+            includeMemory: { type: 'boolean' },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const files = Array.isArray(input['files'])
+            ? input['files'].filter((x) => typeof x === 'string')
+            : undefined;
+        const since = typeof input['since'] === 'string' ? input['since'] : undefined;
+        const staged = input['staged'] === true;
+        const includeMemory = input['includeMemory'] === true;
+        const report = await buildTaskRiskReport(task, ctx.inspection, {
+            ...(files ? { files } : {}),
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+            ...(includeMemory ? { includeMemory: true } : {}),
+        });
+        return { data: report };
+    },
+};

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

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

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * Migration / readiness MCP tools. All read-only.
+ */
+import { buildMigrationReadiness, listMigrationProfiles, listMigrationProfilesFromPacks, } from '@shrkcrft/inspector';
+export const getMigrationReadinessTool = {
+    name: 'get_migration_readiness',
+    description: 'Migration readiness verdict for a profile id. Read-only — probes local files and env vars; never runs source.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            profileId: { type: 'string' },
+        },
+        required: ['profileId'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const profileId = typeof input['profileId'] === 'string' ? input['profileId'] : '';
+        const packProfiles = await listMigrationProfilesFromPacks(ctx.inspection);
+        const report = buildMigrationReadiness({
+            profileId,
+            projectRoot: ctx.inspection.projectRoot,
+            customProfiles: packProfiles,
+        });
+        return { data: report };
+    },
+};
+export const listMigrationProfilesTool = {
+    name: 'list_migration_profiles',
+    description: 'List registered migration profiles (built-in + pack-contributed). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const packProfiles = await listMigrationProfilesFromPacks(ctx.inspection);
+        const profiles = listMigrationProfiles(packProfiles).map((p) => ({
+            id: p.id,
+            title: p.title,
+            description: p.description,
+            successVerdict: p.successVerdict,
+            checks: p.checks.length,
+        }));
+        return { data: profiles };
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createAgentContractTool: IToolDefinition;
+export declare const simulatePlanTool: IToolDefinition;
+export declare const getMemoryReportTool: IToolDefinition;
+export declare const getMemoryRiskTool: IToolDefinition;
+export declare const listMemoryFilesTool: IToolDefinition;
+export declare const getMemoryDiagnosticsTool: IToolDefinition;
+export declare const createHealingPlanTool: IToolDefinition;
+export declare const createExecutionGraphTool: IToolDefinition;
+//# sourceMappingURL=r23-extras.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"r23-extras.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r23-extras.tool.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,eAmCrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAsC9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eA0BjC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eAc/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAsBjC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAsBtC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAwCnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAmCtC,CAAC"}