@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/languages.command.js

@@ -0,0 +1,300 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildLanguageCommandReport, buildLanguageRunPlan, buildPolyglotBoundaryReport, clearLanguageCache, computePolyglotTestImpact, defaultLanguageRunReportPath, detectLanguageProfiles, detectLanguageProfilesWithCache, getLanguageCacheStatus, LanguageId, renderLanguageCommandsMarkdown, renderLanguageCommandsText, renderLanguageProfilesMarkdown, renderLanguageProfilesText, renderLanguageRunPlanJson, renderLanguageRunPlanMarkdown, renderLanguageRunPlanText, renderPolyglotBoundaryReportJson, renderPolyglotBoundaryReportMarkdown, renderPolyglotBoundaryReportText, renderPolyglotDependenciesText, renderPolyglotTestImpactText, scanPolyglotDependencies, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function writeOutOrPrint(args, cwd, body) {
+    const out = flagString(args, 'output');
+    if (out) {
+        const abs = nodePath.isAbsolute(out) ? out : nodePath.resolve(cwd, out);
+        mkdirSync(nodePath.dirname(abs), { recursive: true });
+        writeFileSync(abs, body, 'utf8');
+        process.stdout.write(`Wrote ${abs}\n`);
+        return 0;
+    }
+    process.stdout.write(body);
+    return 0;
+}
+const SHARKCRAFT_VERSION = '0.1.0';
+const languagesDetectCommand = {
+    name: 'detect',
+    description: 'Detect language profiles in the current project (TS/JS/Java/C#/Python/Go/Rust). Read-only. Pass --cache to use/refresh the language cache.',
+    usage: 'shrk languages detect [--format text|markdown|json] [--cache] [--refresh-cache] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const useCache = flagBool(args, 'cache');
+        const refreshCache = flagBool(args, 'refresh-cache');
+        let report;
+        let cacheHit = false;
+        let staleReasons = [];
+        if (useCache || refreshCache) {
+            const r = detectLanguageProfilesWithCache({ projectRoot: cwd, sharkcraftVersion: SHARKCRAFT_VERSION, useCache, refresh: refreshCache });
+            report = r.report;
+            cacheHit = r.cacheHit;
+            staleReasons = r.staleReasons;
+        }
+        else {
+            report = detectLanguageProfiles(cwd);
+        }
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json')) {
+            body = asJson({ ...report, _cacheHit: cacheHit, _staleReasons: staleReasons }) + '\n';
+        }
+        else if (format === 'markdown' || format === 'md') {
+            body = renderLanguageProfilesMarkdown(report);
+            if (cacheHit)
+                body += `\n_(loaded from cache; stale: ${staleReasons.length > 0})_\n`;
+        }
+        else {
+            body = renderLanguageProfilesText(report);
+            if (cacheHit)
+                body += `\n(loaded from cache; stale: ${staleReasons.length > 0})\n`;
+        }
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+const languagesCacheCommand = {
+    name: 'cache',
+    description: 'Language profile cache: `shrk languages cache status` / `cache clear --write`. Default dry-run.',
+    usage: 'shrk languages cache <status|clear> [--write] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const sub = args.positional[0] ?? 'status';
+        if (sub === 'status') {
+            const status = getLanguageCacheStatus(cwd, SHARKCRAFT_VERSION);
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson(status) + '\n');
+                return 0;
+            }
+            process.stdout.write(`=== Language cache ===\n`);
+            process.stdout.write(`  file:        ${status.cacheFile}\n`);
+            process.stdout.write(`  exists:      ${status.exists ? 'yes' : 'no'}\n`);
+            if (status.exists) {
+                process.stdout.write(`  cached at:   ${status.cachedAt ?? '(unknown)'}\n`);
+                process.stdout.write(`  fresh:       ${status.fresh ? 'yes' : 'no'}\n`);
+                if (status.staleReasons.length > 0) {
+                    process.stdout.write(`  stale because:\n`);
+                    for (const r of status.staleReasons)
+                        process.stdout.write(`    - ${r}\n`);
+                }
+            }
+            return 0;
+        }
+        if (sub === 'clear') {
+            const write = flagBool(args, 'write');
+            const res = clearLanguageCache(cwd, { write });
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson(res) + '\n');
+                return 0;
+            }
+            if (!write) {
+                process.stdout.write(`Would remove ${res.cacheFile}\n  (re-run with --write to actually delete)\n`);
+            }
+            else {
+                process.stdout.write(res.cleared ? `Removed ${res.cacheFile}\n` : `Nothing to remove at ${res.cacheFile}\n`);
+            }
+            return 0;
+        }
+        process.stderr.write(`Unknown subcommand: ${sub}\n`);
+        return 2;
+    },
+};
+const languagesRunCommand = {
+    name: 'run',
+    description: 'Plan or execute a language command (test/build/lint/format/check/typecheck). Dry-run by default; --execute to run; --allow-install to permit install/restore.',
+    usage: 'shrk languages run [--category test|build|lint|format|check|all] [--language <id>] [--command-id <lang.cat>] [--all-tests] [--execute] [--allow-install] [--report] [--format text|markdown|json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const category = (flagString(args, 'category') ?? 'test');
+        const language = flagString(args, 'language');
+        const commandId = flagString(args, 'command-id');
+        const allTests = flagBool(args, 'all-tests');
+        const execute = flagBool(args, 'execute');
+        const allowInstall = flagBool(args, 'allow-install');
+        const wantReport = flagBool(args, 'report');
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        // Optional policy explanation block.
+        const explainPolicy = flagBool(args, 'explain-policy');
+        const plan = buildLanguageRunPlan({
+            projectRoot: cwd,
+            category,
+            ...(language ? { language } : {}),
+            ...(commandId ? { commandId } : {}),
+            allTests,
+            execute,
+            allowInstall,
+        });
+        if (explainPolicy) {
+            const { getLanguageRunnerPolicy, explainCommandPolicy } = await import('@shrkcrft/inspector');
+            const policy = getLanguageRunnerPolicy(cwd);
+            const decisions = plan.steps.map((s) => ({
+                command: s.command,
+                decision: explainCommandPolicy(s.command, cwd),
+            }));
+            const body = JSON.stringify({ policy, decisions }, null, 2) + '\n';
+            return writeOutOrPrint(args, cwd, body);
+        }
+        if (wantReport) {
+            const reportPath = defaultLanguageRunReportPath(cwd, plan.generatedAt);
+            mkdirSync(nodePath.dirname(reportPath), { recursive: true });
+            writeFileSync(reportPath, renderLanguageRunPlanJson(plan), 'utf8');
+            process.stderr.write(`wrote ${reportPath}\n`);
+        }
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = renderLanguageRunPlanJson(plan) + '\n';
+        else if (format === 'markdown' || format === 'md')
+            body = renderLanguageRunPlanMarkdown(plan);
+        else
+            body = renderLanguageRunPlanText(plan);
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+const languagesBoundariesCommand = {
+    name: 'boundaries',
+    description: 'Polyglot boundary enforcement report. Read-only.',
+    usage: 'shrk languages boundaries [--language java|csharp|python|go|rust|all] [--format text|markdown|json] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const langFlag = (flagString(args, 'language') ?? 'all').toLowerCase();
+        const languages = langFlag === 'all'
+            ? undefined
+            : [langFlag];
+        const report = buildPolyglotBoundaryReport({ projectRoot: cwd, ...(languages ? { languages } : {}) });
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = renderPolyglotBoundaryReportJson(report) + '\n';
+        else if (format === 'markdown' || format === 'md')
+            body = renderPolyglotBoundaryReportMarkdown(report);
+        else
+            body = renderPolyglotBoundaryReportText(report);
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+const languagesCommandsCommand = {
+    name: 'commands',
+    description: 'Infer install / test / typecheck / lint / build commands per detected language. Read-only.',
+    usage: 'shrk languages commands [--format text|markdown|json] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const report = buildLanguageCommandReport(cwd);
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson(report) + '\n';
+        else if (format === 'markdown' || format === 'md')
+            body = renderLanguageCommandsMarkdown(report);
+        else
+            body = renderLanguageCommandsText(report);
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+const languagesDepsCommand = {
+    name: 'deps',
+    description: 'Scan polyglot dependency graph (Java/C#/Python/Go/Rust imports). Read-only.',
+    usage: 'shrk languages deps [--language java|csharp|python|go|rust|all] [--format text|json] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const langFlag = (flagString(args, 'language') ?? 'all').toLowerCase();
+        const languages = langFlag === 'all'
+            ? [LanguageId.Java, LanguageId.CSharp, LanguageId.Python, LanguageId.Go, LanguageId.Rust]
+            : [langFlag];
+        const graph = scanPolyglotDependencies(cwd, { languages });
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson(graph) + '\n';
+        else
+            body = renderPolyglotDependenciesText(graph);
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+const languagesTestsCommand = {
+    name: 'tests',
+    description: 'Predict per-language test files impacted by a set of changed source files. Read-only.',
+    usage: 'shrk languages tests --files a,b,c [--format text|json] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const filesFlag = flagString(args, 'files');
+        if (!filesFlag) {
+            process.stderr.write('--files <a,b,c> is required.\n');
+            return 2;
+        }
+        const files = filesFlag.split(',').map((f) => f.trim()).filter(Boolean);
+        const report = computePolyglotTestImpact(cwd, files);
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson(report) + '\n';
+        else
+            body = renderPolyglotTestImpactText(report);
+        return writeOutOrPrint(args, cwd, body);
+    },
+};
+export const languagesCommand = {
+    name: 'languages',
+    description: 'Polyglot language support: detect language profiles, infer commands, scan dependencies, predict test impact, enforce boundaries, run safe commands, manage cache. Read-only by default.',
+    usage: 'shrk languages <detect|commands|deps|tests|boundaries|run|cache> [...]',
+    async run(args) {
+        const sub = args.positional[0];
+        if (!sub) {
+            process.stderr.write('Usage: shrk languages <detect|commands|deps|tests|boundaries|run|cache>\n');
+            return 2;
+        }
+        const next = { ...args, positional: args.positional.slice(1) };
+        if (sub === 'detect')
+            return (await languagesDetectCommand.run(next));
+        if (sub === 'commands')
+            return (await languagesCommandsCommand.run(next));
+        if (sub === 'deps')
+            return (await languagesDepsCommand.run(next));
+        if (sub === 'tests')
+            return (await languagesTestsCommand.run(next));
+        if (sub === 'boundaries')
+            return (await languagesBoundariesCommand.run(next));
+        if (sub === 'run')
+            return (await languagesRunCommand.run(next));
+        if (sub === 'cache')
+            return (await languagesCacheCommand.run(next));
+        if (sub === 'runner') {
+            const sub2 = next.positional[0];
+            const next2 = { ...next, positional: next.positional.slice(1) };
+            if (sub2 === 'config')
+                return (await languagesRunnerConfigCommand.run(next2));
+            process.stderr.write(`Usage: shrk languages runner config\n`);
+            return 2;
+        }
+        process.stderr.write(`Unknown subcommand: ${sub}\n`);
+        return 2;
+    },
+};
+const languagesRunnerConfigCommand = {
+    name: 'config',
+    description: 'Show the language runner policy (allowlist + denylist + built-in deny patterns). Read-only.',
+    usage: 'shrk languages runner config [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const { getLanguageRunnerPolicy } = await import('@shrkcrft/inspector');
+        const policy = getLanguageRunnerPolicy(cwd);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(policy) + '\n');
+            return 0;
+        }
+        process.stdout.write('=== Language runner policy ===\n');
+        process.stdout.write(`  source: ${policy.source}\n`);
+        process.stdout.write(`  allow:  ${policy.allow.length}\n`);
+        for (const a of policy.allow) {
+            process.stdout.write(`    + ${a.command}${a.reason ? `  (${a.reason})` : ''}\n`);
+        }
+        process.stdout.write(`  deny:   ${policy.deny.length}\n`);
+        for (const d of policy.deny) {
+            process.stdout.write(`    - /${d.pattern}/${d.reason ? `  (${d.reason})` : ''}\n`);
+        }
+        process.stdout.write(`  built-in deny: ${policy.builtinDeny.length}\n`);
+        for (const b of policy.builtinDeny)
+            process.stdout.write(`    - /${b}/\n`);
+        return 0;
+    },
+};

