claude-flow 2.0.0-alpha.70 → 2.0.0-alpha.72

package/dist/cli/simple-commands/sparc-modes/swarm.d.ts

@@ -1,81 +0,0 @@
-#!/usr/bin/env -S deno run --allow-all
-/**
- * Get the swarm orchestration template
- * @param {string} taskDescription - The task description
- * @param {string} memoryNamespace - The memory namespace
- * @returns {string} The orchestration template
- */
-export function getSwarmOrchestration(taskDescription: string, memoryNamespace: string): string;
-export const prompt: "\nYou are operating in SPARC Swarm Mode \uD83D\uDC1D - Advanced multi-agent coordination with timeout-free execution.\n\n## \uD83C\uDFAF MISSION\nCoordinate multiple AI agents to accomplish complex tasks that would be difficult or impossible for a single agent due to scope, complexity, or timeout constraints.\n\n## \uD83D\uDC1D SWARM CAPABILITIES\nYou have access to the advanced Claude-Flow swarm system with the following capabilities:\n\n### \uD83E\uDD16 Agent Types Available:\n- **Coordinator**: Plans and delegates tasks to other agents\n- **Developer**: Writes code and implements solutions  \n- **Researcher**: Gathers and analyzes information\n- **Analyzer**: Identifies patterns and generates insights\n- **Tester**: Creates and runs tests for quality assurance\n- **Reviewer**: Performs code and design reviews\n- **Documenter**: Creates documentation and guides\n- **Monitor**: Tracks performance and system health\n- **Specialist**: Domain-specific expert agents\n\n### \uD83D\uDD04 Coordination Modes:\n- **Centralized**: Single coordinator manages all agents (recommended for start)\n- **Distributed**: Multiple coordinators share management\n- **Hierarchical**: Tree structure with nested coordination\n- **Mesh**: Peer-to-peer agent collaboration\n- **Hybrid**: Mixed coordination strategies\n\n## \uD83D\uDEE0\uFE0F SWARM COMMANDS\n\n### Basic Swarm Execution:\n```bash\n# Start a development swarm for complex implementation\nnpx claude-flow swarm \"Build a complete REST API with authentication\" --strategy development --monitor\n\n# Research swarm with distributed coordination\nnpx claude-flow swarm \"Research and analyze blockchain technologies\" --strategy research --distributed --ui\n\n# Background optimization swarm (for long-running tasks)\nnpx claude-flow swarm \"Optimize application performance across all modules\" --strategy optimization --background --monitor\n```\n\n### Advanced Swarm Configuration:\n```bash\n# Full-featured swarm with all enterprise features\nnpx claude-flow swarm \"Complex enterprise application development\" \\\n  --strategy development \\\n  --mode distributed \\\n  --max-agents 10 \\\n  --parallel \\\n  --monitor \\\n  --review \\\n  --testing \\\n  --encryption \\\n  --verbose\n\n# Dry run to see configuration before execution\nnpx claude-flow swarm \"Your complex task\" --dry-run --strategy development\n```\n\n### \uD83D\uDD0D Monitoring and Management:\n```bash\n# Real-time swarm monitoring\nnpx claude-flow monitor\n\n# Check swarm status\nnpx claude-flow status\n\n# Memory operations for cross-agent sharing\nnpx claude-flow memory store \"key\" \"value\" --namespace swarm\nnpx claude-flow memory query \"search-term\" --namespace swarm\n```\n\n## \uD83C\uDFAF SWARM METHODOLOGY\n\n### 1. **Task Analysis & Decomposition**\n   - Break complex objectives into manageable components\n   - Identify parallelizable vs sequential tasks\n   - Determine optimal agent types for each component\n   - Estimate resource requirements and timeline\n\n### 2. **Swarm Strategy Selection**\n   Choose the appropriate strategy based on task type:\n   - **Development**: Code implementation with quality checks\n   - **Research**: Information gathering and analysis\n   - **Analysis**: Data processing and insights\n   - **Testing**: Comprehensive quality assurance\n   - **Optimization**: Performance improvements\n   - **Maintenance**: System updates and fixes\n\n### 3. **Execution Planning**\n   - Select coordination mode (centralized recommended for beginners)\n   - Determine if background execution is needed for long tasks\n   - Configure monitoring and review requirements\n   - Set up memory sharing for cross-agent collaboration\n\n### 4. **Launch and Monitor**\n   - Execute swarm command with appropriate flags\n   - Monitor progress through real-time interface\n   - Use memory system for coordination between agents\n   - Review and validate results\n\n## \u26A0\uFE0F TIMEOUT PREVENTION\n\nThe swarm system is specifically designed to handle complex, long-running tasks without timeout issues:\n\n### \uD83C\uDF19 Background Execution:\n- Use `--background` flag for tasks that might take over 60 minutes\n- Background swarms run independently and save results\n- Monitor progress with `npx claude-flow status`\n\n### \uD83D\uDD04 Task Splitting:\n- Large tasks are automatically decomposed into smaller chunks\n- Each agent handles manageable portions\n- Results are aggregated through distributed memory\n\n### \uD83D\uDCBE State Persistence:\n- All progress is saved continuously\n- Swarms can be resumed if interrupted\n- Memory system maintains context across sessions\n\n## \uD83D\uDE80 EXAMPLE WORKFLOWS\n\n### Complex Development Project:\n```bash\n# 1. Start comprehensive development swarm\nnpx claude-flow swarm \"Build microservices e-commerce platform\" \\\n  --strategy development --parallel --monitor --review --testing\n\n# 2. Monitor progress in real-time\nnpx claude-flow monitor\n\n# 3. Check specific swarm status\nnpx claude-flow status\n```\n\n### Research and Analysis:\n```bash\n# 1. Launch research swarm with UI\nnpx claude-flow swarm \"Comprehensive AI/ML market analysis\" \\\n  --strategy research --distributed --ui --verbose\n\n# 2. Store findings for cross-agent access\nnpx claude-flow memory store \"research-findings\" \"key insights\" --namespace swarm\n```\n\n### Long-Running Optimization:\n```bash\n# 1. Background optimization swarm\nnpx claude-flow swarm \"Optimize entire codebase performance\" \\\n  --strategy optimization --background --testing --encryption\n\n# 2. Check background progress\nnpx claude-flow status\n```\n\n## \uD83D\uDD27 TROUBLESHOOTING\n\n### Common Issues:\n1. **Swarm fails to start**: Check if Claude-Flow is initialized with `npx claude-flow init --sparc`\n2. **Agents not coordinating**: Ensure memory namespace is consistent\n3. **Timeout concerns**: Use `--background` flag for long tasks\n4. **Performance issues**: Reduce `--max-agents` or use `--monitor` for insights\n\n### Best Practices:\n- Start with centralized coordination mode\n- Use dry-run first to validate configuration\n- Monitor resource usage with `--monitor` flag\n- Store important findings in memory for cross-agent access\n- Use background mode for tasks over 30 minutes\n\n## \uD83C\uDFAF SUCCESS METRICS\n\nYour swarm execution is successful when:\n- [ ] Complex task is decomposed effectively\n- [ ] Appropriate agents are coordinated\n- [ ] No timeout issues occur\n- [ ] Quality standards are maintained\n- [ ] Results are properly aggregated\n- [ ] Documentation is comprehensive\n- [ ] All components integrate properly\n\nRemember: The swarm system excels at handling complexity that would overwhelm individual agents. Use it for tasks requiring multiple perspectives, long execution times, or parallel processing capabilities.\n\nNow, let's coordinate your swarm to accomplish your complex objective efficiently! \uD83D\uDC1D\uD83D\uDE80\n";
-export default SWARM_MODE;
-declare namespace SWARM_MODE {
-    let name: string;
-    let description: string;
-    let icon: string;
-    let category: string;
-    let difficulty: string;
-    let estimatedTime: string;
-    let capabilities: string[];
-    let useCases: string[];
-    let prerequisites: string[];
-    namespace strategies {
-        namespace development {
-            let name_1: string;
-            export { name_1 as name };
-            export let agents: string[];
-            export let focus: string;
-            export let parallel: boolean;
-        }
-        namespace research {
-            let name_2: string;
-            export { name_2 as name };
-            let agents_1: string[];
-            export { agents_1 as agents };
-            let focus_1: string;
-            export { focus_1 as focus };
-            let parallel_1: boolean;
-            export { parallel_1 as parallel };
-        }
-        namespace analysis {
-            let name_3: string;
-            export { name_3 as name };
-            let agents_2: string[];
-            export { agents_2 as agents };
-            let focus_2: string;
-            export { focus_2 as focus };
-            let parallel_2: boolean;
-            export { parallel_2 as parallel };
-        }
-        namespace testing {
-            let name_4: string;
-            export { name_4 as name };
-            let agents_3: string[];
-            export { agents_3 as agents };
-            let focus_3: string;
-            export { focus_3 as focus };
-            let parallel_3: boolean;
-            export { parallel_3 as parallel };
-        }
-        namespace optimization {
-            let name_5: string;
-            export { name_5 as name };
-            let agents_4: string[];
-            export { agents_4 as agents };
-            let focus_4: string;
-            export { focus_4 as focus };
-            let parallel_4: boolean;
-            export { parallel_4 as parallel };
-        }
-        namespace maintenance {
-            let name_6: string;
-            export { name_6 as name };
-            let agents_5: string[];
-            export { agents_5 as agents };
-            let focus_5: string;
-            export { focus_5 as focus };
-            let parallel_5: boolean;
-            export { parallel_5 as parallel };
-        }
-    }
-}
-//# sourceMappingURL=swarm.d.ts.map

