@shrkcrft/mcp-server 0.1.0-alpha.1

package/dist/tools/r26-ingest.tool.js

@@ -0,0 +1,174 @@
+import * as nodePath from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { buildContradictionReport, buildGeneratedCodeReport, buildIngestAdoptionPlan, buildRepositoryKnowledgeModel, buildStabilityMap, IngestDepth, IngestSection, } from '@shrkcrft/inspector';
+function nextHint(cmd) {
+    return `Next: \`${cmd}\` (CLI is the only write path).`;
+}
+function parseDepth(raw) {
+    if (typeof raw !== 'string')
+        return IngestDepth.Standard;
+    const lower = raw.toLowerCase();
+    for (const d of Object.values(IngestDepth))
+        if (d === lower)
+            return d;
+    return IngestDepth.Standard;
+}
+function parseSections(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const s of raw) {
+        if (typeof s !== 'string')
+            continue;
+        for (const v of Object.values(IngestSection)) {
+            if (v === s)
+                out.push(v);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+export const createRepositoryIngestionPlanTool = {
+    name: 'create_repository_ingestion_plan',
+    description: 'Build a SharkCraft repository knowledge model (read-only). Returns the model + a next-command hint. MCP never writes; pass --write-drafts to the CLI to materialise drafts under sharkcraft/ingestion/.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            depth: { type: 'string' },
+            include: { type: 'array', items: { type: 'string' } },
+            exclude: { type: 'array', items: { type: 'string' } },
+            presets: { type: 'array', items: { type: 'string' } },
+            task: { type: 'string' },
+        },
+    },
+    async handler(input, ctx) {
+        const model = await buildRepositoryKnowledgeModel({
+            inspection: ctx.inspection,
+            depth: parseDepth(input.depth),
+            selectedSections: parseSections(input.include),
+            excludedSections: parseSections(input.exclude),
+            forcedPresetIds: Array.isArray(input.presets) ? input.presets.filter((p) => typeof p === 'string') : undefined,
+            ...(typeof input.task === 'string' ? { task: input.task } : {}),
+        });
+        return {
+            text: nextHint('shrk ingest repository --write-drafts'),
+            data: model,
+        };
+    },
+};
+export const getRepositoryKnowledgeModelTool = {
+    name: 'get_repository_knowledge_model',
+    description: 'Return the previously-saved repository knowledge model (`sharkcraft/ingestion/repository-knowledge-model.json`). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const file = nodePath.join(ctx.cwd, 'sharkcraft', 'ingestion', 'repository-knowledge-model.json');
+        if (!existsSync(file)) {
+            return {
+                isError: true,
+                error: { code: 'not-found', message: 'No saved knowledge model. Run `shrk ingest repository --write-drafts` first.' },
+            };
+        }
+        try {
+            const body = JSON.parse(readFileSync(file, 'utf8'));
+            return {
+                text: nextHint('shrk ingest report --format markdown'),
+                data: body,
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                error: { code: 'parse-failed', message: err.message },
+            };
+        }
+    },
+};
+export const getRepositoryIngestionStatusTool = {
+    name: 'get_repository_ingestion_status',
+    description: 'Report whether ingest drafts/adoption files exist on disk. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const base = nodePath.join(ctx.cwd, 'sharkcraft', 'ingestion');
+        const modelExists = existsSync(nodePath.join(base, 'repository-knowledge-model.json'));
+        const adoptionExists = existsSync(nodePath.join(base, 'adoption', 'ingest-adoption-state.json'));
+        return {
+            text: nextHint('shrk ingest status'),
+            data: {
+                ingestDirExists: existsSync(base),
+                modelExists,
+                adoptionExists,
+            },
+        };
+    },
+};
+export const getRepositoryIngestionReportTool = {
+    name: 'get_repository_ingestion_report',
+    description: 'Return a markdown summary of the saved repository knowledge model. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const file = nodePath.join(ctx.cwd, 'sharkcraft', 'ingestion', 'REPOSITORY_KNOWLEDGE_MODEL.md');
+        if (!existsSync(file)) {
+            return {
+                isError: true,
+                error: { code: 'not-found', message: 'No saved report — run `shrk ingest repository --write-drafts` first.' },
+            };
+        }
+        return {
+            text: nextHint('shrk ingest report --format markdown'),
+            data: { markdown: readFileSync(file, 'utf8') },
+        };
+    },
+};
+export const getContradictionReportTool = {
+    name: 'get_contradiction_report',
+    description: 'Detect documentation/code contradictions (missing paths, deprecated CLI usage, missing commands). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const report = buildContradictionReport({ inspection: ctx.inspection });
+        return {
+            text: nextHint('shrk contradictions --format markdown'),
+            data: report,
+        };
+    },
+};
+export const getGeneratedCodeReportTool = {
+    name: 'get_generated_code_report',
+    description: 'Classify generated vs hand-written files; surface protect/policy recommendations. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const report = buildGeneratedCodeReport({ inspection: ctx.inspection });
+        return {
+            text: nextHint('shrk generated report --format markdown'),
+            data: report,
+        };
+    },
+};
+export const getStabilityMapTool = {
+    name: 'get_stability_map',
+    description: 'Classify repo areas as stable/experimental/deprecated/legacy/generated/internal/public-api/high-risk. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const generated = buildGeneratedCodeReport({ inspection: ctx.inspection });
+        const map = buildStabilityMap({
+            inspection: ctx.inspection,
+            generatedRoots: generated.generatedRoots.map((r) => r.path),
+        });
+        return {
+            text: nextHint('shrk stability map --format markdown'),
+            data: map,
+        };
+    },
+};
+export const getIngestAdoptionPreviewTool = {
+    name: 'get_ingest_adoption_preview',
+    description: 'Preview the ingest-adoption plan (safe-append / manual-review / low-confidence / already-covered / generated-protected). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const model = await buildRepositoryKnowledgeModel({ inspection: ctx.inspection });
+        const plan = buildIngestAdoptionPlan({ model });
+        return {
+            text: nextHint('shrk ingest adopt --write-patch'),
+            data: plan,
+        };
+    },
+};

