peaks-cli 1.0.0

package/dist/src/cli/commands/config-commands.js

@@ -0,0 +1,212 @@
+import { addWorkspace, getConfig, getMiniMaxProviderConfig, getMiniMaxProviderStatus, isSensitiveConfigPath, readConfig, redactConfigSecrets, removeWorkspace, setConfig, setCurrentWorkspace, setMiniMaxProviderConfig } from '../../services/config/config-service.js';
+import { testMiniMaxProvider } from '../../services/providers/minimax-provider-service.js';
+import { fail, ok } from '../../shared/result.js';
+import { addJsonOption, getErrorMessage, isArtifactProvider, isArtifactRepoSegment, isMiniMaxHttpsUrl, parseConfigLayer, printInvalidConfigLayer, printResult, redactSensitiveErrorMessage, summarizeMiniMaxSmokeResult } from '../cli-helpers.js';
+export function registerConfigCommands(program, io) {
+    const config = program.command('config').description('Manage Peaks configuration');
+    registerConfigGetSetCommands(config, io);
+    registerMiniMaxProviderCommands(config, io);
+    registerWorkspaceCommands(config, io);
+}
+function registerConfigGetSetCommands(config, io) {
+    addJsonOption(config.command('get').description('Get current config or a specific key').option('--key <path>', 'dot-notation key path').option('--layer <layer>', 'user or project')).action((options) => {
+        const layer = parseConfigLayer(options.layer);
+        if (layer === null) {
+            printInvalidConfigLayer(io, 'config.get', options.json);
+            return;
+        }
+        const getOpts = { ...(layer !== undefined ? { layer } : {}), ...(options.key !== undefined ? { key: options.key } : {}) };
+        const value = getConfig(getOpts);
+        const isSensitiveKey = options.key !== undefined && isSensitiveConfigPath(options.key);
+        printResult(io, ok('config.get', isSensitiveKey ? '***' : redactConfigSecrets(value, options.key ?? '')), options.json);
+    });
+    addJsonOption(config.command('set').description('Set a config value').requiredOption('--key <path>', 'dot-notation key path').requiredOption('--value <json>', 'JSON value').option('--layer <layer>', 'user or project')).action((options) => {
+        const parsedLayer = parseConfigLayer(options.layer);
+        if (parsedLayer === null) {
+            printInvalidConfigLayer(io, 'config.set', options.json);
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(options.value);
+        }
+        catch {
+            printResult(io, fail('config.set', 'INVALID_JSON', 'Could not parse value as JSON', {}, ['Use valid JSON: --value \'{"key":"value"}\'']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            setConfig({ key: options.key, value: parsed, layer: parsedLayer ?? 'user' });
+            const value = isSensitiveConfigPath(options.key) ? '***' : redactConfigSecrets(parsed);
+            printResult(io, ok('config.set', { key: options.key, value }), options.json);
+        }
+        catch (error) {
+            printConfigSetError(io, error, options.json);
+        }
+    });
+}
+function printConfigSetError(io, error, asJson) {
+    const message = getErrorMessage(error);
+    if (message === 'Sensitive config keys must be stored in the user config layer') {
+        printResult(io, fail('config.set', 'SECRET_CONFIG_REQUIRES_USER_LAYER', message, {}, ['Use --layer user or peaks config provider minimax set']), asJson);
+        process.exitCode = 1;
+        return;
+    }
+    if (message === 'Project config not found') {
+        printResult(io, fail('config.set', 'PROJECT_CONFIG_NOT_FOUND', message, {}, ['Create a safe .peaks/config.json in the project or use --layer user']), asJson);
+        process.exitCode = 1;
+        return;
+    }
+    if (message === 'MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials') {
+        printResult(io, fail('config.set', 'INVALID_MINIMAX_BASE_URL', message, {}, ['Use a MiniMax Anthropic-compatible HTTPS endpoint']), asJson);
+        process.exitCode = 1;
+        return;
+    }
+    printResult(io, fail('config.set', 'CONFIG_SET_FAILED', message, {}, ['Check the config key and layer, then retry']), asJson);
+    process.exitCode = 1;
+}
+function registerMiniMaxProviderCommands(config, io) {
+    const minimaxProvider = config.command('provider').description('Manage model provider settings').command('minimax').description('Manage MiniMax provider settings');
+    addJsonOption(minimaxProvider.command('set').description('Set MiniMax provider settings in user config').option('--base-url <url>', 'MiniMax Anthropic-compatible base URL')).action((options) => {
+        const baseUrl = options.baseUrl?.trim();
+        const apiKey = process.env.MINIMAX_API_KEY?.trim();
+        if (!baseUrl && !apiKey) {
+            printResult(io, fail('config.provider.minimax.set', 'MINIMAX_PROVIDER_NO_VALUES', 'Provide --base-url and set MINIMAX_API_KEY', {}, ['Export MINIMAX_API_KEY and rerun peaks config provider minimax set --base-url <url>']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        if (baseUrl && !isMiniMaxHttpsUrl(baseUrl)) {
+            printResult(io, fail('config.provider.minimax.set', 'INVALID_MINIMAX_BASE_URL', 'MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials', {}, ['Use a MiniMax Anthropic-compatible HTTPS endpoint']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const input = {};
+            if (baseUrl)
+                input.baseUrl = baseUrl;
+            if (apiKey)
+                input.apiKey = apiKey;
+            const status = setMiniMaxProviderConfig(input);
+            printResult(io, ok('config.provider.minimax.set', status), options.json);
+        }
+        catch (error) {
+            printMiniMaxProviderSetError(io, error, options.json);
+        }
+    });
+    addJsonOption(minimaxProvider.command('get').description('Show redacted MiniMax provider settings')).action((options) => {
+        const configValue = getMiniMaxProviderConfig();
+        const status = getMiniMaxProviderStatus();
+        printResult(io, ok('config.provider.minimax.get', { ...redactConfigSecrets(configValue, 'providers.minimax'), ...status }), options.json);
+    });
+    addJsonOption(minimaxProvider.command('status').description('Show MiniMax provider configuration status')).action((options) => {
+        printResult(io, ok('config.provider.minimax.status', getMiniMaxProviderStatus()), options.json);
+    });
+    addJsonOption(minimaxProvider.command('test').description('Run a redacted MiniMax provider smoke test').option('--model <model>', 'model name for the smoke test', 'MiniMax-M2.7')).action(async (options) => {
+        try {
+            const result = await testMiniMaxProvider(getMiniMaxProviderConfig(), { model: options.model });
+            const safeResult = summarizeMiniMaxSmokeResult(result);
+            if (!result.configured) {
+                printResult(io, fail('config.provider.minimax.test', 'MINIMAX_PROVIDER_NOT_CONFIGURED', 'MiniMax provider requires baseUrl and apiKey in user config', safeResult, ['Export MINIMAX_API_KEY or set MINIMAX_API_KEY']), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(io, result.ok ? ok('config.provider.minimax.test', safeResult) : fail('config.provider.minimax.test', 'MINIMAX_PROVIDER_TEST_FAILED', 'MiniMax provider smoke test failed', safeResult, ['Check the MiniMax base URL, API key, and model name']), options.json);
+            if (!result.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printResult(io, fail('config.provider.minimax.test', 'MINIMAX_PROVIDER_TEST_FAILED', redactSensitiveErrorMessage(getErrorMessage(error)), {}, ['Check network connectivity and MiniMax provider settings']), options.json);
+            process.exitCode = 1;
+        }
+    });
+}
+function printMiniMaxProviderSetError(io, error, asJson) {
+    if (getErrorMessage(error) === 'MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials') {
+        printResult(io, fail('config.provider.minimax.set', 'INVALID_MINIMAX_BASE_URL', 'MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials', {}, ['Use a MiniMax Anthropic-compatible HTTPS endpoint']), asJson);
+        process.exitCode = 1;
+        return;
+    }
+    printResult(io, fail('config.provider.minimax.set', 'MINIMAX_PROVIDER_SET_FAILED', getErrorMessage(error), {}, ['Check MiniMax provider settings and retry']), asJson);
+    process.exitCode = 1;
+}
+function registerWorkspaceCommands(config, io) {
+    const configWorkspace = config.command('workspace').description('Manage workspaces');
+    addJsonOption(configWorkspace.command('list').description('List all workspaces')).action((options) => {
+        const cfg = readConfig();
+        printResult(io, ok('config.workspace.list', { currentWorkspace: cfg.currentWorkspace, workspaces: cfg.workspaces }), options.json);
+    });
+    addJsonOption(configWorkspace.command('add').description('Add a workspace').requiredOption('--id <id>', 'workspace identifier').requiredOption('--name <name>', 'workspace display name').requiredOption('--path <path>', 'workspace root path').option('--provider <provider>', 'artifact repo provider: github or gitlab').option('--repo-owner <owner>', 'artifact repo owner').option('--repo-name <name>', 'artifact repo name').option('--layer <layer>', 'user or project')).action((options) => {
+        const layer = parseConfigLayer(options.layer);
+        if (layer === null) {
+            printInvalidConfigLayer(io, 'config.workspace.add', options.json);
+            return;
+        }
+        const artifactRepo = parseArtifactRepoInput(io, options, options.json);
+        if (artifactRepo === null)
+            return;
+        const workspace = { workspaceId: options.id, name: options.name, rootPath: options.path, installedCapabilityIds: [] };
+        const configLayer = layer ?? 'user';
+        if (artifactRepo) {
+            addWorkspace({ ...workspace, artifactRepo }, configLayer);
+        }
+        else {
+            addWorkspace(workspace, configLayer);
+        }
+        printResult(io, ok('config.workspace.add', { workspaceId: options.id, name: options.name, rootPath: options.path, artifactRepo }), options.json);
+    });
+    addJsonOption(configWorkspace.command('remove').description('Remove a workspace').requiredOption('--id <id>', 'workspace identifier').option('--layer <layer>', 'user or project')).action((options) => {
+        const layer = parseConfigLayer(options.layer);
+        if (layer === null) {
+            printInvalidConfigLayer(io, 'config.workspace.remove', options.json);
+            return;
+        }
+        const configLayer = layer ?? 'user';
+        const removed = removeWorkspace(options.id, configLayer);
+        if (removed) {
+            printResult(io, ok('config.workspace.remove', { workspaceId: options.id }), options.json);
+        }
+        else {
+            printWorkspaceNotFound(io, 'config.workspace.remove', `Workspace ${options.id} not found`, options.json);
+        }
+    });
+    addJsonOption(configWorkspace.command('switch').description('Switch current workspace').requiredOption('--id <id>', 'workspace identifier').option('--layer <layer>', 'user or project')).action((options) => {
+        const layer = parseConfigLayer(options.layer);
+        if (layer === null) {
+            printInvalidConfigLayer(io, 'config.workspace.switch', options.json);
+            return;
+        }
+        const configLayer = layer ?? 'user';
+        const switched = setCurrentWorkspace(options.id, configLayer);
+        if (switched) {
+            printResult(io, ok('config.workspace.switch', { currentWorkspace: options.id }), options.json);
+        }
+        else {
+            printWorkspaceNotFound(io, 'config.workspace.switch', `Workspace ${options.id} not found`, options.json);
+        }
+    });
+}
+function parseArtifactRepoInput(io, options, asJson) {
+    const hasArtifactRepoInput = options.provider !== undefined || options.repoOwner !== undefined || options.repoName !== undefined;
+    if (!hasArtifactRepoInput)
+        return undefined;
+    if (!options.provider || !options.repoOwner || !options.repoName) {
+        printResult(io, fail('config.workspace.add', 'INVALID_ARTIFACT_REPO_CONFIG', 'Artifact repo config requires --provider, --repo-owner, and --repo-name together', {}, ['Provide all three artifact repo options together, or omit them all']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    if (!isArtifactProvider(options.provider)) {
+        printResult(io, fail('config.workspace.add', 'UNSUPPORTED_ARTIFACT_PROVIDER', `Unsupported provider ${options.provider}`, {}, ['Use --provider github or --provider gitlab']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    if (!isArtifactRepoSegment(options.repoOwner) || !isArtifactRepoSegment(options.repoName)) {
+        printResult(io, fail('config.workspace.add', 'INVALID_ARTIFACT_REPO_CONFIG', 'Artifact repo owner and name must use safe GitHub/GitLab path segments', {}, ['Use letters, numbers, dots, underscores, or hyphens without path traversal']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    return { provider: options.provider, owner: options.repoOwner, name: options.repoName };
+}
+function printWorkspaceNotFound(io, command, message, asJson) {
+    printResult(io, fail(command, 'WORKSPACE_NOT_FOUND', message, {}, ['List workspaces with: peaks config workspace list']), asJson);
+    process.exitCode = 1;
+}

package/dist/src/cli/commands/core-artifact-commands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerCoreAndArtifactCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/core-artifact-commands.js

@@ -0,0 +1,200 @@
+import { createArtifactInitPlan, getArtifactStatus, createGuidedArtifactSetup } from '../../services/artifacts/artifact-service.js';
+import { getArtifactWorkspaceStatus, planArtifactSync } from '../../services/artifacts/workspace-service.js';
+import { executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from '../../services/memory/project-memory-service.js';
+import { executeProjectStandardsInit, executeProjectStandardsUpdate, summarizeProjectStandardsInitResult, summarizeProjectStandardsUpdateResult } from '../../services/standards/project-standards-service.js';
+import { listProfiles } from '../../services/profiles/profile-service.js';
+import { planProxyTest } from '../../services/proxy/proxy-service.js';
+import { runDoctor } from '../../services/doctor/doctor-service.js';
+import { listSkills } from '../../services/skills/skill-registry.js';
+import { fail, ok } from '../../shared/result.js';
+import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, isArtifactProvider, isArtifactSetupStep, printResult } from '../cli-helpers.js';
+export function registerCoreAndArtifactCommands(program, io) {
+    addJsonOption(program.command('doctor').description('Run repository doctor checks')).action(async (options) => {
+        const report = await runDoctor();
+        const result = report.summary.ok
+            ? ok('doctor', report)
+            : fail('doctor', 'DOCTOR_FAILED', 'One or more doctor checks failed', report, ['Fix failed checks and rerun peaks doctor']);
+        printResult(io, result, options.json);
+        if (!report.summary.ok) {
+            process.exitCode = 1;
+        }
+    });
+    const skill = program.command('skill').description('Manage Peaks skills');
+    addJsonOption(skill.command('list').description('List skills derived from skills/*/SKILL.md')).action(async (options) => {
+        const skills = await listSkills();
+        printResult(io, ok('skill.list', { skills }), options.json);
+    });
+    addJsonOption(skill.command('doctor').description('Run skill-related doctor checks')).action(async (options) => {
+        const report = await runDoctor();
+        const skillChecks = report.checks.filter((check) => check.id.startsWith('skill'));
+        const failed = skillChecks.filter((check) => !check.ok).length;
+        printResult(io, ok('skill.doctor', { checks: skillChecks, ok: failed === 0 }), options.json);
+        if (failed > 0) {
+            process.exitCode = 1;
+        }
+    });
+    const profile = program.command('profile').description('Manage runtime profiles');
+    addJsonOption(profile.command('list').description('List available profiles')).action((options) => {
+        printResult(io, ok('profile.list', { profiles: listProfiles() }), options.json);
+    });
+    const standards = program.command('standards').description('Manage project-local coding standards');
+    addJsonOption(standards
+        .command('init')
+        .description('Initialize project-local coding standards for Peaks skill preflight')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--language <language>', 'standards language pack')
+        .option('--dry-run', 'preview writes without changing files')
+        .option('--apply', 'write missing standards into the target project')).action((options) => {
+        if (options.dryRun === true && options.apply === true) {
+            printResult(io, fail('standards.init', 'INVALID_STANDARDS_INIT_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview writes, or omit --dry-run when applying standards']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = executeProjectStandardsInit({ projectRoot: options.project, ...(options.language !== undefined ? { language: options.language } : {}), apply: options.apply === true });
+            printResult(io, ok('standards.init', summarizeProjectStandardsInitResult(result)), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('standards.init', 'STANDARDS_INIT_FAILED', getErrorMessage(error), {}, ['Check the project path and existing .claude/rules directory before retrying']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(standards
+        .command('update')
+        .description('Append managed standards metadata to an existing CLAUDE.md without rewriting the body')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--language <language>', 'standards language pack')
+        .option('--dry-run', 'preview writes without changing files')
+        .option('--apply', 'append managed metadata to the target project')).action((options) => {
+        if (options.dryRun === true && options.apply === true) {
+            printResult(io, fail('standards.update', 'INVALID_STANDARDS_UPDATE_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview writes, or omit --dry-run when applying standards updates']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = executeProjectStandardsUpdate({ projectRoot: options.project, ...(options.language !== undefined ? { language: options.language } : {}), apply: options.apply === true });
+            const summary = summarizeProjectStandardsUpdateResult(result);
+            const response = summary.reviewSuggestions.length > 0
+                ? fail('standards.update', 'STANDARDS_UPDATE_REVIEW_REQUIRED', 'Standards update requires manual review', summary, summary.reviewSuggestions)
+                : ok('standards.update', summary);
+            printResult(io, response, options.json);
+            if (summary.reviewSuggestions.length > 0) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            printResult(io, fail('standards.update', 'STANDARDS_UPDATE_FAILED', getErrorMessage(error), {}, ['Check the project path, CLAUDE.md contents, and existing .claude/rules directory before retrying']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    const memory = program.command('memory').description('Manage project-local Peaks memory');
+    addJsonOption(memory
+        .command('extract')
+        .description('Extract stable project memory from skill artifacts into project .claude/memory')
+        .requiredOption('--project <path>', 'target project root')
+        .requiredOption('--artifact <path...>', 'skill artifact paths inside the project')
+        .option('--dry-run', 'preview writes without changing files', true)
+        .option('--apply', 'write extracted memories into project .claude/memory')).action((options) => {
+        try {
+            const result = executeProjectMemoryExtract({ projectRoot: options.project, artifactPaths: options.artifact, apply: options.apply === true });
+            printResult(io, ok('memory.extract', summarizeProjectMemoryExtractResult(result)), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('memory.extract', 'MEMORY_EXTRACT_FAILED', getErrorMessage(error), {}, ['Check artifact paths and remove secrets before extracting memory']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(memory
+        .command('sync')
+        .description('Back up project .claude/memory into the artifact workspace')
+        .requiredOption('--project <path>', 'target project root')
+        .requiredOption('--workspace <path>', 'artifact workspace path')
+        .option('--dry-run', 'preview copies without changing files', true)
+        .option('--apply', 'copy project .claude/memory into artifact workspace backup')).action((options) => {
+        try {
+            const result = executeProjectMemoryBackup({ projectRoot: options.project, artifactWorkspacePath: options.workspace, apply: options.apply === true });
+            printResult(io, ok('memory.sync', summarizeProjectMemoryBackupResult(result)), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('memory.sync', 'MEMORY_SYNC_FAILED', getErrorMessage(error), {}, ['Use an artifact workspace outside the project root']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    const proxy = program.command('proxy').description('Manage proxy settings');
+    addJsonOption(proxy
+        .command('test')
+        .description('Plan or run a proxy connectivity test')
+        .requiredOption('--proxy <url>', 'proxy URL')
+        .option('--target <url>', 'target URL', 'https://www.google.com')
+        .option('--dry-run', 'only print the planned command', true)
+        .option('--no-dry-run', 'unsupported: do not execute connectivity tests from this CLI')).action((options) => {
+        if (options.dryRun === false) {
+            failUnsupportedNonDryRun(io, 'proxy.test', options.json);
+            return;
+        }
+        try {
+            const plan = planProxyTest(options.proxy, options.target, true);
+            printResult(io, ok('proxy.test', plan), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('proxy.test', 'INVALID_PROXY', getErrorMessage(error), {}, ['Use a proxy URL starting with http:// or https://']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    const artifacts = program.command('artifacts').description('Manage intermediate artifact repositories');
+    addJsonOption(artifacts.command('status').description('Show artifact repository status')).action((options) => {
+        printResult(io, ok('artifacts.status', getArtifactStatus()), options.json);
+    });
+    addJsonOption(artifacts
+        .command('init')
+        .description('Plan remote-first artifact repository initialization')
+        .requiredOption('--provider <provider>', 'artifact provider: github or gitlab')
+        .requiredOption('--name <name>', 'remote repository name')
+        .option('--path <path>', 'local artifact working copy path', '.peaks-artifacts')
+        .option('--dry-run', 'preview without creating repositories or files', true)
+        .option('--no-dry-run', 'unsupported: do not create repositories or files from this CLI')).action((options) => {
+        if (options.dryRun === false) {
+            failUnsupportedNonDryRun(io, 'artifacts.init', options.json);
+            return;
+        }
+        if (!isArtifactProvider(options.provider)) {
+            printResult(io, fail('artifacts.init', 'UNSUPPORTED_ARTIFACT_PROVIDER', `Unsupported provider ${options.provider}`, {}, ['Use --provider github or --provider gitlab']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, ok('artifacts.init', createArtifactInitPlan({
+            provider: options.provider,
+            name: options.name,
+            localPath: options.path,
+            dryRun: true
+        })), options.json);
+    });
+    addJsonOption(artifacts
+        .command('sync')
+        .description('Plan sync between local artifact workspace and remote repository')
+        .option('--workspace <id>', 'workspace identifier (uses current if not specified)')
+        .option('--dry-run', 'preview sync plan without executing', true)
+        .option('--no-dry-run', 'unsupported: do not sync from this CLI')).action((options) => {
+        if (options.dryRun === false) {
+            failUnsupportedNonDryRun(io, 'artifacts.sync', options.json);
+            return;
+        }
+        printResult(io, ok('artifacts.sync', planArtifactSync(options.workspace, true)), options.json);
+    });
+    addJsonOption(artifacts.command('workspace').description('Show artifact workspace status for current or specified workspace').option('--workspace <id>', 'workspace identifier')).action((options) => {
+        printResult(io, ok('artifacts.workspace', getArtifactWorkspaceStatus(options.workspace)), options.json);
+    });
+    addJsonOption(artifacts.command('setup').description('Interactive guided artifact repository setup').option('--step <step>', 'start from specific step: detect, configure, validate, complete')).action((options) => {
+        const requestedStep = options.step;
+        const setup = createGuidedArtifactSetup();
+        if (requestedStep) {
+            if (!isArtifactSetupStep(requestedStep)) {
+                printResult(io, fail('artifacts.setup', 'INVALID_ARTIFACT_SETUP_STEP', `Invalid artifact setup step ${requestedStep}`, {}, ['Use one of: detect, configure, validate, complete']), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            setup.step = requestedStep;
+        }
+        printResult(io, ok('artifacts.setup', setup), options.json);
+    });
+}

package/dist/src/cli/commands/sc-commands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerSCCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/sc-commands.js

@@ -0,0 +1,37 @@
+import { createArtifactRetentionReport, createChangeImpact, getChangeTraceabilityStatus, getScHelpText, recordCommitBoundary, validateArtifactRetention } from '../../services/sc/sc-service.js';
+import { ok } from '../../shared/result.js';
+import { addJsonOption, multipleOption, printResult } from '../cli-helpers.js';
+export function registerSCCommands(program, io) {
+    const sc = program.command('sc').description('Source control and change traceability (peaks-sc integration)');
+    registerSCStatusCommands(sc, io);
+    registerSCArtifactCommands(sc, io);
+}
+function registerSCStatusCommands(sc, io) {
+    addJsonOption(sc.command('status').description('Show change traceability status')).action((options) => {
+        printResult(io, ok('sc.status', getChangeTraceabilityStatus()), options.json);
+    });
+    addJsonOption(sc.command('help').description('Show peaks-sc help text')).action((options) => {
+        const helpText = getScHelpText().join('\n');
+        if (options.json) {
+            printResult(io, ok('sc.help', { helpText }), options.json);
+        }
+        else {
+            io.stdout(helpText);
+        }
+    });
+}
+function registerSCArtifactCommands(sc, io) {
+    addJsonOption(sc.command('impact').description('Generate change impact artifact').requiredOption('--change-id <id>', 'change identifier').option('--module <module>', 'affected module', multipleOption).option('--file <file>', 'affected file', multipleOption)).action((options) => {
+        const impactOptions = { changeId: options.changeId, ...(options.module ? { affectedModules: options.module } : {}), ...(options.file ? { affectedFiles: options.file } : {}) };
+        printResult(io, ok('sc.impact', createChangeImpact(impactOptions)), options.json);
+    });
+    addJsonOption(sc.command('retention').description('Create artifact retention report').requiredOption('--slice-id <id>', 'slice identifier').option('--prd <artifact>', 'PRD artifact path', multipleOption).option('--rd <artifact>', 'RD artifact path', multipleOption).option('--qa <artifact>', 'QA artifact path', multipleOption).option('--coverage <artifact>', 'coverage artifact path', multipleOption).option('--review <artifact>', 'review artifact path', multipleOption).option('--code <file>', 'code file path', multipleOption)).action((options) => {
+        printResult(io, ok('sc.retention', createArtifactRetentionReport({ sliceId: options.sliceId, ...(options.prd ? { prdArtifacts: options.prd } : {}), ...(options.rd ? { rdArtifacts: options.rd } : {}), ...(options.qa ? { qaArtifacts: options.qa } : {}), ...(options.coverage ? { coverageArtifacts: options.coverage } : {}), ...(options.review ? { reviewArtifacts: options.review } : {}), ...(options.code ? { codeChanges: options.code } : {}) })), options.json);
+    });
+    addJsonOption(sc.command('validate').description('Validate artifact retention for a slice').requiredOption('--slice-id <id>', 'slice identifier')).action((options) => {
+        printResult(io, ok('sc.validate', validateArtifactRetention(options.sliceId)), options.json);
+    });
+    addJsonOption(sc.command('boundary').description('Record commit boundary for a slice').requiredOption('--slice-id <id>', 'slice identifier').option('--artifact <path>', 'artifact path', multipleOption).option('--code <file>', 'code file path', multipleOption)).action((options) => {
+        printResult(io, ok('sc.boundary', recordCommitBoundary({ sliceId: options.sliceId, ...(options.artifact ? { artifacts: options.artifact } : {}), ...(options.code ? { codeFiles: options.code } : {}) })), options.json);
+    });
+}

package/dist/src/cli/commands/worker-commands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerWorkerCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/worker-commands.js

@@ -0,0 +1,52 @@
+import { getMiniMaxProviderConfig } from '../../services/config/config-service.js';
+import { runMiniMaxWorker } from '../../services/providers/minimax-worker-service.js';
+import { fail, ok } from '../../shared/result.js';
+import { addJsonOption, getErrorMessage, printResult, redactSensitiveErrorMessage, summarizeMiniMaxWorkerResult } from '../cli-helpers.js';
+function addMiniMaxWorkerOptions(command) {
+    return addJsonOption(command
+        .description('Run a single MiniMax coding and unit-test execution worker')
+        .requiredOption('--change-id <id>', 'change identifier')
+        .requiredOption('--goal <goal>', 'execution goal')
+        .requiredOption('--coding-task <task>', 'coding execution task')
+        .requiredOption('--unit-test-task <task>', 'unit-test execution task')
+        .option('--model <model>', 'model name for the worker', 'MiniMax-M2.7')
+        .option('--confirm', 'confirm that worker inputs may be sent to the external MiniMax provider once and only return a review handoff', false));
+}
+async function runMiniMaxWorkerCommand(io, options) {
+    if (!options.confirm) {
+        printResult(io, fail('worker.minimax', 'CONFIRMATION_REQUIRED', 'This worker only runs with explicit confirmation because inputs may be sent to the external MiniMax provider', {}, ['Rerun with --confirm after removing secrets from worker inputs']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const changeId = options.changeId.trim();
+    const goal = options.goal.trim();
+    const codingTask = options.codingTask.trim();
+    const unitTestTask = options.unitTestTask.trim();
+    if (!changeId || !goal || !codingTask || !unitTestTask) {
+        printResult(io, fail('worker.minimax', 'INVALID_WORKER_INPUT', 'Worker inputs must be non-empty', {}, ['Provide non-empty values for --change-id, --goal, --coding-task, and --unit-test-task']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const result = await runMiniMaxWorker(getMiniMaxProviderConfig(), { changeId, goal, codingTask, unitTestTask, model: options.model });
+        const safeResult = summarizeMiniMaxWorkerResult(result);
+        if (!result.provider.configured) {
+            printResult(io, fail('worker.minimax', 'MINIMAX_PROVIDER_NOT_CONFIGURED', 'MiniMax provider requires baseUrl and apiKey in user config', safeResult, ['Run peaks config provider minimax set --base-url <url> and either MINIMAX_API_KEY']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, result.provider.ok ? ok('worker.minimax', safeResult) : fail('worker.minimax', 'MINIMAX_WORKER_FAILED', 'MiniMax worker execution failed', safeResult, ['Check the MiniMax base URL, API key, and worker tasks']), options.json);
+        if (!result.provider.ok) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        printResult(io, fail('worker.minimax', 'MINIMAX_WORKER_FAILED', redactSensitiveErrorMessage(getErrorMessage(error)), {}, ['Check the MiniMax base URL, API key, and worker tasks']), options.json);
+        process.exitCode = 1;
+    }
+}
+export function registerWorkerCommands(program, io) {
+    const worker = program.command('worker').description('Run controlled execution workers');
+    addMiniMaxWorkerOptions(worker.command('minimax')).action(async (options) => runMiniMaxWorkerCommand(io, options));
+    addMiniMaxWorkerOptions(program.command('minimax-worker')).action(async (options) => runMiniMaxWorkerCommand(io, options));
+}

package/dist/src/cli/commands/workflow-commands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerWorkflowCommands(program: Command, io: ProgramIO): void;