claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

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

@@ -0,0 +1,138 @@
+// devops.js - DevOps mode orchestration template
+export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Environment Analysis** (10 mins)
+   - Run system analysis: \`uname -a\`
+   - Understand deployment requirements: "${taskDescription}"
+   - Query architecture and configuration:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_deployment
+     npx claude-flow memory query ${memoryNamespace}_infrastructure
+     \`\`\`
+   - Identify target environments:
+     - Development, staging, production
+     - Cloud providers (AWS, GCP, Azure)
+     - Edge platforms (Vercel, Cloudflare)
+     - Container orchestration (K8s, ECS)
+   - Review current infrastructure state
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_devops_analysis "Task: ${taskDescription}. Target: AWS ECS + CloudFront. Current: Local dev only. Requirements: Auto-scaling, blue-green deployment, monitoring."\`
+
+2. **Infrastructure Provisioning** (20 mins)
+   - Set up infrastructure as code:
+     - Create Terraform/CloudFormation templates
+     - Define resource configurations
+     - Set up networking (VPC, subnets, security groups)
+   - Provision compute resources:
+     - Cloud functions (Lambda, Cloud Functions)
+     - Container services (ECS, GKE)
+     - Edge runtimes (Workers, Functions)
+   - Configure managed services:
+     - Databases (RDS, DynamoDB, Firestore)
+     - Caching (ElastiCache, Memorystore)
+     - Message queues (SQS, Pub/Sub)
+   - Set up secrets management:
+     - AWS Secrets Manager / GCP Secret Manager
+     - Vault integration
+     - Environment injection layers
+   - NEVER hardcode credentials or tokens
+   - Store provisioning: \`npx claude-flow memory store ${memoryNamespace}_infrastructure "Provisioned: ECS cluster (2 AZs), RDS PostgreSQL, ElastiCache Redis, ALB. Secrets: AWS Secrets Manager configured. Terraform state: S3 backend."\`
+
+3. **CI/CD Pipeline Setup** (15 mins)
+   - Create pipeline configuration:
+     - GitHub Actions / GitLab CI / Jenkins
+     - Multi-stage pipeline (build, test, deploy)
+     - Environment-specific deployments
+   - Implement build stages:
+     \`\`\`yaml
+     - Build: Compile, bundle, optimize
+     - Test: Unit, integration, e2e
+     - Security: SAST, dependency scanning
+     - Package: Docker images, artifacts
+     \`\`\`
+   - Configure deployment strategies:
+     - Blue-green deployments
+     - Canary releases
+     - Rollback procedures
+   - Set up quality gates:
+     - Code coverage thresholds
+     - Performance benchmarks
+     - Security scan results
+   - Store pipeline config: \`npx claude-flow memory store ${memoryNamespace}_cicd "Pipeline: GitHub Actions. Stages: build->test->security->deploy. Environments: dev (auto), staging (manual), prod (approved). Rollback: Automated on failure."\`
+
+4. **Monitoring & Observability** (15 mins)
+   - Set up application monitoring:
+     - APM tools (DataDog, New Relic, AppDynamics)
+     - Custom metrics and dashboards
+     - Real-time alerting
+   - Configure infrastructure monitoring:
+     - CloudWatch / Stackdriver metrics
+     - Resource utilization alerts
+     - Cost optimization tracking
+   - Implement logging strategy:
+     - Centralized logging (ELK, CloudWatch Logs)
+     - Structured logging format
+     - Log retention policies
+   - Set up distributed tracing:
+     - Request flow tracking
+     - Performance bottleneck identification
+     - Error correlation
+   - Configure alerting rules:
+     - SLA/SLO monitoring
+     - Anomaly detection
+     - Escalation procedures
+   - Store monitoring setup: \`npx claude-flow memory store ${memoryNamespace}_monitoring "APM: DataDog configured. Logs: CloudWatch Logs with 30-day retention. Alerts: CPU >80%, Memory >85%, Error rate >1%. Dashboards: App performance, infra health, cost tracking."\`
+
+5. **Security & Compliance** (10 mins)
+   - Implement security best practices:
+     - TLS/SSL certificates (Let's Encrypt, ACM)
+     - WAF rules and DDoS protection
+     - Network segmentation
+     - IAM roles and policies
+   - Configure compliance controls:
+     - Audit logging
+     - Data encryption at rest/transit
+     - Backup and disaster recovery
+   - Set up security scanning:
+     - Container image scanning
+     - Infrastructure vulnerability scanning
+     - Compliance policy validation
+   - Document security procedures
+   - Store security config: \`npx claude-flow memory store ${memoryNamespace}_devops_security "TLS: ACM certificates on ALB. WAF: OWASP rules enabled. IAM: Least privilege roles. Backups: Daily snapshots, 30-day retention. Compliance: SOC2 controls implemented."\`
+
+## Deliverables
+- infrastructure/
+  - terraform/ (IaC templates, < 500 lines per file)
+  - scripts/ (deployment scripts)
+  - configs/ (environment configurations)
+- .github/workflows/ or .gitlab-ci.yml
+  - ci.yml (build and test pipeline)
+  - deploy.yml (deployment pipeline)
+- monitoring/
+  - dashboards/ (monitoring dashboards)
+  - alerts/ (alerting rules)
+- docs/
+  - DEPLOYMENT.md (deployment procedures)
+  - RUNBOOK.md (operational runbook)
+  - DISASTER_RECOVERY.md (DR procedures)
+  - ROLLBACK.md (rollback instructions)
+
+## DevOps Best Practices
+- Immutable infrastructure deployments
+- Blue-green deployment strategy
+- Automated rollback on failures
+- Never hardcode credentials - use secrets managers
+- Infrastructure as Code for everything
+- Comprehensive monitoring and alerting
+- Regular disaster recovery testing
+- Cost optimization reviews
+
+## Next Steps
+After DevOps setup:
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Verify production deployment health" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Audit infrastructure security" --non-interactive\`
+- \`npx claude-flow sparc run refinement-optimization-mode "Optimize deployment performance" --non-interactive\``;
+}
+//# sourceMappingURL=devops.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"devops.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/devops.js"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,MAAM,UAAU,sBAAsB,CAAC,eAAe,EAAE,eAAe;IACrE,OAAO;;;;;4CAKmC,eAAe;;;oCAGvB,eAAe;oCACf,eAAe;oCACf,eAAe;;;;;;;;sDAQG,eAAe,2BAA2B,eAAe;;;;;;;;;;;;;;;;;;;;0DAoBrD,eAAe;;;;;;;;;;;;;;;;;;;;;;6DAsBZ,eAAe;;;;;;;;;;;;;;;;;;;;;;;8DAuBd,eAAe;;;;;;;;;;;;;;;;;6DAiBhB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iHAiCqC,CAAC;AAClH,CAAC"}

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

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

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

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

