@claude-flow/cli 3.0.0-alpha.1

package/dist/src/init/claudemd-generator.js

@@ -0,0 +1,626 @@
+/**
+ * CLAUDE.md Generator
+ * Generates project-specific Claude Code configuration with V3 swarm guidance
+ */
+/**
+ * Generate CLAUDE.md content based on init options
+ */
+export function generateClaudeMd(options) {
+    const topology = options.runtime.topology;
+    const maxAgents = options.runtime.maxAgents;
+    const memoryBackend = options.runtime.memoryBackend;
+    return `# Claude Code Configuration - SPARC Development Environment
+
+## 🚨 AUTOMATIC SWARM ORCHESTRATION
+
+**When starting work on complex tasks, Claude Code MUST automatically:**
+
+1. **Initialize the swarm** using MCP tools
+2. **Spawn concurrent agents** using Claude Code's Task tool
+3. **Coordinate via hooks** and memory
+
+### 🚨 CRITICAL: MCP + Task Tool in SAME Message
+
+**When user says "spawn swarm" or requests complex work, Claude Code MUST in ONE message:**
+1. Call MCP tools to initialize coordination
+2. **IMMEDIATELY** call Task tool to spawn REAL working agents
+3. Both MCP and Task calls must be in the SAME response
+
+**MCP alone does NOT execute work - Task tool agents do the actual work!**
+
+### 🔄 Auto-Start Swarm Protocol
+
+When the user requests a complex task (multi-file changes, feature implementation, refactoring), **immediately execute this pattern in a SINGLE message:**
+
+\`\`\`javascript
+// STEP 1: Initialize swarm coordination via MCP (in parallel with agent spawning)
+mcp__claude-flow__swarm_init({
+  topology: "${topology}",
+  maxAgents: ${maxAgents},
+  strategy: "adaptive"
+})
+
+// STEP 2: Spawn agents concurrently using Claude Code's Task tool
+// ALL Task calls MUST be in the SAME message for parallel execution
+Task("Coordinator", "You are the swarm coordinator. Initialize session, coordinate other agents via memory. Run: npx claude-flow@v3alpha hooks session-start", "hierarchical-coordinator")
+Task("Researcher", "Analyze requirements and existing code patterns. Store findings in memory via hooks.", "researcher")
+Task("Architect", "Design implementation approach based on research. Document decisions in memory.", "system-architect")
+Task("Coder", "Implement the solution following architect's design. Coordinate via hooks.", "coder")
+Task("Tester", "Write tests for the implementation. Report coverage via hooks.", "tester")
+Task("Reviewer", "Review code quality and security. Document findings.", "reviewer")
+
+// STEP 3: Batch all todos
+TodoWrite({ todos: [
+  {content: "Initialize swarm coordination", status: "in_progress", activeForm: "Initializing swarm"},
+  {content: "Research and analyze requirements", status: "in_progress", activeForm: "Researching requirements"},
+  {content: "Design architecture", status: "pending", activeForm: "Designing architecture"},
+  {content: "Implement solution", status: "pending", activeForm: "Implementing solution"},
+  {content: "Write tests", status: "pending", activeForm: "Writing tests"},
+  {content: "Review and finalize", status: "pending", activeForm: "Reviewing code"}
+]})
+
+// STEP 4: Store swarm state in memory
+mcp__claude-flow__memory_usage({
+  action: "store",
+  namespace: "swarm",
+  key: "current-session",
+  value: JSON.stringify({task: "[user's task]", agents: 6, startedAt: new Date().toISOString()})
+})
+\`\`\`
+
+### 📋 Agent Routing by Task Type
+
+**Automatically select agents based on task:**
+
+| Task Type | Required Agents | Topology |
+|-----------|-----------------|----------|
+| Bug Fix | researcher, coder, tester | mesh |
+| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
+| Refactoring | architect, coder, reviewer | mesh |
+| Performance | researcher, coder, perf-analyzer | hierarchical |
+| Security Audit | security-manager, reviewer, tester | hierarchical |
+| Documentation | researcher, api-docs | mesh |
+
+### 🎯 Task Complexity Detection
+
+**AUTO-INVOKE SWARM when task involves:**
+- Multiple files (3+)
+- New feature implementation
+- Refactoring across modules
+- API changes with tests
+- Security-related changes
+- Performance optimization
+- Database schema changes
+
+**SKIP SWARM for:**
+- Single file edits
+- Simple bug fixes (1-2 lines)
+- Documentation updates
+- Configuration changes
+- Quick questions/exploration
+
+### 🔧 Settings Configuration
+
+The following settings are auto-configured in \`.claude/settings.json\`:
+
+\`\`\`json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Task",
+      "commands": ["npx claude-flow@v3alpha hooks pre-task --tool Task"]
+    }],
+    "PostToolUse": [{
+      "matcher": "Task",
+      "commands": ["npx claude-flow@v3alpha hooks post-task --tool Task"]
+    }],
+    "UserPromptSubmit": [{
+      "matcher": ".*",
+      "commands": ["npx claude-flow@v3alpha hooks route-task"]
+    }]
+  },
+  "permissions": {
+    "allow": [
+      "Bash(npx claude-flow:*)",
+      "mcp__claude-flow__*",
+      "mcp__ruv-swarm__*"
+    ]
+  }
+}
+\`\`\`
+
+## 🚨 CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT
+
+**ABSOLUTE RULES**:
+1. ALL operations MUST be concurrent/parallel in a single message
+2. **NEVER save working files, text/mds and tests to the root folder**
+3. ALWAYS organize files in appropriate subdirectories
+4. **USE CLAUDE CODE'S TASK TOOL** for spawning agents concurrently, not just MCP
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**MANDATORY PATTERNS:**
+- **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+- **Task tool (Claude Code)**: ALWAYS spawn ALL agents in ONE message with full instructions
+- **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+- **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+- **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### 🎯 CRITICAL: Claude Code Task Tool for Agent Execution
+
+**Claude Code's Task tool is the PRIMARY way to spawn agents:**
+\`\`\`javascript
+// ✅ CORRECT: Use Claude Code's Task tool for parallel agent execution
+[Single Message]:
+  Task("Research agent", "Analyze requirements and patterns...", "researcher")
+  Task("Coder agent", "Implement core features...", "coder")
+  Task("Tester agent", "Create comprehensive tests...", "tester")
+  Task("Reviewer agent", "Review code quality...", "reviewer")
+  Task("Architect agent", "Design system architecture...", "system-architect")
+\`\`\`
+
+**MCP tools are ONLY for coordination setup:**
+- \`mcp__claude-flow__swarm_init\` - Initialize coordination topology
+- \`mcp__claude-flow__agent_spawn\` - Define agent types for coordination
+- \`mcp__claude-flow__task_orchestrate\` - Orchestrate high-level workflows
+
+### 📁 File Organization Rules
+
+**NEVER save to root folder. Use these directories:**
+- \`/src\` - Source code files
+- \`/tests\` - Test files
+- \`/docs\` - Documentation and markdown files
+- \`/config\` - Configuration files
+- \`/scripts\` - Utility scripts
+- \`/examples\` - Example code
+
+## Project Configuration
+
+This project is configured with Claude Flow V3:
+- **Topology**: ${topology}
+- **Max Agents**: ${maxAgents}
+- **Memory Backend**: ${memoryBackend}
+- **HNSW Indexing**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
+- **Neural Learning**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}
+
+## SPARC Workflow Phases
+
+1. **Specification** - Requirements analysis (\`sparc run spec-pseudocode\`)
+2. **Pseudocode** - Algorithm design (\`sparc run spec-pseudocode\`)
+3. **Architecture** - System design (\`sparc run architect\`)
+4. **Refinement** - TDD implementation (\`sparc tdd\`)
+5. **Completion** - Integration (\`sparc run integration\`)
+
+## Code Style & Best Practices
+
+- **Modular Design**: Files under 500 lines
+- **Environment Safety**: Never hardcode secrets
+- **Test-First**: Write tests before implementation
+- **Clean Architecture**: Separate concerns
+- **Documentation**: Keep updated
+
+## 🚀 Available Agents
+
+### Core Development
+\`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
+
+### Swarm Coordination
+\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`, \`collective-intelligence-coordinator\`, \`swarm-memory-manager\`
+
+### Consensus & Distributed
+\`byzantine-coordinator\`, \`raft-manager\`, \`gossip-coordinator\`, \`consensus-builder\`, \`crdt-synchronizer\`, \`quorum-manager\`, \`security-manager\`
+
+### Performance & Optimization
+\`perf-analyzer\`, \`performance-benchmarker\`, \`task-orchestrator\`, \`memory-coordinator\`, \`smart-agent\`
+
+### GitHub & Repository
+\`github-modes\`, \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`, \`workflow-automation\`, \`project-board-sync\`, \`repo-architect\`, \`multi-repo-swarm\`
+
+### SPARC Methodology
+\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\`, \`refinement\`
+
+### Specialized Development
+\`backend-dev\`, \`mobile-dev\`, \`ml-developer\`, \`cicd-engineer\`, \`api-docs\`, \`system-architect\`, \`code-analyzer\`, \`base-template-generator\`
+
+### Testing & Validation
+\`tdd-london-swarm\`, \`production-validator\`
+
+## 🎯 Claude Code vs MCP Tools
+
+### Claude Code Handles ALL EXECUTION:
+- **Task tool**: Spawn and run agents concurrently for actual work
+- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
+- Code generation and programming
+- Bash commands and system operations
+- Implementation work
+- Project navigation and analysis
+- TodoWrite and task management
+- Git operations
+- Package management
+- Testing and debugging
+
+### MCP Tools ONLY COORDINATE:
+- Swarm initialization (topology setup)
+- Agent type definitions (coordination patterns)
+- Task orchestration (high-level planning)
+- Memory management
+- Neural features
+- Performance tracking
+- GitHub integration
+
+**KEY**: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.
+
+## 🚀 Quick Setup
+
+\`\`\`bash
+# Add MCP servers (Claude Flow required, others optional)
+claude mcp add claude-flow npx claude-flow@v3alpha mcp start
+claude mcp add ruv-swarm npx ruv-swarm mcp start  # Optional: Enhanced coordination
+claude mcp add flow-nexus npx flow-nexus@latest mcp start  # Optional: Cloud features
+\`\`\`
+
+## MCP Tool Categories
+
+### Coordination
+\`swarm_init\`, \`agent_spawn\`, \`task_orchestrate\`
+
+### Monitoring
+\`swarm_status\`, \`agent_list\`, \`agent_metrics\`, \`task_status\`, \`task_results\`
+
+### Memory & Neural
+\`memory_usage\`, \`neural_status\`, \`neural_train\`, \`neural_patterns\`
+
+### GitHub Integration
+\`github_swarm\`, \`repo_analyze\`, \`pr_enhance\`, \`issue_triage\`, \`code_review\`
+
+### System
+\`benchmark_run\`, \`features_detect\`, \`swarm_monitor\`
+
+## 🚀 Agent Execution Flow with Claude Code
+
+### The Correct Pattern:
+
+1. **Optional**: Use MCP tools to set up coordination topology
+2. **REQUIRED**: Use Claude Code's Task tool to spawn agents that do actual work
+3. **REQUIRED**: Each agent runs hooks for coordination
+4. **REQUIRED**: Batch all operations in single messages
+
+### Example Full-Stack Development:
+
+\`\`\`javascript
+// Single message with all agent spawning via Claude Code's Task tool
+[Parallel Agent Execution]:
+  Task("Backend Developer", "Build REST API with Express. Use hooks for coordination.", "backend-dev")
+  Task("Frontend Developer", "Create React UI. Coordinate with backend via memory.", "coder")
+  Task("Database Architect", "Design PostgreSQL schema. Store schema in memory.", "code-analyzer")
+  Task("Test Engineer", "Write Jest tests. Check memory for API contracts.", "tester")
+  Task("DevOps Engineer", "Setup Docker and CI/CD. Document in memory.", "cicd-engineer")
+  Task("Security Auditor", "Review authentication. Report findings via hooks.", "reviewer")
+
+  // All todos batched together
+  TodoWrite { todos: [...8-10 todos...] }
+
+  // All file operations together
+  Write "backend/server.js"
+  Write "frontend/App.jsx"
+  Write "database/schema.sql"
+\`\`\`
+
+## 📋 Agent Coordination Protocol
+
+### Every Agent Spawned via Task Tool MUST:
+
+**1️⃣ BEFORE Work:**
+\`\`\`bash
+npx claude-flow@v3alpha hooks pre-task --description "[task]"
+npx claude-flow@v3alpha hooks session-restore --session-id "swarm-[id]"
+\`\`\`
+
+**2️⃣ DURING Work:**
+\`\`\`bash
+npx claude-flow@v3alpha hooks post-edit --file "[file]" --memory-key "swarm/[agent]/[step]"
+npx claude-flow@v3alpha hooks notify --message "[what was done]"
+\`\`\`
+
+**3️⃣ AFTER Work:**
+\`\`\`bash
+npx claude-flow@v3alpha hooks post-task --task-id "[task]"
+npx claude-flow@v3alpha hooks session-end --export-metrics true
+\`\`\`
+
+## 🚀 Swarm Lifecycle Management
+
+### Session Start (AUTOMATIC)
+When beginning ANY development task, Claude Code should:
+
+\`\`\`javascript
+// 1. Check for existing swarm session
+mcp__claude-flow__swarm_status({})
+
+// 2. If no active swarm, initialize one
+mcp__claude-flow__swarm_init({ topology: "${topology}", maxAgents: ${maxAgents} })
+
+// 3. Restore previous context if available
+mcp__claude-flow__memory_usage({ action: "retrieve", namespace: "swarm", key: "last-session" })
+\`\`\`
+
+### Task Execution (AUTOMATIC)
+For each significant task:
+
+\`\`\`javascript
+// 1. Create task orchestration
+mcp__claude-flow__task_orchestrate({
+  task: "[task description]",
+  priority: "high",
+  strategy: "adaptive"
+})
+
+// 2. Spawn appropriate agents via Task tool (PARALLEL)
+Task("Agent1", "...", "agent-type")
+Task("Agent2", "...", "agent-type")
+Task("Agent3", "...", "agent-type")
+
+// 3. Monitor progress via MCP
+mcp__claude-flow__swarm_status({ includeAgents: true, includeMetrics: true })
+\`\`\`
+
+### Session End (AUTOMATIC)
+When task completes or user ends session:
+
+\`\`\`javascript
+// 1. Save session state
+mcp__claude-flow__memory_usage({
+  action: "store",
+  namespace: "swarm",
+  key: "last-session",
+  value: JSON.stringify({ completedAt: new Date().toISOString(), summary: "..." })
+})
+
+// 2. Export metrics if enabled
+mcp__claude-flow__agent_metrics({})
+
+// 3. Graceful shutdown (only if explicitly requested)
+// mcp__claude-flow__swarm_destroy({ swarmId: "..." })
+\`\`\`
+
+## 🎯 Concurrent Execution Examples
+
+### ✅ CORRECT WORKFLOW: MCP Coordinates, Claude Code Executes
+
+\`\`\`javascript
+// Step 1: MCP tools set up coordination (optional, for complex tasks)
+[Single Message - Coordination Setup]:
+  mcp__claude-flow__swarm_init { topology: "${topology}", maxAgents: ${maxAgents} }
+  mcp__claude-flow__agent_spawn { type: "researcher" }
+  mcp__claude-flow__agent_spawn { type: "coder" }
+  mcp__claude-flow__agent_spawn { type: "tester" }
+
+// Step 2: Claude Code Task tool spawns ACTUAL agents that do the work
+[Single Message - Parallel Agent Execution]:
+  // Claude Code's Task tool spawns real agents concurrently
+  Task("Research agent", "Analyze API requirements and best practices. Check memory for prior decisions.", "researcher")
+  Task("Coder agent", "Implement REST endpoints with authentication. Coordinate via hooks.", "coder")
+  Task("Database agent", "Design and implement database schema. Store decisions in memory.", "code-analyzer")
+  Task("Tester agent", "Create comprehensive test suite with 90% coverage.", "tester")
+  Task("Reviewer agent", "Review code quality and security. Document findings.", "reviewer")
+
+  // Batch ALL todos in ONE call
+  TodoWrite { todos: [
+    {id: "1", content: "Research API patterns", status: "in_progress", priority: "high"},
+    {id: "2", content: "Design database schema", status: "in_progress", priority: "high"},
+    {id: "3", content: "Implement authentication", status: "pending", priority: "high"},
+    {id: "4", content: "Build REST endpoints", status: "pending", priority: "high"},
+    {id: "5", content: "Write unit tests", status: "pending", priority: "medium"},
+    {id: "6", content: "Integration tests", status: "pending", priority: "medium"},
+    {id: "7", content: "API documentation", status: "pending", priority: "low"},
+    {id: "8", content: "Performance optimization", status: "pending", priority: "low"}
+  ]}
+
+  // Parallel file operations
+  Bash "mkdir -p app/{src,tests,docs,config}"
+  Write "app/package.json"
+  Write "app/src/server.js"
+  Write "app/tests/server.test.js"
+  Write "app/docs/API.md"
+\`\`\`
+
+### ❌ WRONG (Multiple Messages):
+\`\`\`javascript
+Message 1: mcp__claude-flow__swarm_init
+Message 2: Task("agent 1")
+Message 3: TodoWrite { todos: [single todo] }
+Message 4: Write "file.js"
+// This breaks parallel coordination!
+\`\`\`
+
+## V3 Performance Targets
+
+- **2.49x-7.47x** Flash Attention speedup
+- **150x-12,500x** search improvements with HNSW
+- **50-75%** memory reduction with quantization
+- **Sub-100ms** MCP response times
+
+## 🪝 V3 Hooks System (26 Hooks)
+
+Claude Flow V3 provides 26 hooks for comprehensive agent coordination and self-learning.
+
+### Hook Categories
+
+| Category | Hooks | Purpose |
+|----------|-------|---------|
+| **Core** | \`pre-edit\`, \`post-edit\`, \`pre-command\`, \`post-command\`, \`pre-task\`, \`post-task\` | Tool lifecycle |
+| **Routing** | \`route\`, \`metrics\`, \`list\` | Task analysis |
+| **Intelligence** | \`explain\`, \`pretrain\`, \`build-agents\`, \`transfer\`, \`init\` | Neural learning |
+| **Session** | \`session-start\`, \`session-end\`, \`session-restore\`, \`notify\` | Context management |
+| **Learning** | \`trajectory-start\`, \`trajectory-step\`, \`trajectory-end\` | Reinforcement learning |
+| **Patterns** | \`pattern-store\`, \`pattern-search\`, \`stats\`, \`learn\`, \`attention\` | Memory & search |
+
+### Essential Hook Commands
+
+\`\`\`bash
+# Core hooks for tool coordination
+npx claude-flow@v3alpha hooks pre-task --description "[task]"
+npx claude-flow@v3alpha hooks post-task --task-id "[id]" --success true
+npx claude-flow@v3alpha hooks post-edit --file "[file]" --train-patterns
+
+# Session management
+npx claude-flow@v3alpha hooks session-start --session-id "[id]"
+npx claude-flow@v3alpha hooks session-end --export-metrics true --persist-patterns
+npx claude-flow@v3alpha hooks session-restore --session-id "[id]"
+
+# Intelligence routing
+npx claude-flow@v3alpha hooks route --task "[task]" --include-explanation
+npx claude-flow@v3alpha hooks explain --topic "[topic]" --depth comprehensive
+
+# Neural learning
+npx claude-flow@v3alpha hooks pretrain --model-type moe --epochs 10
+npx claude-flow@v3alpha hooks build-agents --agent-types coder,tester --config-format yaml
+
+# Trajectory learning (reinforcement)
+npx claude-flow@v3alpha hooks intelligence trajectory-start --session "[session]"
+npx claude-flow@v3alpha hooks intelligence trajectory-step --action "[action]" --reward "[reward]"
+npx claude-flow@v3alpha hooks intelligence trajectory-end --verdict success
+
+# Pattern storage (HNSW-indexed)
+npx claude-flow@v3alpha hooks intelligence pattern-store --pattern "[pattern]" --embedding "[json]"
+npx claude-flow@v3alpha hooks intelligence pattern-search --query "[query]" --limit 10
+
+# Learning stats & attention
+npx claude-flow@v3alpha hooks intelligence stats
+npx claude-flow@v3alpha hooks intelligence attention --focus "[task]"
+\`\`\`
+
+### Intelligence System (RuVector)
+
+V3 includes the RuVector Intelligence System with:
+- **SONA**: Self-Optimizing Neural Architecture
+- **MoE**: Mixture of Experts for specialized routing
+- **HNSW**: 150x faster pattern search
+- **EWC++**: Elastic Weight Consolidation (prevents forgetting)
+- **Flash Attention**: 2.49x-7.47x speedup
+
+The 4-step intelligence pipeline:
+1. **RETRIEVE** - Fetch relevant patterns via HNSW
+2. **JUDGE** - Evaluate with verdicts (success/failure)
+3. **DISTILL** - Extract key learnings via LoRA
+4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++
+
+### Auto-Configured Hooks
+
+The init system configures these hooks in \`.claude/settings.json\`:
+
+\`\`\`json
+{
+  "hooks": {
+    "PreToolUse": [
+      { "matcher": "Task", "commands": ["npx claude-flow@v3alpha hooks pre-task --tool Task"] }
+    ],
+    "PostToolUse": [
+      { "matcher": "Task", "commands": ["npx claude-flow@v3alpha hooks post-task --tool Task --train-patterns"] }
+    ],
+    "UserPromptSubmit": [
+      { "matcher": ".*", "commands": ["npx claude-flow@v3alpha hooks route-task --analyze-complexity"] }
+    ],
+    "SessionStart": [
+      { "commands": ["npx claude-flow@v3alpha hooks session-start --load-context"] }
+    ]
+  }
+}
+\`\`\`
+
+### Agent Coordination via Hooks
+
+Every spawned agent should use hooks for coordination:
+
+\`\`\`javascript
+// In agent prompt instructions
+Task("Coder", \`
+  BEFORE starting: npx claude-flow@v3alpha hooks pre-task --description "Implement feature X"
+
+  DURING work:
+  - After each file edit: npx claude-flow@v3alpha hooks post-edit --file "[file]"
+  - To notify others: npx claude-flow@v3alpha hooks notify --message "[update]"
+
+  AFTER completing: npx claude-flow@v3alpha hooks post-task --success true
+\`, "coder")
+\`\`\`
+
+## Advanced Features (V3)
+
+- 🚀 Automatic Topology Selection
+- ⚡ Parallel Execution (2.8-4.4x speed)
+- 🧠 Neural Training with ReasoningBank
+- 📊 Bottleneck Analysis
+- 🤖 Smart Auto-Spawning
+- 🛡️ Self-Healing Workflows
+- 💾 Cross-Session Memory with AgentDB
+- 🔗 GitHub Integration
+- 🔐 Security-Hardened Architecture
+
+## Integration Tips
+
+1. Start with basic swarm init
+2. Scale agents gradually
+3. Use memory for context
+4. Monitor progress regularly
+5. Train patterns from success
+6. Enable hooks automation
+7. Use GitHub tools first
+
+## Support
+
+- Documentation: https://github.com/ruvnet/claude-flow
+- Issues: https://github.com/ruvnet/claude-flow/issues
+
+---
+
+Remember: **Claude Flow coordinates, Claude Code creates!**
+
+# important-instruction-reminders
+Do what has been asked; nothing more, nothing less.
+NEVER create files unless they're absolutely necessary for achieving your goal.
+ALWAYS prefer editing an existing file to creating a new one.
+NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+Never save working files, text/mds and tests to the root folder.
+`;
+}
+/**
+ * Generate minimal CLAUDE.md content
+ */
+export function generateMinimalClaudeMd(options) {
+    return `# Claude Code Configuration
+
+## Quick Reference
+
+- **Topology**: ${options.runtime.topology}
+- **Max Agents**: ${options.runtime.maxAgents}
+- **Memory**: ${options.runtime.memoryBackend}
+
+## Key Rules
+
+1. **Batch Operations**: All related operations in ONE message
+2. **Task Tool**: Use Claude Code's Task tool for agent execution
+3. **MCP Tools**: Only for coordination, not execution
+4. **File Organization**: Never save to root folder
+
+## Agent Execution Pattern
+
+\`\`\`javascript
+// Single message with parallel agents
+Task("Researcher", "Analyze requirements...", "researcher")
+Task("Coder", "Implement features...", "coder")
+Task("Tester", "Write tests...", "tester")
+\`\`\`
+
+## MCP Setup
+
+\`\`\`bash
+claude mcp add claude-flow npx claude-flow@v3alpha mcp start
+\`\`\`
+
+---
+Remember: **Claude Flow coordinates, Claude Code creates!**
+`;
+}
+export default generateClaudeMd;
+//# sourceMappingURL=claudemd-generator.js.map

package/dist/src/init/claudemd-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudemd-generator.js","sourceRoot":"","sources":["../../../src/init/claudemd-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAoB;IACnD,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC1C,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;IAC5C,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC;IAEpD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;eA0BM,QAAQ;eACR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6IN,QAAQ;oBACN,SAAS;wBACL,aAAa;uBACd,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;yBACjD,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA6JlC,QAAQ,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAoDhC,QAAQ,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgM/E,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAoB;IAC1D,OAAO;;;;kBAIS,OAAO,CAAC,OAAO,CAAC,QAAQ;oBACtB,OAAO,CAAC,OAAO,CAAC,SAAS;gBAC7B,OAAO,CAAC,OAAO,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B5C,CAAC;AACF,CAAC;AAED,eAAe,gBAAgB,CAAC"}

package/dist/src/init/executor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Init Executor
+ * Main execution logic for V3 initialization
+ */
+import type { InitOptions, InitResult } from './types.js';
+/**
+ * Execute initialization
+ */
+export declare function executeInit(options: InitOptions): Promise<InitResult>;
+export default executeInit;
+//# sourceMappingURL=executor.d.ts.map

package/dist/src/init/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/init/executor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA8GxE;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAiF3E;AA0iBD,eAAe,WAAW,CAAC"}