package/dist/commands/lint.command.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Unified `shrk lint` verb.
+ *
+ * Pure CLI aggregator over the per-kind doctor / lint surfaces:
+ *   - knowledge → `lintKnowledge` + `buildKnowledgeLintFixPreview`
+ *   - rules     → `diagnoseRuleQuality`
+ *   - templates → `buildTemplateDriftReport`
+ *
+ * No new domain logic. Layer order preserved (inspector → cli only).
+ * The per-kind verbs (`knowledge lint`, `rules doctor`, `rules lint`,
+ * `templates doctor`, `templates drift`) keep working unchanged.
+ */
+import { type ICommandHandler } from '../command-registry.js';
+export declare const lintCommand: ICommandHandler;
+//# sourceMappingURL=lint.command.d.ts.map

package/dist/commands/lint.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.command.d.ts","sourceRoot":"","sources":["../../src/commands/lint.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAmBhC,eAAO,MAAM,WAAW,EAAE,eAuHzB,CAAC"}

package/dist/commands/lint.command.js

@@ -0,0 +1,194 @@
+/**
+ * Unified `shrk lint` verb.
+ *
+ * Pure CLI aggregator over the per-kind doctor / lint surfaces:
+ *   - knowledge → `lintKnowledge` + `buildKnowledgeLintFixPreview`
+ *   - rules     → `diagnoseRuleQuality`
+ *   - templates → `buildTemplateDriftReport`
+ *
+ * No new domain logic. Layer order preserved (inspector → cli only).
+ * The per-kind verbs (`knowledge lint`, `rules doctor`, `rules lint`,
+ * `templates doctor`, `templates drift`) keep working unchanged.
+ */
+import { buildKnowledgeLintFixPreview, buildKnowledgeStaleReport, buildTemplateDriftReport, diagnoseRuleQuality, inspectSharkcraft, lintKnowledge, ReferenceCheckOutcome, TemplateDriftStatus, } from '@shrkcrft/inspector';
+import { flagBool, flagList, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+import { collectChangedPaths } from "../diff/collect-changed-paths.js";
+function parseKind(value) {
+    switch ((value ?? 'all').toLowerCase()) {
+        case 'knowledge':
+            return 'knowledge';
+        case 'rules':
+            return 'rules';
+        case 'templates':
+            return 'templates';
+        default:
+            return 'all';
+    }
+}
+export const lintCommand = {
+    name: 'lint',
+    description: 'Unified lint aggregator. Runs knowledge / rules / templates per-kind doctors in one pass. `--since <ref>` annotates the run with diff-aware metadata (lints themselves run whole-graph and emit a notice).',
+    usage: 'shrk lint [--kind knowledge|rules|templates|all] [--strict] [--fix-preview] [--since <ref>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const kind = parseKind(flagString(args, 'kind'));
+        const strict = flagBool(args, 'strict');
+        const fixPreview = flagBool(args, 'fix-preview');
+        const wantJson = flagBool(args, 'json');
+        // Diff-aware metadata. The per-kind lints operate on the
+        // whole asset graph (entries / rules / templates), so `--since`
+        // is recorded in the report but does not restrict the lint. Add
+        // a one-line notice in the text render so the user knows.
+        const sinceRaw = args.flags.get('since');
+        const since = typeof sinceRaw === 'string'
+            ? collectChangedPaths({ cwd, ref: sinceRaw })
+            : sinceRaw === true
+                ? collectChangedPaths({ cwd })
+                : null;
+        const knowledgePart = kind === 'all' || kind === 'knowledge'
+            ? runKnowledgeLint(inspection, { fixPreview })
+            : null;
+        const rulesPart = kind === 'all' || kind === 'rules' ? runRulesLint(inspection, { strict }) : null;
+        const templatesPart = kind === 'all' || kind === 'templates'
+            ? runTemplatesLint(inspection, { strict })
+            : null;
+        // Knowledge lint emits info/warning only; we no longer carry a
+        // hardcoded errors=0 through the totals. Errors come from rules and
+        // templates whose underlying doctors actually emit error severity.
+        const errors = (rulesPart?.errors ?? 0) + (templatesPart?.errors ?? 0);
+        const warnings = (knowledgePart?.warnings ?? 0) +
+            (rulesPart?.warnings ?? 0) +
+            (templatesPart?.warnings ?? 0);
+        const ready = errors === 0 && (!strict || warnings === 0);
+        if (wantJson) {
+            process.stdout.write(asJson({
+                // Schema v2: knowledge.errors field removed (was hardcoded
+                // to 0); totals now reflect rules+templates only.
+                schema: 'sharkcraft.lint/v2',
+                generatedAt: new Date().toISOString(),
+                kind,
+                strict,
+                fixPreview,
+                totals: { errors, warnings, ready },
+                ...(since
+                    ? {
+                        since: {
+                            ref: since.ref,
+                            available: since.isAvailable,
+                            changedPaths: since.changed.length,
+                            note: 'whole-graph lints ignore --since; reported here for tooling parity',
+                            ...(since.error ? { error: since.error } : {}),
+                        },
+                    }
+                    : {}),
+                ...(knowledgePart ? { knowledge: knowledgePart } : {}),
+                ...(rulesPart ? { rules: rulesPart } : {}),
+                ...(templatesPart ? { templates: templatesPart } : {}),
+            }) + '\n');
+            return ready ? 0 : 1;
+        }
+        process.stdout.write(header(`Lint — ${kind}${strict ? ' (strict)' : ''}`));
+        if (since) {
+            process.stdout.write(`  --since ${since.ref}${since.isAvailable ? ` (${since.changed.length} changed)` : ' (unavailable)'} — whole-graph lints run regardless\n\n`);
+        }
+        if (knowledgePart) {
+            process.stdout.write(`  knowledge:   ${knowledgePart.warnings} warnings (${knowledgePart.findings} findings)\n`);
+        }
+        if (rulesPart) {
+            process.stdout.write(`  rules:       ${rulesPart.errors} errors, ${rulesPart.warnings} warnings (${rulesPart.findings} findings)\n`);
+        }
+        if (templatesPart) {
+            process.stdout.write(`  templates:   ${templatesPart.errors} errors, ${templatesPart.warnings} warnings across ${templatesPart.totalTemplates} template(s)\n`);
+        }
+        process.stdout.write(`\n  totals:      ${errors} errors, ${warnings} warnings\n`);
+        if (ready) {
+            process.stdout.write('\nClean. ✓\n');
+        }
+        else {
+            process.stdout.write('\nIssues found. Drill in:\n' +
+                (knowledgePart && knowledgePart.warnings > 0
+                    ? '  $ shrk knowledge lint --fix-preview\n'
+                    : '') +
+                (rulesPart && (rulesPart.errors > 0 || rulesPart.warnings > 0)
+                    ? '  $ shrk rules doctor --strict\n'
+                    : '') +
+                (templatesPart && (templatesPart.errors > 0 || templatesPart.warnings > 0)
+                    ? '  $ shrk templates drift --min-severity warning\n'
+                    : ''));
+        }
+        return ready ? 0 : 1;
+    },
+};
+function runKnowledgeLint(inspection, options) {
+    const stale = buildKnowledgeStaleReport(inspection);
+    const staleIds = new Set();
+    for (const c of stale.referenceChecks) {
+        if (c.outcome === ReferenceCheckOutcome.Stale ||
+            c.outcome === ReferenceCheckOutcome.Missing) {
+            staleIds.add(c.entryId);
+        }
+    }
+    const report = lintKnowledge(inspection.knowledgeEntries, {
+        staleReferenceEntryIds: [...staleIds],
+    });
+    const warnings = report.findings.filter((f) => f.severity === 'warning' && !f.advisory).length;
+    const categories = {};
+    for (const f of report.findings) {
+        categories[f.category] = (categories[f.category] ?? 0) + 1;
+    }
+    const summary = {
+        warnings,
+        findings: report.findings.length,
+        categories,
+        staleReferences: stale.referenceChecks.filter((c) => c.outcome === ReferenceCheckOutcome.Stale ||
+            c.outcome === ReferenceCheckOutcome.Missing).length,
+    };
+    if (options.fixPreview) {
+        summary.fixPreview = buildKnowledgeLintFixPreview(report);
+    }
+    return summary;
+}
+function runRulesLint(inspection, _options) {
+    const rules = inspection.ruleService.list();
+    const knownVerificationIds = new Set((inspection.config?.verificationCommands ?? []).map((c) => c.id));
+    const report = diagnoseRuleQuality(rules, {}, { knownVerificationIds });
+    const byCode = {};
+    for (const f of report.findings) {
+        byCode[f.code] = (byCode[f.code] ?? 0) + 1;
+    }
+    return {
+        errors: report.summary.errors,
+        warnings: report.summary.warnings,
+        findings: report.findings.length,
+        byCode,
+    };
+}
+function runTemplatesLint(inspection, _options) {
+    const drift = buildTemplateDriftReport(inspection, {});
+    let errors = 0;
+    let warnings = 0;
+    let passing = 0;
+    const byCode = {};
+    for (const e of drift.entries) {
+        if (e.status === TemplateDriftStatus.Pass)
+            passing++;
+        for (const i of e.issues) {
+            if (i.severity === 'error')
+                errors++;
+            else if (i.severity === 'warning')
+                warnings++;
+            byCode[i.code] = (byCode[i.code] ?? 0) + 1;
+        }
+    }
+    return {
+        totalTemplates: drift.entries.length,
+        errors,
+        warnings,
+        passing,
+        byCode,
+    };
+}
+// Silence unused-imports warnings if optional drill-in paths get rolled back.
+void flagList;

