claude-flow 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Advanced AI agent orchestration system for Claude Code",
   "main": "src/cli/main.ts",
   "bin": {

package/src/cli/commands/help.ts

@@ -177,6 +177,67 @@ const HELP_TOPICS: HelpTopic[] = [
     ],
     related: ['agents', 'workflows', 'coordination']
   },
+  {
+    name: 'claude',
+    description: 'Spawning Claude instances with specific configurations',
+    category: 'basic',
+    examples: [
+      {
+        description: 'Spawn Claude with web research capabilities',
+        command: 'claude-flow claude spawn "implement user authentication" --research --parallel',
+        explanation: 'Creates a Claude instance with WebFetchTool and BatchTool for parallel web research'
+      },
+      {
+        description: 'Spawn Claude without permission prompts',
+        command: 'claude-flow claude spawn "fix payment bug" --no-permissions',
+        explanation: 'Runs Claude with --dangerously-skip-permissions flag to avoid interruptions'
+      },
+      {
+        description: 'Spawn Claude with custom tools',
+        command: 'claude-flow claude spawn "analyze codebase" --tools "View,Edit,GrepTool,LS"',
+        explanation: 'Specifies exactly which tools Claude can use for the task'
+      },
+      {
+        description: 'Spawn Claude with test coverage target',
+        command: 'claude-flow claude spawn "write unit tests" --coverage 95 --commit feature',
+        explanation: 'Sets test coverage goal to 95% and commits after each feature'
+      },
+      {
+        description: 'Dry run to preview command',
+        command: 'claude-flow claude spawn "build API" --mode backend-only --dry-run',
+        explanation: 'Shows what would be executed without actually running Claude'
+      }
+    ],
+    tutorial: [
+      'The claude spawn command launches Claude instances with specific configurations.',
+      '',
+      'Available Options:',
+      '• --tools, -t: Specify allowed tools (default: View,Edit,Replace,GlobTool,GrepTool,LS,Bash)',
+      '• --no-permissions: Skip permission prompts with --dangerously-skip-permissions',
+      '• --config, -c: Path to MCP configuration file',
+      '• --mode, -m: Development mode (full, backend-only, frontend-only, api-only)',
+      '• --parallel: Enable BatchTool and dispatch_agent for parallel execution',
+      '• --research: Enable WebFetchTool for web research capabilities',
+      '• --coverage: Test coverage target percentage (default: 80)',
+      '• --commit: Commit frequency (phase, feature, manual)',
+      '• --verbose, -v: Enable verbose output',
+      '• --dry-run, -d: Preview what would be executed',
+      '',
+      'Environment Variables Set:',
+      '• CLAUDE_INSTANCE_ID: Unique identifier for the Claude instance',
+      '• CLAUDE_FLOW_MODE: Development mode setting',
+      '• CLAUDE_FLOW_COVERAGE: Target test coverage percentage',
+      '• CLAUDE_FLOW_COMMIT: Commit frequency setting',
+      '',
+      'Common Use Cases:',
+      '• Full-stack development: --mode full --parallel',
+      '• API development: --mode backend-only --coverage 90',
+      '• Bug fixing: --no-permissions --verbose',
+      '• Research tasks: --research --parallel',
+      '• Test writing: --coverage 95 --commit feature'
+    ],
+    related: ['agents', 'tasks', 'workflows']
+  },
   {
     name: 'workflows',
     description: 'Building complex multi-step workflows',

package/src/cli/simple-cli.js

@@ -14,6 +14,7 @@ USAGE:
   claude-flow [COMMAND] [OPTIONS]
 
 COMMANDS:
+  init                  Initialize Claude Code integration files
   start                 Start the orchestration system
   agent                 Manage agents (spawn, list, terminate, info)
   task                  Manage tasks (create, list, status, cancel, workflow)
@@ -35,9 +36,12 @@ GLOBAL OPTIONS:
   --help               Show help for specific command
 
 EXAMPLES:
+  claude-flow init                                     # Initialize Claude integration files
   claude-flow start                                    # Start orchestrator
   claude-flow agent spawn researcher --name "Bot"     # Spawn research agent
   claude-flow task create research "Analyze data"     # Create task
+  claude-flow claude spawn "implement auth" --research # Spawn Claude with web research
+  claude-flow claude spawn "fix bug" --no-permissions # Spawn Claude without permission prompts
   claude-flow config init                             # Initialize config
   claude-flow status                                  # Show system status
   claude-flow workflow my-workflow.json              # Execute workflow
@@ -92,6 +96,100 @@ async function main() {
       printHelp();
       break;
       
+    case 'init':
+      // Parse init options
+      const initForce = subArgs.includes('--force') || subArgs.includes('-f');
+      const initMinimal = subArgs.includes('--minimal') || subArgs.includes('-m');
+      
+      try {
+        printSuccess('Initializing Claude Code integration files...');
+        
+        // Check if files already exist
+        const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
+        const existingFiles = [];
+        
+        for (const file of files) {
+          try {
+            await Deno.stat(file);
+            existingFiles.push(file);
+          } catch {
+            // File doesn't exist, which is what we want
+          }
+        }
+        
+        if (existingFiles.length > 0 && !initForce) {
+          printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
+          console.log('Use --force to overwrite existing files');
+          break;
+        }
+        
+        // Create CLAUDE.md
+        const claudeMd = initMinimal ? createMinimalClaudeMd() : createFullClaudeMd();
+        await Deno.writeTextFile('CLAUDE.md', claudeMd);
+        console.log('  ✓ Created CLAUDE.md');
+        
+        // Create memory-bank.md
+        const memoryBankMd = initMinimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
+        await Deno.writeTextFile('memory-bank.md', memoryBankMd);
+        console.log('  ✓ Created memory-bank.md');
+        
+        // Create coordination.md
+        const coordinationMd = initMinimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
+        await Deno.writeTextFile('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 Deno.mkdir(dir, { recursive: true });
+            console.log(`  ✓ Created ${dir}/ directory`);
+          } catch (err) {
+            if (!(err instanceof Deno.errors.AlreadyExists)) {
+              throw err;
+            }
+          }
+        }
+        
+        // Create placeholder files
+        const agentsReadme = createAgentsReadme();
+        await Deno.writeTextFile('memory/agents/README.md', agentsReadme);
+        console.log('  ✓ Created memory/agents/README.md');
+        
+        const sessionsReadme = createSessionsReadme();
+        await Deno.writeTextFile('memory/sessions/README.md', sessionsReadme);
+        console.log('  ✓ Created memory/sessions/README.md');
+        
+        // Initialize persistence database
+        const initialData = {
+          agents: [],
+          tasks: [],
+          lastUpdated: Date.now()
+        };
+        await Deno.writeTextFile('memory/claude-flow-data.json', JSON.stringify(initialData, null, 2));
+        console.log('  ✓ Created memory/claude-flow-data.json (persistence database)');
+        
+        printSuccess('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');
+        console.log('\nNote: Persistence database initialized at memory/claude-flow-data.json');
+        
+      } catch (err) {
+        printError(`Failed to initialize files: ${err.message}`);
+      }
+      break;
+      
     case 'start':
       printSuccess('Starting Claude-Flow orchestration system...');
       printWarning('Full orchestrator implementation coming soon!');
@@ -348,6 +446,319 @@ async function main() {
   }
 }
 