package/dist/tools/r26-task-context.tool.d.ts

@@ -0,0 +1,5 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const understandTaskTool: IToolDefinition;
+export declare const getTaskContextTool: IToolDefinition;
+export declare const validateChangeContextTool: IToolDefinition;
+//# sourceMappingURL=r26-task-context.tool.d.ts.map

package/dist/tools/r26-task-context.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r26-task-context.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r26-task-context.tool.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,kBAAkB,EAAE,eA4ChC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAgChC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eAqCvC,CAAC"}

package/dist/tools/r26-task-context.tool.js

@@ -0,0 +1,121 @@
+import * as nodePath from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { buildContradictionReport, buildGeneratedCodeReport, buildRepositoryKnowledgeModel, buildTaskPacket, buildTaskRiskReport, classifyChangeIntent, getChangedFiles, isGitRepo, } from '@shrkcrft/inspector';
+function nextHint(cmd) {
+    return `Next: \`${cmd}\` (CLI is the only write path).`;
+}
+export const understandTaskTool = {
+    name: 'understand_task',
+    description: 'Return task-specific context (intent + relevant rules + likely files + risks + recommended commands). **Prefer `prepare_agent_task` for first task grounding** — it bundles this with safety notes + next-safe-action. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            task: { type: 'string' },
+            presets: { type: 'array', items: { type: 'string' } },
+        },
+        required: ['task'],
+    },
+    async handler(input, ctx) {
+        const task = typeof input.task === 'string' ? input.task : '';
+        if (!task) {
+            return { isError: true, error: { code: 'bad-input', message: 'task is required' } };
+        }
+        const packet = buildTaskPacket(ctx.inspection, task);
+        const intent = await classifyChangeIntent(task, ctx.inspection);
+        const risk = await buildTaskRiskReport(task, ctx.inspection);
+        const presets = Array.isArray(input.presets) ? input.presets.filter((s) => typeof s === 'string') : undefined;
+        const model = await buildRepositoryKnowledgeModel({
+            inspection: ctx.inspection,
+            task,
+            forcedPresetIds: presets,
+        });
+        return {
+            text: nextHint('shrk understand-task "<task>"'),
+            data: {
+                task,
+                intent,
+                relevantRules: packet.relevantRules.map((r) => ({ id: r.id, title: r.title })),
+                relevantPaths: packet.relevantPaths.map((p) => ({ id: p.id, title: p.title })),
+                relevantTemplates: packet.relevantTemplates.map((t) => ({ id: t.id })),
+                risks: risk.reasons.map((r) => r.message),
+                riskLevel: risk.riskLevel,
+                requiredValidations: packet.recommendedCliCommands,
+                recommendedPipelineId: packet.recommendedPipelines[0]?.pipelineId ?? null,
+                modelPresetIds: model.presets.map((p) => p.preset.id),
+                transformationalIntents: model.transformationalIntents,
+            },
+        };
+    },
+};
+export const getTaskContextTool = {
+    name: 'get_task_context',
+    description: 'Return the most recently saved task context bundle (under .sharkcraft/context/). Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { task: { type: 'string' } },
+    },
+    handler(input, ctx) {
+        const baseDir = nodePath.join(ctx.cwd, '.sharkcraft', 'context');
+        const statusFile = nodePath.join(baseDir, 'status.json');
+        if (!existsSync(statusFile)) {
+            return { isError: true, error: { code: 'not-found', message: 'No task context yet — run `shrk context build --task "..."` first.' } };
+        }
+        const status = JSON.parse(readFileSync(statusFile, 'utf8'));
+        const taskSlug = typeof input.task === 'string'
+            ? input.task.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-+|-+$)/g, '').slice(0, 60)
+            : status.lastTask
+                ? status.lastTask.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-+|-+$)/g, '').slice(0, 60)
+                : '';
+        if (!taskSlug) {
+            return { isError: true, error: { code: 'not-found', message: 'No task slug to look up.' } };
+        }
+        const jsonFile = nodePath.join(baseDir, 'task-contexts', `${taskSlug}.json`);
+        if (!existsSync(jsonFile)) {
+            return { isError: true, error: { code: 'not-found', message: `No bundle for ${taskSlug}` } };
+        }
+        return {
+            text: nextHint('shrk context build --task "<task>"'),
+            data: JSON.parse(readFileSync(jsonFile, 'utf8')),
+        };
+    },
+};
+export const validateChangeContextTool = {
+    name: 'validate_change_context',
+    description: 'Inspect a proposed/staged change for boundary violations, generated-code edits, missing tests, doc contradictions. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            files: { type: 'array', items: { type: 'string' } },
+            since: { type: 'string' },
+            staged: { type: 'boolean' },
+        },
+    },
+    async handler(input, ctx) {
+        const filesIn = Array.isArray(input.files) ? input.files.filter((f) => typeof f === 'string') : [];
+        const since = typeof input.since === 'string' ? input.since : undefined;
+        const staged = input.staged === true;
+        let changed = filesIn;
+        if (changed.length === 0 && isGitRepo(ctx.cwd)) {
+            changed = getChangedFiles(ctx.cwd, { staged, ...(since ? { since } : {}) });
+        }
+        const contradictions = buildContradictionReport({ inspection: ctx.inspection });
+        const generated = buildGeneratedCodeReport({ inspection: ctx.inspection });
+        const generatedPaths = new Set(generated.generatedFiles.map((f) => f.path));
+        const boundaryHits = changed.filter((f) => /(^|\/)packages\/[^\/]+\/src\/index\.(ts|tsx|js)$/.test(f));
+        const generatedHits = changed.filter((f) => generatedPaths.has(f) || f.endsWith('.d.ts'));
+        const docContradictions = contradictions.findings.filter((c) => changed.includes(c.source));
+        return {
+            text: nextHint('shrk validate-change --staged'),
+            data: {
+                changedFiles: changed,
+                boundaryHits,
+                generatedHits,
+                docContradictions: docContradictions.map((c) => ({ source: c.source, line: c.line, message: c.message })),
+                verdict: boundaryHits.length === 0 && generatedHits.length === 0 ? 'pass' : 'review',
+            },
+        };
+    },
+};

