claude-flow 2.7.0-alpha.13 → 2.7.0-alpha.14

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"}

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

@@ -0,0 +1,39 @@
+// optimization.js - Optimizer mode orchestration template
+export function getOptimizationOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Performance Analysis** (15 mins)
+   - Analyze optimization needs: "${taskDescription}"
+   - Profile current performance
+   - Identify bottlenecks
+   - Review code quality metrics
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_performance_analysis "..."\`
+
+2. **Refactoring Plan** (10 mins)
+   - Prioritize improvements
+   - Plan refactoring approach
+   - Identify quick wins
+   - Estimate impact
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_refactor_plan "..."\`
+
+3. **Code Optimization** (25 mins)
+   - Refactor large files (>500 lines)
+   - Optimize algorithms
+   - Improve data structures
+   - Enhance caching strategies
+   - Store changes: \`npx claude-flow memory store ${memoryNamespace}_optimizations "..."\`
+
+4. **Validation** (10 mins)
+   - Run performance benchmarks
+   - Verify functionality preserved
+   - Check test coverage
+   - Document improvements
+
+5. **Deliverables**
+   - Optimized codebase
+   - Performance metrics
+   - Refactoring documentation
+   - Best practices guide`;
+}
+//# sourceMappingURL=optimization.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimization.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/optimization.js"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,MAAM,UAAU,4BAA4B,CAAC,eAAe,EAAE,eAAe;IAC3E,OAAO;;;;oCAI2B,eAAe;;;;sDAIG,eAAe;;;;;;;kDAOnB,eAAe;;;;;;;qDAOZ,eAAe;;;;;;;;;;;;0BAY1C,CAAC;AAC3B,CAAC"}

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

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

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

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

package/dist/cli/simple-commands/sparc-modes/security-review.js

