@fractary/faber-cli 1.0.0 → 1.2.0

package/dist/commands/init.js

@@ -6,7 +6,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import chalk from 'chalk';
 export function createInitCommand() {
-    return new Command('init')
+    return new Command('workflow-init')
         .description('Initialize a new FABER project')
         .option('--preset <name>', 'Use a preset configuration', 'default')
         .option('--force', 'Overwrite existing configuration')

package/dist/commands/plan/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Plan command - FABER CLI planning command
+ *
+ * Batch workflow planning for GitHub issues
+ */
+import { Command } from 'commander';
+/**
+ * Create the plan command
+ */
+export declare function createPlanCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/plan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/plan/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+CpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAkB3C"}

package/dist/commands/plan/index.js

@@ -0,0 +1,383 @@
+/**
+ * Plan command - FABER CLI planning command
+ *
+ * Batch workflow planning for GitHub issues
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { AnthropicClient } from '../../lib/anthropic-client.js';
+import { RepoClient } from '../../lib/repo-client.js';
+import { ConfigManager } from '../../lib/config.js';
+import { prompt } from '../../utils/prompt.js';
+import { validateWorkIds, validateLabels, validateWorkflowName, validatePlanId, } from '../../utils/validation.js';
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Create the plan command
+ */
+export function createPlanCommand() {
+    return new Command('plan')
+        .description('Plan workflows for GitHub issues')
+        .option('--work-id <ids>', 'Comma-separated list of work item IDs (e.g., "258,259,260")')
+        .option('--work-label <labels>', 'Comma-separated label filters (e.g., "workflow:etl,status:approved")')
+        .option('--workflow <name>', 'Override workflow (default: read from issue "workflow:*" label)')
+        .option('--no-worktree', 'Skip worktree creation')
+        .option('--no-branch', 'Skip branch creation')
+        .option('--skip-confirm', 'Skip confirmation prompt (use with caution)')
+        .option('--output <format>', 'Output format: text|json|yaml', 'text')
+        .option('--json', 'Output as JSON (shorthand for --output json)')
+        .action(async (options) => {
+        try {
+            await executePlanCommand(options);
+        }
+        catch (error) {
+            handlePlanError(error, options);
+        }
+    });
+}
+/**
+ * Main execution logic for plan command
+ */
+async function executePlanCommand(options) {
+    const outputFormat = options.json ? 'json' : options.output || 'text';
+    // Validate arguments
+    if (!options.workId && !options.workLabel) {
+        throw new Error('Either --work-id or --work-label must be provided');
+    }
+    if (options.workId && options.workLabel) {
+        throw new Error('Cannot use both --work-id and --work-label at the same time');
+    }
+    // Initialize clients
+    const config = await ConfigManager.load();
+    const repoClient = new RepoClient(config);
+    const anthropicClient = new AnthropicClient(config);
+    if (outputFormat === 'text') {
+        console.log(chalk.blue('FABER CLI - Workflow Planning'));
+        console.log(chalk.gray('═'.repeat(50)));
+    }
+    // Step 1: Fetch issues from GitHub
+    if (outputFormat === 'text') {
+        console.log(chalk.cyan('\n→ Fetching issues from GitHub...'));
+    }
+    let issues;
+    try {
+        if (options.workId) {
+            // Validate work IDs before fetching
+            const ids = validateWorkIds(options.workId);
+            issues = await repoClient.fetchIssues(ids);
+            if (outputFormat === 'text') {
+                console.log(chalk.green(`  ✓ Fetched ${issues.length} issue(s) by ID`));
+            }
+        }
+        else if (options.workLabel) {
+            // Validate labels before searching
+            const labels = validateLabels(options.workLabel);
+            issues = await repoClient.searchIssues(labels);
+            if (outputFormat === 'text') {
+                console.log(chalk.green(`  ✓ Found ${issues.length} issue(s) matching labels`));
+            }
+        }
+        else {
+            throw new Error('No issues to process');
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('not yet implemented')) {
+            if (outputFormat === 'text') {
+                console.log(chalk.yellow('\n⚠️  fractary-repo commands not yet available'));
+                console.log(chalk.gray('   This command requires fractary-repo plugin implementation.'));
+                console.log(chalk.gray('   See SPEC-00030-FRACTARY-REPO-ENHANCEMENTS.md'));
+            }
+            else {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    error: {
+                        code: 'DEPENDENCY_NOT_AVAILABLE',
+                        message: 'fractary-repo commands not yet implemented',
+                        details: 'See SPEC-00030-FRACTARY-REPO-ENHANCEMENTS.md',
+                    },
+                }, null, 2));
+            }
+            return;
+        }
+        throw error;
+    }
+    if (issues.length === 0) {
+        if (outputFormat === 'text') {
+            console.log(chalk.yellow('\n⚠️  No issues found'));
+        }
+        else {
+            console.log(JSON.stringify({ status: 'success', issues: [], message: 'No issues found' }, null, 2));
+        }
+        return;
+    }
+    // Step 2: Extract workflows from labels or prompt user
+    if (outputFormat === 'text') {
+        console.log(chalk.cyan('\n→ Identifying workflows...'));
+    }
+    const availableWorkflows = await loadAvailableWorkflows(config);
+    const issuesWithWorkflows = await assignWorkflows(issues, availableWorkflows, options, outputFormat);
+    // Step 3: Show confirmation prompt
+    if (!options.skipConfirm) {
+        const confirmed = await showConfirmationPrompt(issuesWithWorkflows, config, outputFormat);
+        if (!confirmed) {
+            if (outputFormat === 'text') {
+                console.log(chalk.yellow('\n✖ Planning cancelled'));
+            }
+            else {
+                console.log(JSON.stringify({ status: 'cancelled', message: 'User cancelled planning' }, null, 2));
+            }
+            return;
+        }
+    }
+    // Step 4: Plan each issue
+    if (outputFormat === 'text') {
+        console.log(chalk.cyan('\n→ Planning workflows...'));
+    }
+    const results = [];
+    for (const issue of issuesWithWorkflows) {
+        if (outputFormat === 'text') {
+            console.log(chalk.gray(`\n[${results.length + 1}/${issuesWithWorkflows.length}] Issue #${issue.number}: ${issue.title}`));
+        }
+        try {
+            const result = await planSingleIssue(issue, config, repoClient, anthropicClient, options, outputFormat);
+            results.push(result);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (outputFormat === 'text') {
+                console.log(chalk.red(`  ✗ Error: ${errorMessage}`));
+            }
+            results.push({
+                issue,
+                planId: '',
+                branch: '',
+                worktree: '',
+                error: errorMessage,
+            });
+        }
+    }
+    // Step 5: Output summary
+    if (outputFormat === 'json') {
+        console.log(JSON.stringify({
+            status: 'success',
+            total: results.length,
+            successful: results.filter(r => !r.error).length,
+            failed: results.filter(r => r.error).length,
+            results,
+        }, null, 2));
+    }
+    else {
+        outputTextSummary(results);
+    }
+}
+/**
+ * Load available workflow configurations
+ */
+async function loadAvailableWorkflows(config) {
+    const workflowDir = config.workflow?.config_path || './plugins/faber/config/workflows';
+    try {
+        const files = await fs.readdir(workflowDir);
+        return files
+            .filter(f => f.endsWith('.json'))
+            .map(f => path.basename(f, '.json'));
+    }
+    catch (error) {
+        // Default workflows if directory doesn't exist
+        return ['core', 'etl', 'bugfix', 'feature'];
+    }
+}
+/**
+ * Assign workflows to issues (extract from labels or prompt user)
+ */
+async function assignWorkflows(issues, availableWorkflows, options, outputFormat) {
+    const issuesWithWorkflows = [];
+    for (const issue of issues) {
+        let workflow = options.workflow; // Command-line override
+        // Validate workflow override if provided
+        if (workflow) {
+            validateWorkflowName(workflow);
+        }
+        if (!workflow) {
+            // Extract from issue labels
+            const workflowLabel = issue.labels.find(label => label.startsWith('workflow:'));
+            if (workflowLabel) {
+                workflow = workflowLabel.replace('workflow:', '');
+                // Validate extracted workflow name
+                validateWorkflowName(workflow);
+            }
+        }
+        if (!workflow) {
+            // Prompt user
+            if (outputFormat === 'text') {
+                console.log(chalk.yellow(`\n⚠️  Issue #${issue.number} is missing a workflow label:`));
+                console.log(chalk.gray(`    ${issue.title}`));
+                console.log(chalk.gray(`    Available workflows: ${availableWorkflows.join(', ')}`));
+                workflow = await prompt(`    Select workflow for this issue [${availableWorkflows[0]}]: `);
+                if (!workflow) {
+                    workflow = availableWorkflows[0];
+                }
+                if (!availableWorkflows.includes(workflow)) {
+                    throw new Error(`Invalid workflow: ${workflow}. Available: ${availableWorkflows.join(', ')}`);
+                }
+            }
+            else {
+                throw new Error(`Issue #${issue.number} is missing workflow label and interactive prompts are disabled in JSON mode`);
+            }
+        }
+        issuesWithWorkflows.push({ ...issue, workflow });
+    }
+    if (outputFormat === 'text') {
+        console.log(chalk.green(`  ✓ All issues have workflows assigned`));
+    }
+    return issuesWithWorkflows;
+}
+/**
+ * Show confirmation prompt before planning
+ */
+async function showConfirmationPrompt(issues, config, outputFormat) {
+    if (outputFormat !== 'text') {
+        return true; // Skip in JSON mode
+    }
+    console.log(chalk.cyan('\n📋 Will plan workflows for the following issues:\n'));
+    for (const issue of issues) {
+        const { organization, project } = getRepoInfoFromConfig(config);
+        const branch = `feature/${issue.number}`;
+        const worktree = `~/.claude-worktrees/${organization}-${project}-${issue.number}`;
+        console.log(chalk.bold(`#${issue.number}: ${issue.title}`));
+        console.log(chalk.gray(`  Workflow: ${issue.workflow}`));
+        console.log(chalk.gray(`  Branch: ${branch}`));
+        console.log(chalk.gray(`  Worktree: ${worktree}`));
+        console.log();
+    }
+    const response = await prompt('Proceed? [Y/n]: ');
+    return !response || response.toLowerCase() === 'y' || response.toLowerCase() === 'yes';
+}
+/**
+ * Plan a single issue
+ */
+async function planSingleIssue(issue, config, repoClient, anthropicClient, options, outputFormat) {
+    const { organization, project } = getRepoInfoFromConfig(config);
+    const branch = `feature/${issue.number}`;
+    const worktree = `~/.claude-worktrees/${organization}-${project}-${issue.number}`;
+    // Generate plan via Anthropic API
+    if (outputFormat === 'text') {
+        console.log(chalk.gray('  → Generating plan...'));
+    }
+    const plan = await anthropicClient.generatePlan({
+        workflow: issue.workflow,
+        issueTitle: issue.title,
+        issueDescription: issue.description,
+        issueNumber: issue.number,
+    });
+    const planId = plan.plan_id;
+    // Create branch
+    if (!options.noBranch) {
+        if (outputFormat === 'text') {
+            console.log(chalk.gray(`  → Creating branch: ${branch}...`));
+        }
+        await repoClient.createBranch(branch);
+    }
+    // Create worktree
+    let worktreePath = worktree;
+    if (!options.noWorktree) {
+        if (outputFormat === 'text') {
+            console.log(chalk.gray(`  → Creating worktree: ${worktree}...`));
+        }
+        const worktreeResult = await repoClient.createWorktree({
+            workId: issue.number.toString(),
+            path: worktree,
+        });
+        worktreePath = worktreeResult.absolute_path;
+    }
+    // Write plan to worktree
+    if (!options.noWorktree) {
+        // Validate plan ID format (prevent path traversal via malicious plan IDs)
+        validatePlanId(planId);
+        const planDir = path.join(worktreePath, '.fractary', 'plans');
+        await fs.mkdir(planDir, { recursive: true });
+        // Construct and validate path
+        const planPath = path.join(planDir, `${planId}.json`);
+        // Note: path.join automatically normalizes and prevents basic traversal,
+        // but we validate the plan ID format as an additional layer of defense
+        await fs.writeFile(planPath, JSON.stringify(plan, null, 2));
+        if (outputFormat === 'text') {
+            console.log(chalk.gray(`  → Plan written to ${planPath}`));
+        }
+    }
+    // Update GitHub issue with plan_id
+    if (outputFormat === 'text') {
+        console.log(chalk.gray(`  → Updating GitHub issue...`));
+    }
+    await repoClient.updateIssue({
+        id: issue.number.toString(),
+        comment: `🤖 Workflow plan created: ${planId}`,
+        addLabel: 'faber:planned',
+    });
+    if (outputFormat === 'text') {
+        console.log(chalk.green(`  ✓ Plan: ${planId}`));
+    }
+    return {
+        issue,
+        planId,
+        branch,
+        worktree: worktreePath,
+    };
+}
+/**
+ * Get repository info from config
+ */
+function getRepoInfoFromConfig(config) {
+    return {
+        organization: config.github?.organization || 'unknown',
+        project: config.github?.project || 'unknown',
+    };
+}
+/**
+ * Output text summary
+ */
+function outputTextSummary(results) {
+    console.log(chalk.cyan('\n' + '═'.repeat(50)));
+    const successful = results.filter(r => !r.error);
+    const failed = results.filter(r => r.error);
+    if (successful.length > 0) {
+        console.log(chalk.green(`\n✓ Planned ${successful.length} workflow(s) successfully:\n`));
+        successful.forEach((result, index) => {
+            console.log(chalk.bold(`[${index + 1}/${successful.length}] Issue #${result.issue.number}: ${result.issue.title}`));
+            console.log(chalk.gray(`      Workflow: ${result.issue.workflow}`));
+            console.log(chalk.gray(`      Plan: ${result.planId}`));
+            console.log(chalk.gray(`      Branch: ${result.branch}`));
+            console.log(chalk.gray(`      Worktree: ${result.worktree}`));
+            console.log();
+            console.log(chalk.cyan('      To execute:'));
+            console.log(chalk.gray(`        cd ${result.worktree} && claude`));
+            console.log(chalk.gray(`        /fractary-faber:workflow-run ${result.issue.number}`));
+            console.log();
+        });
+    }
+    if (failed.length > 0) {
+        console.log(chalk.red(`\n✗ Failed to plan ${failed.length} workflow(s):\n`));
+        failed.forEach((result, index) => {
+            console.log(chalk.bold(`[${index + 1}/${failed.length}] Issue #${result.issue.number}: ${result.issue.title}`));
+            console.log(chalk.red(`      Error: ${result.error}`));
+            console.log();
+        });
+    }
+}
+/**
+ * Error handling
+ */
+function handlePlanError(error, options) {
+    const message = error instanceof Error ? error.message : String(error);
+    const outputFormat = options.json ? 'json' : options.output || 'text';
+    if (outputFormat === 'json') {
+        console.error(JSON.stringify({
+            status: 'error',
+            error: { code: 'PLAN_ERROR', message },
+        }));
+    }
+    else {
+        console.error(chalk.red('Error:'), message);
+    }
+    process.exit(1);
+}

