claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/cli/index-remote.ts

@@ -130,7 +130,7 @@ async function main() {
   }
 }
 
-if (typeof require !== 'undefined' && require.main === module) {
+if (import.meta.main) {
   main().catch((error) => {
     printError(`Error: ${(error instanceof Error ? error.message : String(error))}`);
     process.exit(1);

package/src/cli/index.ts

@@ -36,15 +36,19 @@ const cli = new Command()
   .name('claude-flow')
   .version(VERSION)
   .description('Claude-Flow: Advanced AI agent orchestration system for multi-agent coordination')
-  .option('--build-date', 'Show build date', BUILD_DATE)
-  .option('--runtime', 'Show runtime info', 'Deno')
-  .option('-c, --config <path:string>', 'Path to configuration file', './claude-flow.config.json')
-  .option('-v, --verbose', 'Enable verbose logging')
-  .option('-q, --quiet', 'Suppress non-essential output')
-  .option('--log-level <level:string>', 'Set log level (debug, info, warn, error)', 'info')
-  .option('--no-color', 'Disable colored output')
-  .option('--json', 'Output in JSON format where applicable')
-  .option('--profile <profile:string>', 'Use named configuration profile')
+  .meta('Build', BUILD_DATE)
+  .meta('Runtime', 'Deno')
+  .globalOption('-c, --config <path:string>', 'Path to configuration file', {
+    default: './claude-flow.config.json',
+  })
+  .globalOption('-v, --verbose', 'Enable verbose logging')
+  .globalOption('-q, --quiet', 'Suppress non-essential output')
+  .globalOption('--log-level <level:string>', 'Set log level (debug, info, warn, error)', {
+    default: 'info',
+  })
+  .globalOption('--no-color', 'Disable colored output')
+  .globalOption('--json', 'Output in JSON format where applicable')
+  .globalOption('--profile <profile:string>', 'Use named configuration profile')
   .action(async (options: any) => {
     // If no subcommand, show banner and start REPL
     await setupLogging(options);
@@ -59,18 +63,18 @@ const cli = new Command()
 
 // Add subcommands
 cli
-  .addCommand('start', startCommand)
-  .addCommand('agent', agentCommand)
-  .addCommand('task', taskCommand)
-  .addCommand('memory', memoryCommand)
-  .addCommand('config', configCommand)
-  .addCommand('status', statusCommand)
-  .addCommand('monitor', monitorCommand)
-  .addCommand('session', sessionCommand)
-  .addCommand('workflow', workflowCommand)
-  .addCommand('mcp', mcpCommand)
-  .addCommand('help', helpCommand)
-  .addCommand('repl', new Command()
+  .command('start', startCommand)
+  .command('agent', agentCommand)
+  .command('task', taskCommand)
+  .command('memory', memoryCommand)
+  .command('config', configCommand)
+  .command('status', statusCommand)
+  .command('monitor', monitorCommand)
+  .command('session', sessionCommand)
+  .command('workflow', workflowCommand)
+  .command('mcp', mcpCommand)
+  .command('help', helpCommand)
+  .command('repl', new Command()
     .description('Start interactive REPL mode with command completion')
     .option('--no-banner', 'Skip welcome banner')
     .option('--history-file <path:string>', 'Custom history file path')
@@ -80,8 +84,9 @@ cli
         displayBanner(VERSION);
       }
       await startREPL(options);
-    }))
-  .addCommand('version', new Command()
+    }),
+  )
+  .command('version', new Command()
     .description('Show detailed version information')
     .option('--short', 'Show version number only')
     .action(async (options: any) => {
@@ -90,15 +95,17 @@ cli
       } else {
         displayVersion(VERSION, BUILD_DATE);
       }
-    }))
-  .addCommand('completion', new Command()
+    }),
+  )
+  .command('completion', new Command()
     .description('Generate shell completion scripts')
     .arguments('[shell:string]')
     .option('--install', 'Install completion script automatically')
     .action(async (options: any, shell: any) => {
       const generator = new CompletionGenerator();
       await generator.generate(shell || 'detect', options.install === true);
-    }));
+    }),
+  );
 
 // Global error handler
 async function handleError(error: unknown, options?: any): Promise<void> {
@@ -179,7 +186,7 @@ function setupSignalHandlers(): void {
 }
 
 // Main entry point
-if (typeof require !== 'undefined' && require.main === module) {
+if (import.meta.main) {
   let globalOptions: any = {};
   
   try {
@@ -197,8 +204,7 @@ if (typeof require !== 'undefined' && require.main === module) {
     
     // Configure colors based on options
     if (globalOptions.noColor) {
-      // Disable colors if needed
-      process.env.NO_COLOR = '1';
+      colors.setColorEnabled(false);
     }
     
     await cli.parse(args);

package/src/cli/node-compat.js

@@ -3,13 +3,11 @@
  * This module provides Node.js equivalents for Deno-specific APIs
  */
 
-import { readdir, stat, mkdir, readFile, writeFile, unlink, rmdir, chmod } from 'fs/promises';
+import { readdir, stat, mkdir, readFile, writeFile, unlink, rmdir } from 'fs/promises';
 import { existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import process from 'process';
-import { spawn } from 'child_process';
-import { promisify } from 'util';
 
 // Process arguments (remove first two: node executable and script path)
 export const args = process.argv.slice(2);
@@ -66,11 +64,6 @@ export const mkdirAsync = async (path, options = {}) => {
   await mkdir(path, { recursive: options.recursive });
 };
 
-// File permissions (Node.js equivalent of Deno.chmod)
-export const chmodAsync = async (path, mode) => {
-  await chmod(path, mode);
-};
-
 // Process operations
 export const pid = process.pid;
 
@@ -137,65 +130,6 @@ export const build = {
   target: `${process.arch}-${process.platform}`
 };
 
-// Environment variables
-export const env = {
-  get: (key) => process.env[key],
-  set: (key, value) => process.env[key] = value,
-  delete: (key) => delete process.env[key],
-  toObject: () => ({ ...process.env })
-};
-
-// Command execution (Node.js equivalent of Deno.Command)
-export class Command {
-  constructor(command, options = {}) {
-    this.command = command;
-    this.options = options;
-  }
-  
-  async output() {
-    return new Promise((resolve) => {
-      const proc = spawn(this.command, this.options.args || [], {
-        cwd: this.options.cwd,
-        env: this.options.env || process.env,
-        stdio: this.options.stdout === 'inherit' ? 'inherit' : 'pipe'
-      });
-      
-      let stdout = '';
-      let stderr = '';
-      
-      if (proc.stdout) {
-        proc.stdout.on('data', (data) => {
-          stdout += data.toString();
-        });
-      }
-      
-      if (proc.stderr) {
-        proc.stderr.on('data', (data) => {
-          stderr += data.toString();
-        });
-      }
-      
-      proc.on('close', (code) => {
-        resolve({
-          success: code === 0,
-          code,
-          stdout,
-          stderr
-        });
-      });
-      
-      proc.on('error', (err) => {
-        resolve({
-          success: false,
-          code: -1,
-          stdout,
-          stderr: err.message
-        });
-      });
-    });
-  }
-}
-
 // Export a Deno-like object for easier migration
 export const Deno = {
   args,
@@ -206,14 +140,11 @@ export const Deno = {
   writeTextFile,
   remove,
   mkdir: mkdirAsync,
-  chmod: chmodAsync,
   pid,
   kill,
   exit,
   errors,
-  build,
-  env,
-  Command
+  build
 };
 
 export default Deno;

package/src/cli/node-repl.ts

@@ -385,11 +385,9 @@ export async function startNodeREPL(options: any = {}): Promise<void> {
   // Set up command completion
   completer.setCommands(commands);
   
-  // Set completer function (using custom implementation)
-  const originalCompleter = (rl as any).completer;
-  (rl as any).completer = (line: string) => {
-    const completions = completer.complete(line);
-    return [completions, line];
+  // Set completer function
+  rl.completer = (line: string) => {
+    return completer.complete(line);
   };
   
   // Show initial status

package/src/cli/repl.ts

@@ -59,7 +59,7 @@ class CommandHistory {
 
   private async loadHistory(): Promise<void> {
     try {
-      const content = await fs.readFile(this.historyFile, 'utf-8');
+      const content = await fs.readFile(this.historyFile);
       this.history = content.split('\n').filter((line: string) => line.trim());
     } catch {
       // History file doesn't exist yet
@@ -380,12 +380,10 @@ export async function startREPL(options: any = {}): Promise<void> {
   while (true) {
     try {
       const prompt = createPrompt(context);
-      const answers = await inquirer.prompt([{
-        type: 'input',
-        name: 'command',
+      const input = await Input.prompt({
         message: prompt,
-      }]);
-      const input = answers.command;
+        suggestions: (input: string) => completer.complete(input),
+      });
 
       if (!input.trim()) {
         continue;
@@ -497,10 +495,9 @@ function showHelp(commands: REPLCommand[]): void {
   console.log(chalk.white.bold('Available Commands:'));
   console.log();
   
-  const table = new Table({
-    head: ['Command', 'Aliases', 'Description'],
-    style: { border: [] }
-  });
+  const table = new Table()
+    .header(['Command', 'Aliases', 'Description'])
+    .border(false);
 
   for (const cmd of commands) {
     table.push([
@@ -646,9 +643,9 @@ async function showAgentList(): Promise<void> {
   console.log(chalk.cyan.bold(`Active Agents (${agents.length})`));
   console.log('─'.repeat(50));
   
-  const table = new Table({
-    head: ['ID', 'Name', 'Type', 'Status', 'Tasks']
-  });
+  const table = new Table()
+    .header(['ID', 'Name', 'Type', 'Status', 'Tasks'])
+    .border(true);
 
   for (const agent of agents) {
     const statusIcon = formatStatusIndicator(agent.status);
@@ -673,16 +670,10 @@ async function handleAgentSpawn(args: string[]): Promise<void> {
   }
 
   const type = args[0];
-  let name = args[1];
-  if (!name) {
-    const answers = await inquirer.prompt([{
-      type: 'input',
-      name: 'name',
-      message: 'Agent name:',
-      default: `${type}-agent`,
-    }]);
-    name = answers.name;
-  }
+  const name = args[1] || await Input.prompt({
+    message: 'Agent name:',
+    default: `${type}-agent`,
+  });
 
   console.log(chalk.yellow('Spawning agent...'));
   
@@ -697,13 +688,10 @@ async function handleAgentSpawn(args: string[]): Promise<void> {
 }
 
 async function handleAgentTerminate(agentId: string): Promise<void> {
-  const answers = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
+  const confirmed = await Confirm.prompt({
     message: `Terminate agent ${agentId}?`,
     default: false,
-  }]);
-  const confirmed = answers.confirmed;
+  });
   
   if (!confirmed) {
     console.log(chalk.gray('Termination cancelled'));
@@ -777,9 +765,9 @@ async function showTaskList(): Promise<void> {
   console.log(chalk.cyan.bold(`Tasks (${tasks.length})`));
   console.log('─'.repeat(60));
   
-  const table = new Table({
-    head: ['ID', 'Type', 'Description', 'Status', 'Agent']
-  });
+  const table = new Table()
+    .header(['ID', 'Type', 'Description', 'Status', 'Agent'])
+    .border(true);
 
   for (const task of tasks) {
     const statusIcon = formatStatusIndicator(task.status);
@@ -827,13 +815,10 @@ async function showTaskStatus(taskId: string): Promise<void> {
 }
 
 async function handleTaskCancel(taskId: string): Promise<void> {
-  const answers = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
+  const confirmed = await Confirm.prompt({
     message: `Cancel task ${taskId}?`,
     default: false,
-  }]);
-  const confirmed = answers.confirmed;
+  });
   
   if (!confirmed) {
     console.log(chalk.gray('Cancellation cancelled'));
@@ -917,9 +902,9 @@ async function showSessionList(): Promise<void> {
   console.log(chalk.cyan.bold(`Saved Sessions (${sessions.length})`));
   console.log('─'.repeat(50));
   
-  const table = new Table({
-    head: ['ID', 'Name', 'Date', 'Agents', 'Tasks']
-  });
+  const table = new Table()
+    .header(['ID', 'Name', 'Date', 'Agents', 'Tasks'])
+    .border(true);
 
   for (const session of sessions) {
     table.push([
@@ -935,16 +920,10 @@ async function showSessionList(): Promise<void> {
 }
 
 async function handleSessionSave(args: string[]): Promise<void> {
-  let name = args.length > 0 ? args.join(' ') : '';
-  if (!name) {
-    const answers = await inquirer.prompt([{
-      type: 'input',
-      name: 'name',
-      message: 'Session name:',
-      default: `session-${new Date().toISOString().split('T')[0]}`,
-    }]);
-    name = answers.name;
-  }
+  const name = args.length > 0 ? args.join(' ') : await Input.prompt({
+    message: 'Session name:',
+    default: `session-${new Date().toISOString().split('T')[0]}`,
+  });
   
   console.log(chalk.yellow('Saving session...'));
   await new Promise(resolve => setTimeout(resolve, 1000));
@@ -956,13 +935,10 @@ async function handleSessionSave(args: string[]): Promise<void> {
 }
 
 async function handleSessionRestore(sessionId: string): Promise<void> {
-  const answers = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
+  const confirmed = await Confirm.prompt({
     message: `Restore session ${sessionId}?`,
     default: false,
-  }]);
-  const confirmed = answers.confirmed;
+  });
   
   if (!confirmed) {
     console.log(chalk.gray('Restore cancelled'));
@@ -1019,9 +995,9 @@ async function showWorkflowList(): Promise<void> {
   console.log(chalk.cyan.bold(`Workflows (${workflows.length})`));
   console.log('─'.repeat(50));
   
-  const table = new Table({
-    head: ['ID', 'Name', 'Status', 'Progress']
-  });
+  const table = new Table()
+    .header(['ID', 'Name', 'Status', 'Progress'])
+    .border(true);
 
   for (const workflow of workflows) {
     const statusIcon = formatStatusIndicator(workflow.status);

package/src/cli/simple-cli.ts

@@ -1,76 +1,19 @@
 #!/usr/bin/env -S deno run --allow-all
 import { getErrorMessage } from '../utils/error-handler.js';
-
-// Type declarations for Deno runtime
-declare const Deno: {
-  args: string[];
-  exit: (code?: number) => never;
-  env: {
-    get: (key: string) => string | undefined;
-    set: (key: string, value: string) => void;
-    toObject: () => Record<string, string>;
-  };
-  stdout: {
-    write: (data: Uint8Array) => Promise<number>;
-  };
-  [key: string]: any;
-};
 /**
  * Simple CLI wrapper for Claude-Flow (JavaScript version)
  * This version avoids TypeScript issues in node_modules
  */
 
 import { promises as fs } from 'node:fs';
-// Import with any type to avoid module resolution issues
-const commandRegistryModule = require('./command-registry.js');
-const executeCommand = commandRegistryModule.executeCommand;
-const hasCommand = commandRegistryModule.hasCommand;
-const showCommandHelp = commandRegistryModule.showCommandHelp;
-const showAllCommands = commandRegistryModule.showAllCommands;
-const listCommands = commandRegistryModule.listCommands;
-
-// Type definitions for external modules
-interface CommandRegistry {
-  executeCommand: (command: string, args: string[]) => Promise<void>;
-  hasCommand: (command: string) => boolean;
-  showCommandHelp: (command: string) => void;
-  showAllCommands: () => void;
-  listCommands: () => string[];
-}
-
-interface Utils {
-  parseFlags: (args: string[]) => Record<string, any>;
-}
-
-// Type assertions to avoid TS7016 errors
-const commandRegistry = {
-  executeCommand: executeCommand as (command: string, args: string[]) => Promise<void>,
-  hasCommand: hasCommand as (command: string) => boolean,
-  showCommandHelp: showCommandHelp as (command: string) => void,
-  showAllCommands: showAllCommands as () => void,
-  listCommands: listCommands as () => string[]
-};
-// Import with any type to avoid module resolution issues
-const utilsModule = require('./utils.js');
-const parseFlags = utilsModule.parseFlags;
-
-// Type assertion for parseFlags
-const typedParseFlags = parseFlags as (args: string[]) => Record<string, any>;
-
-// Type definitions for command flags
-interface CommandFlags {
-  tools?: string;
-  noPermissions?: boolean;
-  config?: string;
-  mode?: string;
-  parallel?: boolean;
-  research?: boolean;
-  coverage?: number;
-  commit?: string;
-  verbose?: boolean;
-  dryRun?: boolean;
-  [key: string]: any;
-}
+import { 
+  executeCommand, 
+  hasCommand, 
+  showCommandHelp, 
+  showAllCommands,
+  listCommands 
+} from './command-registry.js';
+import { parseFlags } from './utils.js';
 
 const VERSION = '2.0.0';
 
@@ -426,7 +369,7 @@ async function main() {
           
         case 'batch-exec':
           // Batch command execution
-          const batchSession = subArgs.find((arg: string) => !arg.startsWith('--'));
+          const batchSession = subArgs.find(arg => !arg.startsWith('--'));
           const commandsFlag = subArgs.indexOf('--commands');
           const fileFlag = subArgs.indexOf('--file');
           
@@ -512,7 +455,7 @@ async function main() {
           
         case 'cleanup':
           // Cleanup idle terminals
-          const idleTime = subArgs.find((arg: string) => arg.includes('--idle-longer-than'));
+          const idleTime = subArgs.find(arg => arg.includes('--idle-longer-than'));
           printSuccess('Cleaning up idle terminals...');
           console.log('🧹 Scanning for idle sessions');
           if (idleTime) {
@@ -563,7 +506,7 @@ async function main() {
         case 'share':
           // Share terminal session
           const shareId = subArgs[1];
-          const accessLevel = subArgs.find((arg: string) => arg.includes('--access-level'));
+          const accessLevel = subArgs.find(arg => arg.includes('--access-level'));
           if (shareId) {
             printSuccess(`Sharing terminal session: ${shareId}`);
             console.log(`🔗 Share URL: https://claude-flow.local/terminal/${shareId}/view`);
@@ -578,7 +521,7 @@ async function main() {
           // Multi-terminal configuration
           const multiCmd = subArgs[1];
           if (multiCmd === 'create') {
-            const configName = subArgs.find((arg: string) => !arg.startsWith('--'));
+            const configName = subArgs.find(arg => !arg.startsWith('--'));
             printSuccess(`Creating multi-terminal configuration: ${configName || 'default'}`);
             console.log('📋 Configuration template created');
           } else {
@@ -603,7 +546,7 @@ async function main() {
           
         case 'batch-create':
           // Batch create terminals
-          const configFile = subArgs.find((arg: string) => arg.includes('--config'));
+          const configFile = subArgs.find(arg => arg.includes('--config'));
           printSuccess('Creating multiple terminal sessions...');
           if (configFile) {
             console.log(`📄 Loading config from: ${configFile.split('=')[1]}`);
@@ -1250,7 +1193,7 @@ async function main() {
           }
           
           // Parse flags
-          const flags: CommandFlags = {};
+          const flags = {};
           for (let i = taskEndIndex; i < subArgs.length; i++) {
             const arg = subArgs[i];
             if (arg === '--tools' || arg === '-t') {
@@ -1513,9 +1456,9 @@ ${flags.mode === 'full' || !flags.mode ? `Full-stack development covering all as
       const deployCmd = subArgs[0];
       switch (deployCmd) {
         case 'ha-cluster':
-          const nodes = subArgs.find((arg: string) => arg.includes('--nodes'));
-          const regions = subArgs.find((arg: string) => arg.includes('--regions'));
-          const replicationFactor = subArgs.find((arg: string) => arg.includes('--replication-factor'));
+          const nodes = subArgs.find(arg => arg.includes('--nodes'));
+          const regions = subArgs.find(arg => arg.includes('--regions'));
+          const replicationFactor = subArgs.find(arg => arg.includes('--replication-factor'));
           
           printSuccess('Deploying High Availability Cluster...');
           console.log('🏗️  HA Configuration:');
@@ -2092,19 +2035,19 @@ async function startRepl() {
   console.log('Type "help" for available commands, "exit" to quit\n');
   
   const replState = {
-    history: [] as string[],
+    history: [],
     historyIndex: -1,
-    currentSession: null as string | null,
+    currentSession: null,
     context: {
-      agents: [] as any[],
-      tasks: [] as any[],
-      terminals: [] as any[],
-      memory: {} as Record<string, any>
+      agents: [],
+      tasks: [],
+      terminals: [],
+      memory: {}
     }
   };
   
   // REPL command handlers
-  const replCommands: Record<string, (...args: string[]) => Promise<void> | void> = {
+  const replCommands = {
     help: () => {
       console.log(`
 📚 Available REPL Commands:
@@ -2169,7 +2112,7 @@ Shortcuts:
     
     config: async (key: string) => {
       try {
-        const config = JSON.parse(await fs.readFile('claude-flow.config.json', 'utf8'));
+        const config = JSON.parse(await fs.readFile('claude-flow.config.json'));
         if (key) {
           const keys = key.split('.');
           let value = config;
@@ -3286,7 +3229,6 @@ For more information about SPARC methodology, see: https://github.com/ruvnet/cla
 `;
 }
 
-// Check if this is the main module being executed
-if (typeof require !== 'undefined' && require.main === module) {
-  main().catch(console.error);
+if (import.meta.main) {
+  await main();
 }

package/src/cli/simple-commands/hive-mind/core.js

@@ -348,7 +348,9 @@ export class HiveMindCore extends EventEmitter {
    * Create and distribute task with performance optimization
    */
   async createTask(description, priority = 5, metadata = {}) {
-    const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const timestamp = Date.now();
+    const randomPart = Math.random().toString(36).substring(2, 11); // Use substring instead of substr
+    const taskId = `task-${timestamp}-${randomPart}`;
     const createdAt = Date.now();
     
     const task = {

package/src/cli/simple-commands/hive-mind/mcp-wrapper.js

@@ -69,6 +69,9 @@ export class MCPToolWrapper {
     this.parallelQueue = [];
     this.executing = false;
     
+    /** @type {import('better-sqlite3').Database | null} */
+    this.memoryDb = null;
+    
     // Initialize real memory storage
     this.initializeMemoryStorage();
   }
@@ -365,7 +368,7 @@ export class MCPToolWrapper {
         status: 'initialized'
       },
       agent_spawn: {
-        agentId: `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        agentId: `agent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
         type: params.type,
         status: 'active'
       },