vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/storage/FileManager.js

@@ -0,0 +1,454 @@
+/**
+ * File-based Storage Manager
+ * 
+ * Manages file-based storage for agent data and logs.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * File-based storage manager class
+ */
+class FileManager {
+  /**
+   * Create file manager instance
+   * @param {Object} options - Storage options
+   * @param {string} options.baseDir - Base directory for storage
+   * @param {string} options.configDir - Configuration directory
+   * @param {string} options.logsDir - Logs directory
+   */
+  constructor(options = {}) {
+    this.baseDir = options.baseDir || path.join(process.cwd(), '.vibecodingmachine');
+    this.configDir = options.configDir || path.join(this.baseDir, 'config');
+    this.logsDir = options.logsDir || path.join(this.baseDir, 'logs');
+    this.statusFile = path.join(this.configDir, 'agent-status.json');
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize storage directories
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    try {
+      await this.ensureDirectory(this.baseDir);
+      await this.ensureDirectory(this.configDir);
+      await this.ensureDirectory(this.logsDir);
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(`Failed to initialize storage: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<void>}
+   */
+  async ensureDirectory(dirPath) {
+    try {
+      await fs.access(dirPath);
+    } catch {
+      await fs.mkdir(dirPath, { recursive: true });
+    }
+  }
+
+  /**
+   * Save agent status data
+   * @param {Object} statusData - Agent status data
+   * @returns {Promise<void>}
+   */
+  async saveAgentStatus(statusData) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    try {
+      await fs.writeFile(this.statusFile, JSON.stringify(statusData, null, 2), 'utf8');
+    } catch (error) {
+      throw new Error(`Failed to save agent status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Load agent status data
+   * @returns {Promise<Object>} - Agent status data
+   */
+  async loadAgentStatus() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    try {
+      const data = await fs.readFile(this.statusFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // Return empty status if file doesn't exist
+        return {
+          lastUpdated: new Date().toISOString(),
+          agents: {}
+        };
+      }
+      throw new Error(`Failed to load agent status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Update individual agent status
+   * @param {string} agentId - Agent identifier
+   * @param {Object} agentStatus - Agent status data
+   * @returns {Promise<void>}
+   */
+  async updateAgentStatus(agentId, agentStatus) {
+    const statusData = await this.loadAgentStatus();
+    statusData.agents[agentId] = {
+      ...agentStatus,
+      lastUpdated: new Date().toISOString()
+    };
+    statusData.lastUpdated = new Date().toISOString();
+    await this.saveAgentStatus(statusData);
+  }
+
+  /**
+   * Get agent status
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<Object|null>} - Agent status data
+   */
+  async getAgentStatus(agentId) {
+    const statusData = await this.loadAgentStatus();
+    return statusData.agents[agentId] || null;
+  }
+
+  /**
+   * Delete agent status
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<boolean>} - True if status was deleted
+   */
+  async deleteAgentStatus(agentId) {
+    const statusData = await this.loadAgentStatus();
+    
+    if (statusData.agents[agentId]) {
+      delete statusData.agents[agentId];
+      statusData.lastUpdated = new Date().toISOString();
+      await this.saveAgentStatus(statusData);
+      return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Write log entry to log file
+   * @param {string} logType - Type of log (installation, verification, error)
+   * @param {Object} logEntry - Log entry data
+   * @returns {Promise<void>}
+   */
+  async writeLog(logType, logEntry) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const logFile = path.join(this.logsDir, `${logType}.log`);
+    const logLine = JSON.stringify({
+      ...logEntry,
+      timestamp: logEntry.timestamp || new Date().toISOString()
+    }) + '\n';
+
+    try {
+      await fs.appendFile(logFile, logLine, 'utf8');
+    } catch (error) {
+      throw new Error(`Failed to write log entry: ${error.message}`);
+    }
+  }
+
+  /**
+   * Read log entries
+   * @param {string} logType - Type of log
+   * @param {Object} options - Read options
+   * @param {number} options.limit - Maximum number of entries to read
+   * @param {number} options.offset - Number of entries to skip
+   * @param {Date} options.since - Only entries since this date
+   * @returns {Promise<Array>} - Array of log entries
+   */
+  async readLogs(logType, options = {}) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const { limit = 100, offset = 0, since = null } = options;
+    const logFile = path.join(this.logsDir, `${logType}.log`);
+
+    try {
+      const data = await fs.readFile(logFile, 'utf8');
+      const lines = data.trim().split('\n').filter(line => line.length > 0);
+      
+      let entries = lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(entry => entry !== null);
+
+      // Filter by date if specified
+      if (since) {
+        const sinceTime = since.getTime();
+        entries = entries.filter(entry => {
+          const entryTime = new Date(entry.timestamp).getTime();
+          return entryTime >= sinceTime;
+        });
+      }
+
+      // Sort by timestamp (newest first)
+      entries.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+      // Apply offset and limit
+      return entries.slice(offset, offset + limit);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw new Error(`Failed to read logs: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get log statistics
+   * @param {string} logType - Type of log
+   * @returns {Promise<Object>} - Log statistics
+   */
+  async getLogStats(logType) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const logFile = path.join(this.logsDir, `${logType}.log`);
+
+    try {
+      const stats = await fs.stat(logFile);
+      const entries = await this.readLogs(logType, { limit: 10000 }); // Read up to 10k entries for stats
+
+      const statsData = {
+        fileExists: true,
+        fileSize: stats.size,
+        lastModified: stats.mtime.toISOString(),
+        totalEntries: entries.length,
+        dateRange: null
+      };
+
+      if (entries.length > 0) {
+        const timestamps = entries.map(entry => new Date(entry.timestamp));
+        const minDate = new Date(Math.min(...timestamps));
+        const maxDate = new Date(Math.max(...timestamps));
+        
+        statsData.dateRange = {
+          earliest: minDate.toISOString(),
+          latest: maxDate.toISOString()
+        };
+      }
+
+      return statsData;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return {
+          fileExists: false,
+          fileSize: 0,
+          lastModified: null,
+          totalEntries: 0,
+          dateRange: null
+        };
+      }
+      throw new Error(`Failed to get log stats: ${error.message}`);
+    }
+  }
+
+  /**
+   * Clean old log entries
+   * @param {string} logType - Type of log
+   * @param {number} olderThanDays - Remove entries older than this many days
+   * @returns {Promise<number>} - Number of entries removed
+   */
+  async cleanOldLogs(logType, olderThanDays = 30) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+
+    const entries = await this.readLogs(logType, { limit: 10000 });
+    const recentEntries = entries.filter(entry => {
+      return new Date(entry.timestamp) >= cutoffDate;
+    });
+
+    const logFile = path.join(this.logsDir, `${logType}.log`);
+    
+    // Rewrite log file with only recent entries
+    const logLines = recentEntries.map(entry => JSON.stringify(entry) + '\n');
+    await fs.writeFile(logFile, logLines.join(''), 'utf8');
+
+    return entries.length - recentEntries.length;
+  }
+
+  /**
+   * Rotate log files (move current log to backup and create new one)
+   * @param {string} logType - Type of log
+   * @returns {Promise<void>}
+   */
+  async rotateLog(logType) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const logFile = path.join(this.logsDir, `${logType}.log`);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupFile = path.join(this.logsDir, `${logType}-${timestamp}.log`);
+
+    try {
+      await fs.access(logFile);
+      await fs.rename(logFile, backupFile);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw new Error(`Failed to rotate log: ${error.message}`);
+      }
+      // If file doesn't exist, no rotation needed
+    }
+  }
+
+  /**
+   * Get storage usage statistics
+   * @returns {Promise<Object>} - Storage usage data
+   */
+  async getStorageUsage() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const usage = {
+      baseDir: this.baseDir,
+      totalSize: 0,
+      directories: {},
+      files: []
+    };
+
+    try {
+      // Calculate directory sizes
+      const dirs = ['config', 'logs'];
+      
+      for (const dir of dirs) {
+        const dirPath = path.join(this.baseDir, dir);
+        try {
+          const dirSize = await this.calculateDirectorySize(dirPath);
+          usage.directories[dir] = dirSize;
+          usage.totalSize += dirSize;
+        } catch {
+          usage.directories[dir] = 0;
+        }
+      }
+
+      // List files
+      const files = await this.listFiles(this.baseDir);
+      usage.files = files;
+    } catch (error) {
+      throw new Error(`Failed to get storage usage: ${error.message}`);
+    }
+
+    return usage;
+  }
+
+  /**
+   * Calculate directory size
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<number>} - Directory size in bytes
+   */
+  async calculateDirectorySize(dirPath) {
+    let totalSize = 0;
+
+    try {
+      const items = await fs.readdir(dirPath);
+      
+      for (const item of items) {
+        const itemPath = path.join(dirPath, item);
+        const stats = await fs.stat(itemPath);
+        
+        if (stats.isDirectory()) {
+          totalSize += await this.calculateDirectorySize(itemPath);
+        } else {
+          totalSize += stats.size;
+        }
+      }
+    } catch {
+      // Directory doesn't exist or can't be accessed
+    }
+
+    return totalSize;
+  }
+
+  /**
+   * List files in directory recursively
+   * @param {string} dirPath - Directory path
+   * @param {number} maxDepth - Maximum recursion depth
+   * @returns {Promise<Array>} - Array of file information
+   */
+  async listFiles(dirPath, maxDepth = 3) {
+    const files = [];
+
+    try {
+      const items = await fs.readdir(dirPath);
+      
+      for (const item of items) {
+        const itemPath = path.join(dirPath, item);
+        const stats = await fs.stat(itemPath);
+        const relativePath = path.relative(this.baseDir, itemPath);
+        
+        if (stats.isDirectory() && maxDepth > 0) {
+          const subFiles = await this.listFiles(itemPath, maxDepth - 1);
+          files.push(...subFiles);
+        } else if (stats.isFile()) {
+          files.push({
+            path: relativePath,
+            size: stats.size,
+            modified: stats.mtime.toISOString(),
+            type: path.extname(itemPath).slice(1) || 'file'
+          });
+        }
+      }
+    } catch {
+      // Directory doesn't exist or can't be accessed
+    }
+
+    return files;
+  }
+
+  /**
+   * Backup storage data
+   * @param {string} backupPath - Backup directory path
+   * @returns {Promise<void>}
+   */
+  async backup(backupPath) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const { execSync } = require('child_process');
+    
+    try {
+      // Create backup directory
+      await fs.mkdir(backupPath, { recursive: true });
+      
+      // Copy storage directory
+      const command = process.platform === 'win32' 
+        ? `xcopy "${this.baseDir}" "${backupPath}" /E /I /H /Y`
+        : `cp -r "${this.baseDir}"/* "${backupPath}/"`;
+      
+      execSync(command, { stdio: 'ignore' });
+    } catch (error) {
+      throw new Error(`Failed to backup storage: ${error.message}`);
+    }
+  }
+}
+
+module.exports = FileManager;