claude-flow-novice 1.2.1 → 1.3.1

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

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

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

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

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

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