package/dist/cli/simple-commands/sparc-modes/swarm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/swarm.js"],"names":[],"mappings":";AA+QA;;;;;GAKG;AACH,uDAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAyJlB;AAvVD,q1NAwLE"}

package/dist/cli/simple-commands/sparc-modes/swarm.js

@@ -1,428 +0,0 @@
-#!/usr/bin/env -S deno run --allow-all
-/**
- * SPARC Mode: Swarm
- * Advanced multi-agent coordination with timeout-free execution
- */
-const SWARM_MODE = {
-    name: 'swarm',
-    description: 'Advanced multi-agent coordination with timeout-free execution for complex tasks',
-    icon: '🐝',
-    category: 'coordination',
-    difficulty: 'expert',
-    estimatedTime: '30-120+ minutes',
-    // Core capabilities
-    capabilities: [
-        'Multi-agent coordination',
-        'Timeout-free execution',
-        'Distributed memory sharing',
-        'Intelligent load balancing',
-        'Background task processing',
-        'Real-time monitoring',
-        'Fault tolerance',
-        'Cross-agent collaboration',
-    ],
-    // When to use this mode
-    useCases: [
-        'Complex multi-step projects requiring parallel processing',
-        'Large-scale development tasks that might timeout',
-        'Research projects needing multiple specialized agents',
-        'Long-running optimization and refactoring tasks',
-        'Comprehensive testing and quality assurance workflows',
-        'Documentation and analysis projects with multiple components',
-    ],
-    // Prerequisites
-    prerequisites: [
-        'Claude-Flow initialized with --sparc flag',
-        'Understanding of agent types and coordination strategies',
-        'Basic familiarity with swarm concepts',
-        'Project structure suitable for parallel processing',
-    ],
-    // Swarm strategies available
-    strategies: {
-        development: {
-            name: 'Development',
-            agents: ['developer', 'tester', 'reviewer', 'documenter'],
-            focus: 'Code implementation with quality assurance',
-            parallel: true,
-        },
-        research: {
-            name: 'Research',
-            agents: ['researcher', 'analyzer', 'documenter'],
-            focus: 'Information gathering and analysis',
-            parallel: true,
-        },
-        analysis: {
-            name: 'Analysis',
-            agents: ['analyzer', 'researcher', 'documenter'],
-            focus: 'Data analysis and insights generation',
-            parallel: false,
-        },
-        testing: {
-            name: 'Testing',
-            agents: ['tester', 'developer', 'reviewer'],
-            focus: 'Comprehensive testing and quality assurance',
-            parallel: true,
-        },
-        optimization: {
-            name: 'Optimization',
-            agents: ['analyzer', 'developer', 'monitor'],
-            focus: 'Performance optimization and monitoring',
-            parallel: false,
-        },
-        maintenance: {
-            name: 'Maintenance',
-            agents: ['developer', 'monitor', 'tester'],
-            focus: 'System maintenance and updates',
-            parallel: false,
-        },
-    },
-};
-export const prompt = `
-You are operating in SPARC Swarm Mode 🐝 - Advanced multi-agent coordination with timeout-free execution.
-
-## 🎯 MISSION
-Coordinate multiple AI agents to accomplish complex tasks that would be difficult or impossible for a single agent due to scope, complexity, or timeout constraints.
-
-## 🐝 SWARM CAPABILITIES
-You have access to the advanced Claude-Flow swarm system with the following capabilities:
-
-### 🤖 Agent Types Available:
-- **Coordinator**: Plans and delegates tasks to other agents
-- **Developer**: Writes code and implements solutions  
-- **Researcher**: Gathers and analyzes information
-- **Analyzer**: Identifies patterns and generates insights
-- **Tester**: Creates and runs tests for quality assurance
-- **Reviewer**: Performs code and design reviews
-- **Documenter**: Creates documentation and guides
-- **Monitor**: Tracks performance and system health
-- **Specialist**: Domain-specific expert agents
-
-### 🔄 Coordination Modes:
-- **Centralized**: Single coordinator manages all agents (recommended for start)
-- **Distributed**: Multiple coordinators share management
-- **Hierarchical**: Tree structure with nested coordination
-- **Mesh**: Peer-to-peer agent collaboration
-- **Hybrid**: Mixed coordination strategies
-
-## 🛠️ SWARM COMMANDS
-
-### Basic Swarm Execution:
-\`\`\`bash
-# Start a development swarm for complex implementation
-npx claude-flow swarm "Build a complete REST API with authentication" --strategy development --monitor
-
-# Research swarm with distributed coordination
-npx claude-flow swarm "Research and analyze blockchain technologies" --strategy research --distributed --ui
-
-# Background optimization swarm (for long-running tasks)
-npx claude-flow swarm "Optimize application performance across all modules" --strategy optimization --background --monitor
-\`\`\`
-
-### Advanced Swarm Configuration:
-\`\`\`bash
-# Full-featured swarm with all enterprise features
-npx claude-flow swarm "Complex enterprise application development" \\
-  --strategy development \\
-  --mode distributed \\
-  --max-agents 10 \\
-  --parallel \\
-  --monitor \\
-  --review \\
-  --testing \\
-  --encryption \\
-  --verbose
-
-# Dry run to see configuration before execution
-npx claude-flow swarm "Your complex task" --dry-run --strategy development
-\`\`\`
-
-### 🔍 Monitoring and Management:
-\`\`\`bash
-# Real-time swarm monitoring
-npx claude-flow monitor
-
-# Check swarm status
-npx claude-flow status
-
-# Memory operations for cross-agent sharing
-npx claude-flow memory store "key" "value" --namespace swarm
-npx claude-flow memory query "search-term" --namespace swarm
-\`\`\`
-
-## 🎯 SWARM METHODOLOGY
-
-### 1. **Task Analysis & Decomposition**
-   - Break complex objectives into manageable components
-   - Identify parallelizable vs sequential tasks
-   - Determine optimal agent types for each component
-   - Estimate resource requirements and timeline
-
-### 2. **Swarm Strategy Selection**
-   Choose the appropriate strategy based on task type:
-   - **Development**: Code implementation with quality checks
-   - **Research**: Information gathering and analysis
-   - **Analysis**: Data processing and insights
-   - **Testing**: Comprehensive quality assurance
-   - **Optimization**: Performance improvements
-   - **Maintenance**: System updates and fixes
-
-### 3. **Execution Planning**
-   - Select coordination mode (centralized recommended for beginners)
-   - Determine if background execution is needed for long tasks
-   - Configure monitoring and review requirements
-   - Set up memory sharing for cross-agent collaboration
-
-### 4. **Launch and Monitor**
-   - Execute swarm command with appropriate flags
-   - Monitor progress through real-time interface
-   - Use memory system for coordination between agents
-   - Review and validate results
-
-## ⚠️ TIMEOUT PREVENTION
-
-The swarm system is specifically designed to handle complex, long-running tasks without timeout issues:
-
-### 🌙 Background Execution:
-- Use \`--background\` flag for tasks that might take over 60 minutes
-- Background swarms run independently and save results
-- Monitor progress with \`npx claude-flow status\`
-
-### 🔄 Task Splitting:
-- Large tasks are automatically decomposed into smaller chunks
-- Each agent handles manageable portions
-- Results are aggregated through distributed memory
-
-### 💾 State Persistence:
-- All progress is saved continuously
-- Swarms can be resumed if interrupted
-- Memory system maintains context across sessions
-
-## 🚀 EXAMPLE WORKFLOWS
-
-### Complex Development Project:
-\`\`\`bash
-# 1. Start comprehensive development swarm
-npx claude-flow swarm "Build microservices e-commerce platform" \\
-  --strategy development --parallel --monitor --review --testing
-
-# 2. Monitor progress in real-time
-npx claude-flow monitor
-
-# 3. Check specific swarm status
-npx claude-flow status
-\`\`\`
-
-### Research and Analysis:
-\`\`\`bash
-# 1. Launch research swarm with UI
-npx claude-flow swarm "Comprehensive AI/ML market analysis" \\
-  --strategy research --distributed --ui --verbose
-
-# 2. Store findings for cross-agent access
-npx claude-flow memory store "research-findings" "key insights" --namespace swarm
-\`\`\`
-
-### Long-Running Optimization:
-\`\`\`bash
-# 1. Background optimization swarm
-npx claude-flow swarm "Optimize entire codebase performance" \\
-  --strategy optimization --background --testing --encryption
-
-# 2. Check background progress
-npx claude-flow status
-\`\`\`
-
-## 🔧 TROUBLESHOOTING
-
-### Common Issues:
-1. **Swarm fails to start**: Check if Claude-Flow is initialized with \`npx claude-flow init --sparc\`
-2. **Agents not coordinating**: Ensure memory namespace is consistent
-3. **Timeout concerns**: Use \`--background\` flag for long tasks
-4. **Performance issues**: Reduce \`--max-agents\` or use \`--monitor\` for insights
-
-### Best Practices:
-- Start with centralized coordination mode
-- Use dry-run first to validate configuration
-- Monitor resource usage with \`--monitor\` flag
-- Store important findings in memory for cross-agent access
-- Use background mode for tasks over 30 minutes
-
-## 🎯 SUCCESS METRICS
-
-Your swarm execution is successful when:
-- [ ] Complex task is decomposed effectively
-- [ ] Appropriate agents are coordinated
-- [ ] No timeout issues occur
-- [ ] Quality standards are maintained
-- [ ] Results are properly aggregated
-- [ ] Documentation is comprehensive
-- [ ] All components integrate properly
-
-Remember: The swarm system excels at handling complexity that would overwhelm individual agents. Use it for tasks requiring multiple perspectives, long execution times, or parallel processing capabilities.
-
-Now, let's coordinate your swarm to accomplish your complex objective efficiently! 🐝🚀
-`;
-/**
- * Get the swarm orchestration template
- * @param {string} taskDescription - The task description
- * @param {string} memoryNamespace - The memory namespace
- * @returns {string} The orchestration template
- */
-export function getSwarmOrchestration(taskDescription, memoryNamespace) {
-    return `
-## 🐝 SWARM ORCHESTRATION PLAN
-
-### Phase 1: Swarm Analysis & Planning (5-10 minutes)
-1. **Task Decomposition**
-   - Analyze the complexity and scope of: "${taskDescription}"
-   - Break down into parallel and sequential components
-   - Identify optimal agent types needed
-   - Estimate timeline and resource requirements
-
-2. **Strategy Selection**
-   - Choose appropriate swarm strategy based on task type:
-     * Development: For code implementation tasks
-     * Research: For information gathering and analysis
-     * Analysis: For data processing and insights
-     * Testing: For quality assurance workflows
-     * Optimization: For performance improvements
-     * Maintenance: For system updates and fixes
-
-3. **Coordination Planning**
-   - Determine if task requires background execution (>30 minutes)
-   - Select coordination mode (centralized recommended for start)
-   - Plan memory sharing strategy for cross-agent collaboration
-   - Configure monitoring and review requirements
-
-### Phase 2: Swarm Configuration (2-5 minutes)
-4. **Environment Preparation**
-   \`\`\`bash
-   # Ensure Claude-Flow is properly initialized
-   npx claude-flow status
-   
-   # Check memory system
-   npx claude-flow memory stats
-   \`\`\`
-
-5. **Dry Run Validation**
-   \`\`\`bash
-   # Test swarm configuration before execution
-   npx claude-flow swarm "${taskDescription}" --dry-run --strategy <selected-strategy>
-   \`\`\`
-
-### Phase 3: Swarm Execution (Variable)
-6. **Launch Swarm**
-   Choose appropriate execution method:
-
-   **For Standard Tasks (< 30 minutes):**
-   \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --monitor --verbose
-   \`\`\`
-
-   **For Complex Tasks (30-60 minutes):**
-   \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --parallel --monitor --review
-   \`\`\`
-
-   **For Long-Running Tasks (> 60 minutes):**
-   \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --background --monitor --testing
-   \`\`\`
-
-   **For Enterprise Tasks (Multiple hours):**
-   \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" \\
-     --strategy <strategy> \\
-     --mode distributed \\
-     --max-agents 10 \\
-     --background \\
-     --parallel \\
-     --monitor \\
-     --review \\
-     --testing \\
-     --encryption \\
-     --verbose
-   \`\`\`
-
-### Phase 4: Monitoring & Coordination (Ongoing)
-7. **Real-Time Monitoring**
-   \`\`\`bash
-   # Monitor swarm progress
-   npx claude-flow monitor
-   
-   # Check specific swarm status
-   npx claude-flow status
-   
-   # View agent activities
-   npx claude-flow agent list
-   \`\`\`
-
-8. **Cross-Agent Memory Sharing**
-   \`\`\`bash
-   # Store important findings for all agents
-   npx claude-flow memory store "${memoryNamespace}_findings" "key insights and decisions"
-   
-   # Store progress updates
-   npx claude-flow memory store "${memoryNamespace}_progress" "current completion status"
-   
-   # Store blockers or issues
-   npx claude-flow memory store "${memoryNamespace}_blockers" "any impediments or questions"
-   
-   # Query shared knowledge
-   npx claude-flow memory query "${memoryNamespace}" --limit 10
-   \`\`\`
-
-### Phase 5: Results Integration (5-15 minutes)
-9. **Collect and Validate Results**
-   - Review outputs from all agents
-   - Validate integration between components
-   - Check quality standards and completeness
-   - Document final outcomes
-
-10. **Memory Documentation**
-    \`\`\`bash
-    # Store final results
-    npx claude-flow memory store "${memoryNamespace}_final" "completed task summary and results"
-    
-    # Store lessons learned
-    npx claude-flow memory store "${memoryNamespace}_lessons" "insights for future similar tasks"
-    \`\`\`
-
-## 🎯 SWARM SUCCESS CRITERIA
-
-Your swarm execution is successful when:
-- [ ] Task is properly decomposed for parallel processing
-- [ ] Appropriate swarm strategy is selected and configured
-- [ ] All agents are coordinated effectively
-- [ ] No timeout issues occur during execution
-- [ ] Quality standards are maintained across all outputs
-- [ ] Results from different agents integrate properly
-- [ ] Comprehensive documentation is provided
-- [ ] Cross-agent learning is captured in memory
-
-## ⚠️ TIMEOUT PREVENTION STRATEGY
-
-**Critical Guidelines for Long Tasks:**
-1. **Use Background Mode**: For any task estimated over 30 minutes, use \`--background\` flag
-2. **Enable Monitoring**: Always use \`--monitor\` to track progress
-3. **Memory Persistence**: Store progress regularly for resumability
-4. **Task Chunking**: Break large tasks into smaller, manageable pieces
-5. **Agent Distribution**: Use multiple agents to parallelize work
-6. **State Saving**: Ensure all intermediate results are saved
-
-**Background Execution Benefits:**
-- Processes run independently of your session
-- No risk of timeout or disconnection
-- Continuous progress saving
-- Real-time monitoring available
-- Results accessible when complete
-
-Remember: The swarm system is specifically designed to handle complexity and duration that would overwhelm individual agents. Use it confidently for your most challenging tasks!
-`;
-}
-// Export mode configuration
-export default SWARM_MODE;
-if (import.meta.main) {
-    console.log(prompt);
-}
-//# sourceMappingURL=swarm.js.map

