claude-flow 1.0.6 → 1.0.8

package/bin/claude-flow-node.js

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+/**
+ * Pure Node.js CLI for Claude-Flow
+ * This version works without Deno dependency
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { spawn } = require('child_process');
+const os = require('os');
+
+const VERSION = '1.0.0';
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+function success(msg) {
+  console.log(`${colors.green}✅ ${msg}${colors.reset}`);
+}
+
+function error(msg) {
+  console.log(`${colors.red}❌ ${msg}${colors.reset}`);
+}
+
+function warning(msg) {
+  console.log(`${colors.yellow}⚠️  ${msg}${colors.reset}`);
+}
+
+function info(msg) {
+  console.log(`${colors.blue}ℹ️  ${msg}${colors.reset}`);
+}
+
+// Check if Deno is available
+function checkDeno() {
+  return new Promise((resolve) => {
+    const deno = spawn('deno', ['--version'], { stdio: 'pipe' });
+    deno.on('close', (code) => {
+      resolve(code === 0);
+    });
+    deno.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+// Install Deno if not available
+async function installDeno() {
+  console.log('Deno not found. Installing Deno...');
+  
+  const platform = os.platform();
+  
+  if (platform === 'win32') {
+    console.log('Please install Deno manually from https://deno.land/');
+    process.exit(1);
+  }
+  
+  return new Promise((resolve, reject) => {
+    const installScript = spawn('curl', ['-fsSL', 'https://deno.land/x/install/install.sh'], { stdio: 'pipe' });
+    const sh = spawn('sh', [], { stdio: ['pipe', 'inherit', 'inherit'] });
+    
+    installScript.stdout.pipe(sh.stdin);
+    
+    sh.on('close', (code) => {
+      if (code === 0) {
+        success('Deno installed successfully!');
+        console.log('Please restart your terminal or run: export PATH="$HOME/.deno/bin:$PATH"');
+        resolve();
+      } else {
+        reject(new Error('Failed to install Deno'));
+      }
+    });
+  });
+}
+
+// Handle commands that require Deno
+async function handleDenoCommand(command, args) {
+  try {
+    const denoAvailable = await checkDeno();
+    
+    if (!denoAvailable) {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      warning(`The '${command}' command requires Deno to be installed.`);
+      console.log('Would you like to install Deno automatically? (y/n)');
+      
+      const answer = await new Promise((resolve) => {
+        rl.question('', (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase());
+        });
+      });
+      
+      if (answer === 'y' || answer === 'yes') {
+        await installDeno();
+        console.log('\nNow you can run the command again after restarting your terminal or running:');
+        console.log('export PATH="$HOME/.deno/bin:$PATH"');
+        console.log(`\nThen: npx claude-flow ${command} ${args.join(' ')}`);
+      } else {
+        console.log('Please install Deno manually from https://deno.land/ and run:');
+        console.log(`  deno run --allow-all src/cli/index.ts ${command} ${args.join(' ')}`);
+      }
+    } else {
+      console.log(`Running: deno run --allow-all src/cli/index.ts ${command} ${args.join(' ')}`);
+      console.log('Note: Make sure you\'re in the claude-flow project directory');
+    }
+  } catch (error) {
+    error(`Failed to handle Deno command: ${error.message}`);
+  }
+}
+
+function printHelp() {
+  console.log(`
+${colors.blue}🧠 Claude-Flow v${VERSION}${colors.reset} - Advanced AI Agent Orchestration System
+
+USAGE:
+  claude-flow [COMMAND] [OPTIONS]
+
+COMMANDS:
+  ${colors.cyan}init${colors.reset}                  Initialize Claude Code integration files
+  ${colors.cyan}start${colors.reset}                 Start the orchestration system
+  ${colors.cyan}agent${colors.reset}                 Manage agents (spawn, list, terminate, info)
+  ${colors.cyan}task${colors.reset}                  Manage tasks (create, list, status, cancel, workflow)
+  ${colors.cyan}memory${colors.reset}                Manage memory (query, export, import, stats, cleanup)
+  ${colors.cyan}config${colors.reset}                Manage configuration (show, get, set, init, validate)
+  ${colors.cyan}status${colors.reset}                Show system status
+  ${colors.cyan}monitor${colors.reset}               Monitor system in real-time
+  ${colors.cyan}mcp${colors.reset}                   MCP server management (status, tools, config, logs)
+  ${colors.cyan}claude${colors.reset}                Spawn Claude instances with specific configurations
+  ${colors.cyan}session${colors.reset}               Manage terminal sessions
+  ${colors.cyan}workflow${colors.reset}              Execute workflow files
+  ${colors.cyan}version${colors.reset}               Show version information
+  ${colors.cyan}help${colors.reset}                  Show this help message
+
+GLOBAL OPTIONS:
+  -c, --config <path>   Path to configuration file
+  -v, --verbose         Enable verbose logging
+  --log-level <level>   Set log level (debug, info, warn, error)
+  --help               Show help for specific command
+
+EXAMPLES:
+  claude-flow init                                    # Initialize project
+  claude-flow start                                   # Start orchestrator (auto-installs Deno)
+  claude-flow agent spawn researcher --name "Bot"     # Spawn research agent
+  claude-flow task create research "Analyze data"     # Create task
+  claude-flow status                                  # Show system status
+
+NOTE: Commands requiring Deno will offer automatic installation
+
+Documentation: https://github.com/ruvnet/claude-code-flow
+`);
+}
+
+async function executeInit(args) {
+  const force = args.includes('-f') || args.includes('--force');
+  const minimal = args.includes('-m') || args.includes('--minimal');
+  
+  success('Initializing Claude Code integration files...');
+  
+  try {
+    // Check if files already exist
+    const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
+    const existingFiles = [];
+    
+    for (const file of files) {
+      try {
+        await fs.access(file);
+        existingFiles.push(file);
+      } catch {
+        // File doesn't exist, which is fine
+      }
+    }
+    
+    if (existingFiles.length > 0 && !force) {
+      warning(`The following files already exist: ${existingFiles.join(', ')}`);
+      console.log('Use --force to overwrite existing files');
+      return;
+    }
+    
+    // Create CLAUDE.md
+    const claudeMd = minimal ? createMinimalClaudeMd() : createFullClaudeMd();
+    await fs.writeFile('CLAUDE.md', claudeMd);
+    console.log('  ✓ Created CLAUDE.md');
+    
+    // Create memory-bank.md
+    const memoryBankMd = minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
+    await fs.writeFile('memory-bank.md', memoryBankMd);
+    console.log('  ✓ Created memory-bank.md');
+    
+    // Create coordination.md
+    const coordinationMd = minimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
+    await fs.writeFile('coordination.md', coordinationMd);
+    console.log('  ✓ Created coordination.md');
+    
+    // Create directory structure
+    const directories = [
+      'memory',
+      'memory/agents',
+      'memory/sessions',
+      'coordination',
+      'coordination/memory_bank',
+      'coordination/subtasks',
+      'coordination/orchestration'
+    ];
+    
+    for (const dir of directories) {
+      try {
+        await fs.mkdir(dir, { recursive: true });
+        console.log(`  ✓ Created ${dir}/ directory`);
+      } catch (err) {
+        if (err.code !== 'EEXIST') {
+          throw err;
+        }
+      }
+    }
+    
+    // Create placeholder files
+    const agentsReadme = createAgentsReadme();
+    await fs.writeFile('memory/agents/README.md', agentsReadme);
+    console.log('  ✓ Created memory/agents/README.md');
+    
+    const sessionsReadme = createSessionsReadme();
+    await fs.writeFile('memory/sessions/README.md', sessionsReadme);
+    console.log('  ✓ Created memory/sessions/README.md');
+    
+    // Initialize persistence database
+    const initialData = {
+      agents: [],
+      tasks: [],
+      lastUpdated: Date.now()
+    };
+    await fs.writeFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
+    console.log('  ✓ Created memory/claude-flow-data.json (persistence database)');
+    
+    success('Claude Code integration files initialized successfully!');
+    console.log('\nNext steps:');
+    console.log('1. Review and customize the generated files for your project');
+    console.log('2. Run \'npx claude-flow start\' to begin the orchestration system');
+    console.log('3. Use \'claude --dangerously-skip-permissions\' for unattended operation');
+    
+  } catch (err) {
+    error(`Failed to initialize files: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function executeStatus() {
+  try {
+    // Check if persistence file exists
+    let data;
+    try {
+      const content = await fs.readFile('memory/claude-flow-data.json', 'utf8');
+      data = JSON.parse(content);
+    } catch {
+      data = { agents: [], tasks: [] };
+    }
+    
+    // Check if orchestrator is running (simplified check)
+    let isRunning = false;
+    try {
+      await fs.access('orchestrator.log');
+      isRunning = true;
+    } catch {
+      // Log file doesn't exist, orchestrator not running
+    }
+    
+    const activeAgents = data.agents.filter(a => a.status === 'active').length;
+    const totalAgents = data.agents.length;
+    const pendingTasks = data.tasks.filter(t => t.status === 'pending' || t.status === 'assigned').length;
+    const totalTasks = data.tasks.length;
+    const completedTasks = data.tasks.filter(t => t.status === 'completed').length;
+    
+    success('Claude-Flow System Status:');
+    console.log(`🟢 Status: ${isRunning ? 'Running' : 'Stopped'}`);
+    console.log(`🤖 Agents: ${activeAgents} active (${totalAgents} total)`);
+    console.log(`📋 Tasks: ${pendingTasks} in queue (${totalTasks} total)`);
+    console.log(`✅ Completed: ${completedTasks} tasks`);
+    console.log(`💾 Memory: Ready`);
+    console.log(`🖥️  Terminal Pool: Ready`);
+    console.log(`🌐 MCP Server: ${isRunning ? 'Running' : 'Stopped'}`);
+    
+  } catch (err) {
+    error(`Failed to get status: ${err.message}`);
+  }
+}
+
+// Template functions
+function createMinimalClaudeMd() {
+  return `# Claude Code Configuration
+
+## Build Commands
+- \`npm run build\`: Build the project
+- \`npm run test\`: Run tests
+- \`npm run lint\`: Run linter
+
+## Code Style
+- Use TypeScript/ES modules
+- Follow project conventions
+- Run typecheck before committing
+
+## Project Info
+This is a Claude-Flow AI agent orchestration system.
+`;
+}
+
+function createFullClaudeMd() {
+  return `# Claude Code Configuration
+
+## Build Commands
+- \`npm run build\`: Build the project using Deno compile
+- \`npm run test\`: Run the full test suite
+- \`npm run lint\`: Run ESLint and format checks
+- \`npm run typecheck\`: Run TypeScript type checking
+- \`npx claude-flow start\`: Start the orchestration system
+- \`npx claude-flow --help\`: Show all available commands
+
+## Code Style Preferences
+- Use ES modules (import/export) syntax, not CommonJS (require)
+- Destructure imports when possible (e.g., \`import { foo } from 'bar'\`)
+- Use TypeScript for all new code
+- Follow existing naming conventions (camelCase for variables, PascalCase for classes)
+- Add JSDoc comments for public APIs
+- Use async/await instead of Promise chains
+- Prefer const/let over var
+
+## Workflow Guidelines
+- Always run typecheck after making code changes
+- Run tests before committing changes
+- Use meaningful commit messages following conventional commits
+- Create feature branches for new functionality
+- Ensure all tests pass before merging
+
+## Project Architecture
+This is a Claude-Flow AI agent orchestration system with the following components:
+- **CLI Interface**: Command-line tools for managing the system
+- **Orchestrator**: Core engine for coordinating agents and tasks
+- **Memory System**: Persistent storage and retrieval of information
+- **Terminal Management**: Automated terminal session handling
+- **MCP Integration**: Model Context Protocol server for Claude integration
+- **Agent Coordination**: Multi-agent task distribution and management
+
+## Important Notes
+- Use \`claude --dangerously-skip-permissions\` for unattended operation
+- The system supports both daemon and interactive modes
+- Memory persistence is handled automatically
+- All components are event-driven for scalability
+
+## Debugging
+- Check logs in \`./claude-flow.log\`
+- Use \`npx claude-flow status\` to check system health
+- Monitor with \`npx claude-flow monitor\` for real-time updates
+- Verbose output available with \`--verbose\` flag on most commands
+`;
+}
+
+function createMinimalMemoryBankMd() {
+  return `# Memory Bank
+
+## Quick Reference
+- Project uses JSON for memory persistence
+- Memory is organized by namespaces
+- Query with \`npx claude-flow memory query <search>\`
+
+## Storage Location
+- Database: \`./memory/claude-flow-data.json\`
+- Sessions: \`./memory/sessions/\`
+`;
+}
+
+function createFullMemoryBankMd() {
+  return `# Memory Bank Configuration
+
+## Overview
+The Claude-Flow memory system provides persistent storage and intelligent retrieval of information across agent sessions. It uses a hybrid approach combining JSON databases with semantic search capabilities.
+
+## Storage Backends
+- **Primary**: JSON database (\`./memory/claude-flow-data.json\`)
+- **Sessions**: File-based storage in \`./memory/sessions/\`
+- **Cache**: In-memory cache for frequently accessed data
+
+## Memory Organization
+- **Namespaces**: Logical groupings of related information
+- **Sessions**: Time-bound conversation contexts
+- **Indexing**: Automatic content indexing for fast retrieval
+- **Replication**: Optional distributed storage support
+
+## Commands
+- \`npx claude-flow memory query <search>\`: Search stored information
+- \`npx claude-flow memory stats\`: Show memory usage statistics
+- \`npx claude-flow memory export <file>\`: Export memory to file
+- \`npx claude-flow memory import <file>\`: Import memory from file
+
+## Configuration
+Memory settings are configured in \`claude-flow.config.json\`:
+\`\`\`json
+{
+  "memory": {
+    "backend": "json",
+    "path": "./memory/claude-flow-data.json",
+    "cacheSize": 1000,
+    "indexing": true,
+    "namespaces": ["default", "agents", "tasks", "sessions"],
+    "retentionPolicy": {
+      "sessions": "30d",
+      "tasks": "90d",
+      "agents": "permanent"
+    }
+  }
+}
+\`\`\`
+
+## Best Practices
+- Use descriptive namespaces for different data types
+- Regular memory exports for backup purposes
+- Monitor memory usage with stats command
+- Clean up old sessions periodically
+
+## Memory Types
+- **Episodic**: Conversation and interaction history
+- **Semantic**: Factual knowledge and relationships
+- **Procedural**: Task patterns and workflows
+- **Meta**: System configuration and preferences
+
+## Integration Notes
+- Memory is automatically synchronized across agents
+- Search supports both exact match and semantic similarity
+- Memory contents are private to your local instance
+- No data is sent to external services without explicit commands
+`;
+}
+
+function createMinimalCoordinationMd() {
+  return `# Agent Coordination
+
+## Quick Commands
+- \`npx claude-flow agent spawn <type>\`: Create new agent
+- \`npx claude-flow agent list\`: Show active agents
+- \`npx claude-flow task create <type> <description>\`: Create task
+
+## Agent Types
+- researcher, coder, analyst, coordinator, general
+`;
+}
+
+function createFullCoordinationMd() {
+  return `# Agent Coordination System
+
+## Overview
+The Claude-Flow coordination system manages multiple AI agents working together on complex tasks. It provides intelligent task distribution, resource management, and inter-agent communication.
+
+## Agent Types and Capabilities
+- **Researcher**: Web search, information gathering, knowledge synthesis
+- **Coder**: Code analysis, development, debugging, testing
+- **Analyst**: Data processing, pattern recognition, insights generation
+- **Coordinator**: Task planning, resource allocation, workflow management
+- **General**: Multi-purpose agent with balanced capabilities
+
+## Task Management
+- **Priority Levels**: 1 (lowest) to 10 (highest)
+- **Dependencies**: Tasks can depend on completion of other tasks
+- **Parallel Execution**: Independent tasks run concurrently
+- **Load Balancing**: Automatic distribution based on agent capacity
+
+## Coordination Commands
+\`\`\`bash
+# Agent Management
+npx claude-flow agent spawn <type> --name <name> --priority <1-10>
+npx claude-flow agent list
+npx claude-flow agent info <agent-id>
+npx claude-flow agent terminate <agent-id>
+
+# Task Management  
+npx claude-flow task create <type> <description> --priority <1-10> --deps <task-ids>
+npx claude-flow task list --verbose
+npx claude-flow task status <task-id>
+npx claude-flow task cancel <task-id>
+
+# System Monitoring
+npx claude-flow status --verbose
+npx claude-flow monitor --interval 5000
+\`\`\`
+
+## Workflow Execution
+Workflows are defined in JSON format and can orchestrate complex multi-agent operations:
+\`\`\`bash
+npx claude-flow workflow examples/research-workflow.json
+npx claude-flow workflow examples/development-config.json --async
+\`\`\`
+
+## Advanced Features
+- **Circuit Breakers**: Automatic failure handling and recovery
+- **Work Stealing**: Dynamic load redistribution for efficiency
+- **Resource Limits**: Memory and CPU usage constraints
+- **Metrics Collection**: Performance monitoring and optimization
+
+## Configuration
+Coordination settings in \`claude-flow.config.json\`:
+\`\`\`json
+{
+  "orchestrator": {
+    "maxConcurrentTasks": 10,
+    "taskTimeout": 300000,
+    "defaultPriority": 5
+  },
+  "agents": {
+    "maxAgents": 20,
+    "defaultCapabilities": ["research", "code", "terminal"],
+    "resourceLimits": {
+      "memory": "1GB",
+      "cpu": "50%"
+    }
+  }
+}
+\`\`\`
+
+## Communication Patterns
+- **Direct Messaging**: Agent-to-agent communication
+- **Event Broadcasting**: System-wide notifications
+- **Shared Memory**: Common information access
+- **Task Handoff**: Seamless work transfer between agents
+
+## Best Practices
+- Start with general agents and specialize as needed
+- Use descriptive task names and clear requirements
+- Monitor system resources during heavy workloads
+- Implement proper error handling in workflows
+- Regular cleanup of completed tasks and inactive agents
+
+## Troubleshooting
+- Check agent health with \`npx claude-flow status\`
+- View detailed logs with \`npx claude-flow monitor\`
+- Restart stuck agents with terminate/spawn cycle
+- Use \`--verbose\` flags for detailed diagnostic information
+`;
+}
+
+function createAgentsReadme() {
+  return `# Agent Memory Storage
+
+## Purpose
+This directory stores agent-specific memory data, configurations, and persistent state information for individual Claude agents in the orchestration system.
+
+## Structure
+Each agent gets its own subdirectory for isolated memory storage:
+
+\`\`\`
+memory/agents/
+├── agent_001/
+│   ├── state.json           # Agent state and configuration
+│   ├── knowledge.md         # Agent-specific knowledge base
+│   ├── tasks.json          # Completed and active tasks
+│   └── calibration.json    # Agent-specific calibrations
+├── agent_002/
+│   └── ...
+└── shared/
+    ├── common_knowledge.md  # Shared knowledge across agents
+    └── global_config.json  # Global agent configurations
+\`\`\`
+
+## Usage Guidelines
+1. **Agent Isolation**: Each agent should only read/write to its own directory
+2. **Shared Resources**: Use the \`shared/\` directory for cross-agent information
+3. **State Persistence**: Update state.json whenever agent status changes
+4. **Knowledge Sharing**: Document discoveries in knowledge.md files
+5. **Cleanup**: Remove directories for terminated agents periodically
+
+## Last Updated
+${new Date().toISOString()}
+`;
+}
+
+function createSessionsReadme() {
+  return `# Session Memory Storage
+
+## Purpose
+This directory stores session-based memory data, conversation history, and contextual information for development sessions using the Claude-Flow orchestration system.
+
+## Structure
+Sessions are organized by date and session ID for easy retrieval:
+
+\`\`\`
+memory/sessions/
+├── 2024-01-10/
+│   ├── session_001/
+│   │   ├── metadata.json        # Session metadata and configuration
+│   │   ├── conversation.md      # Full conversation history
+│   │   ├── decisions.md         # Key decisions and rationale
+│   │   ├── artifacts/           # Generated files and outputs
+│   │   └── coordination_state/  # Coordination system snapshots
+│   └── ...
+└── shared/
+    ├── patterns.md              # Common session patterns
+    └── templates/               # Session template files
+\`\`\`
+
+## Usage Guidelines
+1. **Session Isolation**: Each session gets its own directory
+2. **Metadata Completeness**: Always fill out session metadata
+3. **Conversation Logging**: Document all significant interactions
+4. **Artifact Organization**: Structure generated files clearly
+5. **State Preservation**: Snapshot coordination state regularly
+
+## Last Updated
+${new Date().toISOString()}
+`;
+}
+
+// Main CLI handler
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  if (!command || command === 'help' || command === '--help') {
+    printHelp();
+    return;
+  }
+  
+  if (command === 'version' || command === '--version') {
+    console.log(`Claude-Flow v${VERSION}`);
+    return;
+  }
+  
+  switch (command) {
+    case 'init':
+      await executeInit(args.slice(1));
+      break;
+      
+    case 'status':
+      await executeStatus();
+      break;
+      
+    case 'start':
+      await handleDenoCommand('start', args.slice(1));
+      break;
+      
+    case 'agent':
+    case 'task':
+    case 'memory':
+    case 'config':
+    case 'monitor':
+    case 'mcp':
+    case 'claude':
+    case 'session':
+    case 'workflow':
+      await handleDenoCommand(command, args.slice(1));
+      break;
+      
+    default:
+      error(`Unknown command: ${command}`);
+      console.log('Run \'claude-flow help\' for usage information.');
+      process.exit(1);
+  }
+}
+
+// Run the CLI
+main().catch(err => {
+  error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {
@@ -35,7 +35,7 @@
     "node": ">=16.0.0"
   },
   "files": [
-    "bin/claude-flow",
+    "bin/",
     "src/",
     "scripts/install.js",
     "README.md",