@sparkleideas/claude-flow 2.7.50 → 2.7.51

package/src/cli/simple-commands/sparc/phase-base.js

@@ -108,13 +108,13 @@ export class SparcPhase {
     if (!this.options.swarmEnabled) return;
 
     try {
-      // Use @sparkleideas/ruv-swarm memory hooks
+      // Use ruv-swarm memory hooks
       const { spawn } = await import('child_process');
 
       return new Promise((resolve, reject) => {
         const process = spawn(
           'npx',
-          ['@sparkleideas/ruv-swarm', 'hook', 'memory-store', '--key', key, '--data', data],
+          ['ruv-swarm', 'hook', 'memory-store', '--key', key, '--data', data],
           {
             stdio: 'pipe',
           },
@@ -148,7 +148,7 @@ export class SparcPhase {
       const { spawn } = await import('child_process');
 
       return new Promise((resolve, reject) => {
-        const process = spawn('npx', ['@sparkleideas/ruv-swarm', 'hook', 'memory-retrieve', '--key', key], {
+        const process = spawn('npx', ['ruv-swarm', 'hook', 'memory-retrieve', '--key', key], {
           stdio: 'pipe',
         });
 

package/src/cli/simple-commands/sparc-modes/architect.js

@@ -5,11 +5,11 @@ export function getArchitectOrchestration(taskDescription, memoryNamespace) {
 
 1. **Requirements Analysis** (10 mins)
    - Analyze the user's request: "${taskDescription}"
-   - Query existing project context: \`npx @sparkleideas/claude-flow memory query ${memoryNamespace}\`
+   - Query existing project context: \`npx claude-flow memory query ${memoryNamespace}\`
    - Identify core components, services, and modular boundaries
    - List external dependencies and integration points
    - Document scalability and security requirements
-   - Store findings: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_requirements "Core components: X, Y, Z. External deps: API-A, Service-B. Security: OAuth2, RLS policies needed."\`
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_requirements "Core components: X, Y, Z. External deps: API-A, Service-B. Security: OAuth2, RLS policies needed."\`
 
 2. **System Architecture Design** (20 mins)
    - Create modular architecture diagram using Mermaid syntax
@@ -18,7 +18,7 @@ export function getArchitectOrchestration(taskDescription, memoryNamespace) {
    - Plan data flow and state management patterns
    - Ensure NO hardcoded secrets or env values in design
    - Create extensible integration points
-   - Store architecture: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_architecture "Microservices: auth-service, user-service, data-processor. APIs: REST for external, gRPC for internal. State: Event-sourced with CQRS."\`
+   - Store architecture: \`npx claude-flow memory store ${memoryNamespace}_architecture "Microservices: auth-service, user-service, data-processor. APIs: REST for external, gRPC for internal. State: Event-sourced with CQRS."\`
 
 3. **Technical Specifications** (15 mins)
    - Define detailed interface contracts (OpenAPI/AsyncAPI)
@@ -26,7 +26,7 @@ export function getArchitectOrchestration(taskDescription, memoryNamespace) {
    - Plan security boundaries and authentication flows
    - Document performance and scaling considerations
    - Define configuration management strategy
-   - Store specs: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_tech_specs "Auth: JWT with refresh tokens. DB: PostgreSQL with read replicas. Cache: Redis. Config: Environment-based with secrets manager."\`
+   - Store specs: \`npx claude-flow memory store ${memoryNamespace}_tech_specs "Auth: JWT with refresh tokens. DB: PostgreSQL with read replicas. Cache: Redis. Config: Environment-based with secrets manager."\`
 
 4. **Modular Implementation Plan** (10 mins)
    - Break system into modules < 500 lines each
@@ -34,7 +34,7 @@ export function getArchitectOrchestration(taskDescription, memoryNamespace) {
    - Define testing strategy (unit, integration, e2e)
    - Plan deployment and rollback procedures
    - Identify tasks for other SPARC modes
-   - Store plan: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_implementation_plan "Phase 1: Core auth (tdd mode). Phase 2: User management (code mode). Phase 3: Integration (integration mode)."\`
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_implementation_plan "Phase 1: Core auth (tdd mode). Phase 2: User management (code mode). Phase 3: Integration (integration mode)."\`
 
 5. **Directory Safety**
    - **IMPORTANT**: All files should be created in the current working directory
@@ -63,40 +63,40 @@ export function getArchitectOrchestration(taskDescription, memoryNamespace) {
 After completing architecture, delegate to appropriate modes:
 
 ### Sequential Mode (for simple tasks):
-- \`npx @sparkleideas/claude-flow sparc run spec-pseudocode "Create detailed pseudocode for ${taskDescription}" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run security-review "Review architecture for vulnerabilities" --non-interactive\`
+- \`npx claude-flow sparc run spec-pseudocode "Create detailed pseudocode for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Review architecture for vulnerabilities" --non-interactive\`
 
 ### Background Swarm Mode (for complex implementation):
-- \`npx @sparkleideas/claude-flow swarm "Implement complete ${taskDescription} based on architecture" --strategy development --background --monitor\`
-- \`npx @sparkleideas/claude-flow swarm "Create comprehensive test suite for ${taskDescription}" --strategy testing --background --parallel\`
-- \`npx @sparkleideas/claude-flow swarm "Generate complete documentation for ${taskDescription}" --strategy research --background\`
+- \`npx claude-flow swarm "Implement complete ${taskDescription} based on architecture" --strategy development --background --monitor\`
+- \`npx claude-flow swarm "Create comprehensive test suite for ${taskDescription}" --strategy testing --background --parallel\`
+- \`npx claude-flow swarm "Generate complete documentation for ${taskDescription}" --strategy research --background\`
 
 ## 🐝 Enhanced Architecture with Background Swarms
 Leverage background swarm processing for complex architecture tasks:
 
 \`\`\`bash
 # Background research swarm for comprehensive analysis
-npx @sparkleideas/claude-flow swarm "Research and analyze all architectural patterns for ${taskDescription}" \\
+npx claude-flow swarm "Research and analyze all architectural patterns for ${taskDescription}" \\
   --strategy research --background --parallel --monitor \\
   --output ./architecture-research
 
 # Background development swarm for proof of concepts
-npx @sparkleideas/claude-flow swarm "Create architectural proof of concepts and prototypes for ${taskDescription}" \\
+npx claude-flow swarm "Create architectural proof of concepts and prototypes for ${taskDescription}" \\
   --strategy development --background --testing --monitor \\
   --output ./architecture-prototypes
 
 # Background documentation swarm for comprehensive specs
-npx @sparkleideas/claude-flow swarm "Generate complete technical specifications and API documentation for ${taskDescription}" \\
+npx claude-flow swarm "Generate complete technical specifications and API documentation for ${taskDescription}" \\
   --strategy research --background --parallel \\
   --output ./architecture-docs
 
 # Monitor all background swarms
-npx @sparkleideas/claude-flow status
-npx @sparkleideas/claude-flow monitor
+npx claude-flow status
+npx claude-flow monitor
 
 # Sequential architecture refinement with background support
-npx @sparkleideas/claude-flow sparc run architect "Initial system design for ${taskDescription}" --non-interactive
-npx @sparkleideas/claude-flow swarm "Refine architecture based on security and performance analysis" \\
+npx claude-flow sparc run architect "Initial system design for ${taskDescription}" --non-interactive
+npx claude-flow swarm "Refine architecture based on security and performance analysis" \\
   --strategy optimization --background --review --testing \\
   --output ./architecture-refined
 \`\`\`
@@ -106,20 +106,20 @@ Combine SPARC modes with background swarms for optimal efficiency:
 
 \`\`\`bash
 # Phase 1: Quick architecture analysis (SPARC)
-npx @sparkleideas/claude-flow sparc run architect "Core system design" --non-interactive
+npx claude-flow sparc run architect "Core system design" --non-interactive
 
 # Phase 2: Parallel background research (Swarm)
-npx @sparkleideas/claude-flow swarm "Deep dive research into scalability patterns" --strategy research --background &
-npx @sparkleideas/claude-flow swarm "Security analysis and threat modeling" --strategy analysis --background &
-npx @sparkleideas/claude-flow swarm "Performance benchmarking and optimization research" --strategy optimization --background &
+npx claude-flow swarm "Deep dive research into scalability patterns" --strategy research --background &
+npx claude-flow swarm "Security analysis and threat modeling" --strategy analysis --background &
+npx claude-flow swarm "Performance benchmarking and optimization research" --strategy optimization --background &
 
 # Phase 3: Implementation swarm (Background)
-npx @sparkleideas/claude-flow swarm "Full implementation of ${taskDescription} architecture" \\
+npx claude-flow swarm "Full implementation of ${taskDescription} architecture" \\
   --strategy development --background --parallel --monitor --testing \\
   --max-agents 8 --output ./implementation
 
 # Monitor progress
-npx @sparkleideas/claude-flow status
+npx claude-flow status
 tail -f ./swarm-runs/*/swarm.log
 \`\`\``;
 }

package/src/cli/simple-commands/sparc-modes/ask.js

@@ -21,60 +21,60 @@ Based on your request, here are the relevant SPARC modes:
 #### 📋 Planning & Design Modes:
 - **\`spec-pseudocode\`** - For creating detailed specifications, requirements, and high-level logic
   - Use when: Starting a new feature, defining requirements, planning algorithms
-  - Example: \`npx @sparkleideas/claude-flow sparc run spec-pseudocode "Create user authentication flow" --non-interactive\`
+  - Example: \`npx claude-flow sparc run spec-pseudocode "Create user authentication flow" --non-interactive\`
 
 - **\`architect\`** - For system design, API boundaries, and service architecture
   - Use when: Designing system structure, defining APIs, planning microservices
-  - Example: \`npx @sparkleideas/claude-flow sparc run architect "Design e-commerce platform architecture" --non-interactive\`
+  - Example: \`npx claude-flow sparc run architect "Design e-commerce platform architecture" --non-interactive\`
 
 #### 🧠 Implementation Modes:
 - **\`code\`** - For implementing features with clean architecture
   - Use when: Building new features, writing production code
-  - Example: \`npx @sparkleideas/claude-flow sparc run code "Implement payment processing service" --non-interactive\`
+  - Example: \`npx claude-flow sparc run code "Implement payment processing service" --non-interactive\`
 
 - **\`tdd\`** - For test-first development with comprehensive coverage
   - Use when: Want high quality code, need test coverage, following TDD practices
-  - Example: \`npx @sparkleideas/claude-flow sparc run tdd "Build shopping cart with TDD" --non-interactive\`
+  - Example: \`npx claude-flow sparc run tdd "Build shopping cart with TDD" --non-interactive\`
 
 #### 🔧 Quality & Maintenance Modes:
 - **\`debug\`** - For troubleshooting issues and fixing bugs
   - Use when: Something's broken, need to trace errors, fix runtime issues
-  - Example: \`npx @sparkleideas/claude-flow sparc run debug "Fix memory leak in data processor" --non-interactive\`
+  - Example: \`npx claude-flow sparc run debug "Fix memory leak in data processor" --non-interactive\`
 
 - **\`security-review\`** - For security audits and vulnerability checks
   - Use when: Need security audit, checking for exposed secrets, compliance review
-  - Example: \`npx @sparkleideas/claude-flow sparc run security-review "Audit user data handling" --non-interactive\`
+  - Example: \`npx claude-flow sparc run security-review "Audit user data handling" --non-interactive\`
 
 - **\`refinement-optimization-mode\`** - For performance optimization and refactoring
   - Use when: Code needs optimization, files too large, performance issues
-  - Example: \`npx @sparkleideas/claude-flow sparc run refinement-optimization-mode "Optimize database queries" --non-interactive\`
+  - Example: \`npx claude-flow sparc run refinement-optimization-mode "Optimize database queries" --non-interactive\`
 
 #### 📚 Documentation & Integration:
 - **\`docs-writer\`** - For creating documentation and guides
   - Use when: Need README, API docs, user guides
-  - Example: \`npx @sparkleideas/claude-flow sparc run docs-writer "Create API documentation" --non-interactive\`
+  - Example: \`npx claude-flow sparc run docs-writer "Create API documentation" --non-interactive\`
 
 - **\`integration\`** - For connecting services and ensuring system cohesion
   - Use when: Integrating components, connecting APIs, system integration
-  - Example: \`npx @sparkleideas/claude-flow sparc run integration "Connect auth service to user service" --non-interactive\`
+  - Example: \`npx claude-flow sparc run integration "Connect auth service to user service" --non-interactive\`
 
 #### 🚀 Deployment & Operations:
 - **\`devops\`** - For deployment, CI/CD, and infrastructure
   - Use when: Setting up deployment, configuring CI/CD, provisioning infrastructure
-  - Example: \`npx @sparkleideas/claude-flow sparc run devops "Deploy to AWS with auto-scaling" --non-interactive\`
+  - Example: \`npx claude-flow sparc run devops "Deploy to AWS with auto-scaling" --non-interactive\`
 
 - **\`post-deployment-monitoring-mode\`** - For production monitoring
   - Use when: Setting up monitoring, configuring alerts, tracking metrics
-  - Example: \`npx @sparkleideas/claude-flow sparc run post-deployment-monitoring-mode "Setup DataDog monitoring" --non-interactive\`
+  - Example: \`npx claude-flow sparc run post-deployment-monitoring-mode "Setup DataDog monitoring" --non-interactive\`
 
 #### 🔐 Specialized Modes:
 - **\`supabase-admin\`** - For Supabase database and auth management
   - Use when: Working with Supabase, setting up database, configuring auth
-  - Example: \`npx @sparkleideas/claude-flow sparc run supabase-admin "Setup user authentication database" --non-interactive\`
+  - Example: \`npx claude-flow sparc run supabase-admin "Setup user authentication database" --non-interactive\`
 
 - **\`mcp\`** - For MCP (Model Context Protocol) integrations
   - Use when: Integrating external tools via MCP, API connections
-  - Example: \`npx @sparkleideas/claude-flow sparc run mcp "Integrate Stripe payment API" --non-interactive\`
+  - Example: \`npx claude-flow sparc run mcp "Integrate Stripe payment API" --non-interactive\`
 
 ### 3. **Workflow Recommendations**
 
@@ -82,19 +82,19 @@ For "${taskDescription}", I recommend this workflow:
 
 \`\`\`bash
 # Step 1: Define requirements
-npx @sparkleideas/claude-flow sparc run spec-pseudocode "${taskDescription} - requirements and pseudocode" --non-interactive
+npx claude-flow sparc run spec-pseudocode "${taskDescription} - requirements and pseudocode" --non-interactive
 
 # Step 2: Design architecture (if needed)
-npx @sparkleideas/claude-flow sparc run architect "${taskDescription} - system design" --non-interactive
+npx claude-flow sparc run architect "${taskDescription} - system design" --non-interactive
 
 # Step 3: Implement with TDD
-npx @sparkleideas/claude-flow sparc run tdd "${taskDescription} - implementation" --non-interactive
+npx claude-flow sparc run tdd "${taskDescription} - implementation" --non-interactive
 
 # Step 4: Security review
-npx @sparkleideas/claude-flow sparc run security-review "${taskDescription} - security audit" --non-interactive
+npx claude-flow sparc run security-review "${taskDescription} - security audit" --non-interactive
 
 # Step 5: Documentation
-npx @sparkleideas/claude-flow sparc run docs-writer "${taskDescription} - documentation" --non-interactive
+npx claude-flow sparc run docs-writer "${taskDescription} - documentation" --non-interactive
 \`\`\`
 
 ### 4. **Best Practices Reminder**
@@ -109,13 +109,13 @@ When using any SPARC mode, remember:
 Track your progress across modes:
 \`\`\`bash
 # Store project context
-npx @sparkleideas/claude-flow memory store ${memoryNamespace}_context "Working on: ${taskDescription}"
+npx claude-flow memory store ${memoryNamespace}_context "Working on: ${taskDescription}"
 
 # Query previous work
-npx @sparkleideas/claude-flow memory query ${memoryNamespace}
+npx claude-flow memory query ${memoryNamespace}
 
 # List all memory entries
-npx @sparkleideas/claude-flow memory list
+npx claude-flow memory list
 \`\`\`
 
 ## Next Steps

package/src/cli/simple-commands/sparc-modes/code.js

@@ -9,9 +9,9 @@ export function getCodeOrchestration(taskDescription, memoryNamespace) {
    - Review implementation task: "${taskDescription}"
    - Query architecture and pseudocode: 
      \`\`\`bash
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_architecture
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_pseudocode
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_tech_specs
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_pseudocode
+     npx claude-flow memory query ${memoryNamespace}_tech_specs
      \`\`\`
    - Identify modules to implement and their boundaries
    - Review configuration requirements
@@ -26,7 +26,7 @@ export function getCodeOrchestration(taskDescription, memoryNamespace) {
      - Implement secrets management abstraction
    - Install dependencies based on tech specs
    - Create module structure (each file < 500 lines)
-   - Store setup: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_setup "Project structure: src/{domain,application,infrastructure}. Config: dotenv + vault integration. Dependencies: express, joi, winston."\`
+   - Store setup: \`npx claude-flow memory store ${memoryNamespace}_setup "Project structure: src/{domain,application,infrastructure}. Config: dotenv + vault integration. Dependencies: express, joi, winston."\`
 
 3. **Modular Implementation** (30 mins)
    - Implement features using clean architecture principles:
@@ -38,7 +38,7 @@ export function getCodeOrchestration(taskDescription, memoryNamespace) {
    - Use configuration for ALL environment-specific values
    - Implement comprehensive error handling
    - Add structured logging with context
-   - Store progress: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_implementation "Completed: auth-service (3 modules), user-repository (2 modules). Remaining: notification-service."\`
+   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_implementation "Completed: auth-service (3 modules), user-repository (2 modules). Remaining: notification-service."\`
 
 4. **Integration & Basic Testing** (15 mins)
    - Wire up dependency injection container
@@ -48,7 +48,7 @@ export function getCodeOrchestration(taskDescription, memoryNamespace) {
    - Create smoke tests for critical paths
    - Verify configuration loading works correctly
    - Test error scenarios and graceful degradation
-   - Store results: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_tests "Smoke tests passing. Health checks operational. Error handling verified. Ready for TDD mode deep testing."\`
+   - Store results: \`npx claude-flow memory store ${memoryNamespace}_tests "Smoke tests passing. Health checks operational. Error handling verified. Ready for TDD mode deep testing."\`
 
 5. **Code Quality & Documentation** (10 mins)
    - Run linters and formatters
@@ -56,7 +56,7 @@ export function getCodeOrchestration(taskDescription, memoryNamespace) {
    - Create API documentation (if applicable)
    - Generate dependency graphs
    - Update README with setup instructions
-   - Store completion: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_code_complete "Implementation complete. All modules < 500 lines. No hardcoded secrets. Ready for testing and integration."\`
+   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_code_complete "Implementation complete. All modules < 500 lines. No hardcoded secrets. Ready for testing and integration."\`
 
 ## Directory Safety Check
 Before creating any files:
@@ -92,36 +92,36 @@ All files should be created relative to the current working directory:
 After implementation, choose appropriate execution mode:
 
 ### Sequential Mode (for simple follow-up tasks):
-- \`npx @sparkleideas/claude-flow sparc run tdd "Write comprehensive tests for ${taskDescription}" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run security-review "Security audit for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run tdd "Write comprehensive tests for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Security audit for ${taskDescription}" --non-interactive\`
 
 ### Background Swarm Mode (for complex comprehensive tasks):
-- \`npx @sparkleideas/claude-flow swarm "Create comprehensive test suite with unit, integration, and e2e tests for ${taskDescription}" --strategy testing --background --parallel\`
-- \`npx @sparkleideas/claude-flow swarm "Perform full security audit and penetration testing for ${taskDescription}" --strategy analysis --background --review\`
-- \`npx @sparkleideas/claude-flow swarm "Generate complete documentation, API specs, and deployment guides for ${taskDescription}" --strategy research --background\`
+- \`npx claude-flow swarm "Create comprehensive test suite with unit, integration, and e2e tests for ${taskDescription}" --strategy testing --background --parallel\`
+- \`npx claude-flow swarm "Perform full security audit and penetration testing for ${taskDescription}" --strategy analysis --background --review\`
+- \`npx claude-flow swarm "Generate complete documentation, API specs, and deployment guides for ${taskDescription}" --strategy research --background\`
 
 ## 🐝 Enhanced Development with Background Swarms
 Leverage background swarm processing for large-scale development:
 
 \`\`\`bash
 # Background comprehensive implementation swarm
-npx @sparkleideas/claude-flow swarm "Implement complete ${taskDescription} with all modules, testing, and documentation" \\
+npx claude-flow swarm "Implement complete ${taskDescription} with all modules, testing, and documentation" \\
   --strategy development --background --parallel --monitor --testing \\
   --max-agents 6 --output ./implementation
 
 # Background quality assurance swarm
-npx @sparkleideas/claude-flow swarm "Comprehensive QA including testing, security review, and performance optimization for ${taskDescription}" \\
+npx claude-flow swarm "Comprehensive QA including testing, security review, and performance optimization for ${taskDescription}" \\
   --strategy testing --background --review --monitor \\
   --output ./qa-results
 
 # Background documentation and deployment swarm
-npx @sparkleideas/claude-flow swarm "Create production-ready documentation, deployment scripts, and monitoring for ${taskDescription}" \\
+npx claude-flow swarm "Create production-ready documentation, deployment scripts, and monitoring for ${taskDescription}" \\
   --strategy research --background --parallel \\
   --output ./deployment-ready
 
 # Monitor all background development
-npx @sparkleideas/claude-flow status
-npx @sparkleideas/claude-flow monitor
+npx claude-flow status
+npx claude-flow monitor
 \`\`\`
 
 ## 🔄 Hybrid SPARC-Swarm Development Workflow
@@ -129,20 +129,20 @@ Combine SPARC modes with background swarms for optimal development velocity:
 
 \`\`\`bash
 # Phase 1: Quick prototyping (SPARC)
-npx @sparkleideas/claude-flow sparc run code "Core ${taskDescription} prototype" --non-interactive
+npx claude-flow sparc run code "Core ${taskDescription} prototype" --non-interactive
 
 # Phase 2: Parallel background development (Swarm)
-npx @sparkleideas/claude-flow swarm "Full implementation of ${taskDescription} with advanced features" --strategy development --background --parallel &
-npx @sparkleideas/claude-flow swarm "Comprehensive testing strategy for ${taskDescription}" --strategy testing --background &
-npx @sparkleideas/claude-flow swarm "Security hardening and performance optimization" --strategy optimization --background &
+npx claude-flow swarm "Full implementation of ${taskDescription} with advanced features" --strategy development --background --parallel &
+npx claude-flow swarm "Comprehensive testing strategy for ${taskDescription}" --strategy testing --background &
+npx claude-flow swarm "Security hardening and performance optimization" --strategy optimization --background &
 
 # Phase 3: Integration and deployment (Background)
-npx @sparkleideas/claude-flow swarm "Integration testing and production deployment preparation for ${taskDescription}" \\
+npx claude-flow swarm "Integration testing and production deployment preparation for ${taskDescription}" \\
   --strategy integration --background --monitor --testing \\
   --output ./production-ready
 
 # Monitor all development streams
-npx @sparkleideas/claude-flow status
+npx claude-flow status
 tail -f ./swarm-runs/*/swarm.log
 \`\`\``;
 }

package/src/cli/simple-commands/sparc-modes/debug.js

@@ -7,9 +7,9 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
    - Understand the reported issue: "${taskDescription}"
    - Query relevant context and previous issues:
      \`\`\`bash
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_bugs
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_implementation
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_tests
+     npx claude-flow memory query ${memoryNamespace}_bugs
+     npx claude-flow memory query ${memoryNamespace}_implementation
+     npx claude-flow memory query ${memoryNamespace}_tests
      \`\`\`
    - Set up debugging environment:
      - Enable verbose logging
@@ -18,7 +18,7 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
    - Reproduce the issue consistently
    - Collect error messages, stack traces, and logs
    - Identify affected components and dependencies
-   - Store findings: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_issue_analysis "Issue: ${taskDescription}. Reproduction: Steps 1-3. Error: Stack trace at line X. Affected: auth-service, user-repository."\`
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_issue_analysis "Issue: ${taskDescription}. Reproduction: Steps 1-3. Error: Stack trace at line X. Affected: auth-service, user-repository."\`
 
 2. **Root Cause Investigation** (20 mins)
    - Add strategic debug logging:
@@ -37,7 +37,7 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
      - When does it fail? (timing, load, specific data)
      - What changed recently? (code, config, dependencies)
    - Avoid changing env configuration directly
-   - Store investigation: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_root_cause "Root cause: Race condition in auth token refresh. Occurs under high load when token expires during request processing. Fix approach: Implement token refresh mutex."\`
+   - Store investigation: \`npx claude-flow memory store ${memoryNamespace}_root_cause "Root cause: Race condition in auth token refresh. Occurs under high load when token expires during request processing. Fix approach: Implement token refresh mutex."\`
 
 3. **Solution Development** (15 mins)
    - Develop targeted fix approach:
@@ -56,7 +56,7 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
      - Add validation where missing
      - Improve error messages
      - Add circuit breakers if needed
-   - Store solution: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_solution "Fix: Added mutex lock for token refresh. Tests: 3 regression tests added. Validation: Added token expiry check. No breaking changes."\`
+   - Store solution: \`npx claude-flow memory store ${memoryNamespace}_solution "Fix: Added mutex lock for token refresh. Tests: 3 regression tests added. Validation: Added token expiry check. No breaking changes."\`
 
 4. **Validation & Performance Check** (10 mins)
    - Run comprehensive test suite:
@@ -73,7 +73,7 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
    - Test in conditions that triggered the bug
    - Verify no new issues introduced
    - Document the fix with context
-   - Store validation: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_debug_validation "All tests passing. Performance impact: <5ms latency increase. Memory usage unchanged. Original issue resolved."\`
+   - Store validation: \`npx claude-flow memory store ${memoryNamespace}_debug_validation "All tests passing. Performance impact: <5ms latency increase. Memory usage unchanged. Original issue resolved."\`
 
 5. **Documentation & Cleanup** (5 mins)
    - Create detailed fix documentation
@@ -106,7 +106,7 @@ export function getDebugOrchestration(taskDescription, memoryNamespace) {
 
 ## Next Steps
 After debugging completes:
-- \`npx @sparkleideas/claude-flow sparc run security-review "Review security impact of ${taskDescription} fix" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run refinement-optimization-mode "Refactor affected modules for better maintainability" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run post-deployment-monitoring-mode "Monitor ${taskDescription} fix in production" --non-interactive\``;
+- \`npx claude-flow sparc run security-review "Review security impact of ${taskDescription} fix" --non-interactive\`
+- \`npx claude-flow sparc run refinement-optimization-mode "Refactor affected modules for better maintainability" --non-interactive\`
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Monitor ${taskDescription} fix in production" --non-interactive\``;
 }

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

@@ -8,9 +8,9 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
    - Understand deployment requirements: "${taskDescription}"
    - Query architecture and configuration:
      \`\`\`bash
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_architecture
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_deployment
-     npx @sparkleideas/claude-flow memory query ${memoryNamespace}_infrastructure
+     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
@@ -18,7 +18,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
      - Edge platforms (Vercel, Cloudflare)
      - Container orchestration (K8s, ECS)
    - Review current infrastructure state
-   - Store analysis: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_devops_analysis "Task: ${taskDescription}. Target: AWS ECS + CloudFront. Current: Local dev only. Requirements: Auto-scaling, blue-green deployment, monitoring."\`
+   - 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:
@@ -38,7 +38,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
      - Vault integration
      - Environment injection layers
    - NEVER hardcode credentials or tokens
-   - Store provisioning: \`npx @sparkleideas/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."\`
+   - 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:
@@ -60,7 +60,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
      - Code coverage thresholds
      - Performance benchmarks
      - Security scan results
-   - Store pipeline config: \`npx @sparkleideas/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."\`
+   - 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:
@@ -83,7 +83,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
      - SLA/SLO monitoring
      - Anomaly detection
      - Escalation procedures
-   - Store monitoring setup: \`npx @sparkleideas/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."\`
+   - 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:
@@ -100,7 +100,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
      - Infrastructure vulnerability scanning
      - Compliance policy validation
    - Document security procedures
-   - Store security config: \`npx @sparkleideas/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."\`
+   - 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/
@@ -131,7 +131,7 @@ export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
 
 ## Next Steps
 After DevOps setup:
-- \`npx @sparkleideas/claude-flow sparc run post-deployment-monitoring-mode "Verify production deployment health" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run security-review "Audit infrastructure security" --non-interactive\`
-- \`npx @sparkleideas/claude-flow sparc run refinement-optimization-mode "Optimize deployment performance" --non-interactive\``;
+- \`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\``;
 }

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

@@ -8,21 +8,21 @@ export function getDocsWriterOrchestration(taskDescription, memoryNamespace) {
    - Identify target audience
    - Define documentation structure
    - List required sections
-   - Store plan: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_doc_plan "..."\`
+   - 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 @sparkleideas/claude-flow memory store ${memoryNamespace}_doc_content "..."\`
+   - 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 @sparkleideas/claude-flow memory store ${memoryNamespace}_user_guides "..."\`
+   - Store guides: \`npx claude-flow memory store ${memoryNamespace}_user_guides "..."\`
 
 4. **Review & Polish** (10 mins)
    - Check for clarity and accuracy

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

@@ -7,25 +7,25 @@ export function getGenericOrchestration(taskDescription, memoryNamespace) {
    - Understand the task: "${taskDescription}"
    - Break down requirements
    - Identify deliverables
-   - Store analysis: \`npx @sparkleideas/claude-flow memory store ${memoryNamespace}_analysis "..."\`
+   - 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 @sparkleideas/claude-flow memory store ${memoryNamespace}_plan "..."\`
+   - 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 @sparkleideas/claude-flow memory store ${memoryNamespace}_implementation "..."\`
+   - 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 @sparkleideas/claude-flow memory store ${memoryNamespace}_validation "..."\`
+   - Store validation: \`npx claude-flow memory store ${memoryNamespace}_validation "..."\`
 
 5. **Deliverables**
    - Completed implementation