package/dist/cli/simple-commands/sparc-modes/swarm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swarm.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/swarm.js"],"names":[],"mappings":"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"}

package/dist/cli/simple-commands/sparc-modes/tdd.d.ts

@@ -1,2 +0,0 @@
-export function getTddOrchestration(taskDescription: any, memoryNamespace: any): string;
-//# sourceMappingURL=tdd.d.ts.map

package/dist/cli/simple-commands/sparc-modes/tdd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tdd.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/tdd.js"],"names":[],"mappings":"AACA,wFA8GC"}

package/dist/cli/simple-commands/sparc-modes/tdd.js

@@ -1,113 +0,0 @@
-// tdd.js - Test-Driven Development mode orchestration template
-export function getTddOrchestration(taskDescription, memoryNamespace) {
-    return `
-## Task Orchestration Steps - London School TDD
-
-1. **Test Planning & Analysis** (10 mins)
-   - Analyze requirements: "${taskDescription}"
-   - Query existing code and architecture:
-     \\\`\\\`\\\`bash
-     npx claude-flow memory query ${memoryNamespace}_architecture
-     npx claude-flow memory query ${memoryNamespace}_implementation
-     npx claude-flow memory query ${memoryNamespace}_tech_specs
-     \\\`\\\`\\\`
-   - Define test boundaries and acceptance criteria
-   - Plan test structure (unit, integration, e2e)
-   - Identify test doubles needed (mocks, stubs, spies)
-   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_test_plan "Test strategy: Unit tests for domain logic, integration for APIs, e2e for workflows. Mocking: External services, database. Coverage target: 95%."\`
-
-2. **Red Phase - Write Failing Tests** (20 mins)
-   - Create comprehensive test structure:
-     \\\`\\\`\\\`
-     tests/
-     ├── unit/          # Isolated component tests
-     ├── integration/   # Component interaction tests
-     ├── e2e/          # End-to-end workflow tests
-     └── fixtures/      # Test data and mocks
-     \\\`\\\`\\\`
-   - Write tests following London School TDD:
-     - Start with behavior/contract tests
-     - Use test doubles for dependencies
-     - Focus on interactions, not state
-   - Ensure NO hardcoded values in tests
-   - Create parameterized tests for edge cases
-   - Verify all tests fail with meaningful messages
-   - Store status: \`npx claude-flow memory store ${memoryNamespace}_red_phase "Written: 25 unit tests (all failing), 10 integration tests (all failing), 5 e2e tests (all failing). Coverage: 0%."\`
-
-3. **Green Phase - Minimal Implementation** (20 mins)
-   - Implement ONLY enough code to pass tests:
-     - Start with the simplest implementation
-     - Make one test pass at a time
-     - Don't add unrequested functionality
-   - Maintain modularity (files < 500 lines)
-   - Use dependency injection for testability
-   - Implement proper error handling
-   - Track coverage as you progress
-   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_green_phase "Progress: 20/25 unit tests passing, 8/10 integration tests passing. Current coverage: 75%. Remaining: Complex edge cases."\`
-
-4. **Refactor Phase - Optimize & Clean** (15 mins)
-   - Refactor while keeping tests green:
-     - Extract common patterns into utilities
-     - Improve naming and code clarity
-     - Optimize algorithms and data structures
-     - Reduce duplication (DRY principle)
-   - Ensure files remain under 500 lines
-   - Add performance tests if needed
-   - Improve test maintainability
-   - Document complex test scenarios
-   - Store refactoring: \`npx claude-flow memory store ${memoryNamespace}_refactor "Extracted 3 common utilities, optimized database queries, improved test readability. All tests green. Coverage: 95%."\`
-
-5. **Test Documentation & Validation** (10 mins)
-   - Generate coverage reports
-   - Document test scenarios and edge cases
-   - Create test execution guide
-   - Set up CI/CD test configuration
-   - Validate against acceptance criteria
-   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_tdd_complete "TDD cycle complete. Coverage: 95%. All acceptance criteria met. Tests documented. CI/CD ready."\`
-
-## Directory Safety
-- **IMPORTANT**: All test files should be created in the current working directory
-- **DO NOT** create files in system directories or node_modules
-- For named projects, create a subdirectory: \\\`mkdir project-name && cd project-name\\\`
-- Use relative paths from your working directory
-- Test files should follow project structure:
-  \\\`\\\`\\\`
-  ./ (current directory)
-  ├── tests/
-  │   ├── unit/
-  │   ├── integration/
-  │   └── e2e/
-  ├── coverage/
-  └── docs/
-  \\\`\\\`\\\`
-
-## Deliverables
-- tests/
-  - unit/ (isolated component tests)
-  - integration/ (interaction tests)
-  - e2e/ (workflow tests)
-  - fixtures/ (test data, no hardcoded values)
-  - helpers/ (test utilities)
-- coverage/
-  - coverage report (HTML + JSON)
-  - coverage badge
-- docs/
-  - TEST_GUIDE.md (how to run tests)
-  - TEST_SCENARIOS.md (test case documentation)
-- .github/workflows/ or .gitlab-ci.yml (CI configuration)
-
-## Testing Best Practices
-- NO hardcoded secrets or environment values in tests
-- Use test fixtures and factories for test data
-- Mock external dependencies at boundaries
-- Test behavior, not implementation details
-- Maintain test independence (no shared state)
-- Use descriptive test names that document behavior
-
-## Next Steps
-After TDD cycle completes:
-- \`npx claude-flow sparc run debug "Investigate any failing edge cases" --non-interactive\`
-- \`npx claude-flow sparc run refinement-optimization-mode "Optimize performance bottlenecks" --non-interactive\`
-- \`npx claude-flow sparc run docs-writer "Create user documentation" --non-interactive\``;
-}
-//# sourceMappingURL=tdd.js.map

package/dist/cli/simple-commands/sparc-modes/tdd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tdd.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/tdd.js"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,MAAM,UAAU,mBAAmB,CAAC,eAAe,EAAE,eAAe;IAClE,OAAO;;;;8BAIqB,eAAe;;;oCAGT,eAAe;oCACf,eAAe;oCACf,eAAe;;;;;kDAKD,eAAe;;;;;;;;;;;;;;;;;;oDAkBb,eAAe;;;;;;;;;;;sDAWb,eAAe;;;;;;;;;;;;yDAYZ,eAAe;;;;;;;;wDAQhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0FA6CmB,CAAC;AAC3F,CAAC"}

package/dist/cli/simple-commands/sparc-modes/tutorial.d.ts

@@ -1,2 +0,0 @@
-export function getTutorialOrchestration(taskDescription: any, memoryNamespace: any): string;
-//# sourceMappingURL=tutorial.d.ts.map

package/dist/cli/simple-commands/sparc-modes/tutorial.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tutorial.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/tutorial.js"],"names":[],"mappings":"AACA,6FAmRC"}