claude-flow 2.0.0-alpha.48 → 2.0.0-alpha.49

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

@@ -1,138 +0,0 @@
-// 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

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

@@ -1,2 +0,0 @@
-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

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

@@ -1,39 +0,0 @@
-// 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

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

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

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

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

@@ -1,35 +0,0 @@
-// 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

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

@@ -1,17 +0,0 @@
-/**
- * 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: Object, taskDescription: string, memoryNamespace: string): string;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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,wCALW,MAAM,mBACN,MAAM,mBACN,MAAM,GACJ,MAAM,CAwIlB"}

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

@@ -1,196 +0,0 @@
-// 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 = Deno.env.get('PWD') || Deno.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

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

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

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

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

@@ -1,56 +0,0 @@
-// 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

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

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

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

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

@@ -1,39 +0,0 @@
-// 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

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

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

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

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

@@ -1,39 +0,0 @@
-// 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

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

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

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

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