package/dist/commands/mcp.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const mcpCommand: ICommandHandler;
+//# sourceMappingURL=mcp.command.d.ts.map

package/dist/commands/mcp.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.command.d.ts","sourceRoot":"","sources":["../../src/commands/mcp.command.ts"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAKhC,eAAO,MAAM,UAAU,EAAE,eAiCxB,CAAC"}

package/dist/commands/mcp.command.js

@@ -0,0 +1,74 @@
+import { startMcpServer, } from '@shrkcrft/mcp-server';
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { printError } from "../output/print-error.js";
+import { loadSurfaceContext } from "../surface/load-surface-context.js";
+import { buildSurfaceSummary, findCommandInSummary } from "../surface/surface-summary.js";
+export const mcpCommand = {
+    name: 'mcp',
+    description: 'MCP server operations (subcommand required).',
+    usage: 'shrk [--cwd <dir>] mcp serve [--verbose] [--watch] [--http] [--port <n>] [--host <h>]',
+    async run(args) {
+        const sub = args.positional[0];
+        if (sub === 'serve') {
+            try {
+                const cwd = resolveCwd(args);
+                const opts = {
+                    cwd,
+                    verbose: flagBool(args, 'verbose'),
+                    watch: flagBool(args, 'watch'),
+                    gateResolver: await buildMcpGateResolver(cwd),
+                };
+                if (flagBool(args, 'http')) {
+                    opts.transport = 'http';
+                    const host = flagString(args, 'host');
+                    if (host)
+                        opts.host = host;
+                    const port = flagNumber(args, 'port');
+                    if (port !== undefined)
+                        opts.port = port;
+                }
+                await startMcpServer(opts);
+                return 0;
+            }
+            catch (e) {
+                printError(e instanceof Error ? e : new Error(String(e)));
+                return 1;
+            }
+        }
+        process.stderr.write('Usage: shrk mcp serve [--http] [--port N] [--watch]\n');
+        return 2;
+    },
+};
+/**
+ * Build the MCP tier-gate resolver from the surface summary.
+ * Returns a function that, given a tool, decides whether to refuse the
+ * call (when the tool's sibling CLI command is experimental and not
+ * enabled). Tools without `cliCommand` are always callable
+ * (bootstrap MCP-only tools).
+ *
+ * Failure-soft: any error building the summary returns a no-op
+ * resolver — the server stays open rather than failing closed on
+ * unrelated issues.
+ */
+async function buildMcpGateResolver(cwd) {
+    try {
+        const { context } = await loadSurfaceContext({ cwd });
+        const summary = buildSurfaceSummary(context);
+        return (tool) => {
+            if (!tool.cliCommand)
+                return null;
+            const view = findCommandInSummary(summary, tool.cliCommand);
+            if (!view || view.callable)
+                return null;
+            return {
+                command: tool.cliCommand,
+                reason: view.detail
+                    ? `Sibling CLI command \`${tool.cliCommand}\` is experimental: ${view.detail}.`
+                    : `Sibling CLI command \`${tool.cliCommand}\` is experimental and not enabled.`,
+            };
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/commands/memory.command.d.ts

@@ -0,0 +1,11 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const memoryBuildCommand: ICommandHandler;
+export declare const memoryDiffCommand: ICommandHandler;
+export declare const memoryDriftCommand: ICommandHandler;
+export declare const memorySnapshotsCommand: ICommandHandler;
+export declare const memoryReportCommand: ICommandHandler;
+export declare const memoryRiskCommand: ICommandHandler;
+export declare const memoryFilesCommand: ICommandHandler;
+export declare const memoryDiagnosticsCommand: ICommandHandler;
+export declare const memoryResetCommand: ICommandHandler;
+//# sourceMappingURL=memory.command.d.ts.map

package/dist/commands/memory.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.command.d.ts","sourceRoot":"","sources":["../../src/commands/memory.command.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAgBhC,eAAO,MAAM,kBAAkB,EAAE,eAyBhC,CAAC;AAWF,eAAO,MAAM,iBAAiB,EAAE,eA0C/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAgChC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAkBpC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAkBjC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eAmB/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAyBhC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAuBtC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAwBhC,CAAC"}