claude-flow-novice 1.0.0

package/dist/src/cli/commands/task.js

@@ -0,0 +1,44 @@
+import { getErrorMessage } from '../../utils/error-handler.js';
+/**
+ * Task management commands
+ */ import { Command } from 'commander';
+import { promises as fs } from 'node:fs';
+import chalk from 'chalk';
+import { generateId } from '../../utils/helpers.js';
+export const taskCommand = new Command().name('task').description('Manage tasks').action(()=>{
+    taskCommand.outputHelp();
+}).command('create').description('Create a new task').argument('<type>', 'Task type').argument('<description>', 'Task description').option('-p, --priority <priority>', 'Task priority', '0').option('-d, --dependencies <deps>', 'Comma-separated list of dependency task IDs').option('-i, --input <input>', 'Task input as JSON').option('-a, --assign <agent>', 'Assign to specific agent').action(async (type, description, options)=>{
+    const task = {
+        id: generateId('task'),
+        type,
+        description,
+        priority: parseInt(options.priority, 10),
+        dependencies: options.dependencies ? options.dependencies.split(',') : [],
+        assignedAgent: options.assign,
+        status: 'pending',
+        input: options.input ? JSON.parse(options.input) : {},
+        createdAt: new Date()
+    };
+    console.log(chalk.green('Task created:'));
+    console.log(JSON.stringify(task, null, 2));
+    console.log(chalk.yellow('\nTo submit this task, ensure Claude-Flow is running'));
+}).command('list').description('List all tasks').option('-s, --status <status:string>', 'Filter by status').option('-a, --agent <agent:string>', 'Filter by assigned agent').action(async (options)=>{
+    console.log(chalk.yellow('Task listing requires a running Claude-Flow instance'));
+}).command('status').description('Get task status').argument('<task-id>', 'Task ID').action(async (taskId, options)=>{
+    console.log(chalk.yellow(`Task status requires a running Claude-Flow instance`));
+}).command('cancel').description('Cancel a task').argument('<task-id>', 'Task ID').option('-r, --reason <reason>', 'Cancellation reason').action(async (taskId, options)=>{
+    console.log(chalk.yellow(`Cancelling task ${taskId} requires a running Claude-Flow instance`));
+}).command('workflow').description('Execute a workflow from file').argument('<workflow-file>', 'Workflow file path').action(async (workflowFile, options)=>{
+    try {
+        const content = await fs.readFile(workflowFile, 'utf-8');
+        const workflow = JSON.parse(content);
+        console.log(chalk.green('Workflow loaded:'));
+        console.log(`- Name: ${workflow.name || 'Unnamed'}`);
+        console.log(`- Tasks: ${workflow.tasks?.length || 0}`);
+        console.log(chalk.yellow('\nTo execute this workflow, ensure Claude-Flow is running'));
+    } catch (error) {
+        console.error(chalk.red('Failed to load workflow:'), getErrorMessage(error));
+    }
+});
+
+//# sourceMappingURL=task.js.map

