claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/init/rollback/state-tracker.js

@@ -0,0 +1,486 @@
+import { promises as fs } from 'fs';
+// state-tracker.js - Track initialization state and rollback points
+
+export class StateTracker {
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+    this.stateFile = `${workingDir}/.claude-flow-state.json`;
+  }
+
+  /**
+   * Record a rollback point
+   */
+  async recordRollbackPoint(type, data) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+
+      const rollbackPoint = {
+        id: this.generateId(),
+        type,
+        timestamp: Date.now(),
+        data,
+        ...data,
+      };
+
+      state.rollbackPoints = state.rollbackPoints || [];
+      state.rollbackPoints.push(rollbackPoint);
+
+      // Keep only the last 10 rollback points
+      if (state.rollbackPoints.length > 10) {
+        state.rollbackPoints = state.rollbackPoints.slice(-10);
+      }
+
+      await this.saveState(state);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to record rollback point: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Create a checkpoint
+   */
+  async createCheckpoint(phase, data) {
+    const result = {
+      success: true,
+      id: null,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+
+      const checkpoint = {
+        id: this.generateId(),
+        phase,
+        timestamp: Date.now(),
+        data,
+        status: 'active',
+      };
+
+      result.id = checkpoint.id;
+
+      state.checkpoints = state.checkpoints || [];
+      state.checkpoints.push(checkpoint);
+
+      // Keep only the last 20 checkpoints
+      if (state.checkpoints.length > 20) {
+        state.checkpoints = state.checkpoints.slice(-20);
+      }
+
+      await this.saveState(state);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to create checkpoint: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Update a checkpoint
+   */
+  async updateCheckpoint(checkpointId, updates) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+
+      if (state.checkpoints) {
+        const checkpoint = state.checkpoints.find((cp) => cp.id === checkpointId);
+        if (checkpoint) {
+          Object.assign(checkpoint, updates);
+          await this.saveState(state);
+        } else {
+          result.success = false;
+          result.errors.push(`Checkpoint not found: ${checkpointId}`);
+        }
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to update checkpoint: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Record a rollback operation
+   */
+  async recordRollback(targetId, rollbackType, phase = null) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+
+      const rollbackRecord = {
+        id: this.generateId(),
+        targetId,
+        rollbackType,
+        phase,
+        timestamp: Date.now(),
+        status: 'completed',
+      };
+
+      state.rollbackHistory = state.rollbackHistory || [];
+      state.rollbackHistory.push(rollbackRecord);
+
+      // Keep only the last 50 rollback records
+      if (state.rollbackHistory.length > 50) {
+        state.rollbackHistory = state.rollbackHistory.slice(-50);
+      }
+
+      await this.saveState(state);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to record rollback: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get rollback points
+   */
+  async getRollbackPoints() {
+    try {
+      const state = await this.loadState();
+      return state.rollbackPoints || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get checkpoints
+   */
+  async getCheckpoints() {
+    try {
+      const state = await this.loadState();
+      return state.checkpoints || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get rollback history
+   */
+  async getRollbackHistory() {
+    try {
+      const state = await this.loadState();
+      return state.rollbackHistory || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Track file operation
+   */
+  async trackFileOperation(operation, filePath, metadata = {}) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+
+      const fileOp = {
+        id: this.generateId(),
+        operation, // 'create', 'modify', 'delete'
+        filePath,
+        timestamp: Date.now(),
+        metadata,
+      };
+
+      state.fileOperations = state.fileOperations || [];
+      state.fileOperations.push(fileOp);
+
+      // Keep only the last 100 file operations
+      if (state.fileOperations.length > 100) {
+        state.fileOperations = state.fileOperations.slice(-100);
+      }
+
+      await this.saveState(state);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to track file operation: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get current initialization phase
+   */
+  async getCurrentPhase() {
+    try {
+      const state = await this.loadState();
+      return state.currentPhase || 'not-started';
+    } catch {
+      return 'not-started';
+    }
+  }
+
+  /**
+   * Set current initialization phase
+   */
+  async setCurrentPhase(phase) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+      state.currentPhase = phase;
+      state.phaseTimestamp = Date.now();
+
+      // Track phase transitions
+      state.phaseHistory = state.phaseHistory || [];
+      state.phaseHistory.push({
+        phase,
+        timestamp: Date.now(),
+      });
+
+      await this.saveState(state);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to set phase: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get initialization statistics
+   */
+  async getInitializationStats() {
+    try {
+      const state = await this.loadState();
+
+      return {
+        rollbackPoints: (state.rollbackPoints || []).length,
+        checkpoints: (state.checkpoints || []).length,
+        rollbackHistory: (state.rollbackHistory || []).length,
+        fileOperations: (state.fileOperations || []).length,
+        currentPhase: state.currentPhase || 'not-started',
+        lastActivity: state.lastActivity || 0,
+        phaseHistory: state.phaseHistory || [],
+      };
+    } catch {
+      return {
+        rollbackPoints: 0,
+        checkpoints: 0,
+        rollbackHistory: 0,
+        fileOperations: 0,
+        currentPhase: 'not-started',
+        lastActivity: 0,
+        phaseHistory: [],
+      };
+    }
+  }
+
+  /**
+   * Clean up old state data
+   */
+  async cleanupOldState(daysToKeep = 7) {
+    const result = {
+      success: true,
+      cleaned: 0,
+      errors: [],
+    };
+
+    try {
+      const state = await this.loadState();
+      const cutoffTime = Date.now() - daysToKeep * 24 * 60 * 60 * 1000;
+
+      let cleaned = 0;
+
+      // Clean rollback points
+      if (state.rollbackPoints) {
+        const before = state.rollbackPoints.length;
+        state.rollbackPoints = state.rollbackPoints.filter((rp) => rp.timestamp > cutoffTime);
+        cleaned += before - state.rollbackPoints.length;
+      }
+
+      // Clean checkpoints
+      if (state.checkpoints) {
+        const before = state.checkpoints.length;
+        state.checkpoints = state.checkpoints.filter((cp) => cp.timestamp > cutoffTime);
+        cleaned += before - state.checkpoints.length;
+      }
+
+      // Clean file operations
+      if (state.fileOperations) {
+        const before = state.fileOperations.length;
+        state.fileOperations = state.fileOperations.filter((fo) => fo.timestamp > cutoffTime);
+        cleaned += before - state.fileOperations.length;
+      }
+
+      result.cleaned = cleaned;
+
+      if (cleaned > 0) {
+        await this.saveState(state);
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`State cleanup failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate state tracking system
+   */
+  async validateStateTracking() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+    };
+
+    try {
+      // Test state file access
+      const state = await this.loadState();
+
+      // Test write access
+      state.lastValidation = Date.now();
+      await this.saveState(state);
+
+      // Validate state structure
+      const validationResult = this.validateStateStructure(state);
+      if (!validationResult.valid) {
+        result.warnings.push(...validationResult.issues);
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`State tracking validation failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Export state for backup
+   */
+  async exportState() {
+    try {
+      const state = await this.loadState();
+      return {
+        success: true,
+        data: state,
+        timestamp: Date.now(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Import state from backup
+   */
+  async importState(stateData) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      if (this.validateStateStructure(stateData).valid) {
+        await this.saveState(stateData);
+      } else {
+        result.success = false;
+        result.errors.push('Invalid state data structure');
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`State import failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  // Helper methods
+
+  async loadState() {
+    try {
+      const content = await fs.readFile(this.stateFile, 'utf8');
+      return JSON.parse(content);
+    } catch {
+      // Return default state if file doesn't exist or is invalid
+      return {
+        version: '1.0',
+        created: Date.now(),
+        lastActivity: Date.now(),
+        rollbackPoints: [],
+        checkpoints: [],
+        rollbackHistory: [],
+        fileOperations: [],
+        currentPhase: 'not-started',
+        phaseHistory: [],
+      };
+    }
+  }
+
+  async saveState(state) {
+    state.lastActivity = Date.now();
+    state.version = '1.0';
+
+    await fs.writeFile(this.stateFile, JSON.stringify(state, null, 2, 'utf8'));
+  }
+
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  validateStateStructure(state) {
+    const result = {
+      valid: true,
+      issues: [],
+    };
+
+    if (!state || typeof state !== 'object') {
+      result.valid = false;
+      result.issues.push('State must be an object');
+      return result;
+    }
+
+    // Check required fields
+    const requiredFields = ['version', 'created', 'lastActivity'];
+    for (const field of requiredFields) {
+      if (!(field in state)) {
+        result.issues.push(`Missing required field: ${field}`);
+      }
+    }
+
+    // Check array fields
+    const arrayFields = ['rollbackPoints', 'checkpoints', 'rollbackHistory', 'fileOperations'];
+    for (const field of arrayFields) {
+      if (field in state && !Array.isArray(state[field])) {
+        result.issues.push(`Field ${field} must be an array`);
+      }
+    }
+
+    return result;
+  }
+}

package/src/cli/simple-commands/init/sparc/roo-readme.js

@@ -0,0 +1,61 @@
+// roo-readme.js - README for .roo directory
+
+export function createRooReadme() {
+  return `# .roo Directory - SPARC Development Environment
+
+This directory contains the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) development environment configuration and templates.
+
+## Directory Structure
+
+\`\`\`
+.roo/
+├── README.md           # This file
+├── templates/          # Template files for common patterns
+├── workflows/          # Predefined SPARC workflows
+│   └── basic-tdd.json  # Basic TDD workflow
+├── modes/              # Custom mode definitions (optional)
+└── configs/            # Configuration files
+\`\`\`
+
+## SPARC Methodology
+
+SPARC is a systematic approach to software development:
+
+1. **Specification**: Define clear requirements and constraints
+2. **Pseudocode**: Create detailed logic flows and algorithms  
+3. **Architecture**: Design system structure and components
+4. **Refinement**: Implement, test, and optimize using TDD
+5. **Completion**: Integrate, document, and validate
+
+## Usage with Claude-Flow
+
+Use the claude-flow SPARC commands to leverage this environment:
+
+\`\`\`bash
+# List available modes
+claude-flow sparc modes
+
+# Run specific mode
+claude-flow sparc run code "implement user authentication"
+
+# Execute full TDD workflow  
+claude-flow sparc tdd "payment processing system"
+
+# Use custom workflow
+claude-flow sparc workflow .roo/workflows/basic-tdd.json
+\`\`\`
+
+## Configuration
+
+The main configuration is in \`.roomodes\` at the project root. This directory provides additional templates and workflows to support the SPARC development process.
+
+## Customization
+
+You can customize this environment by:
+- Adding new workflow templates to \`workflows/\`
+- Creating mode-specific templates in \`templates/\`
+- Adding project-specific configurations in \`configs/\`
+
+For more information, see: https://github.com/ruvnet/claude-code-flow/docs/sparc.md
+`;
+}

package/src/cli/simple-commands/init/sparc/roomodes-config.js

@@ -0,0 +1,102 @@
+// roomodes-config.js - Basic .roomodes configuration
+
+export function createBasicRoomodesConfig() {
+  return JSON.stringify(
+    {
+      customModes: [
+        {
+          slug: 'architect',
+          name: '🏗️ Architect',
+          roleDefinition:
+            'You design scalable, secure, and modular architectures based on functional specs and user needs. You define responsibilities across services, APIs, and components.',
+          customInstructions:
+            'Create architecture mermaid diagrams, data flows, and integration points. Ensure no part of the design includes secrets or hardcoded env values. Emphasize modular boundaries and maintain extensibility.',
+          groups: ['read', 'edit'],
+          source: 'project',
+        },
+        {
+          slug: 'code',
+          name: '🧠 Auto-Coder',
+          roleDefinition:
+            'You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.',
+          customInstructions:
+            'Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.',
+          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
+          source: 'project',
+        },
+        {
+          slug: 'tdd',
+          name: '🧪 Tester (TDD)',
+          roleDefinition:
+            'You implement Test-Driven Development (TDD, London School), writing tests first and refactoring after minimal implementation passes.',
+          customInstructions:
+            'Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines.',
+          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
+          source: 'project',
+        },
+        {
+          slug: 'spec-pseudocode',
+          name: '📋 Specification Writer',
+          roleDefinition:
+            'You capture full project context—functional requirements, edge cases, constraints—and translate that into modular pseudocode with TDD anchors.',
+          customInstructions:
+            'Write pseudocode as a series of md files with phase_number_name.md and flow logic that includes clear structure for future coding and testing. Split complex logic across modules.',
+          groups: ['read', 'edit'],
+          source: 'project',
+        },
+        {
+          slug: 'integration',
+          name: '🔗 System Integrator',
+          roleDefinition:
+            'You merge the outputs of all modes into a working, tested, production-ready system. You ensure consistency, cohesion, and modularity.',
+          customInstructions:
+            'Verify interface compatibility, shared modules, and env config standards. Split integration logic across domains as needed. Use `new_task` for preflight testing.',
+          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
+          source: 'project',
+        },
+        {
+          slug: 'debug',
+          name: '🪲 Debugger',
+          roleDefinition:
+            'You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.',
+          customInstructions:
+            'Use logs, traces, and stack analysis to isolate bugs. Avoid changing env configuration directly. Keep fixes modular.',
+          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
+          source: 'project',
+        },
+        {
+          slug: 'security-review',
+          name: '🛡️ Security Reviewer',
+          roleDefinition:
+            'You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor modular boundaries, and oversized files.',
+          customInstructions:
+            'Scan for exposed secrets, env leaks, and monoliths. Recommend mitigations or refactors to reduce risk. Flag files > 500 lines or direct environment coupling.',
+          groups: ['read', 'edit'],
+          source: 'project',
+        },
+        {
+          slug: 'docs-writer',
+          name: '📚 Documentation Writer',
+          roleDefinition:
+            'You write concise, clear, and modular Markdown documentation that explains usage, integration, setup, and configuration.',
+          customInstructions:
+            'Only work in .md files. Use sections, examples, and headings. Keep each file under 500 lines. Do not leak env values.',
+          groups: ['read', ['edit', { fileRegex: '\\.md$', description: 'Markdown files only' }]],
+          source: 'project',
+        },
+        {
+          slug: 'swarm',
+          name: '🐝 Swarm Coordinator',
+          roleDefinition:
+            'You are the swarm coordination specialist, orchestrating multiple AI agents to handle complex, long-running tasks that would be difficult or impossible for a single agent due to scope, complexity, or timeout constraints.',
+          customInstructions:
+            'Coordinate advanced multi-agent swarms with timeout-free execution capabilities. Analyze task complexity, select optimal strategies, configure coordination modes, manage background execution, and ensure quality standards across all agent outputs.',
+          groups: ['read', 'edit', 'command'],
+          source: 'project',
+        },
+      ],
+    },
+    null,
+    2,
+  );
+}

package/src/cli/simple-commands/init/sparc/workflows.js

@@ -0,0 +1,40 @@
+// workflows.js - SPARC workflow templates
+
+export function createBasicSparcWorkflow() {
+  return JSON.stringify(
+    {
+      name: 'Basic TDD Workflow',
+      description: 'A simple SPARC-based TDD workflow for development',
+      sequential: true,
+      steps: [
+        {
+          mode: 'spec-pseudocode',
+          description: 'Create detailed specifications and pseudocode',
+          phase: 'specification',
+        },
+        {
+          mode: 'tdd',
+          description: 'Write failing tests (Red phase)',
+          phase: 'red',
+        },
+        {
+          mode: 'code',
+          description: 'Implement minimal code to pass tests (Green phase)',
+          phase: 'green',
+        },
+        {
+          mode: 'tdd',
+          description: 'Refactor and optimize (Refactor phase)',
+          phase: 'refactor',
+        },
+        {
+          mode: 'integration',
+          description: 'Integrate and verify complete solution',
+          phase: 'integration',
+        },
+      ],
+    },
+    null,
+    2,
+  );
+}