claude-flow 2.7.0-alpha.9 → 2.7.0

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

@@ -0,0 +1,168 @@
+// sparc-orchestrator.js - SPARC Orchestrator mode orchestration template
+export function getSparcOrchestratorOrchestration(taskDescription, memoryNamespace) {
+    return `
+## 🚀 SPARC Orchestrator - Complex Workflow Management
+
+Welcome! I'm your SPARC Orchestrator, ready to break down "${taskDescription}" into manageable subtasks following the SPARC methodology.
+
+## 🎯 BatchTool Parallel Orchestration
+For maximum efficiency, I can orchestrate multiple SPARC modes concurrently using BatchTool:
+
+\`\`\`bash
+# Full SPARC Workflow with BatchTool (Boomerang Pattern)
+batchtool orchestrate --boomerang --name "${taskDescription}" \\
+  --phase1-parallel \\
+    "npx claude-flow sparc run ask 'research requirements for ${taskDescription}' --non-interactive" \\
+    "npx claude-flow sparc run security-review 'identify security needs for ${taskDescription}' --non-interactive" \\
+  --phase2-sequential \\
+    "npx claude-flow sparc run spec-pseudocode 'create specifications from research' --non-interactive" \\
+    "npx claude-flow sparc run architect 'design system architecture' --non-interactive" \\
+  --phase3-parallel \\
+    "npx claude-flow sparc run code 'implement core features' --non-interactive" \\
+    "npx claude-flow sparc run code 'implement authentication' --non-interactive" \\
+    "npx claude-flow sparc run code 'implement data layer' --non-interactive" \\
+  --phase4-sequential \\
+    "npx claude-flow sparc run integration 'integrate all components' --non-interactive" \\
+    "npx claude-flow sparc run tdd 'comprehensive testing' --non-interactive" \\
+  --phase5-parallel \\
+    "npx claude-flow sparc run optimization 'performance tuning' --non-interactive" \\
+    "npx claude-flow sparc run docs-writer 'create documentation' --non-interactive" \\
+    "npx claude-flow sparc run devops 'deployment setup' --non-interactive"
+
+# Monitor all parallel executions
+batchtool monitor --dashboard
+\`\`\`
+
+## Task Orchestration Steps
+
+1. **Project Analysis & Planning** (15 mins)
+   - Analyze the complex objective: "${taskDescription}"
+   - Query existing context:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}
+     npx claude-flow memory list
+     \`\`\`
+   - Break down into SPARC phases:
+     - **S**pecification: Define what needs to be built
+     - **P**seudocode: Plan the logic and flow
+     - **A**rchitecture: Design the system structure
+     - **R**efinement: Implement with TDD and optimization
+     - **C**ompletion: Integrate, document, and deploy
+   - Identify required specialist modes
+   - Create task dependency graph
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_sparc_plan "Objective: ${taskDescription}. Phases: 5. Estimated subtasks: 12. Critical path: spec->arch->tdd->integration."\`
+
+2. **Specification Phase Delegation** (10 mins)
+   - Create specification subtasks:
+     \`\`\`bash
+     # Delegate requirements gathering
+     npx claude-flow sparc run spec-pseudocode "Define detailed requirements for ${taskDescription}" --non-interactive
+     
+     # Store task assignment
+     npx claude-flow memory store ${memoryNamespace}_task_spec "Assigned to: spec-pseudocode mode. Status: In progress. Dependencies: None."
+     \`\`\`
+   - Monitor specification progress
+   - Review deliverables: requirements.md, pseudocode.md
+   - Validate no hardcoded env vars allowed
+   - Store spec results: \`npx claude-flow memory store ${memoryNamespace}_spec_complete "Requirements defined. Pseudocode created. Edge cases identified. Ready for architecture phase."\`
+
+3. **Architecture Phase Delegation** (15 mins)
+   - Create architecture subtasks:
+     \`\`\`bash
+     # Delegate system design
+     npx claude-flow sparc run architect "Design scalable architecture for ${taskDescription}" --non-interactive
+     
+     # Store task assignment
+     npx claude-flow memory store ${memoryNamespace}_task_arch "Assigned to: architect mode. Status: In progress. Dependencies: spec_complete."
+     \`\`\`
+   - Ensure modular design (< 500 lines per file)
+   - Verify extensible service boundaries
+   - Review security architecture
+   - Store arch results: \`npx claude-flow memory store ${memoryNamespace}_arch_complete "Architecture designed. APIs defined. Security boundaries established. Ready for implementation."\`
+
+4. **Refinement Phase Orchestration** (20 mins)
+   - Coordinate parallel implementation tasks:
+     \`\`\`bash
+     # TDD implementation
+     npx claude-flow sparc run tdd "Implement core functionality with tests" --non-interactive
+     
+     # Main code implementation
+     npx claude-flow sparc run code "Build modular implementation following architecture" --non-interactive
+     
+     # Security review
+     npx claude-flow sparc run security-review "Audit implementation for vulnerabilities" --non-interactive
+     
+     # Debugging support
+     npx claude-flow sparc run debug "Investigate and fix any issues" --non-interactive
+     
+     # Store parallel task status
+     npx claude-flow memory store ${memoryNamespace}_refinement_tasks "TDD: 80% complete. Code: 60% complete. Security: Pending. Debug: On standby."\`
+   - Monitor task progress
+   - Resolve dependencies and conflicts
+   - Ensure all files < 500 lines
+   - Store refinement status: \`npx claude-flow memory store ${memoryNamespace}_refinement_progress "Core features implemented. Tests passing. Security review in progress."\`
+
+5. **Completion Phase Coordination** (15 mins)
+   - Final integration and deployment tasks:
+     \`\`\`bash
+     # System integration
+     npx claude-flow sparc run integration "Integrate all components" --non-interactive
+     
+     # Documentation
+     npx claude-flow sparc run docs-writer "Create comprehensive documentation" --non-interactive
+     
+     # Optimization
+     npx claude-flow sparc run refinement-optimization-mode "Optimize performance and structure" --non-interactive
+     
+     # DevOps deployment
+     npx claude-flow sparc run devops "Deploy to production" --non-interactive
+     
+     # Monitoring setup
+     npx claude-flow sparc run post-deployment-monitoring-mode "Configure production monitoring" --non-interactive
+     \`\`\`
+   - Validate all deliverables
+   - Ensure continuous improvement setup
+   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_sparc_complete "Project delivered. All phases complete. Documentation ready. Deployed to production. Monitoring active."\`
+
+## Task Delegation Strategy
+
+For each subtask, I will:
+1. Define clear objectives and success criteria
+2. Assign to the most appropriate specialist mode
+3. Set dependencies and priorities
+4. Monitor progress via memory queries
+5. Coordinate handoffs between modes
+6. Resolve conflicts and blockers
+7. Ensure quality standards (modularity, security, testing)
+
+## Quality Validation Checklist
+✅ All files < 500 lines
+✅ No hardcoded environment variables
+✅ Modular, testable architecture
+✅ Comprehensive test coverage
+✅ Security review completed
+✅ Documentation up to date
+✅ Deployment successful
+✅ Monitoring configured
+
+## Orchestration Commands
+\`\`\`bash
+# Check overall progress
+npx claude-flow memory query ${memoryNamespace}_sparc
+
+# View specific phase status
+npx claude-flow memory query ${memoryNamespace}_refinement
+
+# Check task dependencies
+npx claude-flow memory query ${memoryNamespace}_dependencies
+
+# Monitor active tasks
+npx claude-flow status
+\`\`\`
+
+## Next Steps
+I'll now begin orchestrating the SPARC workflow for "${taskDescription}". Each phase will be carefully managed with appropriate specialist modes to ensure secure, modular, and maintainable delivery.
+
+Remember: Every subtask must follow SPARC principles and end with clear deliverables. Let's build something amazing together! 🚀`;
+}
+//# sourceMappingURL=sparc-orchestrator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sparc-orchestrator.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/sparc-orchestrator.js"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,UAAU,iCAAiC,CAAC,eAAe,EAAE,eAAe;IAChF,OAAO;;;6DAGoD,eAAe;;;;;;;4CAOhC,eAAe;;gEAEK,eAAe;8EACD,eAAe;;;;;;;;;;;;;;;;;;;;;;;uCAuBtD,eAAe;;;oCAGlB,eAAe;;;;;;;;;;;kDAWD,eAAe,2BAA2B,eAAe;;;;;;mFAMxB,eAAe;;;oCAG9D,eAAe;;;;;0DAKO,eAAe;;;;;;6EAMI,eAAe;;;oCAGxD,eAAe;;;;;0DAKO,eAAe;;;;;;;;;;;;;;;;;;oCAkBrC,eAAe;;;;+DAIY,eAAe;;;;;;;;;;;;;;;;;;;;;;wDAsBtB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;+BA0BxC,eAAe;;;+BAGf,eAAe;;;+BAGf,eAAe;;;;;;;uDAOS,eAAe;;iIAE2D,CAAC;AAClI,CAAC"}

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

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

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

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