package/dist/src/cli/commands/task.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/commands/task.ts"],"names":["getErrorMessage","Command","promises","fs","chalk","generateId","taskCommand","name","description","action","outputHelp","command","argument","option","type","options","task","id","priority","parseInt","dependencies","split","assignedAgent","assign","status","input","JSON","parse","createdAt","Date","console","log","green","stringify","yellow","taskId","workflowFile","content","readFile","workflow","tasks","length","error","red"],"mappings":"AAAA,SAASA,eAAe,QAAQ,+BAA+B;AAC/D;;CAEC,GAED,SAASC,OAAO,QAAQ,YAAY;AACpC,SAASC,YAAYC,EAAE,QAAQ,UAAU;AACzC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,UAAU,QAAQ,yBAAyB;AAEpD,OAAO,MAAMC,cAAc,IAAIL,UAC5BM,IAAI,CAAC,QACLC,WAAW,CAAC,gBACZC,MAAM,CAAC;IACNH,YAAYI,UAAU;AACxB,GACCC,OAAO,CAAC,UACRH,WAAW,CAAC,qBACZI,QAAQ,CAAC,UAAU,aACnBA,QAAQ,CAAC,iBAAiB,oBAC1BC,MAAM,CAAC,6BAA6B,iBAAiB,KACrDA,MAAM,CAAC,6BAA6B,+CACpCA,MAAM,CAAC,uBAAuB,sBAC9BA,MAAM,CAAC,wBAAwB,4BAC/BJ,MAAM,CAAC,OAAOK,MAAcN,aAAqBO;IAChD,MAAMC,OAAa;QACjBC,IAAIZ,WAAW;QACfS;QACAN;QACAU,UAAUC,SAASJ,QAAQG,QAAQ,EAAE;QACrCE,cAAcL,QAAQK,YAAY,GAAGL,QAAQK,YAAY,CAACC,KAAK,CAAC,OAAO,EAAE;QACzEC,eAAeP,QAAQQ,MAAM;QAC7BC,QAAQ;QACRC,OAAOV,QAAQU,KAAK,GAAGC,KAAKC,KAAK,CAACZ,QAAQU,KAAK,IAAI,CAAC;QACpDG,WAAW,IAAIC;IACjB;IAEAC,QAAQC,GAAG,CAAC3B,MAAM4B,KAAK,CAAC;IACxBF,QAAQC,GAAG,CAACL,KAAKO,SAAS,CAACjB,MAAM,MAAM;IACvCc,QAAQC,GAAG,CAAC3B,MAAM8B,MAAM,CAAC;AAC3B,GACCvB,OAAO,CAAC,QACRH,WAAW,CAAC,kBACZK,MAAM,CAAC,gCAAgC,oBACvCA,MAAM,CAAC,8BAA8B,4BACrCJ,MAAM,CAAC,OAAOM;IACbe,QAAQC,GAAG,CAAC3B,MAAM8B,MAAM,CAAC;AAC3B,GACCvB,OAAO,CAAC,UACRH,WAAW,CAAC,mBACZI,QAAQ,CAAC,aAAa,WACtBH,MAAM,CAAC,OAAO0B,QAAgBpB;IAC7Be,QAAQC,GAAG,CAAC3B,MAAM8B,MAAM,CAAC,CAAC,mDAAmD,CAAC;AAChF,GACCvB,OAAO,CAAC,UACRH,WAAW,CAAC,iBACZI,QAAQ,CAAC,aAAa,WACtBC,MAAM,CAAC,yBAAyB,uBAChCJ,MAAM,CAAC,OAAO0B,QAAgBpB;IAC7Be,QAAQC,GAAG,CAAC3B,MAAM8B,MAAM,CAAC,CAAC,gBAAgB,EAAEC,OAAO,wCAAwC,CAAC;AAC9F,GACCxB,OAAO,CAAC,YACRH,WAAW,CAAC,gCACZI,QAAQ,CAAC,mBAAmB,sBAC5BH,MAAM,CAAC,OAAO2B,cAAsBrB;IACnC,IAAI;QACF,MAAMsB,UAAU,MAAMlC,GAAGmC,QAAQ,CAACF,cAAc;QAChD,MAAMG,WAAWb,KAAKC,KAAK,CAACU;QAE5BP,QAAQC,GAAG,CAAC3B,MAAM4B,KAAK,CAAC;QACxBF,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEQ,SAAShC,IAAI,IAAI,WAAW;QACnDuB,QAAQC,GAAG,CAAC,CAAC,SAAS,EAAEQ,SAASC,KAAK,EAAEC,UAAU,GAAG;QACrDX,QAAQC,GAAG,CAAC3B,MAAM8B,MAAM,CAAC;IAC3B,EAAE,OAAOQ,OAAO;QACdZ,QAAQY,KAAK,CAACtC,MAAMuC,GAAG,CAAC,6BAA6B3C,gBAAgB0C;IACvE;AACF,GAAG"}

package/dist/src/cli/commands/validate-integration.js

