claude-flow 2.0.0-alpha.99 → 2.0.1

package/src/cli/commands/index.ts

@@ -15,6 +15,7 @@ import { SimpleMemoryManager } from './memory.js';
 import { sparcAction } from './sparc.js';
 import { createMigrateCommand } from './migrate.js';
 import { enterpriseCommands } from './enterprise.js';
+import { createFlowNexusClaudeMd } from '../simple-commands/init/templates/claude-md.js';
 
 // Import enhanced orchestration commands
 import { startCommand } from './start.js';
@@ -70,6 +71,11 @@ export function setupCommands(cli: CLI): void {
         description: 'Create minimal configuration files',
         type: 'boolean',
       },
+      {
+        name: 'flow-nexus',
+        description: 'Initialize with Flow Nexus commands, agents, and CLAUDE.md only',
+        type: 'boolean',
+      },
     ],
     action: async (ctx: CommandContext) => {
       try {
@@ -77,8 +83,33 @@ export function setupCommands(cli: CLI): void {
 
         const force = (ctx.flags.force as boolean) || (ctx.flags.f as boolean);
         const minimal = (ctx.flags.minimal as boolean) || (ctx.flags.m as boolean);
+        const flowNexus = ctx.flags['flow-nexus'] as boolean;
+
+        // Handle Flow Nexus minimal init
+        if (flowNexus) {
+          success('Initializing Flow Nexus minimal setup...');
+          
+          // Create Flow Nexus CLAUDE.md with integrated section
+          const flowNexusClaudeMd = createFlowNexusClaudeMd();
+          const { writeFile, mkdir } = await import('fs/promises');
+          await writeFile('CLAUDE.md', flowNexusClaudeMd);
+          console.log('  ✓ Created CLAUDE.md with Flow Nexus integration');
+          
+          // Create .claude/commands/flow-nexus directory and copy commands
+          await mkdir('.claude/commands/flow-nexus', { recursive: true });
+          
+          // Create .claude/agents/flow-nexus directory and copy agents
+          await mkdir('.claude/agents/flow-nexus', { recursive: true });
+          
+          success('Flow Nexus initialization complete!');
+          console.log('📚 Created: CLAUDE.md with Flow Nexus documentation');
+          console.log('📁 Created: .claude/commands/flow-nexus/ directory structure');  
+          console.log('🤖 Created: .claude/agents/flow-nexus/ directory structure');
+          console.log('💡 Use MCP Flow Nexus tools in Claude Code for full functionality');
+          return;
+        }
 
-        // Check if files already exist
+        // Check if files already exist for full init
         const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
         const existingFiles = [];
 
@@ -2481,6 +2512,7 @@ This is a Claude-Flow AI agent orchestration system.
 `;
 }
 
+
 function createFullClaudeMd(): string {
   return `# Claude Code Configuration
 
@@ -2531,6 +2563,7 @@ This is a Claude-Flow AI agent orchestration system with the following component
 `;
 }
 
+
 function createMinimalMemoryBankMd(): string {
   return `# Memory Bank
 
@@ -2545,6 +2578,7 @@ function createMinimalMemoryBankMd(): string {
 `;
 }
 
+
 function createFullMemoryBankMd(): string {
   return `# Memory Bank Configuration
 
@@ -2607,6 +2641,7 @@ Memory settings are configured in \`claude-flow.config.json\`:
 `;
 }
 
+
 function createMinimalCoordinationMd(): string {
   return `# Agent Coordination
 
@@ -2620,6 +2655,7 @@ function createMinimalCoordinationMd(): string {
 `;
 }
 
+
 function createFullCoordinationMd(): string {
   return `# Agent Coordination System
 
@@ -2712,6 +2748,7 @@ Coordination settings in \`claude-flow.config.json\`:
 `;
 }
 
+
 function createAgentsReadme(): string {
   return `# Agent Memory Storage
 
@@ -2747,6 +2784,7 @@ ${new Date().toISOString()}
 `;
 }
 
+
 function createSessionsReadme(): string {
   return `# Session Memory Storage
 
@@ -2782,3 +2820,4 @@ memory/sessions/
 ${new Date().toISOString()}
 `;
 }
+

package/src/cli/simple-commands/hive-mind/session-manager.js

@@ -983,6 +983,12 @@ To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/wind
       return true;
     }
     
+    // Check if database connection is still open before operations
+    if (!this.db || !this.db.open) {
+      console.warn('Database connection closed, cannot remove child PID during cleanup');
+      return false;
+    }
+    
     const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
     if (!session) return false;
 
@@ -1016,6 +1022,12 @@ To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/wind
       if (!session || !session.child_pids) return [];
       return sessionSerializer.deserializeLogData(session.child_pids);
     } else {
+      // Check if database connection is still open
+      if (!this.db || !this.db.open) {
+        console.warn('Database connection closed, cannot get child PIDs during cleanup');
+        return [];
+      }
+      
       // Use SQLite
       const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
       if (!session || !session.child_pids) return [];

package/src/cli/simple-commands/init/agent-copier.js

@@ -162,7 +162,10 @@ export async function createAgentDirectories(targetDir, dryRun = false) {
     '.claude/agents/documentation',
     '.claude/agents/documentation/api-docs',
     '.claude/agents/specialized',
-    '.claude/agents/specialized/mobile'
+    '.claude/agents/specialized/mobile',
+    '.claude/agents/flow-nexus',
+    '.claude/commands',
+    '.claude/commands/flow-nexus'
   ];
   
   if (dryRun) {
@@ -180,6 +183,131 @@ export async function createAgentDirectories(targetDir, dryRun = false) {
 /**
  * Validate agent system after copying
  */
+/**
+ * Copy all command files from the installed package to project directory
+ */
+export async function copyCommandFiles(targetDir, options = {}) {
+  const { force = false, dryRun = false } = options;
+  
+  // Path to command files - try multiple locations
+  const packageCommandsDir = join(__dirname, '../../../../.claude/commands'); // From npm package
+  const localCommandsDir = '/workspaces/claude-code-flow/.claude/commands';   // Local development
+  const cwdCommandsDir = join(process.cwd(), '.claude/commands');              // Current working directory
+  
+  let sourceCommandsDir;
+  
+  // Try local development first, then package, then cwd
+  try {
+    await fs.access(localCommandsDir);
+    sourceCommandsDir = localCommandsDir;
+    console.log('  📁 Using local development command files');
+  } catch {
+    try {
+      await fs.access(packageCommandsDir);
+      sourceCommandsDir = packageCommandsDir;
+      console.log('  📁 Using packaged command files');
+    } catch {
+      try {
+        await fs.access(cwdCommandsDir);
+        sourceCommandsDir = cwdCommandsDir;
+        console.log('  📁 Using current directory command files');
+      } catch {
+        console.log('  ⚠️  No command files found in any location');
+        return { success: false, error: 'Command files not found' };
+      }
+    }
+  }
+  
+  const targetCommandsDir = join(targetDir, '.claude/commands');
+  
+  console.log('📁 Copying command system files...');
+  console.log(`  📂 Source: ${sourceCommandsDir}`);
+  console.log(`  📂 Target: ${targetCommandsDir}`);
+  
+  try {
+    // Create target directory
+    if (!dryRun) {
+      await fs.mkdir(targetCommandsDir, { recursive: true });
+    }
+    
+    const copiedFiles = [];
+    const errors = [];
+    
+    // Recursively copy all command files
+    async function copyRecursive(srcDir, destDir) {
+      const items = await fs.readdir(srcDir, { withFileTypes: true });
+      
+      for (const item of items) {
+        const srcPath = join(srcDir, item.name);
+        const destPath = join(destDir, item.name);
+        
+        if (item.isDirectory()) {
+          if (!dryRun) {
+            await fs.mkdir(destPath, { recursive: true });
+          }
+          await copyRecursive(srcPath, destPath);
+        } else if (item.isFile() && item.name.endsWith('.md')) {
+          try {
+            // Check if file already exists
+            let shouldCopy = force;
+            if (!force) {
+              try {
+                await fs.access(destPath);
+                // File exists, skip unless force is true
+                continue;
+              } catch {
+                // File doesn't exist, safe to copy
+                shouldCopy = true;
+              }
+            }
+            
+            if (shouldCopy && !dryRun) {
+              const content = await fs.readFile(srcPath, 'utf8');
+              await fs.writeFile(destPath, content, 'utf8');
+              copiedFiles.push(destPath.replace(targetDir + '/', ''));
+            } else if (dryRun) {
+              copiedFiles.push(destPath.replace(targetDir + '/', ''));
+            }
+          } catch (err) {
+            errors.push(`Failed to copy ${item.name}: ${err.message}`);
+          }
+        }
+      }
+    }
+    
+    await copyRecursive(sourceCommandsDir, targetCommandsDir);
+    
+    if (!dryRun && copiedFiles.length > 0) {
+      console.log(`  ✅ Copied ${copiedFiles.length} command files`);
+      console.log('  📋 Command system initialized with comprehensive documentation');
+      console.log('  🎯 Available categories: Analysis, Automation, GitHub, Hooks, Memory, Flow Nexus');
+    } else if (dryRun) {
+      console.log(`  [DRY RUN] Would copy ${copiedFiles.length} command files`);
+    }
+    
+    if (errors.length > 0) {
+      console.log('  ⚠️  Some command files could not be copied:');
+      errors.forEach(error => console.log(`    - ${error}`));
+    }
+    
+    return {
+      success: true,
+      copiedFiles,
+      errors,
+      totalCommands: copiedFiles.length
+    };
+    
+  } catch (err) {
+    console.log(`  ❌ Failed to copy command files: ${err.message}`);
+    return {
+      success: false,
+      error: err.message,
+      copiedFiles: [],
+      errors: [err.message]
+    };
+  }
+}
+
 export async function validateAgentSystem(targetDir) {
   const agentsDir = join(targetDir, '.claude/agents');
   

package/src/cli/simple-commands/init/index.js

@@ -41,7 +41,7 @@ import { createOptimizedClaudeSlashCommands } from './claude-commands/optimized-
 import { promises as fs } from 'fs';
 import { copyTemplates } from './template-copier.js';
 import { copyRevisedTemplates, validateTemplatesExist } from './copy-revised-templates.js';
-import { copyAgentFiles, createAgentDirectories, validateAgentSystem } from './agent-copier.js';
+import { copyAgentFiles, createAgentDirectories, validateAgentSystem, copyCommandFiles } from './agent-copier.js';
 import { showInitHelp } from './help.js';
 import { batchInitCommand, batchInitFromConfig, validateBatchOptions } from './batch-init.js';
 import { ValidationSystem, runFullValidation } from './validation/index.js';
@@ -110,6 +110,11 @@ async function setupMcpServers(dryRun = false) {
       command: 'npx ruv-swarm mcp start',
       description: 'ruv-swarm MCP server for enhanced coordination',
     },
+    {
+      name: 'flow-nexus',
+      command: 'npx flow-nexus@latest mcp start',
+      description: 'Flow Nexus Complete MCP server for advanced AI orchestration',
+    },
   ];
 
   for (const server of servers) {
@@ -150,6 +155,11 @@ export async function initCommand(subArgs, flags) {
   const hasVerificationFlags = subArgs.includes('--verify') || subArgs.includes('--pair') || 
                                flags.verify || flags.pair;
   
+  // Handle Flow Nexus minimal init
+  if (flags['flow-nexus']) {
+    return await flowNexusMinimalInit(flags, subArgs);
+  }
+
   // Default to enhanced Claude Flow v2 init unless other modes are specified
   // Use --basic flag for old behavior, or verification flags for verification mode
   if (!flags.basic && !flags.minimal && !flags.sparc && !hasVerificationFlags) {
@@ -529,6 +539,7 @@ export async function initCommand(subArgs, flags) {
         console.log('  📋 Then add MCP servers manually with:');
         console.log('     claude mcp add claude-flow claude-flow mcp start');
         console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
+        console.log('     claude mcp add flow-nexus npx flow-nexus@latest mcp start');
       }
     }
   } catch (err) {
@@ -1437,6 +1448,7 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
         console.log('\n  📋 To add MCP servers manually:');
         console.log('     claude mcp add claude-flow npx claude-flow@alpha mcp start');
         console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+        console.log('     claude mcp add flow-nexus npx flow-nexus@latest mcp start');
         console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
       }
     } else if (!dryRun && !isClaudeCodeInstalled()) {
@@ -1446,6 +1458,7 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
       console.log('\n  📋 After installing, add MCP servers:');
       console.log('     claude mcp add claude-flow npx claude-flow@alpha mcp start');
       console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+      console.log('     claude mcp add flow-nexus npx flow-nexus@latest mcp start');
       console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
     }
 
@@ -1460,6 +1473,20 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
       
       if (agentResult.success) {
         await validateAgentSystem(workingDir);
+        
+        // Copy command files including Flow Nexus commands
+        console.log('\n📚 Setting up command system...');
+        const commandResult = await copyCommandFiles(workingDir, {
+          force: force,
+          dryRun: dryRun
+        });
+        
+        if (commandResult.success) {
+          console.log('✅ ✓ Command system setup complete with Flow Nexus integration');
+        } else {
+          console.log('⚠️  Command system setup failed:', commandResult.error);
+        }
+        
         console.log('✅ ✓ Agent system setup complete with 64 specialized agents');
       } else {
         console.log('⚠️  Agent system setup failed:', agentResult.error);
@@ -1531,3 +1558,91 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
     }
   }
 }
+
+/**
+ * Flow Nexus minimal initialization - only creates Flow Nexus CLAUDE.md, commands, and agents
+ */
+async function flowNexusMinimalInit(flags, subArgs) {
+  console.log('🌐 Flow Nexus: Initializing minimal setup...');
+  
+  try {
+    const force = flags.force || flags.f;
+    
+    // Import functions we need
+    const { createFlowNexusClaudeMd } = await import('./templates/claude-md.js');
+    const { promises: fs } = await import('fs');
+    
+    // Create Flow Nexus CLAUDE.md
+    console.log('📝 Creating Flow Nexus CLAUDE.md...');
+    const flowNexusClaudeMd = createFlowNexusClaudeMd();
+    await fs.writeFile('CLAUDE.md', flowNexusClaudeMd);
+    console.log('  ✅ Created CLAUDE.md with Flow Nexus integration');
+    
+    // Create .claude/commands/flow-nexus directory and copy commands
+    console.log('📁 Setting up Flow Nexus commands...');
+    await fs.mkdir('.claude/commands/flow-nexus', { recursive: true });
+    
+    // Copy Flow Nexus command files
+    const sourceCommandsDir = '/workspaces/claude-code-flow/.claude/commands/flow-nexus';
+    try {
+      const commandFiles = await fs.readdir(sourceCommandsDir);
+      let copiedCommands = 0;
+      
+      for (const file of commandFiles) {
+        if (file.endsWith('.md')) {
+          const sourcePath = `${sourceCommandsDir}/${file}`;
+          const destPath = `.claude/commands/flow-nexus/${file}`;
+          const content = await fs.readFile(sourcePath, 'utf8');
+          await fs.writeFile(destPath, content);
+          copiedCommands++;
+        }
+      }
+      
+      console.log(`  ✅ Copied ${copiedCommands} Flow Nexus command files`);
+    } catch (err) {
+      console.log('  ⚠️  Could not copy Flow Nexus commands:', err.message);
+    }
+    
+    // Create .claude/agents/flow-nexus directory and copy agents
+    console.log('🤖 Setting up Flow Nexus agents...');
+    await fs.mkdir('.claude/agents/flow-nexus', { recursive: true });
+    
+    // Copy Flow Nexus agent files
+    const sourceAgentsDir = '/workspaces/claude-code-flow/.claude/agents/flow-nexus';
+    try {
+      const agentFiles = await fs.readdir(sourceAgentsDir);
+      let copiedAgents = 0;
+      
+      for (const file of agentFiles) {
+        if (file.endsWith('.md')) {
+          const sourcePath = `${sourceAgentsDir}/${file}`;
+          const destPath = `.claude/agents/flow-nexus/${file}`;
+          const content = await fs.readFile(sourcePath, 'utf8');
+          await fs.writeFile(destPath, content);
+          copiedAgents++;
+        }
+      }
+      
+      console.log(`  ✅ Copied ${copiedAgents} Flow Nexus agent files`);
+    } catch (err) {
+      console.log('  ⚠️  Could not copy Flow Nexus agents:', err.message);
+    }
+    
+    console.log('\n🎉 Flow Nexus minimal initialization complete!');
+    console.log('📚 Created: CLAUDE.md with Flow Nexus documentation');
+    console.log('📁 Created: .claude/commands/flow-nexus/ directory with command documentation');
+    console.log('🤖 Created: .claude/agents/flow-nexus/ directory with specialized agents');
+    console.log('');
+    console.log('💡 Quick Start:');
+    console.log('  1. Register: mcp__flow-nexus__user_register({ email, password })');
+    console.log('  2. Login: mcp__flow-nexus__user_login({ email, password })');
+    console.log('  3. Deploy: mcp__flow-nexus__swarm_init({ topology: "mesh", maxAgents: 5 })');
+    console.log('');
+    console.log('🔗 Use Flow Nexus MCP tools in Claude Code for full functionality');
+    
+  } catch (err) {
+    console.log(`❌ Flow Nexus initialization failed: ${err.message}`);
+    console.log('Stack trace:', err.stack);
+    process.exit(1);
+  }
+}