package/dist/cli/simple-commands/sparc-modes/docs-writer.js

@@ -0,0 +1,39 @@
+// docs-writer.js - Documentation Writer mode orchestration template
+export function getDocsWriterOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Documentation Planning** (10 mins)
+   - Understand documentation needs: "${taskDescription}"
+   - Identify target audience
+   - Define documentation structure
+   - List required sections
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_doc_plan "..."\`
+
+2. **Content Creation** (25 mins)
+   - Write clear, concise documentation
+   - Include code examples
+   - Add diagrams where helpful
+   - Create API references
+   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_doc_content "..."\`
+
+3. **User Guides** (15 mins)
+   - Create quickstart guide
+   - Write installation instructions
+   - Document common use cases
+   - Add troubleshooting section
+   - Store guides: \`npx claude-flow memory store ${memoryNamespace}_user_guides "..."\`
+
+4. **Review & Polish** (10 mins)
+   - Check for clarity and accuracy
+   - Verify code examples work
+   - Add cross-references
+   - Create table of contents
+
+5. **Deliverables**
+   - README.md with overview
+   - docs/getting-started.md
+   - docs/api-reference.md
+   - docs/troubleshooting.md`;
+}
+//# sourceMappingURL=docs-writer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docs-writer.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/docs-writer.js"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,UAAU,0BAA0B,CAAC,eAAe,EAAE,eAAe;IACzE,OAAO;;;;wCAI+B,eAAe;;;;kDAIL,eAAe;;;;;;;sDAOX,eAAe;;;;;;;oDAOjB,eAAe;;;;;;;;;;;;6BAYtC,CAAC;AAC9B,CAAC"}

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

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

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

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

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