@@ -0,0 +1,122 @@
+/**
+ * Validation Commands TypeScript Integration
+ * Phase 2 Implementation - TypeScript CLI Integration
+ *
+ * Integrates JavaScript validation commands with TypeScript CLI system
+ */ export function setupValidationCommands(cli) {
+    cli.command({
+        name: 'validate',
+        description: 'Completion validation framework commands',
+        subcommands: [
+            {
+                name: 'setup',
+                description: 'Interactive setup wizard for completion validation',
+                options: [
+                    {
+                        name: 'verbose',
+                        short: 'v',
+                        description: 'Enable verbose output',
+                        type: 'boolean'
+                    },
+                    {
+                        name: 'reset',
+                        description: 'Reset to default configuration',
+                        type: 'boolean'
+                    }
+                ],
+                action: async (ctx)=>{
+                    try {
+                        const { setupCommand } = await import('../../completion/cli-wizard.js');
+                        console.log('🔧 Starting Completion Validation Setup...\n');
+                        const result = await setupCommand({
+                            verbose: ctx.flags.verbose,
+                            reset: ctx.flags.reset
+                        });
+                        if (result.success) {
+                            console.log('🎉 Setup completed successfully!');
+                            console.log('You can now use completion validation in your project.');
+                            console.log('\nNext steps:');
+                            console.log('  • claude-flow-novice validate test    # Test your configuration');
+                            console.log('  • claude-flow-novice validate show-config   # View current settings');
+                        } else {
+                            console.error(`❌ Setup failed: ${result.error}`);
+                            process.exit(1);
+                        }
+                    } catch (error) {
+                        console.error(`❌ Setup error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                        if (ctx.flags.verbose) {
+                            console.error(error);
+                        }
+                        process.exit(1);
+                    }
+                }
+            },
+            {
+                name: 'show-config',
+                description: 'Display current validation configuration',
+                options: [
+                    {
+                        name: 'verbose',
+                        short: 'v',
+                        description: 'Enable verbose output',
+                        type: 'boolean'
+                    },
+                    {
+                        name: 'json',
+                        description: 'Output as JSON',
+                        type: 'boolean'
+                    }
+                ],
+                action: async (ctx)=>{
+                    try {
+                        const { showConfigCommand } = await import('../../completion/cli-wizard.js');
+                        await showConfigCommand({
+                            verbose: ctx.flags.verbose,
+                            json: ctx.flags.json
+                        });
+                    } catch (error) {
+                        console.error(`❌ Configuration error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                        if (ctx.flags.verbose) {
+                            console.error(error);
+                        }
+                        process.exit(1);
+                    }
+                }
+            },
+            {
+                name: 'test',
+                description: 'Test validation configuration and framework detection',
+                options: [
+                    {
+                        name: 'verbose',
+                        short: 'v',
+                        description: 'Enable verbose output',
+                        type: 'boolean'
+                    },
+                    {
+                        name: 'fix',
+                        description: 'Attempt to fix detected issues',
+                        type: 'boolean'
+                    }
+                ],
+                action: async (ctx)=>{
+                    try {
+                        const { testConfigCommand } = await import('../../completion/cli-wizard.js');
+                        await testConfigCommand({
+                            verbose: ctx.flags.verbose,
+                            fix: ctx.flags.fix
+                        });
+                    } catch (error) {
+                        console.error(`❌ Test error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                        if (ctx.flags.verbose) {
+                            console.error(error);
+                        }
+                        process.exit(1);
+                    }
+                }
+            }
+        ]
+    });
+}
+
+//# sourceMappingURL=validate-integration.js.map

package/dist/src/cli/commands/validate-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/commands/validate-integration.ts"],"names":["setupValidationCommands","cli","command","name","description","subcommands","options","short","type","action","ctx","setupCommand","console","log","result","verbose","flags","reset","success","error","process","exit","Error","message","showConfigCommand","json","testConfigCommand","fix"],"mappings":"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"}

package/dist/src/cli/commands/verification.js

@@ -0,0 +1,351 @@
+/**
+ * Verification Commands for Claude Flow CLI
+ *
+ * Provides CLI commands for verification system management and execution.
+ * Integrates with the existing claude-flow command structure.
+ */ import { Logger } from '../../core/logger.js';
+import { VerificationCLICommands, executeVerificationFromCLI } from '../../verification/index.js';
+const logger = new Logger({
+    level: 'info',
+    format: 'text',
+    destination: 'console'
+}, {
+    prefix: 'VerificationCLI'
+});
+/**
+ * Main verification command that provides subcommands
+ */ export async function verificationCommand(args) {
+    const { subcommand = 'status', ...subArgs } = args;
+    try {
+        logger.debug(`Executing verification subcommand: ${subcommand}`);
+        switch(subcommand){
+            case 'status':
+                return await executeStatusCommand(subArgs);
+            case 'check':
+                return await executeCheckCommand(subArgs);
+            case 'config':
+                return await executeConfigCommand(subArgs);
+            case 'validate':
+                return await executeValidateCommand(subArgs);
+            case 'cleanup':
+                return await executeCleanupCommand(subArgs);
+            case 'pre-task':
+                return await executePreTaskCommand(subArgs);
+            case 'post-task':
+                return await executePostTaskCommand(subArgs);
+            case 'integration':
+                return await executeIntegrationCommand(subArgs);
+            case 'truth':
+                return await executeTruthCommand(subArgs);
+            case 'rollback':
+                return await executeRollbackCommand(subArgs);
+            case 'help':
+                return showVerificationHelp();
+            default:
+                throw new Error(`Unknown verification subcommand: ${subcommand}`);
+        }
+    } catch (error) {
+        logger.error(`Verification command failed:`, error);
+        throw error;
+    }
+}
+/**
+ * Execute status command
+ */ async function executeStatusCommand(args) {
+    const command = VerificationCLICommands.status();
+    return await command.execute(args);
+}
+/**
+ * Execute check command
+ */ async function executeCheckCommand(args) {
+    const command = VerificationCLICommands.check();
+    return await command.execute(args);
+}
+/**
+ * Execute config command
+ */ async function executeConfigCommand(args) {
+    const command = VerificationCLICommands.config();
+    return await command.execute(args);
+}
+/**
+ * Execute validate command
+ */ async function executeValidateCommand(args) {
+    const command = VerificationCLICommands.validate();
+    return await command.execute(args);
+}
+/**
+ * Execute cleanup command
+ */ async function executeCleanupCommand(args) {
+    const command = VerificationCLICommands.cleanup();
+    return await command.execute(args);
+}
+/**
+ * Execute pre-task verification
+ */ async function executePreTaskCommand(args) {
+    return await executeVerificationFromCLI('pre-task', args);
+}
+/**
+ * Execute post-task verification
+ */ async function executePostTaskCommand(args) {
+    return await executeVerificationFromCLI('post-task', args);
+}
+/**
+ * Execute integration tests
+ */ async function executeIntegrationCommand(args) {
+    return await executeVerificationFromCLI('integration', args);
+}
+/**
+ * Execute truth telemetry
+ */ async function executeTruthCommand(args) {
+    return await executeVerificationFromCLI('truth', args);
+}
+/**
+ * Execute rollback
+ */ async function executeRollbackCommand(args) {
+    return await executeVerificationFromCLI('rollback', args);
+}
+/**
+ * Show verification help
+ */ function showVerificationHelp() {
+    const help = `
+🔍 Claude Flow Verification System
+
+USAGE:
+  npx claude-flow verification <subcommand> [options]
+
+SUBCOMMANDS:
+  status      Show verification system status and metrics
+  check       Run verification checks for a specific task
+  config      View or update verification configuration
+  validate    Run post-task validation for a completed task
+  cleanup     Cleanup old verification contexts and snapshots
+  pre-task    Run pre-task verification hooks
+  post-task   Run post-task verification hooks
+  integration Run integration test hooks
+  truth       Run truth telemetry hooks
+  rollback    Execute rollback procedures
+  help        Show this help message
+
+EXAMPLES:
+  npx claude-flow verification status
+  npx claude-flow verification check --taskId task-123
+  npx claude-flow verification config --action set --key preTask.enabled --value true
+  npx claude-flow verification validate --taskId task-123
+  npx claude-flow verification cleanup --force --maxAge 86400000
+  npx claude-flow verification pre-task --taskId task-123 --sessionId session-456
+  npx claude-flow verification post-task --taskId task-123
+  npx claude-flow verification integration --parallel true
+  npx claude-flow verification truth --metric accuracy --threshold 0.8
+  npx claude-flow verification rollback --taskId task-123 --strategy automatic
+
+GLOBAL OPTIONS:
+  --json      Output results in JSON format
+  --verbose   Enable verbose logging
+  --help      Show help for specific subcommand
+
+For more information about a specific subcommand:
+  npx claude-flow verification <subcommand> --help
+`;
+    console.log(help);
+    return {
+        help: true
+    };
+}
+/**
+ * Hook command for direct hook execution (for backward compatibility)
+ */ export async function hookCommand(args) {
+    const { type, ...hookArgs } = args;
+    try {
+        logger.info(`Executing hook command: ${type}`);
+        switch(type){
+            case 'pre-task':
+            case 'pre_task':
+                return await executeVerificationFromCLI('pre-task', hookArgs);
+            case 'post-task':
+            case 'post_task':
+                return await executeVerificationFromCLI('post-task', hookArgs);
+            case 'validation':
+                const validateCommand = VerificationCLICommands.validate();
+                return await validateCommand.execute(hookArgs);
+            case 'integration':
+            case 'integration-test':
+                return await executeVerificationFromCLI('integration', hookArgs);
+            case 'truth':
+            case 'truth-telemetry':
+                return await executeVerificationFromCLI('truth', hookArgs);
+            case 'rollback':
+                return await executeVerificationFromCLI('rollback', hookArgs);
+            default:
+                throw new Error(`Unknown hook type: ${type}`);
+        }
+    } catch (error) {
+        logger.error(`Hook command failed:`, error);
+        throw error;
+    }
+}
+/**
+ * Command definitions for CLI integration
+ */ export const VERIFICATION_COMMANDS = {
+    verification: {
+        name: 'verification',
+        description: 'Verification system management and execution',
+        handler: verificationCommand,
+        subcommands: {
+            status: {
+                name: 'status',
+                description: 'Show verification system status',
+                options: {
+                    json: {
+                        type: 'boolean',
+                        description: 'Output in JSON format'
+                    }
+                }
+            },
+            check: {
+                name: 'check',
+                description: 'Run verification checks',
+                options: {
+                    taskId: {
+                        type: 'string',
+                        required: true,
+                        description: 'Task ID to check'
+                    },
+                    type: {
+                        type: 'string',
+                        description: 'Type of checks to run'
+                    },
+                    json: {
+                        type: 'boolean',
+                        description: 'Output in JSON format'
+                    }
+                }
+            },
+            config: {
+                name: 'config',
+                description: 'Manage verification configuration',
+                options: {
+                    action: {
+                        type: 'string',
+                        description: 'Action to perform (show, set)'
+                    },
+                    key: {
+                        type: 'string',
+                        description: 'Configuration key'
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'Configuration value'
+                    },
+                    json: {
+                        type: 'boolean',
+                        description: 'Output in JSON format'
+                    }
+                }
+            },
+            validate: {
+                name: 'validate',
+                description: 'Run post-task validation',
+                options: {
+                    taskId: {
+                        type: 'string',
+                        required: true,
+                        description: 'Task ID to validate'
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force validation even if not complete'
+                    },
+                    json: {
+                        type: 'boolean',
+                        description: 'Output in JSON format'
+                    }
+                }
+            },
+            cleanup: {
+                name: 'cleanup',
+                description: 'Cleanup old verification data',
+                options: {
+                    maxAge: {
+                        type: 'number',
+                        description: 'Maximum age in milliseconds'
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force cleanup without confirmation'
+                    },
+                    json: {
+                        type: 'boolean',
+                        description: 'Output in JSON format'
+                    }
+                }
+            }
+        }
+    },
+    hook: {
+        name: 'hook',
+        description: 'Execute verification hooks directly',
+        handler: hookCommand,
+        options: {
+            type: {
+                type: 'string',
+                required: true,
+                description: 'Hook type to execute'
+            },
+            taskId: {
+                type: 'string',
+                description: 'Task ID for context'
+            },
+            sessionId: {
+                type: 'string',
+                description: 'Session ID for context'
+            },
+            json: {
+                type: 'boolean',
+                description: 'Output in JSON format'
+            }
+        }
+    }
+};
+/**
+ * Integration function for registering commands with CLI framework
+ */ export function registerVerificationCommands(commandRegistry) {
+    try {
+        // Register main verification command
+        commandRegistry.register({
+            name: 'verification',
+            description: 'Verification system management',
+            handler: verificationCommand,
+            examples: [
+                'npx claude-flow verification status',
+                'npx claude-flow verification check --taskId task-123',
+                'npx claude-flow verification validate --taskId task-123'
+            ]
+        });
+        // Register hook command for backward compatibility
+        commandRegistry.register({
+            name: 'hook',
+            description: 'Execute verification hooks',
+            handler: hookCommand,
+            examples: [
+                'npx claude-flow hook --type pre-task --taskId task-123',
+                'npx claude-flow hook --type post-task --taskId task-123'
+            ]
+        });
+        logger.info('Verification commands registered successfully');
+    } catch (error) {
+        logger.error('Failed to register verification commands:', error);
+        throw error;
+    }
+}
+/**
+ * Default export for CLI integration
+ */ export default {
+    commands: VERIFICATION_COMMANDS,
+    register: registerVerificationCommands,
+    handlers: {
+        verification: verificationCommand,
+        hook: hookCommand
+    }
+};
+
+//# sourceMappingURL=verification.js.map

package/dist/src/cli/commands/verification.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/commands/verification.ts"],"names":["Logger","VerificationCLICommands","executeVerificationFromCLI","logger","level","format","destination","prefix","verificationCommand","args","subcommand","subArgs","debug","executeStatusCommand","executeCheckCommand","executeConfigCommand","executeValidateCommand","executeCleanupCommand","executePreTaskCommand","executePostTaskCommand","executeIntegrationCommand","executeTruthCommand","executeRollbackCommand","showVerificationHelp","Error","error","command","status","execute","check","config","validate","cleanup","help","console","log","hookCommand","type","hookArgs","info","validateCommand","VERIFICATION_COMMANDS","verification","name","description","handler","subcommands","options","json","taskId","required","action","key","value","force","maxAge","hook","sessionId","registerVerificationCommands","commandRegistry","register","examples","commands","handlers"],"mappings":"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"}