@shrkcrft/cli 0.1.0-alpha.2

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.command.d.ts","sourceRoot":"","sources":["../../src/commands/context.command.ts"],"names":[],"mappings":"AASA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,cAAc,EAAE,eA6H5B,CAAC"}

package/dist/commands/context.command.js

@@ -0,0 +1,120 @@
+import { entrypointBanner, inspectSharkcraft } from '@shrkcrft/inspector';
+import { buildContext } from '@shrkcrft/context';
+import { buildUniversalSearch, explainTaskRouting, recommendCommands, renderOverviewText, buildProjectOverview, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+export const contextCommand = {
+    name: 'context',
+    description: 'Build relevant AI-ready context for a task (token-budgeted). Subcommands: build / refresh / status.',
+    usage: 'shrk context [build|refresh|status] --task "<task>" [--max-tokens 3000] [--framework x] [--area y] [--json]',
+    async run(args) {
+        // Dispatch subcommands (build / refresh / status) based on first positional.
+        const sub = args.positional[0];
+        if (sub === 'build' || sub === 'refresh' || sub === 'status') {
+            const sliced = { ...args, positional: args.positional.slice(1) };
+            const { contextBuildCommand, contextRefreshCommand, contextStatusCommand } = await import("./task-context.command.js");
+            if (sub === 'build')
+                return contextBuildCommand.run(sliced);
+            if (sub === 'refresh')
+                return contextRefreshCommand.run(sliced);
+            return contextStatusCommand.run(sliced);
+        }
+        const task = flagString(args, 'task');
+        if (!task) {
+            process.stderr.write('Missing --task\n');
+            return 2;
+        }
+        const framework = flagString(args, 'framework');
+        const area = flagString(args, 'area');
+        const tags = flagList(args, 'tag');
+        const scope = flagList(args, 'scope');
+        const maxTokens = flagNumber(args, 'max-tokens') ?? flagNumber(args, 'maxTokens');
+        const noExamples = flagBool(args, 'no-examples');
+        const noTemplates = flagBool(args, 'no-templates');
+        const noRules = flagBool(args, 'no-rules');
+        const noPaths = flagBool(args, 'no-paths');
+        const includeDocs = flagBool(args, 'include-docs');
+        const includeCommands = flagBool(args, 'include-commands');
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const overview = buildProjectOverview(inspection.workspace, inspection.config?.projectName);
+        const result = buildContext(inspection.knowledgeEntries, {
+            task,
+            framework,
+            area,
+            tags,
+            scope,
+            maxTokens: maxTokens ?? inspection.config?.defaultMaxTokens ?? 3000,
+            includeExamples: !noExamples,
+            includeTemplates: !noTemplates,
+            includeRules: !noRules,
+            includePaths: !noPaths,
+            includeDocs,
+            includeCommands,
+            projectOverview: renderOverviewText(overview),
+        });
+        // Surface top commands prominently before the long context body.
+        // Auto-promote commands-first for action-like tasks (rename / add /
+        // fix / refactor / remove / migrate / explore / wire). Pass --full to
+        // see the long context body anyway.
+        const actionVerbRe = /^(rename|add|fix|refactor|remove|delete|migrate|wire|explore|create|implement|update|introduce|build|extract|move|inline|generate|scaffold)\b/i;
+        const isActionLike = actionVerbRe.test(task.trim());
+        const wantsFull = flagBool(args, 'full');
+        const commandsFirst = flagBool(args, 'commands-first') || (isActionLike && !wantsFull);
+        let commandRecommendations = null;
+        let routingMatches = [];
+        let searchReport = null;
+        try {
+            commandRecommendations = await recommendCommands(inspection, task);
+            routingMatches = await explainTaskRouting(inspection, task);
+            searchReport = await buildUniversalSearch(inspection, task, {});
+        }
+        catch {
+            // ignore — fall back to legacy context only.
+        }
+        if (flagBool(args, 'json') || flagBool(args, 'machine-json')) {
+            process.stdout.write(asJson({
+                ...result,
+                commands: commandRecommendations,
+                routingMatches,
+                search: searchReport,
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Context for: ${task}`));
+        // Entrypoint banner: commands surface first when present (already
+        // done below), and the banner points operators at the agent-mcp + machine
+        // alternatives so the role of each entrypoint is clear.
+        process.stdout.write(`(${entrypointBanner('context')})\n\n`);
+        process.stdout.write(`tokens ≈ ${result.totalTokens} / ${result.maxTokens}, sections: ${result.sections.length}\n`);
+        if (result.omittedSections.length) {
+            process.stdout.write(`omitted (budget): ${result.omittedSections.join(', ')}\n`);
+        }
+        if (commandRecommendations && commandRecommendations.recommendations.length > 0) {
+            process.stdout.write('\nTop commands:\n');
+            for (const r of commandRecommendations.recommendations.slice(0, 4)) {
+                process.stdout.write(`  $ ${r.command}\n`);
+            }
+        }
+        if (routingMatches.length > 0) {
+            process.stdout.write('\nRouting hints:\n');
+            for (const m of routingMatches.slice(0, 3)) {
+                process.stdout.write(`  • ${m.hint.id}  ${m.hint.title}\n`);
+            }
+        }
+        // Default human text mode keeps the output short. The long
+        // context body is one flag away via `--full`. JSON / commands-first /
+        // markdown paths are unchanged.
+        if (commandsFirst || !wantsFull) {
+            if (!wantsFull) {
+                process.stdout.write('\n(text mode is summary-only — pass --full for the long context body, --json for machine output.)\n');
+            }
+            else if (isActionLike && !flagBool(args, 'commands-first')) {
+                process.stdout.write('\n(action-like task → commands-first; pass --full to see the long context body.)\n');
+            }
+            return 0;
+        }
+        process.stdout.write('\n');
+        process.stdout.write(result.body + '\n');
+        return 0;
+    },
+};

package/dist/commands/contract-gate.command.d.ts

@@ -0,0 +1,5 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const contractCheckCommand: ICommandHandler;
+export declare const contractApproveCommand: ICommandHandler;
+export declare const contractStatusCommand: ICommandHandler;
+//# sourceMappingURL=contract-gate.command.d.ts.map

package/dist/commands/contract-gate.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-gate.command.d.ts","sourceRoot":"","sources":["../../src/commands/contract-gate.command.ts"],"names":[],"mappings":"AAYA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAWhC,eAAO,MAAM,oBAAoB,EAAE,eAqDlC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eA6EpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eA6DnC,CAAC"}

package/dist/commands/contract-gate.command.js

@@ -0,0 +1,208 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildApproval, checkAgentContract, computeContractHash, inspectSharkcraft, parseRelativeExpiry, renderContractCheckMarkdown, renderContractCheckText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function readContract(file) {
+    return JSON.parse(readFileSync(file, 'utf8'));
+}
+function resolveAgainstCwd(cwd, file) {
+    return nodePath.isAbsolute(file) ? file : nodePath.resolve(cwd, file);
+}
+export const contractCheckCommand = {
+    name: 'check',
+    description: 'Validate an agent contract — required gates, plan readiness (if --plan supplied), forbidden files, public-API touch, risk + memory approval. Read-only.',
+    usage: 'shrk contract check <contract.json> [--plan <plan.json>] [--approval <approval.json>] [--format text|markdown|json] [--output <file>]',
+    async run(args) {
+        const contractFile = args.positional[0];
+        if (!contractFile) {
+            process.stderr.write('Usage: shrk contract check <contract.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const absContract = resolveAgainstCwd(cwd, contractFile);
+        if (!existsSync(absContract)) {
+            process.stderr.write(`Contract not found: ${absContract}\n`);
+            return 1;
+        }
+        let contract;
+        try {
+            contract = readContract(absContract);
+        }
+        catch (e) {
+            process.stderr.write(`Failed to parse contract: ${e.message}\n`);
+            return 1;
+        }
+        const planFlag = flagString(args, 'plan');
+        const approvalFlag = flagString(args, 'approval');
+        const planPath = planFlag ? resolveAgainstCwd(cwd, planFlag) : undefined;
+        const approvalPath = approvalFlag ? resolveAgainstCwd(cwd, approvalFlag) : undefined;
+        const report = await checkAgentContract(inspection, contract, {
+            ...(planPath ? { planPath } : {}),
+            ...(approvalPath ? { approvalPath } : {}),
+        });
+        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 = renderContractCheckMarkdown(report);
+        else
+            body = renderContractCheckText(report);
+        const output = flagString(args, 'output');
+        if (output) {
+            const abs = resolveAgainstCwd(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, body, 'utf8');
+            process.stdout.write(`Wrote ${abs}\n`);
+        }
+        else {
+            process.stdout.write(body);
+        }
+        return report.pass ? 0 : 1;
+    },
+};
+export const contractApproveCommand = {
+    name: 'approve',
+    description: 'Sign an approval for a contract. Approval writes only to the supplied --output path (no implicit locations). Read-only otherwise.',
+    usage: 'shrk contract approve <contract.json> --by <name> --reason "<text>" [--expires-in 2d|1h|30m|1w] [--expires-at <ISO>] [--gates a,b,c] [--output <approval.json>] [--secret-env <NAME>]',
+    async run(args) {
+        const contractFile = args.positional[0];
+        if (!contractFile) {
+            process.stderr.write('Usage: shrk contract approve <contract.json> --by <name> --reason "<text>"\n');
+            return 2;
+        }
+        const by = flagString(args, 'by');
+        const reason = flagString(args, 'reason');
+        if (!by || !reason) {
+            process.stderr.write('Both --by <name> and --reason "<text>" are required.\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const absContract = resolveAgainstCwd(cwd, contractFile);
+        if (!existsSync(absContract)) {
+            process.stderr.write(`Contract not found: ${absContract}\n`);
+            return 1;
+        }
+        let contract;
+        try {
+            contract = readContract(absContract);
+        }
+        catch (e) {
+            process.stderr.write(`Failed to parse contract: ${e.message}\n`);
+            return 1;
+        }
+        const gates = flagString(args, 'gates');
+        const expiresIn = flagString(args, 'expires-in');
+        const expiresAt = flagString(args, 'expires-at') ?? flagString(args, 'expires');
+        let resolvedExpiresAt;
+        if (expiresIn) {
+            const parsed = parseRelativeExpiry(expiresIn);
+            if (!parsed) {
+                process.stderr.write(`Invalid --expires-in value: ${expiresIn} (expected e.g. 30m, 2h, 7d, 1w)\n`);
+                return 2;
+            }
+            resolvedExpiresAt = parsed;
+        }
+        else if (expiresAt) {
+            const t = Date.parse(expiresAt);
+            if (Number.isNaN(t)) {
+                process.stderr.write(`Invalid --expires-at value: ${expiresAt} (expected ISO 8601 timestamp)\n`);
+                return 2;
+            }
+            resolvedExpiresAt = new Date(t).toISOString();
+        }
+        const secretEnv = flagString(args, 'secret-env');
+        const hash = computeContractHash(contract);
+        const approval = buildApproval({
+            contractHash: hash,
+            approvedBy: by,
+            reason,
+            ...(gates ? { approvedGates: gates.split(',').map((s) => s.trim()).filter(Boolean) } : {}),
+            ...(resolvedExpiresAt ? { expiresAt: resolvedExpiresAt } : {}),
+            ...(secretEnv ? { secretEnv } : {}),
+        });
+        const output = flagString(args, 'output');
+        if (!output) {
+            // No implicit write location — print and let the human redirect.
+            process.stdout.write(JSON.stringify(approval, null, 2) + '\n');
+            process.stdout.write(`\n(no --output supplied; redirect or re-run with --output <file> to persist the approval)\n`);
+            return 0;
+        }
+        const abs = resolveAgainstCwd(cwd, output);
+        mkdirSync(nodePath.dirname(abs), { recursive: true });
+        writeFileSync(abs, JSON.stringify(approval, null, 2) + '\n', 'utf8');
+        process.stdout.write(`Wrote ${abs}\n`);
+        if (approval.signature)
+            process.stdout.write(`  signed via ${secretEnv ?? 'SHARKCRAFT_CONTRACT_SECRET'}\n`);
+        else
+            process.stdout.write(`  unsigned (no contract secret env set)\n`);
+        return 0;
+    },
+};
+export const contractStatusCommand = {
+    name: 'status',
+    description: 'Show the status of a contract: hash, role, mode, and (optionally) approval verification. Read-only.',
+    usage: 'shrk contract status <contract.json> [--approval <approval.json>] [--json]',
+    async run(args) {
+        const contractFile = args.positional[0];
+        if (!contractFile) {
+            process.stderr.write('Usage: shrk contract status <contract.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const absContract = resolveAgainstCwd(cwd, contractFile);
+        if (!existsSync(absContract)) {
+            process.stderr.write(`Contract not found: ${absContract}\n`);
+            return 1;
+        }
+        let contract;
+        try {
+            contract = readContract(absContract);
+        }
+        catch (e) {
+            process.stderr.write(`Failed to parse contract: ${e.message}\n`);
+            return 1;
+        }
+        const approvalFlag = flagString(args, 'approval');
+        const approvalPath = approvalFlag ? resolveAgainstCwd(cwd, approvalFlag) : undefined;
+        const report = await checkAgentContract(inspection, contract, {
+            ...(approvalPath ? { approvalPath } : {}),
+        });
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                contractHash: report.contractHash,
+                task: report.task,
+                role: report.role,
+                mode: report.mode,
+                approvalStatus: report.approvalStatus,
+                approvalMessage: report.approvalMessage,
+                approvalExpiry: report.approvalExpiry,
+                pass: report.pass,
+                blockingGates: report.blockingGates,
+                warnGates: report.warnGates,
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(`Contract status\n`);
+        process.stdout.write(`  hash         ${report.contractHash}\n`);
+        process.stdout.write(`  task         ${report.task || '(empty)'}\n`);
+        process.stdout.write(`  role/mode    ${report.role} / ${report.mode}\n`);
+        process.stdout.write(`  approval     ${report.approvalStatus}${report.approvalMessage ? ' — ' + report.approvalMessage : ''}\n`);
+        if (report.approvalExpiry) {
+            const e = report.approvalExpiry;
+            const detail = e.expiresAt ? ` — ${e.expiresAt}` : '';
+            process.stdout.write(`  expiry       ${e.status}${detail}\n`);
+            if (e.noExpiryWarning)
+                process.stdout.write(`  warning      ${e.noExpiryWarning}\n`);
+        }
+        process.stdout.write(`  pass         ${report.pass ? 'yes' : 'no'}\n`);
+        if (report.blockingGates.length)
+            process.stdout.write(`  blocking     ${report.blockingGates.join(', ')}\n`);
+        if (report.warnGates.length)
+            process.stdout.write(`  warnings     ${report.warnGates.join(', ')}\n`);
+        return report.pass ? 0 : 1;
+    },
+};

package/dist/commands/contract-templates.command.d.ts

@@ -0,0 +1,8 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const contractTemplateListCommand: ICommandHandler;
+export declare const contractTemplateGetCommand: ICommandHandler;
+export declare const contractTemplateRenderCommand: ICommandHandler;
+export declare const contractTemplateRecommendCommand: ICommandHandler;
+/** Dispatcher for `shrk contract template <list|get|render|recommend>`. */
+export declare const contractTemplateCommand: ICommandHandler;
+//# sourceMappingURL=contract-templates.command.d.ts.map

package/dist/commands/contract-templates.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-templates.command.d.ts","sourceRoot":"","sources":["../../src/commands/contract-templates.command.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,2BAA2B,EAAE,eAiBzC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAgCxC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAuC3C,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,eA0B9C,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,EAAE,eAkBrC,CAAC"}

package/dist/commands/contract-templates.command.js

@@ -0,0 +1,151 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { getContractTemplate, listContractTemplates, recommendContractTemplate, renderContractTemplateMarkdown, renderContractTemplateText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const contractTemplateListCommand = {
+    name: 'list',
+    description: 'List built-in contract templates. Read-only.',
+    usage: 'shrk contract template list [--json]',
+    async run(args) {
+        const list = listContractTemplates();
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(list) + '\n');
+            return 0;
+        }
+        for (const t of list) {
+            process.stdout.write(`${t.id.padEnd(32)} ${t.title}\n`);
+            process.stdout.write(`  role: ${t.role} / mode: ${t.mode}\n`);
+            process.stdout.write(`  ${t.description}\n\n`);
+        }
+        return 0;
+    },
+};
+export const contractTemplateGetCommand = {
+    name: 'get',
+    description: 'Show a single contract template by id. Read-only.',
+    usage: 'shrk contract template get <id> [--format text|markdown|json] [--output <file>]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk contract template get <id>\n');
+            return 2;
+        }
+        const tpl = getContractTemplate(id);
+        if (!tpl) {
+            process.stderr.write(`Unknown template id: ${id}\n`);
+            return 1;
+        }
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson(tpl) + '\n';
+        else if (format === 'markdown' || format === 'md')
+            body = renderContractTemplateMarkdown(tpl);
+        else
+            body = renderContractTemplateText(tpl);
+        const cwd = resolveCwd(args);
+        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;
+    },
+};
+export const contractTemplateRenderCommand = {
+    name: 'render',
+    description: 'Render a contract template against a specific task (does not save). Read-only.',
+    usage: 'shrk contract template render <id> --task "<task>" [--role ai-agent|developer|...] [--format text|markdown|json] [--output <file>]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk contract template render <id> --task "<task>"\n');
+            return 2;
+        }
+        const task = flagString(args, 'task');
+        if (!task) {
+            process.stderr.write('--task "<task>" is required.\n');
+            return 2;
+        }
+        const tpl = getContractTemplate(id);
+        if (!tpl) {
+            process.stderr.write(`Unknown template id: ${id}\n`);
+            return 1;
+        }
+        const format = (flagString(args, 'format') ?? 'markdown').toLowerCase();
+        let body;
+        if (format === 'json' || flagBool(args, 'json'))
+            body = asJson({ template: tpl, task }) + '\n';
+        else if (format === 'text' || format === 'txt')
+            body = renderContractTemplateText(tpl, task);
+        else
+            body = renderContractTemplateMarkdown(tpl, task);
+        const cwd = resolveCwd(args);
+        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;
+    },
+};
+export const contractTemplateRecommendCommand = {
+    name: 'recommend',
+    description: 'Recommend contract templates for a task. Read-only.',
+    usage: 'shrk contract template recommend "<task>" [--role <role>] [--intent <kind>] [--json]',
+    async run(args) {
+        const task = args.positional.join(' ').trim();
+        if (!task) {
+            process.stderr.write('Usage: shrk contract template recommend "<task>"\n');
+            return 2;
+        }
+        const role = flagString(args, 'role');
+        const intent = flagString(args, 'intent');
+        const matches = recommendContractTemplate(task, role, intent);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(matches) + '\n');
+            return 0;
+        }
+        if (matches.length === 0) {
+            process.stdout.write('No contract templates matched.\n');
+            return 0;
+        }
+        for (const m of matches) {
+            process.stdout.write(`${m.match.padEnd(8)} ${m.template.id}  — ${m.reason}\n`);
+        }
+        return 0;
+    },
+};
+/** Dispatcher for `shrk contract template <list|get|render|recommend>`. */
+export const contractTemplateCommand = {
+    name: 'template',
+    description: 'Reusable agent-contract templates (list / get / render / recommend). Read-only.',
+    usage: 'shrk contract template <list|get|render|recommend> [...]',
+    async run(args) {
+        const sub = args.positional[0];
+        if (!sub) {
+            process.stderr.write('Usage: shrk contract template <list|get|render|recommend>\n');
+            return 2;
+        }
+        const next = { ...args, positional: args.positional.slice(1) };
+        if (sub === 'list')
+            return (await contractTemplateListCommand.run(next));
+        if (sub === 'get')
+            return (await contractTemplateGetCommand.run(next));
+        if (sub === 'render')
+            return (await contractTemplateRenderCommand.run(next));
+        if (sub === 'recommend')
+            return (await contractTemplateRecommendCommand.run(next));
+        process.stderr.write(`Unknown contract template subcommand: ${sub}\n`);
+        return 2;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.command.d.ts","sourceRoot":"","sources":["../../src/commands/contract.command.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA4BhC,eAAO,MAAM,eAAe,EAAE,eAqF7B,CAAC"}

package/dist/commands/contract.command.js

@@ -0,0 +1,105 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAgentContract, inspectSharkcraft, renderAgentContractHtml, renderAgentContractMarkdown, renderAgentContractText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+import { contractApproveCommand, contractCheckCommand, contractStatusCommand, } from "./contract-gate.command.js";
+import { contractTemplateCommand } from "./contract-templates.command.js";
+function parseFiles(args) {
+    const raw = flagString(args, 'files');
+    if (!raw)
+        return [];
+    return raw
+        .split(',')
+        .map((f) => f.trim())
+        .filter((f) => f.length > 0);
+}
+function safeSlug(s) {
+    return (s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 64) || 'contract');
+}
+export const contractCommand = {
+    name: 'contract',
+    description: 'Build a deterministic agent contract for a task (intent + risk + impact + ownership + boundaries + policies + playbooks). Read-only unless --save (writes only to .sharkcraft/contracts/).',
+    usage: 'shrk contract "<task>" [--role developer|reviewer|architect|release-manager|security|ai-agent] [--mode conservative|balanced|aggressive] [--files a,b,c] [--since <ref>] [--staged] [--format text|markdown|html|json] [--output <file>] [--save]',
+    async run(args) {
+        // Dispatch to subcommands (check / approve / status / template).
+        const first = args.positional[0];
+        if (first === 'check' || first === 'approve' || first === 'status') {
+            const sub = first === 'check'
+                ? contractCheckCommand
+                : first === 'approve'
+                    ? contractApproveCommand
+                    : contractStatusCommand;
+            return (await sub.run({ ...args, positional: args.positional.slice(1) }));
+        }
+        if (first === 'template') {
+            return (await contractTemplateCommand.run({ ...args, positional: args.positional.slice(1) }));
+        }
+        const task = args.positional.join(' ').trim();
+        if (!task) {
+            process.stderr.write('Usage: shrk contract "<task>"  |  shrk contract {check|approve|status} <contract.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const role = flagString(args, 'role');
+        const mode = flagString(args, 'mode');
+        const files = parseFiles(args);
+        const since = flagString(args, 'since');
+        const staged = flagBool(args, 'staged');
+        const contract = await buildAgentContract(task, inspection, {
+            ...(role ? { role } : {}),
+            ...(mode ? { mode } : {}),
+            ...(files.length > 0 ? { files } : {}),
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+        });
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        let body;
+        let extension;
+        if (format === 'json' || flagBool(args, 'json')) {
+            body = asJson(contract) + '\n';
+            extension = 'json';
+        }
+        else if (format === 'markdown' || format === 'md') {
+            body = renderAgentContractMarkdown(contract);
+            extension = 'md';
+        }
+        else if (format === 'html') {
+            body = renderAgentContractHtml(contract);
+            extension = 'html';
+        }
+        else {
+            body = renderAgentContractText(contract);
+            extension = 'txt';
+        }
+        const output = flagString(args, 'output');
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, body, 'utf8');
+            process.stdout.write(`Wrote ${abs}\n`);
+            return 0;
+        }
+        if (flagBool(args, 'save')) {
+            // Writes only under .sharkcraft/contracts/ — never anywhere else.
+            const dir = nodePath.join(cwd, '.sharkcraft', 'contracts');
+            mkdirSync(dir, { recursive: true });
+            const ts = new Date().toISOString().replace(/[:.]/g, '-');
+            const file = nodePath.join(dir, `${ts}-${safeSlug(task)}.${extension}`);
+            writeFileSync(file, body, 'utf8');
+            // Also save the canonical JSON alongside so downstream tools can read it.
+            if (extension !== 'json') {
+                writeFileSync(file.replace(/\.[^.]+$/, '.json'), asJson(contract) + '\n', 'utf8');
+            }
+            process.stdout.write(`Wrote ${file}\n`);
+            return 0;
+        }
+        process.stdout.write(body);
+        return 0;
+    },
+};

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

@@ -0,0 +1,8 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const conventionsListCommand: ICommandHandler;
+export declare const conventionsGetCommand: ICommandHandler;
+export declare const conventionsDoctorCommand: ICommandHandler;
+export declare const conventionsCheckCommand: ICommandHandler;
+export declare const conventionsExplainCommand: ICommandHandler;
+export declare const conventionsCommand: ICommandHandler;
+//# sourceMappingURL=conventions.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.command.d.ts","sourceRoot":"","sources":["../../src/commands/conventions.command.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,sBAAsB,EAAE,eAgCpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAsCnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAsBtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAkCrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eAOvC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAgBhC,CAAC"}