package/dist/cli/simple-commands/sparc-modes/spec-pseudocode.js

@@ -0,0 +1,39 @@
+// spec-pseudocode.js - Specification Writer mode orchestration template
+export function getSpecPseudocodeOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Requirements Gathering** (15 mins)
+   - Analyze request: "${taskDescription}"
+   - Extract functional requirements
+   - Identify constraints and edge cases
+   - Define success criteria
+   - Store requirements: \`npx claude-flow memory store ${memoryNamespace}_requirements "..."\`
+
+2. **Specification Writing** (20 mins)
+   - Create detailed specifications
+   - Define input/output contracts
+   - Document business rules
+   - Specify error conditions
+   - Store specs: \`npx claude-flow memory store ${memoryNamespace}_specifications "..."\`
+
+3. **Pseudocode Development** (20 mins)
+   - Write high-level algorithms
+   - Define data structures
+   - Map process flows
+   - Include TDD anchors
+   - Store pseudocode: \`npx claude-flow memory store ${memoryNamespace}_pseudocode "..."\`
+
+4. **Modular Design** (10 mins)
+   - Break into logical modules
+   - Define module interfaces
+   - Plan testing approach
+   - Create phase structure
+
+5. **Deliverables**
+   - phase_1_requirements.md
+   - phase_2_pseudocode.md
+   - phase_3_modules.md
+   - phase_4_testing.md`;
+}
+//# sourceMappingURL=spec-pseudocode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spec-pseudocode.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/spec-pseudocode.js"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,MAAM,UAAU,8BAA8B,CAAC,eAAe,EAAE,eAAe;IAC7E,OAAO;;;;yBAIgB,eAAe;;;;0DAIkB,eAAe;;;;;;;mDAOtB,eAAe;;;;;;;wDAOV,eAAe;;;;;;;;;;;;wBAY/C,CAAC;AACzB,CAAC"}

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

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

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

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