+// Helper functions for init command
+function createMinimalClaudeMd() {
+  return `# Claude Code Integration
+
+This file provides guidance to Claude when working with this codebase.
+
+## Project Overview
+[Describe your project here]
+
+## Key Conventions
+- Code style guidelines
+- Naming conventions
+- Architecture patterns
+
+## Important Notes
+- Special considerations
+- Areas to be careful with
+`;
+}
+
+function createFullClaudeMd() {
+  return `# Claude Code Integration Guide
+
+This document provides comprehensive guidance to Claude when working with this codebase.
+
+## Project Overview
+[Provide a detailed description of your project, its purpose, and main features]
+
+## Architecture
+[Describe the overall architecture, main components, and how they interact]
+
+## Code Conventions
+- **Naming**: [Describe naming conventions for files, functions, variables, etc.]
+- **Style**: [Code formatting preferences, linting rules]
+- **Patterns**: [Design patterns used in the project]
+- **Testing**: [Testing approach and requirements]
+
+## Directory Structure
+\`\`\`
+project/
+├── src/          # Source code
+├── tests/        # Test files
+├── docs/         # Documentation
+└── ...           # Other directories
+\`\`\`
+
+## Development Workflow
+1. [Step-by-step development process]
+2. [How to run tests]
+3. [How to build/deploy]
+
+## Important Considerations
+- [Security considerations]
+- [Performance requirements]
+- [Compatibility requirements]
+
+## Common Tasks
+- **Add a new feature**: [Instructions]
+- **Fix a bug**: [Process]
+- **Update documentation**: [Guidelines]
+
+## Dependencies
+[List key dependencies and their purposes]
+
+## Troubleshooting
+[Common issues and solutions]
+`;
+}
+
+function createMinimalMemoryBankMd() {
+  return `# Memory Bank
+
+Session memory and context storage.
+
+## Current Session
+- Started: ${new Date().toISOString()}
+- Context: [Current work context]
+
+## Key Information
+- [Important facts to remember]
+
+## Progress Log
+- [Track progress here]
+`;
+}
+
+function createFullMemoryBankMd() {
+  return `# Memory Bank
+
+This file serves as persistent memory storage for Claude across sessions.
+
+## Session Information
+- **Current Session**: Started ${new Date().toISOString()}
+- **Project Phase**: [Development/Testing/Production]
+- **Active Tasks**: [List current tasks]
+
+## Project Context
+### Technical Stack
+- Languages: [List languages used]
+- Frameworks: [List frameworks]
+- Tools: [Development tools]
+
+### Architecture Decisions
+- [Record key architectural decisions]
+- [Rationale for technology choices]
+
+## Important Information
+### API Keys and Secrets
+- [Never store actual secrets here, just references]
+
+### External Services
+- [List integrated services]
+- [Configuration requirements]
+
+### Database Schema
+- [Current schema version]
+- [Recent migrations]
+
+## Progress Tracking
+### Completed Tasks
+- [x] [Completed task 1]
+- [x] [Completed task 2]
+
+### In Progress
+- [ ] [Current task 1]
+- [ ] [Current task 2]
+
+### Upcoming
+- [ ] [Future task 1]
+- [ ] [Future task 2]
+
+## Code Patterns
+### Established Patterns
+\`\`\`javascript
+// Example pattern
+\`\`\`
+
+### Anti-patterns to Avoid
+- [List anti-patterns]
+
+## Meeting Notes
+### [Date]
+- Participants: [Names]
+- Decisions: [Key decisions]
+- Action items: [Tasks assigned]
+
+## Debugging History
+### Issue: [Issue name]
+- **Date**: [Date]
+- **Symptoms**: [What was observed]
+- **Root Cause**: [What caused it]
+- **Solution**: [How it was fixed]
+
+## Performance Metrics
+- [Baseline metrics]
+- [Optimization goals]
+
+## Documentation Links
+- [API Documentation]: [URL]
+- [Design Documents]: [URL]
+- [Issue Tracker]: [URL]
+`;
+}
+
+function createMinimalCoordinationMd() {
+  return `# Coordination
+
+Task and workflow coordination.
+
+## Active Tasks
+1. [Current task]
+
+## Workflow
+- [ ] Step 1
+- [ ] Step 2
+
+## Resources
+- [Available resources]
+`;
+}
+
+function createFullCoordinationMd() {
+  return `# Coordination Center
+
+Central coordination for multi-agent collaboration and task management.
+
+## Active Agents
+| Agent ID | Type | Status | Assigned Tasks | Last Active |
+|----------|------|--------|----------------|-------------|
+| [ID] | [Type] | [Status] | [Tasks] | [Timestamp] |
+
+## Task Queue
+### High Priority
+1. **[Task Name]**
+   - Description: [What needs to be done]
+   - Assigned to: [Agent ID]
+   - Dependencies: [Other tasks]
+   - Deadline: [Date/Time]
+
+### Medium Priority
+1. [Task details]
+
+### Low Priority
+1. [Task details]
+
+## Workflow Definitions
+### [Workflow Name]
+\`\`\`yaml
+name: [Workflow Name]
+description: [What this workflow does]
+steps:
+  - name: [Step 1]
+    agent: [Agent type]
+    action: [What to do]
+  - name: [Step 2]
+    agent: [Agent type]
+    action: [What to do]
+    depends_on: [Step 1]
+\`\`\`
+
+## Resource Allocation
+### Computational Resources
+- CPU: [Usage/Limits]
+- Memory: [Usage/Limits]
+- Storage: [Usage/Limits]
+
+### External Resources
+- API Rate Limits: [Service: limit]
+- Database Connections: [Current/Max]
+
+## Communication Channels
+### Inter-Agent Messages
+- [Agent A → Agent B]: [Message type]
+
+### External Communications
+- Webhooks: [Configured webhooks]
+- Notifications: [Notification settings]
+
+## Synchronization Points
+- [Sync Point 1]: [Description]
+- [Sync Point 2]: [Description]
+
+## Conflict Resolution
+### Strategy
+- [How conflicts are resolved]
+
+### Recent Conflicts
+- [Date]: [Conflict description] → [Resolution]
+
+## Performance Metrics
+### Task Completion
+- Average time: [Time]
+- Success rate: [Percentage]
+
+### Agent Efficiency
+- [Agent Type]: [Metrics]
+
+## Scheduled Maintenance
+- [Date/Time]: [What will be done]
+
+## Emergency Procedures
+### System Overload
+1. [Step 1]
+2. [Step 2]
+
+### Agent Failure
+1. [Recovery procedure]
+`;
+}
+
+function createAgentsReadme() {
+  return `# Agents Directory
+
+This directory stores agent-specific memory and state information.
+
+## Structure
+Each agent gets its own subdirectory named by agent ID:
+- \`agent-001/\`: First agent's memory
+- \`agent-002/\`: Second agent's memory
+- etc.
+
+## Files per Agent
+- \`profile.json\`: Agent configuration and capabilities
+- \`memory.md\`: Agent's working memory
+- \`tasks.json\`: Assigned tasks and their status
+- \`metrics.json\`: Performance metrics
+
+## Usage
+Files in this directory are automatically managed by the Claude-Flow system.
+`;
+}
+
+function createSessionsReadme() {
+  return `# Sessions Directory
+
+This directory stores session-specific information and terminal states.
+
+## Structure
+Each session gets a unique directory:
+- \`session-[timestamp]/\`: Session data
+  - \`metadata.json\`: Session metadata
+  - \`terminal.log\`: Terminal output
+  - \`commands.history\`: Command history
+  - \`state.json\`: Session state snapshot
+
+## Retention Policy
+Sessions are retained for 30 days by default, then archived or deleted based on configuration.
+
+## Usage
+The Claude-Flow system automatically manages session files. Do not modify these files manually.
+`;
+}
+
 if (import.meta.main) {
   await main();
 }