peaks-cli 1.0.0

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

@@ -0,0 +1,257 @@
+import { createRdSwarmPlan } from '../../services/rd/rd-service.js';
+import { createTechPlan, getTechStatus } from '../../services/tech/tech-service.js';
+import { createWorkflowRouterPlan, isSoloMode, isWorkflowMode } from '../../services/workflow/workflow-router-service.js';
+import { createAutonomousWorkflowPlan } from '../../services/workflow/workflow-autonomous-service.js';
+import { createRecommendationPlan } from '../../services/recommendations/recommendation-service.js';
+import { createRefactorDryRun } from '../../services/refactor/refactor-service.js';
+import { getCurrentWorkspaceConfig, readConfig } from '../../services/config/config-service.js';
+import { getEconomyAwareExecutionModelId } from '../../services/config/model-routing.js';
+import { getLocalArtifactPath } from '../../services/artifacts/workspace-service.js';
+import { fail, ok } from '../../shared/result.js';
+import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, isRecommendationWorkflow, printResult } from '../cli-helpers.js';
+function getWorkspaceContext() {
+    const workspace = getCurrentWorkspaceConfig();
+    if (!workspace)
+        return {};
+    return { workspace, artifactWorkspacePath: getLocalArtifactPath(workspace) };
+}
+function parseMaxWorkers(io, command, value, asJson) {
+    const maxWorkers = Number(value);
+    if (!Number.isInteger(maxWorkers) || maxWorkers < 1) {
+        printResult(io, fail(command, 'INVALID_MAX_WORKERS', 'max-workers must be a positive integer', {}, ['Use --max-workers with a positive integer value']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    return maxWorkers;
+}
+function parseSoloMode(io, command, mode, soloMode, asJson) {
+    if (mode !== 'solo' && soloMode) {
+        printResult(io, fail(command, 'SOLO_MODE_REQUIRES_SOLO_WORKFLOW', '--solo-mode can only be used with --mode solo', {}, ['Remove --solo-mode or use --mode solo']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    if (mode !== 'solo' || !soloMode) {
+        return undefined;
+    }
+    if (!isSoloMode(soloMode)) {
+        printResult(io, fail(command, 'UNSUPPORTED_SOLO_MODE', `Unsupported solo mode ${soloMode}`, {}, ['Use --solo-mode full-auto, guided, or rnd']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    return soloMode;
+}
+function runTechPlan(io, options) {
+    if (options.dryRun === false) {
+        failUnsupportedNonDryRun(io, 'tech.plan', options.json);
+        return;
+    }
+    try {
+        const workspaceContext = getWorkspaceContext();
+        const plan = createTechPlan({
+            changeId: options.changeId,
+            goal: options.goal,
+            swarm: options.swarm ?? false,
+            dryRun: true,
+            ...workspaceContext
+        });
+        printResult(io, ok('tech.plan', plan), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('tech.plan', 'INVALID_CHANGE_ID_OR_GOAL', getErrorMessage(error), {}, ['Use a safe change id and a non-empty goal']), options.json);
+        process.exitCode = 1;
+    }
+}
+function runTechStatus(io, options) {
+    try {
+        const workspaceContext = getWorkspaceContext();
+        printResult(io, ok('tech.status', getTechStatus({ changeId: options.changeId, ...workspaceContext })), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('tech.status', 'INVALID_CHANGE_ID', getErrorMessage(error), {}, ['Use a safe change id']), options.json);
+        process.exitCode = 1;
+    }
+}
+function runWorkflowRoute(io, options) {
+    if (options.dryRun === false) {
+        failUnsupportedNonDryRun(io, 'workflow.route', options.json);
+        return;
+    }
+    if (!isWorkflowMode(options.mode)) {
+        printResult(io, fail('workflow.route', 'UNSUPPORTED_WORKFLOW_MODE', `Unsupported workflow mode ${options.mode}`, {}, ['Use --mode solo or --mode team']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const maxWorkers = parseMaxWorkers(io, 'workflow.route', options.maxWorkers, options.json);
+    if (maxWorkers === null)
+        return;
+    const soloMode = parseSoloMode(io, 'workflow.route', options.mode, options.soloMode, options.json);
+    if (soloMode === null)
+        return;
+    try {
+        const workspaceContext = getWorkspaceContext();
+        const plan = createWorkflowRouterPlan({
+            changeId: options.changeId,
+            goal: options.goal,
+            mode: options.mode,
+            ...(soloMode ? { soloMode } : {}),
+            maxWorkers,
+            dryRun: true,
+            config: readConfig(),
+            ...workspaceContext
+        });
+        printResult(io, ok('workflow.route', plan), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('workflow.route', 'INVALID_CHANGE_ID_OR_GOAL', getErrorMessage(error), {}, ['Use a safe change id and a non-empty goal']), options.json);
+        process.exitCode = 1;
+    }
+}
+function runAutonomousWorkflow(io, options) {
+    if (options.dryRun === false) {
+        failUnsupportedNonDryRun(io, 'workflow.autonomous', options.json);
+        return;
+    }
+    if (!isWorkflowMode(options.mode)) {
+        printResult(io, fail('workflow.autonomous', 'UNSUPPORTED_WORKFLOW_MODE', `Unsupported workflow mode ${options.mode}`, {}, ['Use --mode solo or --mode team']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const maxWorkers = parseMaxWorkers(io, 'workflow.autonomous', options.maxWorkers, options.json);
+    if (maxWorkers === null)
+        return;
+    const soloMode = parseSoloMode(io, 'workflow.autonomous', options.mode, options.soloMode, options.json);
+    if (soloMode === null)
+        return;
+    try {
+        const workspaceContext = getWorkspaceContext();
+        const plan = createAutonomousWorkflowPlan({
+            changeId: options.changeId,
+            goal: options.goal,
+            mode: options.mode,
+            ...(soloMode ? { soloMode } : {}),
+            maxWorkers,
+            dryRun: true,
+            config: readConfig(),
+            ...workspaceContext
+        });
+        printResult(io, ok('workflow.autonomous', plan), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('workflow.autonomous', 'INVALID_CHANGE_ID_OR_GOAL', getErrorMessage(error), {}, ['Use a safe change id and a non-empty goal']), options.json);
+        process.exitCode = 1;
+    }
+}
+function runSwarmPlan(io, options) {
+    if ((options.skill ?? 'rd') !== 'rd') {
+        printResult(io, fail('swarm.plan', 'UNSUPPORTED_SWARM_SKILL', `Unsupported skill ${options.skill}`, {}, ['Use --skill rd']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.dryRun === false) {
+        failUnsupportedNonDryRun(io, 'swarm.plan', options.json);
+        return;
+    }
+    const maxWorkers = parseMaxWorkers(io, 'swarm.plan', options.maxWorkers, options.json);
+    if (maxWorkers === null)
+        return;
+    try {
+        const workspaceContext = getWorkspaceContext();
+        const config = readConfig();
+        const plan = createRdSwarmPlan({
+            skill: 'rd',
+            changeId: options.changeId,
+            goal: options.goal,
+            maxWorkers,
+            dryRun: true,
+            swarmMode: config.swarmMode,
+            executionModelId: getEconomyAwareExecutionModelId(config),
+            ...workspaceContext
+        });
+        printResult(io, ok('swarm.plan', plan), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('swarm.plan', 'INVALID_CHANGE_ID_OR_GOAL', getErrorMessage(error), {}, ['Use a safe change id and a non-empty goal']), options.json);
+        process.exitCode = 1;
+    }
+}
+function addTechPlanOptions(command) {
+    return addJsonOption(command
+        .description('Generate a technical dry-run graph')
+        .requiredOption('--change-id <id>', 'change identifier')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .option('--swarm', 'opt into swarm-oriented planning')
+        .option('--dry-run', 'preview without writing files', true)
+        .option('--no-dry-run', 'unsupported: do not execute tech planning from this CLI'));
+}
+function addTechStatusOptions(command) {
+    return addJsonOption(command.description('Inspect technical approval status').requiredOption('--change-id <id>', 'change identifier'));
+}
+function addWorkflowRouteOptions(command, description) {
+    return addJsonOption(command
+        .description(description)
+        .requiredOption('--mode <mode>', 'workflow mode: solo or team')
+        .requiredOption('--change-id <id>', 'change identifier')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .option('--solo-mode <mode>', 'solo mode: full-auto, guided, or rnd')
+        .option('--max-workers <count>', 'maximum worker count', '40')
+        .option('--dry-run', 'preview without writing files', true)
+        .option('--no-dry-run', 'unsupported: do not execute workflow planning from this CLI'));
+}
+function addSwarmPlanOptions(command, includeSkill) {
+    const configured = command
+        .description('Plan an RD swarm dry-run graph')
+        .requiredOption('--change-id <id>', 'change identifier')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .option('--max-workers <count>', 'maximum worker count', '40')
+        .option('--dry-run', 'preview without writing files', true)
+        .option('--no-dry-run', 'unsupported: do not execute RD planning from this CLI');
+    if (includeSkill) {
+        configured.requiredOption('--skill <skill>', 'skill to plan for');
+    }
+    return addJsonOption(configured);
+}
+export function registerWorkflowCommands(program, io) {
+    const refactor = program.command('refactor').description('Plan a Peaks refactor run without modifying code');
+    addJsonOption(refactor
+        .option('--solo', 'use peaks-solo orchestration mode')
+        .option('--rd', 'use peaks-rd direct mode')
+        .option('--dry-run', 'print gates and required artifacts', true)
+        .option('--no-dry-run', 'unsupported: do not modify code from this command')).action((options) => {
+        if (options.dryRun === false) {
+            failUnsupportedNonDryRun(io, 'refactor', options.json);
+            return;
+        }
+        if (options.solo && options.rd) {
+            printResult(io, fail('refactor', 'CONFLICTING_REFACTOR_MODE', 'Choose either --solo or --rd, not both', {}, ['Run peaks refactor --solo --dry-run']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        const mode = options.rd ? 'rd' : 'solo';
+        printResult(io, ok('refactor', createRefactorDryRun(mode), [], ['This dry run never edits code']), options.json);
+    });
+    const tech = program.command('tech').description('Plan and inspect technical dry-run gates');
+    addTechPlanOptions(tech.command('plan')).action((options) => runTechPlan(io, options));
+    addTechStatusOptions(tech.command('status')).action((options) => runTechStatus(io, options));
+    addTechPlanOptions(program.command('tech-plan')).action((options) => runTechPlan(io, options));
+    addTechStatusOptions(program.command('tech-status')).action((options) => runTechStatus(io, options));
+    const workflow = program.command('workflow').description('Plan workflow routing dry-run graphs');
+    addWorkflowRouteOptions(workflow.command('route'), 'Plan a workflow routing dry-run summary').action((options) => runWorkflowRoute(io, options));
+    addWorkflowRouteOptions(program.command('route'), 'Plan a workflow routing dry-run summary').action((options) => runWorkflowRoute(io, options));
+    addWorkflowRouteOptions(workflow.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
+    addWorkflowRouteOptions(program.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
+    const swarm = program.command('swarm').description('Plan RD swarm dry-run graphs');
+    addSwarmPlanOptions(swarm.command('plan'), true).action((options) => runSwarmPlan(io, options));
+    addSwarmPlanOptions(program.command('swarm-plan'), false).action((options) => runSwarmPlan(io, options));
+    addJsonOption(program
+        .command('recommend')
+        .description('Create a dry-run recommendation plan for a workflow')
+        .requiredOption('--workflow <workflow>', 'workflow: code-refactor, product-refactor, or frontend-design')
+        .option('--language <language>', 'human presentation language', 'en')).action((options) => {
+        if (!isRecommendationWorkflow(options.workflow)) {
+            printResult(io, fail('recommend', 'UNSUPPORTED_RECOMMENDATION_WORKFLOW', `Unsupported recommendation workflow ${options.workflow}`, {}, ['Use --workflow code-refactor, product-refactor, or frontend-design']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, ok('recommend', createRecommendationPlan({ workflow: options.workflow, language: options.language })), options.json);
+    });
+}

package/dist/src/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/index.js

@@ -0,0 +1,14 @@
+import { createProgram } from './program.js';
+import { getErrorMessage } from '../shared/result.js';
+createProgram().parseAsync(process.argv).catch((error) => {
+    console.error(JSON.stringify({
+        ok: false,
+        command: 'cli',
+        code: 'UNHANDLED_ERROR',
+        message: getErrorMessage(error),
+        data: {},
+        warnings: [],
+        nextActions: []
+    }, null, 2));
+    process.exitCode = 1;
+});

package/dist/src/cli/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { ProgramIO } from './cli-helpers.js';
+export { printResult, type ProgramIO } from './cli-helpers.js';
+export declare function createProgram(io?: ProgramIO): Command;

package/dist/src/cli/program.js

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { registerCoreAndArtifactCommands } from './commands/core-artifact-commands.js';
+import { registerWorkflowCommands } from './commands/workflow-commands.js';
+import { registerCapabilityWorkerConfigAndSCCommands } from './commands/capability-worker-config-sc-commands.js';
+export { printResult } from './cli-helpers.js';
+export function createProgram(io = { stdout: (text) => console.log(text), stderr: (text) => console.error(text) }) {
+    const program = new Command();
+    program.name('peaks').description('Peaks CLI and short skill family runtime manager').version('0.1.0').exitOverride();
+    registerCoreAndArtifactCommands(program, io);
+    registerWorkflowCommands(program, io);
+    registerCapabilityWorkerConfigAndSCCommands(program, io);
+    return program;
+}

package/dist/src/services/artifacts/artifact-service.d.ts

@@ -0,0 +1,43 @@
+export type ArtifactProvider = 'github' | 'gitlab';
+export type ArtifactInitPlan = {
+    provider: ArtifactProvider;
+    name: string;
+    visibility: 'private';
+    localPath: string;
+    remoteFirst: boolean;
+    dryRun: boolean;
+    plannedActions: string[];
+    tokenPolicy: string;
+};
+export type GuidedArtifactSetup = {
+    step: 'detect' | 'configure' | 'validate' | 'complete';
+    workspaceId: string | null;
+    workspacePath: string | null;
+    provider: ArtifactProvider | null;
+    repoOwner: string | null;
+    repoName: string | null;
+    localPath: string;
+    remoteUrl: string | null;
+    validationResult: {
+        workspaceExists: boolean;
+        gitAvailable: boolean;
+        ghTokenAvailable: boolean;
+        sshKeyAvailable: boolean;
+    };
+    nextStep: string;
+    guidance: string[];
+};
+export declare function createArtifactInitPlan(options: {
+    provider: ArtifactProvider;
+    name: string;
+    localPath?: string;
+    dryRun?: boolean;
+}): ArtifactInitPlan;
+export declare function createGuidedArtifactSetup(): GuidedArtifactSetup;
+export declare function getArtifactStatus(): {
+    mode: string;
+    supportedProviders: ArtifactProvider[];
+    localPath: string;
+    configured: boolean;
+    nextActions: string[];
+};

package/dist/src/services/artifacts/artifact-service.js

@@ -0,0 +1,97 @@
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { getCurrentWorkspaceConfig } from '../config/config-service.js';
+import { getLocalArtifactPath } from './workspace-service.js';
+function getRemoteUrl(artifactRepo) {
+    if (!artifactRepo)
+        return null;
+    if (artifactRepo.provider === 'github') {
+        return `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
+    }
+    return `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
+}
+function hasGit() {
+    try {
+        execFileSync('git', ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasSshKey() {
+    const sshDir = resolve(process.env.HOME ?? homedir(), '.ssh');
+    const keyNames = ['id_ed25519', 'id_rsa', 'id_ecdsa', 'id_dsa'];
+    return keyNames.some((keyName) => existsSync(resolve(sshDir, keyName)));
+}
+export function createArtifactInitPlan(options) {
+    return {
+        provider: options.provider,
+        name: options.name,
+        visibility: 'private',
+        localPath: options.localPath ?? '.peaks-artifacts',
+        remoteFirst: true,
+        dryRun: options.dryRun ?? true,
+        plannedActions: [
+            `confirm creation of private ${options.provider} artifact repository`,
+            'verify authentication without storing tokens',
+            `create or link remote artifact repository ${options.name}`,
+            `prepare local working copy at ${options.localPath ?? '.peaks-artifacts'}`,
+            'write artifact repository creation report'
+        ],
+        tokenPolicy: 'Use provider auth/CLI or environment tokens only; never write tokens to skills, artifacts, config, or reports.'
+    };
+}
+export function createGuidedArtifactSetup() {
+    const workspace = getCurrentWorkspaceConfig();
+    const artifactRepo = workspace?.artifactRepo ?? null;
+    const validationResult = {
+        workspaceExists: workspace !== null,
+        gitAvailable: hasGit(),
+        ghTokenAvailable: Boolean(process.env.GH_TOKEN?.trim()),
+        sshKeyAvailable: hasSshKey()
+    };
+    const localPath = workspace ? getLocalArtifactPath(workspace) : '.peaks-artifacts';
+    const remoteUrl = getRemoteUrl(artifactRepo ?? undefined);
+    return {
+        step: 'detect',
+        workspaceId: workspace?.workspaceId ?? null,
+        workspacePath: workspace?.rootPath ?? null,
+        provider: artifactRepo?.provider ?? null,
+        repoOwner: artifactRepo?.owner ?? null,
+        repoName: artifactRepo?.name ?? null,
+        localPath,
+        remoteUrl,
+        validationResult,
+        nextStep: workspace ? (artifactRepo ? 'validate' : 'configure') : 'configure',
+        guidance: [
+            'Step 1: Detect current workspace and environment',
+            `  - Workspace: ${workspace?.workspaceId ?? 'not configured'}`,
+            `  - Git available: ${validationResult.gitAvailable ? 'yes' : 'no'}`,
+            `  - GH_TOKEN environment variable: ${validationResult.ghTokenAvailable ? 'available' : 'not set'}`,
+            `  - SSH key for code push: ${validationResult.sshKeyAvailable ? 'available' : 'not found'}`,
+            '',
+            'Step 2: Configure artifact repository',
+            '  - Run: peaks artifacts init --provider github --name <repo> --dry-run',
+            '  - Or add to workspace: peaks config workspace add --id <id> --provider github --repo-owner <owner> --repo-name <name>',
+            '',
+            'Step 3: Validate setup',
+            '  - Run: peaks sc status',
+            '  - Run: peaks artifacts workspace',
+            '',
+            'Step 4: Complete',
+            '  - Artifact sync is ready when workspace has artifactRepo configured'
+        ]
+    };
+}
+export function getArtifactStatus() {
+    return {
+        mode: 'remote-first',
+        supportedProviders: ['github', 'gitlab'],
+        localPath: '.peaks-artifacts',
+        configured: false,
+        nextActions: ['Run peaks artifacts init --provider gitlab --name <repo> --dry-run']
+    };
+}

package/dist/src/services/artifacts/workspace-service.d.ts

@@ -0,0 +1,33 @@
+import type { WorkspaceConfig } from '../config/config-types.js';
+export type SyncStatus = 'synced' | 'pending' | 'out-of-sync' | 'unknown';
+export type ArtifactWorkspaceStatus = {
+    workspaceId: string;
+    localPath: string;
+    configured: boolean;
+    syncStatus: SyncStatus;
+    lastSync: string | null;
+    hasLocalChanges: boolean;
+    artifactRepo: WorkspaceConfig['artifactRepo'] | null;
+    nextActions: string[];
+};
+export type SyncResult = {
+    workspaceId: string;
+    success: boolean;
+    localPath: string;
+    remoteUrl: string | null;
+    commands: string[];
+    output: string[];
+    error?: string;
+};
+export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
+export declare function isArtifactWorkspaceOutsideTarget(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
+export declare function hasValidArtifactWorkspace(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
+export declare function executeArtifactSync(workspaceId?: string): Promise<SyncResult>;
+export declare function getArtifactWorkspaceStatus(workspaceId?: string): ArtifactWorkspaceStatus;
+export declare function planArtifactSync(workspaceId?: string, dryRun?: boolean): {
+    workspaceId: string;
+    dryRun: boolean;
+    localPath: string;
+    remoteUrl: string | null;
+    plannedCommands: string[];
+};