@claude-flow/cli 3.32.29 → 3.32.32

package/node_modules/@claude-flow/codex/dist/cli.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env node
+/**
+ * @claude-flow/codex - CLI
+ *
+ * Command-line interface for Codex integration
+ * Part of the coflow rebranding initiative
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { CodexInitializer } from './initializer.js';
+import { validateAgentsMd, validateSkillMd, validateConfigToml } from './validators/index.js';
+import { migrateFromClaudeCode, analyzeClaudeMd, generateMigrationReport } from './migrations/index.js';
+import { listTemplates, BUILT_IN_SKILLS } from './templates/index.js';
+import { generateSkillMd } from './generators/skill-md.js';
+import { VERSION, PACKAGE_INFO } from './index.js';
+import fs from 'fs-extra';
+import path from 'path';
+const program = new Command();
+// Custom error handler for better output
+function handleError(error, message) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red.bold('\nError:'), chalk.red(message ?? errorMessage));
+    if (error instanceof Error && error.stack && process.env.DEBUG) {
+        console.error(chalk.gray('\nStack trace:'));
+        console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+}
+// Validate project path exists and is accessible
+async function validatePath(projectPath) {
+    const resolvedPath = path.resolve(projectPath);
+    try {
+        const stats = await fs.stat(resolvedPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${resolvedPath}`);
+        }
+        return resolvedPath;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            // Directory doesn't exist, try to create it
+            console.log(chalk.yellow(`Creating directory: ${resolvedPath}`));
+            await fs.ensureDir(resolvedPath);
+            return resolvedPath;
+        }
+        throw error;
+    }
+}
+// Validate skill name format
+function validateSkillName(name) {
+    const validPattern = /^[a-z][a-z0-9-]*$/;
+    return validPattern.test(name);
+}
+// Print banner
+function printBanner() {
+    console.log(chalk.cyan.bold('\n  Claude Flow Codex'));
+    console.log(chalk.gray('  OpenAI Codex integration for Claude Flow'));
+    console.log(chalk.gray('  ----------------------------------------\n'));
+}
+program
+    .name('claude-flow-codex')
+    .description('OpenAI Codex integration for Claude Flow - Part of the coflow ecosystem')
+    .version(VERSION, '-v, --version', 'Display version number')
+    .option('--debug', 'Enable debug mode', false)
+    .hook('preAction', (thisCommand) => {
+    if (thisCommand.opts().debug) {
+        process.env.DEBUG = 'true';
+    }
+});
+// Init command
+program
+    .command('init')
+    .description('Initialize a new Codex project with AGENTS.md and skills')
+    .option('-t, --template <template>', 'Template to use (minimal, default, full, enterprise)', 'default')
+    .option('-s, --skills <skills>', 'Comma-separated list of skills to include')
+    .option('-f, --force', 'Overwrite existing files', false)
+    .option('--dual', 'Generate both Codex and Claude Code configurations', false)
+    .option('-p, --path <path>', 'Project path', process.cwd())
+    .option('-q, --quiet', 'Suppress verbose output', false)
+    .action(async (options) => {
+    try {
+        if (!options.quiet) {
+            printBanner();
+        }
+        // Validate template
+        const validTemplates = ['minimal', 'default', 'full', 'enterprise'];
+        if (!validTemplates.includes(options.template)) {
+            console.error(chalk.red(`Invalid template: ${options.template}`));
+            console.log(chalk.gray(`Valid templates: ${validTemplates.join(', ')}`));
+            process.exit(1);
+        }
+        const projectPath = await validatePath(options.path);
+        console.log(chalk.blue('Initializing Codex project...'));
+        console.log(chalk.gray(`  Path:     ${projectPath}`));
+        console.log(chalk.gray(`  Template: ${options.template}`));
+        if (options.skills) {
+            console.log(chalk.gray(`  Skills:   ${options.skills}`));
+        }
+        if (options.force) {
+            console.log(chalk.yellow('  Force:    enabled (will overwrite existing files)'));
+        }
+        if (options.dual) {
+            console.log(chalk.gray('  Mode:     dual (Codex + Claude Code)'));
+        }
+        const initializer = new CodexInitializer();
+        const skills = options.skills?.split(',').map((s) => s.trim()).filter(Boolean);
+        // Validate skill names if provided
+        if (skills) {
+            for (const skill of skills) {
+                if (!validateSkillName(skill)) {
+                    console.error(chalk.red(`Invalid skill name: ${skill}`));
+                    console.log(chalk.gray('Skill names must be kebab-case (lowercase letters, numbers, hyphens)'));
+                    process.exit(1);
+                }
+            }
+        }
+        const result = await initializer.initialize({
+            projectPath,
+            template: options.template,
+            skills,
+            force: options.force,
+            dual: options.dual,
+        });
+        if (result.success) {
+            console.log(chalk.green.bold('\n  Project initialized successfully!'));
+            if (result.filesCreated.length > 0) {
+                console.log(chalk.white('\n  Files created:'));
+                for (const file of result.filesCreated) {
+                    console.log(chalk.gray(`    ${chalk.green('+')} ${file}`));
+                }
+            }
+            if (result.skillsGenerated.length > 0) {
+                console.log(chalk.white('\n  Skills generated:'));
+                for (const skill of result.skillsGenerated) {
+                    console.log(chalk.gray(`    ${chalk.cyan('$')}${skill}`));
+                }
+            }
+            if (result.warnings && result.warnings.length > 0) {
+                console.log(chalk.yellow('\n  Warnings:'));
+                for (const warning of result.warnings) {
+                    console.log(chalk.yellow(`    ! ${warning}`));
+                }
+            }
+            console.log(chalk.blue.bold('\n  Next steps:'));
+            console.log(chalk.gray('    1. Review AGENTS.md and customize for your project'));
+            console.log(chalk.gray('    2. Review .agents/config.toml settings'));
+            console.log(chalk.gray('    3. Start using skills with $skill-name syntax'));
+            console.log();
+        }
+        else {
+            console.log(chalk.red.bold('\n  Initialization failed'));
+            if (result.errors) {
+                for (const error of result.errors) {
+                    console.log(chalk.red(`    - ${error}`));
+                }
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        handleError(error, 'Failed to initialize project');
+    }
+});
+// Generate skill command
+program
+    .command('generate-skill')
+    .alias('gs')
+    .description('Generate a new SKILL.md file')
+    .requiredOption('-n, --name <name>', 'Skill name (kebab-case)')
+    .option('-d, --description <description>', 'Skill description')
+    .option('-t, --triggers <triggers>', 'Comma-separated trigger conditions')
+    .option('-s, --skip <skip>', 'Comma-separated skip conditions')
+    .option('-p, --path <path>', 'Output path', process.cwd())
+    .option('--dry-run', 'Show what would be generated without writing', false)
+    .action(async (options) => {
+    try {
+        printBanner();
+        // Validate skill name
+        if (!validateSkillName(options.name)) {
+            console.error(chalk.red(`Invalid skill name: ${options.name}`));
+            console.log(chalk.gray('Skill names must be kebab-case (lowercase letters, numbers, hyphens)'));
+            console.log(chalk.gray('Examples: my-skill, code-analyzer, data-processor'));
+            process.exit(1);
+        }
+        const projectPath = await validatePath(options.path);
+        console.log(chalk.blue(`Generating skill: ${chalk.white(options.name)}`));
+        const triggers = options.triggers?.split(',').map((s) => s.trim()).filter(Boolean);
+        const skipWhen = options.skip?.split(',').map((s) => s.trim()).filter(Boolean);
+        const skillMd = await generateSkillMd({
+            name: options.name,
+            description: options.description ?? `Custom skill: ${options.name}`,
+            triggers: triggers ?? ['Define when to trigger this skill'],
+            skipWhen: skipWhen ?? ['Define when to skip this skill'],
+        });
+        if (options.dryRun) {
+            console.log(chalk.yellow('\nDry run - would generate:'));
+            console.log(chalk.gray('---'));
+            console.log(skillMd);
+            console.log(chalk.gray('---'));
+            return;
+        }
+        const skillDir = path.join(projectPath, '.agents', 'skills', options.name);
+        await fs.ensureDir(skillDir);
+        const skillPath = path.join(skillDir, 'SKILL.md');
+        // Check if skill already exists
+        if (await fs.pathExists(skillPath)) {
+            console.log(chalk.yellow(`Skill already exists: ${skillPath}`));
+            console.log(chalk.gray('Use --force to overwrite (not yet implemented)'));
+            process.exit(1);
+        }
+        await fs.writeFile(skillPath, skillMd);
+        console.log(chalk.green.bold(`\n  Skill created successfully!`));
+        console.log(chalk.gray(`  Path: ${skillPath}`));
+        console.log(chalk.gray(`  Use:  ${chalk.cyan('$' + options.name)}`));
+        console.log();
+    }
+    catch (error) {
+        handleError(error, 'Failed to generate skill');
+    }
+});
+// Validate command
+program
+    .command('validate')
+    .alias('check')
+    .description('Validate AGENTS.md, SKILL.md, or config.toml files')
+    .option('-f, --file <file>', 'File to validate')
+    .option('-p, --path <path>', 'Project path to validate all files', process.cwd())
+    .option('--fix', 'Attempt to fix issues (not yet implemented)', false)
+    .option('--strict', 'Treat warnings as errors', false)
+    .action(async (options) => {
+    try {
+        printBanner();
+        const projectPath = path.resolve(options.path);
+        const filesToValidate = [];
+        if (options.file) {
+            // Validate specific file
+            const filePath = path.resolve(options.file);
+            if (!await fs.pathExists(filePath)) {
+                console.error(chalk.red(`File not found: ${filePath}`));
+                process.exit(1);
+            }
+            const fileName = path.basename(filePath).toLowerCase();
+            if (fileName === 'agents.md') {
+                filesToValidate.push({ path: filePath, type: 'agents' });
+            }
+            else if (fileName === 'skill.md') {
+                filesToValidate.push({ path: filePath, type: 'skill' });
+            }
+            else if (fileName === 'config.toml') {
+                filesToValidate.push({ path: filePath, type: 'config' });
+            }
+            else {
+                console.error(chalk.red(`Unknown file type: ${fileName}`));
+                console.log(chalk.gray('Supported files: AGENTS.md, SKILL.md, config.toml'));
+                process.exit(1);
+            }
+        }
+        else {
+            // Validate all files in project
+            console.log(chalk.blue(`Scanning project: ${projectPath}`));
+            const agentsMd = path.join(projectPath, 'AGENTS.md');
+            const configToml = path.join(projectPath, '.agents', 'config.toml');
+            if (await fs.pathExists(agentsMd)) {
+                filesToValidate.push({ path: agentsMd, type: 'agents' });
+            }
+            if (await fs.pathExists(configToml)) {
+                filesToValidate.push({ path: configToml, type: 'config' });
+            }
+            // Find skill files
+            const skillsDir = path.join(projectPath, '.agents', 'skills');
+            if (await fs.pathExists(skillsDir)) {
+                try {
+                    const skills = await fs.readdir(skillsDir);
+                    for (const skill of skills) {
+                        const skillPath = path.join(skillsDir, skill);
+                        const skillStats = await fs.stat(skillPath);
+                        if (skillStats.isDirectory()) {
+                            const skillMd = path.join(skillPath, 'SKILL.md');
+                            if (await fs.pathExists(skillMd)) {
+                                filesToValidate.push({ path: skillMd, type: 'skill' });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore errors reading skills directory
+                }
+            }
+        }
+        if (filesToValidate.length === 0) {
+            console.log(chalk.yellow('No files found to validate'));
+            console.log(chalk.gray('Run `claude-flow-codex init` to create a project'));
+            return;
+        }
+        console.log(chalk.blue(`\nValidating ${filesToValidate.length} file(s)...\n`));
+        let hasErrors = false;
+        let hasWarnings = false;
+        let totalErrors = 0;
+        let totalWarnings = 0;
+        for (const file of filesToValidate) {
+            let content;
+            try {
+                content = await fs.readFile(file.path, 'utf-8');
+            }
+            catch (error) {
+                console.log(chalk.red(`  ! Cannot read: ${file.path}`));
+                hasErrors = true;
+                continue;
+            }
+            let result;
+            switch (file.type) {
+                case 'agents':
+                    result = await validateAgentsMd(content);
+                    break;
+                case 'skill':
+                    result = await validateSkillMd(content);
+                    break;
+                case 'config':
+                    result = await validateConfigToml(content);
+                    break;
+            }
+            const relativePath = path.relative(projectPath, file.path);
+            if (result.valid && result.warnings.length === 0) {
+                console.log(chalk.green(`  ${chalk.green.bold('PASS')} ${relativePath}`));
+            }
+            else if (result.valid) {
+                console.log(chalk.yellow(`  ${chalk.yellow.bold('WARN')} ${relativePath}`));
+                hasWarnings = true;
+            }
+            else {
+                console.log(chalk.red(`  ${chalk.red.bold('FAIL')} ${relativePath}`));
+                hasErrors = true;
+            }
+            for (const error of result.errors) {
+                totalErrors++;
+                const lineInfo = error.line ? chalk.gray(` (line ${error.line})`) : '';
+                console.log(chalk.red(`       ${chalk.red('x')} ${error.message}${lineInfo}`));
+            }
+            for (const warning of result.warnings) {
+                totalWarnings++;
+                console.log(chalk.yellow(`       ${chalk.yellow('!')} ${warning.message}`));
+                if (warning.suggestion) {
+                    console.log(chalk.gray(`         ${warning.suggestion}`));
+                }
+            }
+        }
+        // Summary
+        console.log();
+        if (hasErrors) {
+            console.log(chalk.red.bold(`  ${totalErrors} error(s), ${totalWarnings} warning(s)`));
+            process.exit(1);
+        }
+        else if (hasWarnings && options.strict) {
+            console.log(chalk.yellow.bold(`  ${totalWarnings} warning(s) (strict mode)`));
+            process.exit(1);
+        }
+        else if (hasWarnings) {
+            console.log(chalk.yellow(`  All files valid with ${totalWarnings} warning(s)`));
+        }
+        else {
+            console.log(chalk.green.bold('  All files valid!'));
+        }
+    }
+    catch (error) {
+        handleError(error, 'Validation failed');
+    }
+});
+// Migrate command
+program
+    .command('migrate')
+    .description('Migrate from Claude Code (CLAUDE.md) to Codex (AGENTS.md)')
+    .option('-f, --from <file>', 'Source CLAUDE.md file', 'CLAUDE.md')
+    .option('-o, --output <path>', 'Output directory', process.cwd())
+    .option('--analyze-only', 'Only analyze, do not generate files', false)
+    .option('--generate-skills', 'Generate skill files from detected patterns', true)
+    .option('--preserve-comments', 'Preserve comments from original file', true)
+    .action(async (options) => {
+    try {
+        printBanner();
+        const sourcePath = path.resolve(options.from);
+        if (!await fs.pathExists(sourcePath)) {
+            console.error(chalk.red(`Source file not found: ${sourcePath}`));
+            console.log(chalk.gray('\nLooking for CLAUDE.md in the current directory.'));
+            console.log(chalk.gray('Use --from <path> to specify a different source file.'));
+            process.exit(1);
+        }
+        let content;
+        try {
+            content = await fs.readFile(sourcePath, 'utf-8');
+        }
+        catch (error) {
+            handleError(error, `Cannot read source file: ${sourcePath}`);
+        }
+        if (options.analyzeOnly) {
+            console.log(chalk.blue('Analyzing CLAUDE.md...'));
+            console.log(chalk.gray(`Source: ${sourcePath}\n`));
+            const analysis = await analyzeClaudeMd(content);
+            console.log(chalk.white.bold('Sections found:'));
+            if (analysis.sections.length > 0) {
+                for (const section of analysis.sections) {
+                    console.log(chalk.gray(`  - ${section}`));
+                }
+            }
+            else {
+                console.log(chalk.gray('  (none)'));
+            }
+            console.log(chalk.white.bold('\nSkills detected:'));
+            if (analysis.skills.length > 0) {
+                for (const skill of analysis.skills) {
+                    console.log(chalk.gray(`  - /${skill} ${chalk.cyan('->')} $${skill}`));
+                }
+            }
+            else {
+                console.log(chalk.gray('  (none)'));
+            }
+            console.log(chalk.white.bold('\nHooks used:'));
+            if (analysis.hooks.length > 0) {
+                for (const hook of analysis.hooks) {
+                    console.log(chalk.gray(`  - ${hook}`));
+                }
+            }
+            else {
+                console.log(chalk.gray('  (none)'));
+            }
+            console.log(chalk.white.bold('\nCustom instructions:'));
+            if (analysis.customInstructions.length > 0) {
+                for (const instruction of analysis.customInstructions.slice(0, 5)) {
+                    console.log(chalk.gray(`  - ${instruction.substring(0, 60)}...`));
+                }
+                if (analysis.customInstructions.length > 5) {
+                    console.log(chalk.gray(`  ... and ${analysis.customInstructions.length - 5} more`));
+                }
+            }
+            else {
+                console.log(chalk.gray('  (none)'));
+            }
+            if (analysis.warnings.length > 0) {
+                console.log(chalk.yellow.bold('\nMigration warnings:'));
+                for (const warning of analysis.warnings) {
+                    console.log(chalk.yellow(`  ! ${warning}`));
+                }
+            }
+            console.log();
+        }
+        else {
+            console.log(chalk.blue('Migrating to Codex...'));
+            console.log(chalk.gray(`Source: ${sourcePath}`));
+            console.log(chalk.gray(`Output: ${path.resolve(options.output)}\n`));
+            const result = await migrateFromClaudeCode({
+                sourcePath,
+                targetPath: options.output,
+                generateSkills: options.generateSkills,
+                preserveComments: options.preserveComments,
+            });
+            const report = generateMigrationReport(result);
+            console.log(report);
+            if (result.success) {
+                console.log(chalk.green.bold('\n  Migration completed successfully!'));
+                console.log(chalk.gray('\n  Next steps:'));
+                console.log(chalk.gray('    1. Review the generated AGENTS.md'));
+                console.log(chalk.gray('    2. Check skill invocation syntax (/ -> $)'));
+                console.log(chalk.gray('    3. Run `claude-flow-codex validate` to verify'));
+                console.log();
+            }
+            else {
+                console.log(chalk.red.bold('\n  Migration failed'));
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        handleError(error, 'Migration failed');
+    }
+});
+// Templates command
+program
+    .command('templates')
+    .alias('list-templates')
+    .description('List available templates')
+    .option('--json', 'Output as JSON', false)
+    .action((options) => {
+    try {
+        const templates = listTemplates();
+        if (options.json) {
+            console.log(JSON.stringify(templates, null, 2));
+            return;
+        }
+        printBanner();
+        console.log(chalk.white.bold('Available templates:\n'));
+        for (const template of templates) {
+            console.log(chalk.cyan.bold(`  ${template.name}`));
+            console.log(chalk.gray(`    ${template.description}`));
+            console.log(chalk.gray(`    Skills: ${template.skillCount} included`));
+            console.log();
+        }
+        console.log(chalk.gray('Use: claude-flow-codex init --template <name>'));
+        console.log();
+    }
+    catch (error) {
+        handleError(error, 'Failed to list templates');
+    }
+});
+// Skills command
+program
+    .command('skills')
+    .alias('list-skills')
+    .description('List available built-in skills')
+    .option('--json', 'Output as JSON', false)
+    .action((options) => {
+    try {
+        if (options.json) {
+            console.log(JSON.stringify(BUILT_IN_SKILLS, null, 2));
+            return;
+        }
+        printBanner();
+        console.log(chalk.white.bold('Built-in skills:\n'));
+        for (const [name, info] of Object.entries(BUILT_IN_SKILLS)) {
+            console.log(chalk.cyan(`  $${name}`));
+            console.log(chalk.gray(`    ${info.description}`));
+            console.log(chalk.gray(`    Category: ${info.category}`));
+            console.log();
+        }
+        console.log(chalk.gray('Use: claude-flow-codex generate-skill -n <name> to create a custom skill'));
+        console.log();
+    }
+    catch (error) {
+        handleError(error, 'Failed to list skills');
+    }
+});
+// Info command
+program
+    .command('info')
+    .description('Show package information')
+    .option('--json', 'Output as JSON', false)
+    .action((options) => {
+    try {
+        if (options.json) {
+            console.log(JSON.stringify(PACKAGE_INFO, null, 2));
+            return;
+        }
+        console.log(chalk.cyan.bold('\n  @claude-flow/codex'));
+        console.log(chalk.gray('  ' + '='.repeat(40)));
+        console.log(chalk.white(`  Version:     ${PACKAGE_INFO.version}`));
+        console.log(chalk.white(`  Description: ${PACKAGE_INFO.description}`));
+        console.log(chalk.white(`  Future:      ${PACKAGE_INFO.futureUmbrella} (umbrella package)`));
+        console.log(chalk.white(`  Repository:  ${PACKAGE_INFO.repository}`));
+        console.log(chalk.gray('  ' + '='.repeat(40)));
+        console.log(chalk.gray('\n  Part of the coflow rebranding initiative'));
+        console.log();
+    }
+    catch (error) {
+        handleError(error, 'Failed to show info');
+    }
+});
+// Doctor command - check system health
+program
+    .command('doctor')
+    .description('Check system health and dependencies')
+    .action(async () => {
+    try {
+        printBanner();
+        console.log(chalk.blue('Running health checks...\n'));
+        const checks = [];
+        // Check Node.js version
+        const nodeVersion = process.version;
+        const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0] ?? '0', 10);
+        if (nodeMajor >= 18) {
+            checks.push({ name: 'Node.js', status: 'pass', message: `${nodeVersion} (>= 18 required)` });
+        }
+        else {
+            checks.push({ name: 'Node.js', status: 'fail', message: `${nodeVersion} (>= 18 required)` });
+        }
+        // Check for AGENTS.md in current directory
+        const agentsMdExists = await fs.pathExists(path.join(process.cwd(), 'AGENTS.md'));
+        if (agentsMdExists) {
+            checks.push({ name: 'AGENTS.md', status: 'pass', message: 'Found in current directory' });
+        }
+        else {
+            checks.push({ name: 'AGENTS.md', status: 'warn', message: 'Not found - run init to create' });
+        }
+        // Check for .agents directory
+        const agentsDir = await fs.pathExists(path.join(process.cwd(), '.agents'));
+        if (agentsDir) {
+            checks.push({ name: '.agents/', status: 'pass', message: 'Directory exists' });
+        }
+        else {
+            checks.push({ name: '.agents/', status: 'warn', message: 'Not found - run init to create' });
+        }
+        // Check for config.toml
+        const configExists = await fs.pathExists(path.join(process.cwd(), '.agents', 'config.toml'));
+        if (configExists) {
+            checks.push({ name: 'config.toml', status: 'pass', message: 'Found in .agents/' });
+        }
+        else {
+            checks.push({ name: 'config.toml', status: 'warn', message: 'Not found' });
+        }
+        // Check for git
+        try {
+            const gitExists = await fs.pathExists(path.join(process.cwd(), '.git'));
+            if (gitExists) {
+                checks.push({ name: 'Git', status: 'pass', message: 'Repository detected' });
+            }
+            else {
+                checks.push({ name: 'Git', status: 'warn', message: 'Not a git repository' });
+            }
+        }
+        catch {
+            checks.push({ name: 'Git', status: 'warn', message: 'Cannot check' });
+        }
+        // Print results
+        let hasFailures = false;
+        for (const check of checks) {
+            const icon = check.status === 'pass' ? chalk.green('PASS')
+                : check.status === 'warn' ? chalk.yellow('WARN')
+                    : chalk.red('FAIL');
+            console.log(`  ${icon}  ${chalk.white(check.name)}`);
+            console.log(chalk.gray(`       ${check.message}`));
+            if (check.status === 'fail') {
+                hasFailures = true;
+            }
+        }
+        console.log();
+        if (hasFailures) {
+            console.log(chalk.red.bold('  Some checks failed'));
+            process.exit(1);
+        }
+        else {
+            console.log(chalk.green.bold('  All checks passed!'));
+        }
+        console.log();
+    }
+    catch (error) {
+        handleError(error, 'Health check failed');
+    }
+});
+// Dual-mode command - collaborative Claude Code + Codex execution
+import { createDualModeCommand } from './dual-mode/index.js';
+program.addCommand(createDualModeCommand());
+// Codex /loop-compatible runner
+import { createLoopCommand } from './loop/cli.js';
+program.addCommand(createLoopCommand());
+// Policy-governed worktree isolation for concurrent Codex writers (ADR-324)
+import { CodexWorktreeCoordinator } from './worktrees/index.js';
+const worktree = program.command('worktree').description('Prepare, inspect, integrate, or clean registry-owned Codex swarm worktrees');
+worktree.command('prepare <run-id>')
+    .requiredOption('--agents <ids>', 'Comma-separated writing-agent IDs')
+    .option('--read-only <ids>', 'Comma-separated read-only agent IDs')
+    .option('--base <ref>', 'Git base ref', 'HEAD')
+    .option('--allow-dirty', 'Allow creating worktrees from a dirty coordinator checkout', false)
+    .option('-p, --path <path>', 'Repository root', process.cwd())
+    .action((runId, options) => {
+    const writers = String(options.agents).split(',').map((id) => id.trim()).filter(Boolean).map((id) => ({ id }));
+    const readers = String(options.readOnly ?? '').split(',').map((id) => id.trim()).filter(Boolean).map((id) => ({ id, readOnly: true }));
+    const result = new CodexWorktreeCoordinator(options.path).prepare(runId, [...writers, ...readers], {
+        allowDirty: options.allowDirty,
+        baseRef: options.base,
+    });
+    console.log(JSON.stringify(result, null, 2));
+});
+worktree.command('status <run-id>')
+    .option('-p, --path <path>', 'Repository root', process.cwd())
+    .action((runId, options) => console.log(JSON.stringify(new CodexWorktreeCoordinator(options.path).status(runId), null, 2)));
+worktree.command('integrate <run-id>')
+    .option('--agents <ids>', 'Comma-separated agent IDs; defaults to all writers')
+    .option('-p, --path <path>', 'Repository root', process.cwd())
+    .action((runId, options) => {
+    const ids = options.agents ? String(options.agents).split(',').map((id) => id.trim()).filter(Boolean) : undefined;
+    console.log(JSON.stringify(new CodexWorktreeCoordinator(options.path).integrate(runId, ids), null, 2));
+});
+worktree.command('cleanup <run-id>')
+    .option('-p, --path <path>', 'Repository root', process.cwd())
+    .action((runId, options) => console.log(JSON.stringify(new CodexWorktreeCoordinator(options.path).cleanup(runId), null, 2)));
+// Error handling for unknown commands
+program.on('command:*', () => {
+    console.error(chalk.red(`Invalid command: ${program.args.join(' ')}`));
+    console.log(chalk.gray(`Run ${chalk.white('claude-flow-codex --help')} for available commands.`));
+    process.exit(1);
+});
+// Parse and run
+program.parse();
+// If no command provided, show help
+if (!process.argv.slice(2).length) {
+    printBanner();
+    program.outputHelp();
+}
+//# sourceMappingURL=cli.js.map