package/dist/tools/r27-polyglot.tool.d.ts

@@ -0,0 +1,7 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getPolyglotBoundaryReportTool: IToolDefinition;
+export declare const previewIngestAdoptionPlanTool: IToolDefinition;
+export declare const getLanguageRunPlanTool: IToolDefinition;
+export declare const getLanguageCacheStatusTool: IToolDefinition;
+export declare const getLanguageProfilesLiveTool: IToolDefinition;
+//# sourceMappingURL=r27-polyglot.tool.d.ts.map

package/dist/tools/r27-polyglot.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r27-polyglot.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r27-polyglot.tool.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,6BAA6B,EAAE,eAwB3C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAoC3C,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eA6BpC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAmBxC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,eAQzC,CAAC"}

package/dist/tools/r27-polyglot.tool.js

@@ -0,0 +1,139 @@
+/**
+ * Polyglot boundary / adoption MCP tools. Read-only.
+ *
+ * - get_polyglot_boundary_report
+ * - preview_ingest_adoption_plan (returns the plan only — apply is CLI-only)
+ * - get_language_run_plan (returns a dry-run plan — execute is CLI-only)
+ * - get_language_cache_status
+ *
+ * Every tool returns data + a next-command hint. No tool ever writes.
+ */
+import { readFileSync } from 'node:fs';
+import { buildIngestAdoptionPlan, buildIngestApplyPlan, buildLanguageRunPlan, buildPolyglotBoundaryReport, buildRepositoryKnowledgeModel, detectLanguageProfiles, getLanguageCacheStatus, IngestAdoptionStatus, } from '@shrkcrft/inspector';
+function nextHint(cmd) {
+    return `Next: \`${cmd}\` (CLI is the only write path).`;
+}
+export const getPolyglotBoundaryReportTool = {
+    name: 'get_polyglot_boundary_report',
+    description: 'Polyglot boundary enforcement report (Java/C#/Python/Go/Rust). Returns rules, edges, violations, suggestedFixes. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            language: { type: 'string' },
+            limit: { type: 'number' },
+        },
+    },
+    handler(input, ctx) {
+        const lang = typeof input.language === 'string' ? input.language : undefined;
+        const limit = typeof input.limit === 'number' ? input.limit : undefined;
+        const report = buildPolyglotBoundaryReport({
+            projectRoot: ctx.cwd,
+            ...(lang && lang !== 'all' ? { languages: [lang] } : {}),
+            ...(limit ? { limit } : {}),
+        });
+        return {
+            text: nextHint(`shrk check boundaries --polyglot${lang && lang !== 'all' ? ' --language ' + lang : ''}`),
+            data: report,
+        };
+    },
+};
+export const previewIngestAdoptionPlanTool = {
+    name: 'preview_ingest_adoption_plan',
+    description: 'Preview an ingest adoption apply plan. Read-only — returns the plan body only. To actually apply, run the CLI with the same flags.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            include: { type: 'array', items: { type: 'string' } },
+            includeManualReview: { type: 'boolean' },
+        },
+    },
+    async handler(input, ctx) {
+        const model = await buildRepositoryKnowledgeModel({ inspection: ctx.inspection });
+        const adoption = buildIngestAdoptionPlan({ model });
+        const includeArr = Array.isArray(input.include) ? input.include.map(String) : ['safe-append'];
+        const include = includeArr
+            .map((s) => s)
+            .filter((s) => Object.values(IngestAdoptionStatus).includes(s));
+        const result = buildIngestApplyPlan({
+            plan: adoption,
+            include: include.length > 0 ? include : [IngestAdoptionStatus.SafeAppend],
+            includeManualReview: input.includeManualReview === true,
+        });
+        return {
+            text: nextHint('shrk ingest adopt plan --include safe-append --output sharkcraft/ingestion/adoption/ingest-adopt-plan.json'),
+            data: {
+                plan: result.plan,
+                skipped: result.skipped,
+                fileBodyPreviews: Object.keys(result.files).slice(0, 12).reduce((acc, k) => {
+                    const body = result.files[k] ?? '';
+                    acc[k] = body.slice(0, 600);
+                    return acc;
+                }, {}),
+            },
+        };
+    },
+};
+export const getLanguageRunPlanTool = {
+    name: 'get_language_run_plan',
+    description: 'Plan a per-language test/build/lint command set. Returns the dry-run plan; execution is CLI-only via `shrk languages run --execute`.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            category: { type: 'string' },
+            language: { type: 'string' },
+            commandId: { type: 'string' },
+            allTests: { type: 'boolean' },
+            allowInstall: { type: 'boolean' },
+        },
+    },
+    handler(input, ctx) {
+        const plan = buildLanguageRunPlan({
+            projectRoot: ctx.cwd,
+            category: typeof input.category === 'string' ? input.category : 'test',
+            ...(typeof input.language === 'string' ? { language: input.language } : {}),
+            ...(typeof input.commandId === 'string' ? { commandId: input.commandId } : {}),
+            allTests: input.allTests === true,
+            allowInstall: input.allowInstall === true,
+            execute: false,
+        });
+        return {
+            text: nextHint('shrk languages run --execute' + (input.allowInstall === true ? ' --allow-install' : '')),
+            data: plan,
+        };
+    },
+};
+export const getLanguageCacheStatusTool = {
+    name: 'get_language_cache_status',
+    description: 'Status of the local language profile cache (`.sharkcraft/languages/cache.json`). Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        // SharkCraft version is best-effort — read package.json if present.
+        let version = '0.1.0';
+        try {
+            const pkg = JSON.parse(readFileSync(`${ctx.cwd}/package.json`, 'utf8'));
+            if (typeof pkg.version === 'string')
+                version = pkg.version;
+        }
+        catch {
+            // ignore
+        }
+        const status = getLanguageCacheStatus(ctx.cwd, version);
+        return {
+            text: nextHint(status.fresh ? 'shrk languages detect --cache' : 'shrk languages detect --cache --refresh-cache'),
+            data: status,
+        };
+    },
+};
+// Reuse for completeness — detect on-demand without cache.
+export const getLanguageProfilesLiveTool = {
+    name: 'get_language_profiles_live',
+    description: 'Live language detection (TS/JS/Java/C#/Python/Go/Rust). Pure read-only walk; no cache.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    handler(_input, ctx) {
+        const report = detectLanguageProfiles(ctx.cwd);
+        return { text: nextHint('shrk languages detect --cache'), data: report };
+    },
+};

