@fractary/faber-cli 1.1.0 → 1.3.0

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/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,CA0IxC"}
+{"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"}

package/dist/index.js

@@ -13,6 +13,7 @@ import { createRepoCommand } from './commands/repo/index.js';
 import { createSpecCommand } from './commands/spec/index.js';
 import { createLogsCommand } from './commands/logs/index.js';
 import { createInitCommand } from './commands/init.js';
+import { createPlanCommand } from './commands/plan/index.js';
 const version = '1.0.0';
 /**
  * Create and configure the main CLI program
@@ -27,6 +28,7 @@ export function createFaberCLI() {
     program.option('--debug', 'Enable debug output');
     // Workflow commands (top-level) - NEW NAMES
     program.addCommand(createInitCommand()); // workflow-init
+    program.addCommand(createPlanCommand()); // plan - NEW
     program.addCommand(createRunCommand()); // workflow-run
     program.addCommand(createStatusCommand()); // workflow-status
     program.addCommand(createResumeCommand()); // workflow-resume

package/dist/lib/anthropic-client.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Anthropic API Client
+ *
+ * Generates workflow plans via Claude API
+ */
+import type { FaberConfig } from '../types/config.js';
+interface GeneratePlanInput {
+    workflow: string;
+    issueTitle: string;
+    issueDescription: string;
+    issueNumber: number;
+}
+interface WorkflowPlan {
+    plan_id: string;
+    created_by: string;
+    cli_version: string;
+    created_at: string;
+    issue: {
+        source: string;
+        id: string;
+        url: string;
+    };
+    branch: string;
+    worktree: string;
+    workflow: string;
+    phases: any[];
+    [key: string]: any;
+}
+/**
+ * Anthropic API Client
+ */
+export declare class AnthropicClient {
+    private client;
+    private config;
+    private git;
+    private ajv;
+    private planSchema;
+    constructor(config: FaberConfig);
+    /**
+     * Load plan JSON schema for validation
+     */
+    private loadPlanSchema;
+    /**
+     * Validate plan JSON against schema
+     */
+    private validatePlan;
+    /**
+     * Generate workflow plan via Claude API
+     */
+    generatePlan(input: GeneratePlanInput): Promise<WorkflowPlan>;
+    /**
+     * Load workflow configuration
+     */
+    private loadWorkflowConfig;
+    /**
+     * Construct planning prompt for Claude
+     */
+    private constructPlanningPrompt;
+    /**
+     * Extract JSON from Claude response
+     */
+    private extractJsonFromResponse;
+    /**
+     * Extract repository organization and project name using SDK Git class
+     */
+    private extractRepoInfo;
+}
+export {};
+//# sourceMappingURL=anthropic-client.d.ts.map

package/dist/lib/anthropic-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-client.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,UAAU,CAAM;gBAEZ,MAAM,EAAE,WAAW;IAe/B;;OAEG;YACW,cAAc;IAiB5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IA6DnE;;OAEG;YACW,kBAAkB;IAchC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqD/B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;YACW,eAAe;CAqB9B"}