claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,407 +1,486 @@
-import { promises as fs } from "fs";
+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;
+   */
+  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;
+   */
+  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}`);
+   */
+  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}`);
         }
-        return result;
+      }
+    } 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;
+   */
+  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 [];
-        }
+   */
+  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 [];
-        }
+   */
+  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 [];
-        }
+   */
+  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,
-                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;
+   */
+  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';
-        }
+   */
+  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;
+   */
+  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: []
-            };
-        }
+   */
+  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;
+   */
+  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;
+   */
+  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
-            };
-        }
+   */
+  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;
+   */
+  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}`);
     }
-    // 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: []
-            };
-        }
+
+    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'));
+  }
+
+  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;
     }
-    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;
+
+    // Check required fields
+    const requiredFields = ['version', 'created', 'lastActivity'];
+    for (const field of requiredFields) {
+      if (!(field in state)) {
+        result.issues.push(`Missing required field: ${field}`);
+      }
     }
-    constructor(workingDir){
-        this.workingDir = workingDir;
-        this.stateFile = `${workingDir}/.claude-flow-state.json`;
+
+    // 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;
+  }
 }