@@ -0,0 +1,35 @@
+// generic.js - Generic mode orchestration template
+export function getGenericOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Analysis** (10 mins)
+   - Understand the task: "${taskDescription}"
+   - Break down requirements
+   - Identify deliverables
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_analysis "..."\`
+
+2. **Planning** (10 mins)
+   - Create implementation plan
+   - Define milestones
+   - Set up project structure
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_plan "..."\`
+
+3. **Implementation** (30 mins)
+   - Execute the main task
+   - Follow best practices
+   - Keep code modular
+   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_implementation "..."\`
+
+4. **Validation** (10 mins)
+   - Test the solution
+   - Verify requirements met
+   - Document the work
+   - Store validation: \`npx claude-flow memory store ${memoryNamespace}_validation "..."\`
+
+5. **Deliverables**
+   - Completed implementation
+   - Documentation
+   - Test results`;
+}
+//# sourceMappingURL=generic.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generic.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/generic.js"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,MAAM,UAAU,uBAAuB,CAAC,eAAe,EAAE,eAAe;IACtE,OAAO;;;;6BAIoB,eAAe;;;sDAGU,eAAe;;;;;;kDAMnB,eAAe;;;;;;sDAMX,eAAe;;;;;;wDAMb,eAAe;;;;;kBAKrD,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * Get orchestration template for a specific mode
+ * @param {string} modeSlug - The mode slug identifier
+ * @param {string} taskDescription - The task description
+ * @param {string} memoryNamespace - The memory namespace
+ * @returns {string} The orchestration template
+ */
+export function getModeOrchestration(modeSlug: string, taskDescription: string, memoryNamespace: string): string;
+/**
+ * Get the base SPARC prompt template
+ * @param {Object} mode - The mode configuration
+ * @param {string} taskDescription - The task description
+ * @param {string} memoryNamespace - The memory namespace
+ * @returns {string} The complete SPARC prompt
+ */
+export function createSparcPrompt(mode: any, taskDescription: string, memoryNamespace: string): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/index.js"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,+CALW,MAAM,mBACN,MAAM,mBACN,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;GAMG;AACH,8DAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAwIlB"}

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