package/dist/tools/r28-changed-boundary.tool.d.ts

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

package/dist/tools/r28-changed-boundary.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r28-changed-boundary.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r28-changed-boundary.tool.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,4BAA4B,EAAE,eAiE1C,CAAC"}

package/dist/tools/r28-changed-boundary.tool.js

@@ -0,0 +1,77 @@
+/**
+ * Read-only MCP tool: get_changed_boundary_report.
+ *
+ * Returns the boundary engine output filtered to changes introduced by a
+ * specific set of files (working tree, staged, since <ref>, or explicit list).
+ * The tool never writes — applying a fix is CLI-only.
+ */
+import { evaluateBoundaries, scanImports, summarizeImports } from '@shrkcrft/boundaries';
+import { buildPolyglotBoundaryReport, filterViolationsToChangedScope, } from '@shrkcrft/inspector';
+function nextHint(cmd) {
+    return `Next: \`${cmd}\` (CLI is the only write path).`;
+}
+export const getChangedBoundaryReportTool = {
+    name: 'get_changed_boundary_report',
+    description: 'Run the boundary engine (TS + polyglot) and return only the violations introduced or touched by the supplied scope (working tree, staged, since <ref>, or explicit files). Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            since: { type: 'string', description: 'Compare against the given ref (HEAD, origin/main, SHA).' },
+            staged: { type: 'boolean' },
+            files: { type: 'array', items: { type: 'string' } },
+            polyglot: { type: 'boolean', description: 'Include polyglot engine output.' },
+        },
+    },
+    async handler(input, ctx) {
+        const since = typeof input.since === 'string' ? input.since : undefined;
+        const staged = input.staged === true;
+        const files = Array.isArray(input.files) ? input.files : [];
+        const polyglot = input.polyglot === true;
+        const projectRoot = ctx.cwd;
+        const scopeOpts = {
+            projectRoot,
+            ...(files.length > 0 ? { files } : {}),
+            ...(staged ? { staged: true } : {}),
+            ...(since ? { since } : {}),
+            ...(!since && !staged && files.length === 0 ? { includeWorktree: true } : {}),
+        };
+        const rules = ctx.inspection.boundaryRegistry.list();
+        const tsEval = rules.length === 0
+            ? null
+            : evaluateBoundaries(scanImports({ projectRoot }), rules, {});
+        const tsFiltered = tsEval
+            ? filterViolationsToChangedScope(tsEval.violations, scopeOpts)
+            : null;
+        const polyglotReport = polyglot ? buildPolyglotBoundaryReport({ projectRoot }) : null;
+        const polyglotFiltered = polyglotReport
+            ? filterViolationsToChangedScope(polyglotReport.violations, scopeOpts)
+            : null;
+        return {
+            text: nextHint('shrk check boundaries --changed-only' + (polyglot ? ' --polyglot' : '')),
+            data: {
+                schema: 'sharkcraft.changed-boundary-report/v1',
+                mode: tsFiltered?.mode ?? polyglotFiltered?.mode ?? null,
+                changedFiles: tsFiltered?.changedFiles ?? polyglotFiltered?.changedFiles ?? [],
+                typescript: tsFiltered
+                    ? {
+                        total: tsEval?.violations.length ?? 0,
+                        included: tsFiltered.includedViolations,
+                        ignoredLegacyCount: tsFiltered.ignoredLegacyCount,
+                        ignoredLegacyByRule: tsFiltered.ignoredLegacyByRule,
+                    }
+                    : null,
+                polyglot: polyglotFiltered && polyglotReport
+                    ? {
+                        total: polyglotReport.violations.length,
+                        included: polyglotFiltered.includedViolations,
+                        ignoredLegacyCount: polyglotFiltered.ignoredLegacyCount,
+                        ignoredLegacyByRule: polyglotFiltered.ignoredLegacyByRule,
+                        languages: polyglotReport.languages,
+                    }
+                    : null,
+                graphSummary: rules.length > 0 ? summarizeImports(scanImports({ projectRoot })) : null,
+            },
+        };
+    },
+};