package/dist/commands/workflow/index.d.ts

@@ -1,31 +1,31 @@
 /**
  * Workflow commands - FABER workflow execution
  *
- * Provides run, status, resume, pause commands via FaberWorkflow SDK.
+ * Provides workflow-run, workflow-status, workflow-resume, workflow-pause commands via FaberWorkflow SDK.
  */
 import { Command } from 'commander';
 /**
- * Create the run command
+ * Create the workflow-run command
  */
 export declare function createRunCommand(): Command;
 /**
- * Create the status command
+ * Create the workflow-status command
  */
 export declare function createStatusCommand(): Command;
 /**
- * Create the resume command
+ * Create the workflow-resume command
  */
 export declare function createResumeCommand(): Command;
 /**
- * Create the pause command
+ * Create the workflow-pause command
  */
 export declare function createPauseCommand(): Command;
 /**
- * Create the recover command
+ * Create the workflow-recover command
  */
 export declare function createRecoverCommand(): Command;
 /**
- * Create the cleanup command
+ * Create the workflow-cleanup command
  */
 export declare function createCleanupCommand(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.js

@@ -1,17 +1,17 @@
 /**
  * Workflow commands - FABER workflow execution
  *
- * Provides run, status, resume, pause commands via FaberWorkflow SDK.
+ * Provides workflow-run, workflow-status, workflow-resume, workflow-pause commands via FaberWorkflow SDK.
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { FaberWorkflow, StateManager } from '@fractary/faber';
 import { parsePositiveInteger } from '../../utils/validation.js';
 /**
- * Create the run command
+ * Create the workflow-run command
  */
 export function createRunCommand() {
-    return new Command('run')
+    return new Command('workflow-run')
         .description('Run FABER workflow')
         .requiredOption('--work-id <id>', 'Work item ID to process')
         .option('--autonomy <level>', 'Autonomy level: supervised|assisted|autonomous', 'supervised')
@@ -60,10 +60,10 @@ export function createRunCommand() {
     });
 }
 /**
- * Create the status command
+ * Create the workflow-status command
  */
 export function createStatusCommand() {
-    return new Command('status')
+    return new Command('workflow-status')
         .description('Show workflow status')
         .option('--work-id <id>', 'Work item ID to check')
         .option('--workflow-id <id>', 'Workflow ID to check')
@@ -75,7 +75,7 @@ export function createStatusCommand() {
             if (options.workflowId) {
                 // Status for specific workflow by ID
                 const workflow = new FaberWorkflow();
-                const status = workflow.getStatus(options.workflowId);
+                const status = workflow.status.get(options.workflowId);
                 if (options.json) {
                     console.log(JSON.stringify({ status: 'success', data: status }, null, 2));
                 }
@@ -87,7 +87,7 @@ export function createStatusCommand() {
             }
             else if (options.workId) {
                 // Status for work item's active workflow
-                const state = stateManager.getActiveWorkflow(options.workId);
+                const state = stateManager.workflow.getActive(options.workId);
                 if (!state) {
                     if (options.json) {
                         console.log(JSON.stringify({
@@ -123,7 +123,7 @@ export function createStatusCommand() {
             }
             else {
                 // List all workflows
-                const workflows = stateManager.listWorkflows();
+                const workflows = stateManager.workflow.list();
                 if (options.json) {
                     console.log(JSON.stringify({ status: 'success', data: workflows }, null, 2));
                 }
@@ -147,10 +147,10 @@ export function createStatusCommand() {
     });
 }
 /**
- * Create the resume command
+ * Create the workflow-resume command
  */
 export function createResumeCommand() {
-    return new Command('resume')
+    return new Command('workflow-resume')
         .description('Resume a paused workflow')
         .argument('<workflow_id>', 'Workflow ID to resume')
         .option('--json', 'Output as JSON')
@@ -175,10 +175,10 @@ export function createResumeCommand() {
     });
 }
 /**
- * Create the pause command
+ * Create the workflow-pause command
  */
 export function createPauseCommand() {
-    return new Command('pause')
+    return new Command('workflow-pause')
         .description('Pause a running workflow')
         .argument('<workflow_id>', 'Workflow ID to pause')
         .option('--json', 'Output as JSON')
@@ -199,10 +199,10 @@ export function createPauseCommand() {
     });
 }
 /**
- * Create the recover command
+ * Create the workflow-recover command
  */
 export function createRecoverCommand() {
-    return new Command('recover')
+    return new Command('workflow-recover')
         .description('Recover a workflow from checkpoint')
         .argument('<workflow_id>', 'Workflow ID to recover')
         .option('--checkpoint <id>', 'Specific checkpoint ID to recover from')
@@ -211,7 +211,7 @@ export function createRecoverCommand() {
         .action(async (workflowId, options) => {
         try {
             const stateManager = new StateManager();
-            const state = stateManager.recoverWorkflow(workflowId, {
+            const state = stateManager.workflow.recover(workflowId, {
                 checkpointId: options.checkpoint,
                 fromPhase: options.phase,
             });
@@ -230,10 +230,10 @@ export function createRecoverCommand() {
     });
 }
 /**
- * Create the cleanup command
+ * Create the workflow-cleanup command
  */
 export function createCleanupCommand() {
-    return new Command('cleanup')
+    return new Command('workflow-cleanup')
         .description('Clean up old workflow states')
         .option('--max-age <days>', 'Delete workflows older than N days', '30')
         .option('--json', 'Output as JSON')

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CA0CxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CA2IxC"}