@shrkcrft/mcp-server 0.1.0-alpha.2 → 0.1.0-alpha.21

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

@@ -0,0 +1 @@
+{"version":3,"file":"deps-audit.tool.d.ts","sourceRoot":"","sources":["../../src/tools/deps-audit.tool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,eAkE3B,CAAC"}

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

@@ -0,0 +1,251 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { GraphQueryApi, GraphStore, NodeKind, loadGraphApiCached } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays, COLUMNAR_LEGEND } from "../server/columnar-format.js";
+import { fitArrayToBudget } from "../server/fit-array-to-budget.js";
+/**
+ * `deps_audit` — MCP wrapper around `shrk deps-audit`. Pure read-only.
+ * Returns the same shape the CLI's `--json` mode emits.
+ *
+ * NOTE: we re-implement the body here rather than shell out so MCP
+ * tools never spawn subprocesses. Identical logic, identical output.
+ */
+export const depsAuditTool = {
+    name: 'deps_audit',
+    description: 'Per-package audit of declared dependencies (package.json) vs actually-imported specifiers (graph). Reports missing + unused deps. Pass `format:"table"` for a token-efficient columnar encoding of the per-package report list. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            package: { type: 'string' },
+            ...FORMAT_INPUT_PROPERTY,
+            maxTokens: {
+                type: 'integer',
+                minimum: 1,
+                description: 'Token budget for the per-package report list. When set and the columnar form still exceeds it, falls back to the lossy SmartCrusher row-sampler (full original cached — retrieve via the returned ccrKey).',
+            },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const onlyPackage = typeof input['package'] === 'string' ? input['package'] : null;
+        const store = new GraphStore(ctx.cwd);
+        if (!store.exists()) {
+            return {
+                data: {
+                    error: 'no-graph',
+                    message: 'The SharkCraft graph index is required for deps-audit.',
+                    nextCommand: 'shrk graph index',
+                },
+            };
+        }
+        const api = loadGraphApiCached(ctx.cwd) ?? GraphQueryApi.fromStore(ctx.cwd);
+        const packages = listWorkspacePackages(ctx.cwd, onlyPackage);
+        const reports = packages.map((p) => buildPackageReport(api, ctx.cwd, p));
+        const totals = reports.reduce((acc, r) => {
+            acc.missing += r.missingDeps.length;
+            acc.unused += r.unusedDeps.length;
+            return acc;
+        }, { missing: 0, unused: 0 });
+        // P5.2: an explicit token budget routes the per-package report list through
+        // the SmartCrusher row-sampler (lossy, CCR-recoverable) when even the
+        // columnar form is over budget.
+        const maxTokens = typeof input.maxTokens === 'number' && input.maxTokens > 0 ? Math.floor(input.maxTokens) : undefined;
+        if (maxTokens) {
+            const fitted = fitArrayToBudget(reports, maxTokens, ctx.ccrStore);
+            return {
+                data: {
+                    _format: 'table',
+                    _legend: COLUMNAR_LEGEND,
+                    totals,
+                    packages: fitted.value,
+                    ...(fitted.ccrKey
+                        ? { ccrKey: fitted.ccrKey, retrieveWith: `retrieve_original { "key": "${fitted.ccrKey}" }` }
+                        : {}),
+                },
+            };
+        }
+        // `format:"table"` columnar-encodes the homogeneous `packages` report
+        // list; the `totals` scalar object is left untouched. The per-package
+        // string arrays (importedSpecifiers/missingDeps/unusedDeps) ride along
+        // inside each compacted row and reconstruct losslessly.
+        return { data: formatObjectArrays({ totals, packages: reports }, input) };
+    },
+};
+function listWorkspacePackages(cwd, onlyName) {
+    const roots = ['packages', 'libs', 'apps'].map((r) => nodePath.join(cwd, r)).filter((d) => existsSync(d));
+    const out = [];
+    for (const root of roots) {
+        let entries;
+        try {
+            entries = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const dir = nodePath.join(root, entry);
+            let stat;
+            try {
+                stat = statSync(dir);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const pkgJsonPath = nodePath.join(dir, 'package.json');
+            if (!existsSync(pkgJsonPath))
+                continue;
+            let pkgJson;
+            try {
+                pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            if (!pkgJson.name)
+                continue;
+            if (onlyName !== null && pkgJson.name !== onlyName)
+                continue;
+            out.push({ name: pkgJson.name, dir, pkgJsonPath });
+        }
+    }
+    return out;
+}
+function buildPackageReport(api, cwd, pkg) {
+    const declared = readDeclaredDeps(pkg.pkgJsonPath);
+    const importedSpecifiers = collectImportedSpecifiersForPackage(api, cwd, pkg.dir);
+    const importerCounts = new Map();
+    for (const s of importedSpecifiers)
+        importerCounts.set(s, (importerCounts.get(s) ?? 0) + 1);
+    const distinctImported = new Set(importedSpecifiers);
+    const declaredAll = new Map();
+    for (const [section, map] of [
+        ['dependencies', declared.dependencies],
+        ['devDependencies', declared.devDependencies],
+        ['peerDependencies', declared.peerDependencies],
+        ['optionalDependencies', declared.optionalDependencies],
+    ]) {
+        for (const k of Object.keys(map))
+            declaredAll.set(k, section);
+    }
+    const missingDeps = [];
+    for (const spec of distinctImported) {
+        if (declaredAll.has(spec))
+            continue;
+        if (spec === pkg.name)
+            continue;
+        missingDeps.push({ specifier: spec, importedFromCount: importerCounts.get(spec) ?? 0 });
+    }
+    missingDeps.sort((a, b) => b.importedFromCount - a.importedFromCount);
+    const unusedDeps = [];
+    for (const [spec, section] of declaredAll.entries()) {
+        if (distinctImported.has(spec))
+            continue;
+        unusedDeps.push({ specifier: spec, section });
+    }
+    unusedDeps.sort((a, b) => a.specifier.localeCompare(b.specifier));
+    return {
+        packageName: pkg.name,
+        packageDir: nodePath.relative(cwd, pkg.dir) || '.',
+        importedSpecifiers: [...distinctImported],
+        missingDeps,
+        unusedDeps,
+    };
+}
+function readDeclaredDeps(pkgJsonPath) {
+    try {
+        const body = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+        return {
+            dependencies: asStringMap(body['dependencies']),
+            devDependencies: asStringMap(body['devDependencies']),
+            peerDependencies: asStringMap(body['peerDependencies']),
+            optionalDependencies: asStringMap(body['optionalDependencies']),
+        };
+    }
+    catch {
+        return { dependencies: {}, devDependencies: {}, peerDependencies: {}, optionalDependencies: {} };
+    }
+}
+function asStringMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+}
+function collectImportedSpecifiersForPackage(api, cwd, packageDir) {
+    const out = [];
+    const relDir = nodePath.relative(cwd, packageDir).replace(/\\/g, '/');
+    for (const file of api.allFiles()) {
+        if (file.kind !== NodeKind.File)
+            continue;
+        const p = file.path ?? '';
+        if (!p.startsWith(relDir + '/src/') && !p.startsWith(relDir + '/'))
+            continue;
+        const abs = nodePath.isAbsolute(p) ? p : nodePath.join(cwd, p);
+        if (!existsSync(abs))
+            continue;
+        let body;
+        try {
+            body = readFileSync(abs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const spec of extractRootSpecifiers(body)) {
+            if (isBuiltinModule(spec))
+                continue;
+            if (spec.startsWith('.') || spec.startsWith('/'))
+                continue;
+            out.push(rootOfSpecifier(spec));
+        }
+    }
+    return out;
+}
+const IMPORT_FROM_RE = /(?:^|\n)\s*(?:import|export)\s+[^;]*?\s+from\s+['"]([^'"]+)['"]/g;
+const REQUIRE_RE = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
+// `await import('pkg')` / `import('pkg')` — bare dynamic imports.
+// Note: we intentionally match `\bimport\s*\(` not just `import(` so we
+// don't false-trigger on `LocaleImport(...)` etc.
+const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function extractRootSpecifiers(body) {
+    const out = [];
+    for (const m of body.matchAll(IMPORT_FROM_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    for (const m of body.matchAll(REQUIRE_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    for (const m of body.matchAll(DYNAMIC_IMPORT_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    return out;
+}
+function rootOfSpecifier(spec) {
+    if (spec.startsWith('@')) {
+        const parts = spec.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+    }
+    return spec.split('/')[0];
+}
+function isBuiltinModule(spec) {
+    if (spec.startsWith('node:'))
+        return true;
+    // Bun runtime builtins (`bun:test`, `bun:sqlite`, …) are runtime-provided,
+    // never an npm dependency — so they are not "missing".
+    if (spec.startsWith('bun:'))
+        return true;
+    return new Set([
+        'fs', 'path', 'os', 'crypto', 'http', 'https', 'url', 'util', 'stream',
+        'events', 'child_process', 'process', 'buffer', 'querystring', 'zlib',
+        'tls', 'net', 'dns', 'dgram', 'cluster', 'worker_threads', 'perf_hooks',
+        'readline', 'tty', 'vm',
+    ]).has(spec);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Read-only MCP tool: get_diff_check_report.
+ *
+ * The MCP-side mirror of `shrk diff-check`. Same envelope, same
+ * verdict logic — the agent gets a single structured answer to "did
+ * my edits pass this project's boundary + import-hygiene gates?".
+ *
+ * Still read-only: this tool DOES NOT fix anything, even when it
+ * could trivially suggest the fix. The agent reads the envelope, then
+ * the human (or the agent, via a separate write-path tool) runs the
+ * fix on the CLI. Keeps the safety contract intact.
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getDiffCheckReportTool: IToolDefinition;
+//# sourceMappingURL=diff-check.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff-check.tool.d.ts","sourceRoot":"","sources":["../../src/tools/diff-check.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAyBpE,eAAO,MAAM,sBAAsB,EAAE,eAyHpC,CAAC"}

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

@@ -0,0 +1,157 @@
+/**
+ * Read-only MCP tool: get_diff_check_report.
+ *
+ * The MCP-side mirror of `shrk diff-check`. Same envelope, same
+ * verdict logic — the agent gets a single structured answer to "did
+ * my edits pass this project's boundary + import-hygiene gates?".
+ *
+ * Still read-only: this tool DOES NOT fix anything, even when it
+ * could trivially suggest the fix. The agent reads the envelope, then
+ * the human (or the agent, via a separate write-path tool) runs the
+ * fix on the CLI. Keeps the safety contract intact.
+ */
+import { buildImportHygieneReport, filterViolationsToChangedScope, resolveChangedFiles, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+const SCHEMA = 'sharkcraft.diff-check/v1';
+function resolveScopeFromInput(input, cwd) {
+    const staged = input.staged === true;
+    const since = typeof input.since === 'string' ? input.since : undefined;
+    const files = Array.isArray(input.files)
+        ? input.files.filter((f) => typeof f === 'string')
+        : [];
+    if (files.length > 0) {
+        return { mode: 'files', options: { projectRoot: cwd, files } };
+    }
+    if (staged) {
+        return { mode: 'staged', options: { projectRoot: cwd, staged: true } };
+    }
+    if (since) {
+        return { mode: 'since', options: { projectRoot: cwd, since } };
+    }
+    return { mode: 'worktree', options: { projectRoot: cwd, includeWorktree: true } };
+}
+export const getDiffCheckReportTool = {
+    name: 'get_diff_check_report',
+    description: 'Self-check the current git diff against this project\'s boundary + import-hygiene rules. Single-call composite of the boundary-check and import-hygiene engines, scoped to the changed files, with one verdict (ok | warnings | errors) and one nextAction line. Use after editing code so you can validate before declaring done. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            staged: { type: 'boolean', description: 'Scope to staged changes only.' },
+            since: { type: 'string', description: 'Compare against ref (HEAD, origin/main, SHA).' },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Explicit file list (overrides --staged / --since).',
+            },
+        },
+    },
+    async handler(input, ctx) {
+        const cwd = ctx.cwd;
+        const { mode, options: scopeOptions } = resolveScopeFromInput(input, cwd);
+        const changed = resolveChangedFiles(scopeOptions);
+        const changedFiles = changed.files;
+        const rules = ctx.inspection.boundaryRegistry.list();
+        let boundaryBlock = {
+            ran: false,
+            rulesEvaluated: 0,
+            counts: { error: 0, warning: 0, info: 0 },
+            violations: [],
+        };
+        if (rules.length > 0 && changedFiles.length > 0) {
+            const scan = scanImports({ projectRoot: cwd });
+            const tsconfigPaths = loadTsconfigPaths(cwd);
+            const evalResult = evaluateBoundaries(scan, rules, {
+                ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+            });
+            const filtered = filterViolationsToChangedScope(evalResult.violations, scopeOptions);
+            boundaryBlock = {
+                ran: true,
+                rulesEvaluated: evalResult.rulesEvaluated,
+                counts: {
+                    error: filtered.includedViolations.filter((v) => v.severity === 'error').length,
+                    warning: filtered.includedViolations.filter((v) => v.severity === 'warning').length,
+                    info: filtered.includedViolations.filter((v) => v.severity === 'info').length,
+                },
+                violations: filtered.includedViolations,
+            };
+        }
+        else if (rules.length > 0) {
+            boundaryBlock = { ...boundaryBlock, ran: true, rulesEvaluated: rules.length };
+        }
+        let importsBlock = {
+            ran: false,
+            verdict: 'skipped',
+            counts: {},
+            findings: [],
+        };
+        if (changedFiles.length > 0) {
+            const report = buildImportHygieneReport(cwd, { files: changedFiles });
+            importsBlock = {
+                ran: true,
+                verdict: report.verdict,
+                counts: report.counts ?? {},
+                findings: report.findings,
+            };
+        }
+        // Derive verdict — same logic as the CLI command, duplicated
+        // intentionally to keep the MCP tool self-contained (no CLI
+        // import — preserves the package dependency direction).
+        const bErr = boundaryBlock.counts.error;
+        const bWarn = boundaryBlock.counts.warning;
+        const iErr = importsBlock.verdict === 'errors' ? (importsBlock.counts.error ?? importsBlock.findings.length) : 0;
+        const iWarn = importsBlock.verdict === 'warnings' ? (importsBlock.counts.warning ?? importsBlock.findings.length) : 0;
+        let verdict;
+        let summary;
+        let nextAction;
+        if (changedFiles.length === 0) {
+            verdict = 'ok';
+            summary = 'No files changed in the current diff scope.';
+            nextAction =
+                'Nothing to check. If you expected changes, verify the `staged` / `since` argument or save edits first.';
+        }
+        else if (bErr > 0 || iErr > 0) {
+            verdict = 'errors';
+            const parts = [];
+            if (bErr > 0)
+                parts.push(`${bErr} boundary violation${bErr === 1 ? '' : 's'}`);
+            if (iErr > 0)
+                parts.push(`${iErr} import-hygiene error${iErr === 1 ? '' : 's'}`);
+            summary = `Diff fails the gate: ${parts.join(', ')}.`;
+            nextAction =
+                'Fix every error in `boundaries.violations` and `imports.findings` (each entry\'s `suggestedFix` shows the fix), then re-run.';
+        }
+        else if (bWarn > 0 || iWarn > 0) {
+            verdict = 'warnings';
+            const parts = [];
+            if (bWarn > 0)
+                parts.push(`${bWarn} boundary warning${bWarn === 1 ? '' : 's'}`);
+            if (iWarn > 0)
+                parts.push(`${iWarn} import-hygiene warning${iWarn === 1 ? '' : 's'}`);
+            summary = `Diff passes the gate with ${parts.join(', ')}.`;
+            nextAction = 'Safe to declare done. Review warnings if the diff touches a sensitive area.';
+        }
+        else {
+            verdict = 'ok';
+            summary = `Diff passes the gate (${changedFiles.length} file${changedFiles.length === 1 ? '' : 's'}, 0 violations).`;
+            nextAction = 'Safe to declare done.';
+        }
+        return {
+            text: `verdict=${verdict}. ${summary} ${nextAction}`,
+            data: {
+                schema: SCHEMA,
+                generatedAt: new Date().toISOString(),
+                scope: {
+                    mode,
+                    files: changedFiles,
+                    fileCount: changedFiles.length,
+                },
+                boundaries: boundaryBlock,
+                imports: importsBlock,
+                verdict,
+                summary,
+                nextAction,
+            },
+        };
+    },
+};

package/dist/tools/file-advice.tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read-only MCP tool: get_file_advice.
+ *
+ * For a given file path, returns the rules, path conventions, boundary
+ * rules, and knowledge entries that apply to it. The agent equivalent
+ * of `shrk why <file>` — same engine (`buildWhyReport`), shaped for
+ * MCP consumption.
+ *
+ * Why this exists alongside `inspect_workspace` and the various
+ * `list_*` tools: agents tend to over-explore when given browsable
+ * catalogs. Asking "give me everything for this file" in one call
+ * keeps the prompt window tight and the answer focused — the agent
+ * doesn't have to discover which rule matches the file's path glob,
+ * which boundary rule constrains its imports, or which knowledge
+ * entry is the right one to read first.
+ *
+ * Use after a `shrk diff-check` flags a violation, or before editing
+ * an unfamiliar file. Read-only.
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getFileAdviceTool: IToolDefinition;
+//# sourceMappingURL=file-advice.tool.d.ts.map

package/dist/tools/file-advice.tool.d.ts.map

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

package/dist/tools/file-advice.tool.js

@@ -0,0 +1,88 @@
+/**
+ * Read-only MCP tool: get_file_advice.
+ *
+ * For a given file path, returns the rules, path conventions, boundary
+ * rules, and knowledge entries that apply to it. The agent equivalent
+ * of `shrk why <file>` — same engine (`buildWhyReport`), shaped for
+ * MCP consumption.
+ *
+ * Why this exists alongside `inspect_workspace` and the various
+ * `list_*` tools: agents tend to over-explore when given browsable
+ * catalogs. Asking "give me everything for this file" in one call
+ * keeps the prompt window tight and the answer focused — the agent
+ * doesn't have to discover which rule matches the file's path glob,
+ * which boundary rule constrains its imports, or which knowledge
+ * entry is the right one to read first.
+ *
+ * Use after a `shrk diff-check` flags a violation, or before editing
+ * an unfamiliar file. Read-only.
+ */
+import { buildWhyReport } from '@shrkcrft/inspector';
+export const getFileAdviceTool = {
+    name: 'get_file_advice',
+    description: 'For a given file path, return the rules, path conventions, boundary rules, and knowledge entries that apply to it. Single-call replacement for browsing the registry to figure out what constrains one file. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['file'],
+        properties: {
+            file: {
+                type: 'string',
+                description: 'Path to the file (absolute, or relative to the project root). The file does not need to exist — path-string matching still works.',
+            },
+            limit: {
+                type: 'number',
+                description: 'Cap rules and knowledge entries returned (default 10).',
+            },
+        },
+    },
+    async handler(input, ctx) {
+        const file = typeof input.file === 'string' ? input.file : '';
+        if (!file) {
+            return {
+                text: 'Error: `file` argument is required.',
+                data: { error: 'missing-argument', argument: 'file' },
+            };
+        }
+        const limit = typeof input.limit === 'number' && input.limit > 0 ? Math.floor(input.limit) : 10;
+        const report = buildWhyReport({
+            inspection: ctx.inspection,
+            projectRoot: ctx.cwd,
+            target: file,
+            limit,
+        });
+        const summary = buildSummary(report);
+        return {
+            text: summary,
+            data: report,
+        };
+    },
+};
+function buildSummary(report) {
+    const lines = [];
+    lines.push(`File: ${report.target.relativePath} (${report.target.kind})`);
+    if (report.inferredPackage)
+        lines.push(`Package: ${report.inferredPackage}`);
+    if (report.inferredLayer)
+        lines.push(`Layer: ${report.inferredLayer}`);
+    const counts = {
+        rules: report.rules.length,
+        boundaries: report.boundaries.length,
+        paths: report.pathConventions.length,
+        knowledge: report.knowledge.length,
+    };
+    lines.push(`Matches: ${counts.rules} rule${counts.rules === 1 ? '' : 's'}, ` +
+        `${counts.boundaries} boundary rule${counts.boundaries === 1 ? '' : 's'}, ` +
+        `${counts.paths} path convention${counts.paths === 1 ? '' : 's'}, ` +
+        `${counts.knowledge} knowledge entr${counts.knowledge === 1 ? 'y' : 'ies'}.`);
+    if (counts.rules === 0 &&
+        counts.boundaries === 0 &&
+        counts.paths === 0 &&
+        counts.knowledge === 0) {
+        lines.push('No registry entries matched. The file may be outside the conventions, or the workspace may not have rules / paths defined yet.');
+    }
+    else {
+        lines.push('See `data` for the full per-category list.');
+    }
+    return lines.join('\n');
+}

package/dist/tools/get-api-surface-diff.tool.d.ts

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

package/dist/tools/get-api-surface-diff.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-api-surface-diff.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-api-surface-diff.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,qBAAqB,EAAE,eAsDnC,CAAC"}

package/dist/tools/get-api-surface-diff.tool.js

@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { diffApiSurfaces, extractApiSurface, } from '@shrkcrft/api-surface-diff';
+import { GraphStore } from '@shrkcrft/graph';
+const NEXT = 'shrk graph index';
+export const getApiSurfaceDiffTool = {
+    name: 'get_api_surface_diff',
+    description: 'Read-only: compare the current code-graph public-API surface to a baseline. Provide `baselinePath` (file system path to a previously captured `IApiSurface`) OR `baseline` (inline). Optional `packages` filter restricts both sides to those workspace packages.',
+    cliCommand: 'api-diff',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            baselinePath: { type: 'string' },
+            baseline: { type: 'object' },
+            packages: { type: 'array', items: { type: 'string' } },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: "code-graph store missing",
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        let baseline = args.baseline;
+        if (!baseline && args.baselinePath) {
+            const abs = nodePath.isAbsolute(args.baselinePath)
+                ? args.baselinePath
+                : nodePath.resolve(ctx.inspection.projectRoot, args.baselinePath);
+            try {
+                baseline = JSON.parse(readFileSync(abs, 'utf8'));
+            }
+            catch (e) {
+                return {
+                    isError: true,
+                    error: { code: 'invalid-input', message: `baseline read failed: ${e.message}` },
+                };
+            }
+        }
+        if (!baseline) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'baseline or baselinePath is required' },
+            };
+        }
+        const snap = store.loadSnapshot();
+        const current = extractApiSurface(snap, {
+            ...(args.packages && args.packages.length > 0 ? { packageFilter: args.packages } : {}),
+        });
+        const diff = diffApiSurfaces(baseline, current);
+        return { data: diff };
+    },
+};

package/dist/tools/get-arch-violations.tool.d.ts

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

package/dist/tools/get-arch-violations.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-arch-violations.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-arch-violations.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAWpE,eAAO,MAAM,qBAAqB,EAAE,eA6BnC,CAAC"}

package/dist/tools/get-arch-violations.tool.js

@@ -0,0 +1,30 @@
+import { runArchCheck } from '@shrkcrft/architecture-guard';
+export const getArchViolationsTool = {
+    name: 'get_arch_violations',
+    description: 'Run the architecture-guard checks (public-API misuse, barrel risks, cycle severity) against the code graph. Reads `sharkcraft/arch.ts` if present for project-specific contracts. Read-only.',
+    cliCommand: 'arch check',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            enable: {
+                type: 'object',
+                properties: {
+                    publicApi: { type: 'boolean' },
+                    barrels: { type: 'boolean' },
+                    cycles: { type: 'boolean' },
+                    contract: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const report = runArchCheck({
+            projectRoot: ctx.inspection.projectRoot,
+            ...(args.enable ? { enable: args.enable } : {}),
+        });
+        return { data: report };
+    },
+};

package/dist/tools/get-code-intelligence-state.tool.d.ts

@@ -0,0 +1,11 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Read-only MCP mirror of `shrk code-intel`. Returns the same 14
+ * code-intelligence doctor findings in one shot — agents can pull
+ * the entire state without iterating `shrk doctor`'s full check list.
+ *
+ * Stable output schema (`sharkcraft.code-intelligence-state/v1`) so
+ * downstream renderers (dashboard, CI bots) can rely on the shape.
+ */
+export declare const getCodeIntelligenceStateTool: IToolDefinition;
+//# sourceMappingURL=get-code-intelligence-state.tool.d.ts.map

package/dist/tools/get-code-intelligence-state.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-code-intelligence-state.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-code-intelligence-state.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,EAAE,eAiC1C,CAAC"}