package/dist/tools/r28-helpers.tool.d.ts

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

package/dist/tools/r28-helpers.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r28-helpers.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r28-helpers.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,eAAO,MAAM,eAAe,EAAE,eAU7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,eAoB3B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eA2BnC,CAAC"}

package/dist/tools/r28-helpers.tool.js

@@ -0,0 +1,72 @@
+/**
+ * Read-only helper previews.
+ *
+ *  list_helpers
+ *  get_helper
+ *  preview_helper_plan
+ */
+import { buildHelperPlan, HELPERS } from '@shrkcrft/inspector';
+function nextHint(cmd) {
+    return `Next: \`${cmd}\` (CLI is the only write path).`;
+}
+export const listHelpersTool = {
+    name: 'list_helpers',
+    description: 'List available helpers from the helper registry. Read-only.',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    handler() {
+        return {
+            text: nextHint('shrk helper list'),
+            data: HELPERS,
+        };
+    },
+};
+export const getHelperTool = {
+    name: 'get_helper',
+    description: 'Get a helper definition (variables, safety flags). Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    handler(input) {
+        const id = String(input.id ?? '');
+        const def = HELPERS.find((h) => h.id === id);
+        if (!def) {
+            return { text: `Unknown helper id: ${id}`, data: null };
+        }
+        return {
+            text: nextHint(`shrk helper get ${id}`),
+            data: def,
+        };
+    },
+};
+export const previewHelperPlanTool = {
+    name: 'preview_helper_plan',
+    description: 'Preview a helper plan. Read-only — returns the plan, never writes.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id'],
+        properties: {
+            id: { type: 'string' },
+            vars: { type: 'object', additionalProperties: { type: 'string' } },
+        },
+    },
+    handler(input, ctx) {
+        const id = String(input.id ?? '');
+        const vars = (input.vars && typeof input.vars === 'object'
+            ? input.vars
+            : {});
+        try {
+            const plan = buildHelperPlan({ helperId: id, projectRoot: ctx.cwd, vars });
+            return {
+                text: nextHint(`shrk helper plan ${id} --var ${Object.entries(vars).map(([k, v]) => `${k}=${v}`).join(' ')}`),
+                data: plan,
+            };
+        }
+        catch (e) {
+            return { text: `${e.message}`, data: null };
+        }
+    },
+};

package/dist/tools/r28-pack-author.tool.d.ts

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

package/dist/tools/r28-pack-author.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r28-pack-author.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r28-pack-author.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAOpE,eAAO,MAAM,oBAAoB,EAAE,eA6BlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eA0BlC,CAAC"}