@@ -0,0 +1,131 @@
+// security-review.js - Security Reviewer mode orchestration template
+export function getSecurityReviewOrchestration(taskDescription, memoryNamespace) {
+    return `
+## Task Orchestration Steps
+
+1. **Security Audit Scope Definition** (10 mins)
+   - Define audit boundaries for: "${taskDescription}"
+   - Query system architecture and sensitive areas:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_auth
+     npx claude-flow memory query ${memoryNamespace}_config
+     \`\`\`
+   - Identify critical assets:
+     - User data and PII
+     - Authentication tokens/sessions
+     - API keys and credentials
+     - Payment/financial data
+   - Map data flows and trust boundaries
+   - List all external interfaces and integrations
+   - Review authentication/authorization points
+   - Store scope: \`npx claude-flow memory store ${memoryNamespace}_security_scope "Audit scope: ${taskDescription}. Critical assets: user PII, JWT tokens, payment data. External interfaces: REST API, webhooks, third-party integrations."\`
+
+2. **Static Security Analysis** (20 mins)
+   - Scan for hardcoded secrets and credentials:
+     - Check all code files for API keys, passwords
+     - Verify .env files are properly gitignored
+     - Ensure no secrets in logs or error messages
+   - Review environment configuration:
+     - Check for direct env coupling
+     - Verify secrets management approach
+     - Ensure config files don't expose sensitive data
+   - Analyze authentication/authorization:
+     - Review JWT implementation
+     - Check session management
+     - Verify role-based access control
+   - Inspect input validation and sanitization:
+     - SQL injection prevention
+     - XSS protection
+     - Command injection safeguards
+   - Check cryptographic implementations:
+     - Password hashing (bcrypt/scrypt/argon2)
+     - Data encryption at rest/transit
+     - Secure random number generation
+   - Audit file size compliance (< 500 lines)
+   - Review dependency vulnerabilities:
+     \`\`\`bash
+     npm audit
+     \`\`\`
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_vulnerabilities "Critical: 2 hardcoded API keys found. High: Missing input validation in user-controller. Medium: Outdated JWT library. Low: Verbose error messages expose stack traces."\`
+
+3. **Dynamic Security Analysis** (10 mins)
+   - Test authentication flows:
+     - Login/logout sequences
+     - Password reset process
+     - Token refresh mechanisms
+   - Check authorization boundaries:
+     - Test role-based access
+     - Verify resource ownership checks
+     - Test privilege escalation vectors
+   - Analyze rate limiting and DoS protection
+   - Review CORS and CSP policies
+   - Test error handling for information leakage
+   - Store dynamic findings: \`npx claude-flow memory store ${memoryNamespace}_dynamic_findings "Auth bypass: None found. Rate limiting: Missing on login endpoint. CORS: Overly permissive. Error handling: Leaks database schema in dev mode."\`
+
+4. **Risk Assessment & Prioritization** (15 mins)
+   - Categorize findings by severity (CVSS scores):
+     - Critical (9.0-10.0): Immediate action required
+     - High (7.0-8.9): Fix before deployment
+     - Medium (4.0-6.9): Fix in next sprint
+     - Low (0.1-3.9): Track for future
+   - Assess potential business impact:
+     - Data breach consequences
+     - Compliance violations (GDPR, PCI-DSS)
+     - Reputation damage
+   - Calculate risk scores (likelihood × impact)
+   - Prioritize remediation efforts
+   - Document attack vectors and exploit scenarios
+   - Store assessment: \`npx claude-flow memory store ${memoryNamespace}_risk_assessment "Critical risks: 2 (hardcoded secrets, missing auth on admin endpoints). High risks: 3 (outdated deps, missing rate limiting, weak session management). Compliance impact: GDPR violation risk due to logging PII."\`
+
+5. **Remediation Plan & Implementation** (10 mins)
+   - Create specific fix recommendations:
+     - Move secrets to environment variables
+     - Implement proper secrets management (Vault/AWS Secrets Manager)
+     - Add comprehensive input validation
+     - Update vulnerable dependencies
+     - Implement rate limiting
+     - Fix authorization checks
+   - Suggest security enhancements:
+     - Add security headers (HSTS, CSP, X-Frame-Options)
+     - Implement audit logging
+     - Add intrusion detection
+     - Set up security monitoring
+   - Create security checklist for future development
+   - Implement critical fixes if authorized
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_remediation_plan "Immediate: Remove hardcoded secrets, fix auth bypass. Next sprint: Implement rate limiting, update dependencies. Future: Add WAF, implement SIEM integration."\`
+
+## Deliverables
+- security-audit-report.md:
+  - Executive summary
+  - Detailed findings with CVSS scores
+  - Risk assessment matrix
+  - Compliance gaps
+- remediation-plan.md:
+  - Prioritized fix list
+  - Implementation guidelines
+  - Timeline recommendations
+- security-checklist.md:
+  - Pre-deployment security checks
+  - Code review guidelines
+  - Security testing procedures
+- Fixed code (for critical issues):
+  - Removed hardcoded secrets
+  - Added input validation
+  - Fixed authorization gaps
+
+## Security Review Standards
+- OWASP Top 10 compliance
+- SANS CWE Top 25 coverage
+- Industry-specific requirements (PCI-DSS, HIPAA, etc.)
+- Zero tolerance for hardcoded secrets
+- All files must be < 500 lines for maintainability
+- Comprehensive logging without exposing sensitive data
+
+## Next Steps
+After security review:
+- \`npx claude-flow sparc run code "Implement security remediation plan" --non-interactive\`
+- \`npx claude-flow sparc run tdd "Write security test cases" --non-interactive\`
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Set up security monitoring and alerts" --non-interactive\``;
+}
+//# sourceMappingURL=security-review.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"security-review.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/security-review.js"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,MAAM,UAAU,8BAA8B,CAAC,eAAe,EAAE,eAAe;IAC7E,OAAO;;;;qCAI4B,eAAe;;;oCAGhB,eAAe;oCACf,eAAe;oCACf,eAAe;;;;;;;;;;mDAUA,eAAe,iCAAiC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDA4B5D,eAAe;;;;;;;;;;;;;;8DAcP,eAAe;;;;;;;;;;;;;;;wDAerB,eAAe;;;;;;;;;;;;;;;;;kDAiBrB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0HAiCyD,CAAC;AAC3H,CAAC"}

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

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

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

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