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

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

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

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

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

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

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

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

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

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

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

@@ -1,168 +0,0 @@
-// 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! 🚀`;
-}
-//# sourceMappingURL=sparc-orchestrator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sparc-orchestrator.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/sparc-orchestrator.js"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,UAAU,iCAAiC,CAAC,eAAe,EAAE,eAAe;IAChF,OAAO;;;6DAGoD,eAAe;;;;;;;4CAOhC,eAAe;;gEAEK,eAAe;8EACD,eAAe;;;;;;;;;;;;;;;;;;;;;;;uCAuBtD,eAAe;;;oCAGlB,eAAe;;;;;;;;;;;kDAWD,eAAe,2BAA2B,eAAe;;;;;;mFAMxB,eAAe;;;oCAG9D,eAAe;;;;;0DAKO,eAAe;;;;;;6EAMI,eAAe;;;oCAGxD,eAAe;;;;;0DAKO,eAAe;;;;;;;;;;;;;;;;;;oCAkBrC,eAAe;;;;+DAIY,eAAe;;;;;;;;;;;;;;;;;;;;;;wDAsBtB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;+BA0BxC,eAAe;;;+BAGf,eAAe;;;+BAGf,eAAe;;;;;;;uDAOS,eAAe;;iIAE2D,CAAC;AAClI,CAAC"}

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

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

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

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

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

@@ -1,39 +0,0 @@
-// 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`;
-}
-//# sourceMappingURL=spec-pseudocode.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"spec-pseudocode.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/spec-pseudocode.js"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,MAAM,UAAU,8BAA8B,CAAC,eAAe,EAAE,eAAe;IAC7E,OAAO;;;;yBAIgB,eAAe;;;;0DAIkB,eAAe;;;;;;;mDAOtB,eAAe;;;;;;;wDAOV,eAAe;;;;;;;;;;;;wBAY/C,CAAC;AACzB,CAAC"}

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

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

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

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

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

@@ -1,150 +0,0 @@
-// 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\``;
-}
-//# sourceMappingURL=supabase-admin.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"supabase-admin.js","sourceRoot":"","sources":["../../../../src/cli/simple-commands/sparc-modes/supabase-admin.js"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,UAAU,6BAA6B,CAAC,eAAe,EAAE,eAAe;IAC5E,OAAO;;;;uCAI8B,eAAe;;;oCAGlB,eAAe;oCACf,eAAe;oCACf,eAAe;;;;;;;;;sDASG,eAAe,yCAAyC,eAAe;;;;;;;;;;;;;;;;;oDAiBzE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;wDAwBX,eAAe,mFAAmF,IAAI,CAAC,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;6DA2BvG,eAAe;;;;;;;;;;;;;;;;wDAgBpB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGA2C2B,CAAC;AACnG,CAAC"}