@@ -0,0 +1,196 @@
+// index.js - SPARC mode orchestration loader
+import { getArchitectOrchestration } from './architect.js';
+import { getCodeOrchestration } from './code.js';
+import { getTddOrchestration } from './tdd.js';
+import { getDebugOrchestration } from './debug.js';
+import { getSecurityReviewOrchestration } from './security-review.js';
+import { getDocsWriterOrchestration } from './docs-writer.js';
+import { getIntegrationOrchestration } from './integration.js';
+import { getMonitoringOrchestration } from './monitoring.js';
+import { getOptimizationOrchestration } from './optimization.js';
+import { getSupabaseAdminOrchestration } from './supabase-admin.js';
+import { getSpecPseudocodeOrchestration } from './spec-pseudocode.js';
+import { getMcpOrchestration } from './mcp.js';
+import { getDevOpsOrchestration } from './devops.js';
+import { getAskOrchestration } from './ask.js';
+import { getTutorialOrchestration } from './tutorial.js';
+import { getSparcOrchestratorOrchestration } from './sparc-orchestrator.js';
+import { getGenericOrchestration } from './generic.js';
+import { getSwarmOrchestration } from './swarm.js';
+// Mode orchestration mapping
+const modeOrchestrations = {
+    architect: getArchitectOrchestration,
+    code: getCodeOrchestration,
+    tdd: getTddOrchestration,
+    debug: getDebugOrchestration,
+    'security-review': getSecurityReviewOrchestration,
+    'docs-writer': getDocsWriterOrchestration,
+    integration: getIntegrationOrchestration,
+    'post-deployment-monitoring-mode': getMonitoringOrchestration,
+    'refinement-optimization-mode': getOptimizationOrchestration,
+    'supabase-admin': getSupabaseAdminOrchestration,
+    'spec-pseudocode': getSpecPseudocodeOrchestration,
+    mcp: getMcpOrchestration,
+    devops: getDevOpsOrchestration,
+    ask: getAskOrchestration,
+    tutorial: getTutorialOrchestration,
+    sparc: getSparcOrchestratorOrchestration,
+    swarm: getSwarmOrchestration,
+};
+/**
+ * Get orchestration template for a specific mode
+ * @param {string} modeSlug - The mode slug identifier
+ * @param {string} taskDescription - The task description
+ * @param {string} memoryNamespace - The memory namespace
+ * @returns {string} The orchestration template
+ */
+export function getModeOrchestration(modeSlug, taskDescription, memoryNamespace) {
+    const orchestrationFunction = modeOrchestrations[modeSlug];
+    if (orchestrationFunction) {
+        return orchestrationFunction(taskDescription, memoryNamespace);
+    }
+    // Return generic orchestration for unknown modes
+    return getGenericOrchestration(taskDescription, memoryNamespace);
+}
+/**
+ * Get the base SPARC prompt template
+ * @param {Object} mode - The mode configuration
+ * @param {string} taskDescription - The task description
+ * @param {string} memoryNamespace - The memory namespace
+ * @returns {string} The complete SPARC prompt
+ */
+export function createSparcPrompt(mode, taskDescription, memoryNamespace) {
+    const orchestration = getModeOrchestration(mode.slug, taskDescription, memoryNamespace);
+    // Get the actual working directory where the command was run from
+    const cwd = process.env.PWD || process.cwd();
+    return `# ${mode.name} - Task Execution
+
+## 🎯 Your Mission
+Build exactly what the user requested: "${taskDescription}"
+
+## 📁 IMPORTANT: Project Directory
+**Current Working Directory:** ${cwd}
+
+⚠️ **CRITICAL INSTRUCTIONS:**
+- Create ALL project files in the current working directory: ${cwd}
+- NEVER create files in node_modules/ or any claude-flow directories
+- If the task specifies a project name (e.g., "hello-world"), create it as a subdirectory in ${cwd}
+- Use paths relative to ${cwd} for all file operations
+- Example: If creating "hello-world" app, use ${cwd}/hello-world/
+
+## 🚀 Your Role
+${mode.roleDefinition}
+
+${orchestration}
+
+## 📋 Mode-Specific Guidelines
+${mode.customInstructions}
+
+## 🛠️ Claude-Flow Integration
+
+### Memory Operations
+Use the memory system to track your progress and share context:
+
+\`\`\`bash
+# Store your work
+npx claude-flow memory store ${memoryNamespace}_<phase> "description of work completed"
+
+# Query previous work
+npx claude-flow memory query ${memoryNamespace}
+
+# Examples for this task
+npx claude-flow memory store ${memoryNamespace}_analysis "Analyzed ${taskDescription} - found X components needed"
+npx claude-flow memory store ${memoryNamespace}_progress "Completed Y% of implementation"
+npx claude-flow memory store ${memoryNamespace}_blockers "Issue with Z - need clarification"
+\`\`\`
+
+### Task Orchestration
+For complex tasks, coordinate with other specialists:
+
+\`\`\`bash
+# Check system status
+npx claude-flow status
+
+# View active agents (if --parallel was used)
+npx claude-flow agent list
+
+# Monitor progress
+npx claude-flow monitor
+\`\`\`
+
+### 🚀 Parallel Execution with BatchTool
+Use BatchTool to orchestrate multiple SPARC modes concurrently in a boomerang pattern:
+
+\`\`\`bash
+# Example: Parallel development workflow
+batchtool run --parallel \\
+  "npx claude-flow sparc run architect 'design user authentication system' --non-interactive" \\
+  "npx claude-flow sparc run security-review 'analyze authentication requirements' --non-interactive" \\
+  "npx claude-flow sparc run spec-pseudocode 'create auth flow pseudocode' --non-interactive"
+
+# Boomerang Pattern: Research → Design → Implement → Test → Refine
+batchtool orchestrate --boomerang \\
+  --phase1 "npx claude-flow sparc run ask 'research best auth practices' --non-interactive" \\
+  --phase2 "npx claude-flow sparc run architect 'design based on research' --non-interactive" \\
+  --phase3 "npx claude-flow sparc run code 'implement auth system' --non-interactive" \\
+  --phase4 "npx claude-flow sparc run tdd 'test auth implementation' --non-interactive" \\
+  --phase5 "npx claude-flow sparc run optimization 'refine auth performance' --non-interactive"
+
+# Concurrent Feature Development
+batchtool run --concurrent --max-parallel 3 \\
+  "npx claude-flow sparc run code 'implement login feature' --non-interactive" \\
+  "npx claude-flow sparc run code 'implement registration feature' --non-interactive" \\
+  "npx claude-flow sparc run code 'implement password reset' --non-interactive" \\
+  "npx claude-flow sparc run tdd 'create auth test suite' --non-interactive"
+\`\`\`
+
+#### Boomerang Orchestration Pattern
+The boomerang pattern allows for iterative development where results from one phase inform the next:
+1. **Research Phase**: Gather requirements and best practices
+2. **Design Phase**: Create architecture based on research
+3. **Implementation Phase**: Build according to design
+4. **Testing Phase**: Validate implementation
+5. **Refinement Phase**: Optimize based on test results
+6. **Loop Back**: Results feed back to improve the cycle
+
+Benefits of --non-interactive mode with BatchTool:
+- No manual intervention required
+- Parallel execution of independent tasks
+- Automatic result collection and aggregation
+- Progress tracking across all concurrent operations
+- Efficient resource utilization
+
+## ⚡ Execution Guidelines
+
+1. **Focus on User's Project**
+   - Build what they asked for, not improvements to claude-flow
+   - Create files ONLY in the current working directory: ${cwd}
+   - NEVER create files in node_modules/ or system directories
+   - If creating a named project, make it a subdirectory of ${cwd}
+   - Use appropriate project structure relative to ${cwd}
+
+2. **Directory Rules**
+   - Current directory: ${cwd}
+   - Create new projects as: ${cwd}/<project-name>/
+   - Use relative paths from ${cwd} for all operations
+   - Verify you're in the correct directory before creating files
+
+3. **Quality Standards**
+   - Keep all files under 500 lines
+   - Never hardcode secrets or credentials
+   - Use environment variables and config files
+   - Write clean, maintainable code
+
+4. **Communication**
+   - Store progress updates in memory
+   - Document key decisions
+   - Ask for clarification if needed
+   - Provide clear status updates
+
+## 🏁 Start Execution
+
+Begin with Step 1 of the orchestration plan above. Focus on delivering exactly what was requested: "${taskDescription}"
+
+Remember: You're building the user's project, using claude-flow only for memory and orchestration support.`;
+}
+//# sourceMappingURL=index.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+// integration.js - System Integrator mode orchestration template
+export function getIntegrationOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Integration Analysis** (10 mins)
+   - Review integration requirements: "${taskDescription}"
+   - Identify components to connect
+   - Map data flows between systems
+   - Check compatibility requirements
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_integration_analysis "..."\`
+
+2. **Interface Development** (20 mins)
+   - Create integration adapters
+   - Implement data transformers
+   - Build connection handlers
+   - Add retry mechanisms
+   - Store interfaces: \`npx claude-flow memory store ${memoryNamespace}_interfaces "..."\`
+
+3. **System Connection** (20 mins)
+   - Wire up components
+   - Configure communication channels
+   - Implement error handling
+   - Add monitoring hooks
+   - Store configuration: \`npx claude-flow memory store ${memoryNamespace}_connections "..."\`
+
+4. **End-to-End Testing** (15 mins)
+   - Test data flow scenarios
+   - Verify error handling
+   - Check performance metrics
+   - Validate data integrity
+
+5. **Directory Safety**
+   - **IMPORTANT**: All integration 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
+   - Suggested structure for integration code:
+     \`\`\`
+     ./ (current directory)
+     ├── integrations/
+     │   ├── adapters/
+     │   ├── transformers/
+     │   └── handlers/
+     ├── config/
+     └── tests/
+         └── integration/
+     \`\`\`
+
+6. **Deliverables**
+   - Integration layer code
+   - Configuration templates
+   - Integration test suite
+   - Deployment guide`;
+}
+//# sourceMappingURL=integration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/integration.js"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,UAAU,2BAA2B,CAAC,eAAe,EAAE,eAAe;IAC1E,OAAO;;;;yCAIgC,eAAe;;;;sDAIF,eAAe;;;;;;;wDAOb,eAAe;;;;;;;2DAOZ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6BpD,CAAC;AACvB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,39 @@
+// mcp.js - MCP Integration mode orchestration template
+export function getMcpOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Integration Planning** (10 mins)
+   - Understand integration needs: "${taskDescription}"
+   - Identify MCP endpoints
+   - Review API documentation
+   - Plan data mappings
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_mcp_plan "..."\`
+
+2. **Connection Setup** (15 mins)
+   - Configure MCP servers
+   - Set up authentication
+   - Test connectivity
+   - Implement error handling
+   - Store config: \`npx claude-flow memory store ${memoryNamespace}_mcp_config "..."\`
+
+3. **Data Integration** (20 mins)
+   - Implement data transformers
+   - Create API wrappers
+   - Add validation layers
+   - Build retry mechanisms
+   - Store integration: \`npx claude-flow memory store ${memoryNamespace}_mcp_integration "..."\`
+
+4. **Testing & Validation** (15 mins)
+   - Test all endpoints
+   - Verify data accuracy
+   - Check error scenarios
+   - Monitor performance
+
+5. **Deliverables**
+   - MCP integration code
+   - Configuration files
+   - API documentation
+   - Integration tests`;
+}
+//# sourceMappingURL=mcp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/mcp.js"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,MAAM,UAAU,mBAAmB,CAAC,eAAe,EAAE,eAAe;IAClE,OAAO;;;;sCAI6B,eAAe;;;;kDAIH,eAAe;;;;;;;oDAOb,eAAe;;;;;;;yDAOV,eAAe;;;;;;;;;;;;uBAYjD,CAAC;AACxB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,39 @@
+// monitoring.js - Deployment Monitor mode orchestration template
+export function getMonitoringOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Monitoring Setup** (15 mins)
+   - Define monitoring scope: "${taskDescription}"
+   - Identify key metrics
+   - Set up logging infrastructure
+   - Configure alerting rules
+   - Store setup: \`npx claude-flow memory store ${memoryNamespace}_monitoring_setup "..."\`
+
+2. **Metric Collection** (20 mins)
+   - Implement performance metrics
+   - Add business metrics
+   - Set up error tracking
+   - Configure uptime monitoring
+   - Store metrics: \`npx claude-flow memory store ${memoryNamespace}_metrics "..."\`
+
+3. **Dashboard Creation** (15 mins)
+   - Build monitoring dashboards
+   - Create alert configurations
+   - Set up automated reports
+   - Document metric meanings
+   - Store dashboards: \`npx claude-flow memory store ${memoryNamespace}_dashboards "..."\`
+
+4. **Baseline Establishment** (10 mins)
+   - Collect initial metrics
+   - Define normal ranges
+   - Set alert thresholds
+   - Document SLIs/SLOs
+
+5. **Deliverables**
+   - Monitoring configuration
+   - Dashboard definitions
+   - Alert rules
+   - Ops runbook`;
+}
+//# sourceMappingURL=monitoring.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monitoring.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/monitoring.js"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,UAAU,0BAA0B,CAAC,eAAe,EAAE,eAAe;IACzE,OAAO;;;;iCAIwB,eAAe;;;;mDAIG,eAAe;;;;;;;qDAOb,eAAe;;;;;;;wDAOZ,eAAe;;;;;;;;;;;;iBAYtD,CAAC;AAClB,CAAC"}

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

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

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

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