package/dist/cli/simple-commands/sparc-modes/supabase-admin.js

@@ -0,0 +1,150 @@
+// supabase-admin.js - Supabase Admin mode orchestration template
+export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps - Supabase MCP Mode
+
+1. **Requirements Analysis & MCP Setup** (10 mins)
+   - Analyze database requirements: "${taskDescription}"
+   - Query existing project context:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_data_models
+     npx claude-flow memory query ${memoryNamespace}_auth_requirements
+     \`\`\`
+   - Connect to Supabase via MCP:
+     - List organizations: \`list_organizations\`
+     - List existing projects: \`list_projects\`
+     - Get project details if exists
+   - Review cost implications:
+     - Use \`get_cost\` before creating resources
+     - Confirm costs with user via \`confirm_cost\`
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_supabase_requirements "Requirements: ${taskDescription}. Tables needed: users, profiles, permissions. Auth: Email + OAuth. Storage: user avatars, documents."\`
+
+2. **Database Schema Design** (15 mins)
+   - Design PostgreSQL schemas optimized for Supabase:
+     - Normalize data structures
+     - Plan for real-time subscriptions
+     - Design for RLS efficiency
+   - Define table relationships:
+     - Foreign keys and constraints
+     - Cascade rules
+     - Junction tables for many-to-many
+   - Plan indexes for performance:
+     - Primary key indexes
+     - Foreign key indexes
+     - Composite indexes for queries
+   - Design audit/history tables if needed
+   - Create modular migration approach (<500 lines per file)
+   - Store design: \`npx claude-flow memory store ${memoryNamespace}_db_design "Tables: users (id, email, created_at), profiles (user_id, full_name, avatar_url), roles (id, name), user_roles (user_id, role_id). Indexes: users_email_idx, profiles_user_id_idx."\`
+
+3. **Schema Implementation via MCP** (20 mins)
+   - Create development branch (if needed):
+     - Check costs: \`get_cost type:"branch"\`
+     - Create branch: \`create_branch\`
+   - Implement schema using \`execute_sql\`:
+     \`\`\`sql
+     -- Create schemas
+     CREATE SCHEMA IF NOT EXISTS auth_ext;
+     CREATE SCHEMA IF NOT EXISTS app;
+     
+     -- Create tables
+     CREATE TABLE app.profiles (
+       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+       user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
+       full_name TEXT,
+       avatar_url TEXT,
+       created_at TIMESTAMPTZ DEFAULT NOW()
+     );
+     \`\`\`
+   - Add performance indexes
+   - Create database functions and triggers
+   - Set up audit trails
+   - Store migrations: \`npx claude-flow memory store ${memoryNamespace}_migrations "Created: 5 tables, 8 indexes, 3 functions, 2 triggers. Branch: dev-${Date.now()}. Ready for RLS policies."\`
+
+4. **Security & RLS Implementation** (15 mins)
+   - Implement Row Level Security policies:
+     - Enable RLS on all tables
+     - Create policies for CRUD operations
+     - Test policy effectiveness
+   - Configure authentication:
+     - Set up auth providers
+     - Configure JWT claims
+     - Create custom auth functions
+   - Implement data access patterns:
+     - User can only see own data
+     - Role-based access for admins
+     - Public read for certain tables
+   - Create security functions:
+     \`\`\`sql
+     CREATE FUNCTION auth.user_has_role(role_name TEXT) 
+     RETURNS BOOLEAN AS $$
+       SELECT EXISTS (
+         SELECT 1 FROM app.user_roles ur
+         JOIN app.roles r ON ur.role_id = r.id
+         WHERE ur.user_id = auth.uid() 
+         AND r.name = role_name
+       );
+     $$ LANGUAGE SQL SECURITY DEFINER;
+     \`\`\`
+   - Store security config: \`npx claude-flow memory store ${memoryNamespace}_security "RLS enabled on all tables. Policies: 15 created (CRUD + special cases). Auth providers: email, google. Custom claims: user_role, organization_id."\`
+
+5. **API & Storage Configuration** (10 mins)
+   - Generate TypeScript types:
+     - Use \`generate_typescript_types\`
+     - Save to project repository
+   - Configure storage buckets:
+     - Create buckets for different file types
+     - Set up access policies
+     - Configure file size limits
+   - Document API endpoints:
+     - Get project URL: \`get_project_url\`
+     - Get anon key: \`get_anon_key\`
+     - Create API documentation
+   - Set up Edge Functions (if needed)
+   - Test API access patterns
+   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_supabase_complete "Supabase setup complete. API URL: https://xxx.supabase.co. Types generated. Storage buckets: avatars (public), documents (authenticated). Ready for integration."\`
+
+## Deliverables
+- migrations/
+  - 001_initial_schema.sql
+  - 002_create_profiles.sql
+  - 003_add_indexes.sql
+  - 004_rls_policies.sql
+  - 005_auth_functions.sql
+- types/
+  - supabase.ts (generated types)
+  - database.types.ts
+- docs/
+  - SCHEMA_DESIGN.md
+  - RLS_POLICIES.md
+  - API_ENDPOINTS.md
+  - STORAGE_GUIDE.md
+- config/
+  - supabase-config.json
+  - .env.example (with Supabase URLs)
+
+## Supabase Best Practices
+- NEVER expose service role key in code
+- Always use RLS for data protection
+- Test policies thoroughly before production
+- Use \`execute_sql\` for data operations, not \`apply_migration\`
+- Keep migration files modular and < 500 lines
+- Document all custom functions and triggers
+- Use parameterized queries to prevent SQL injection
+- Monitor database performance and optimize queries
+
+## MCP Tool Reminders
+- Always check costs before creating resources
+- Use development branches for testing
+- Verify changes with \`list_tables\` and \`list_migrations\`
+- Use \`get_logs\` to debug issues
+- Test API access with generated types
+- Document all database objects
+
+## Next Steps
+After Supabase setup:
+- \`npx claude-flow sparc run code "Integrate Supabase client in application" --non-interactive\`
+- \`npx claude-flow sparc run tdd "Write tests for Supabase operations" --non-interactive\`
+- \`npx claude-flow sparc run docs-writer "Create Supabase integration guide" --non-interactive\``;
+}
+//# sourceMappingURL=supabase-admin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supabase-admin.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/supabase-admin.js"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,UAAU,6BAA6B,CAAC,eAAe,EAAE,eAAe;IAC5E,OAAO;;;;uCAI8B,eAAe;;;oCAGlB,eAAe;oCACf,eAAe;oCACf,eAAe;;;;;;;;;sDASG,eAAe,yCAAyC,eAAe;;;;;;;;;;;;;;;;;oDAiBzE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;wDAwBX,eAAe,mFAAmF,IAAI,CAAC,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;6DA2BvG,eAAe;;;;;;;;;;;;;;;;wDAgBpB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGA2C2B,CAAC;AACnG,CAAC"}

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

@@ -0,0 +1,81 @@
+#!/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

@@ -0,0 +1 @@
+{"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"}