devcompass 2.7.1 → 2.8.0

package/src/utils/backup-manager.js

@@ -0,0 +1,113 @@
+// src/utils/backup-manager.js
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+class BackupManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.backupDir = path.join(projectPath, '.devcompass-backups');
+  }
+
+  async createBackup() {
+    try {
+      // Ensure backup directory exists
+      if (!fs.existsSync(this.backupDir)) {
+        fs.mkdirSync(this.backupDir, { recursive: true });
+      }
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = path.join(this.backupDir, `backup-${timestamp}`);
+
+      // Create backup subdirectory
+      fs.mkdirSync(backupPath, { recursive: true });
+
+      // Backup package.json
+      const packageJsonPath = path.join(this.projectPath, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        fs.copyFileSync(
+          packageJsonPath,
+          path.join(backupPath, 'package.json')
+        );
+      }
+
+      // Backup package-lock.json
+      const packageLockPath = path.join(this.projectPath, 'package-lock.json');
+      if (fs.existsSync(packageLockPath)) {
+        fs.copyFileSync(
+          packageLockPath,
+          path.join(backupPath, 'package-lock.json')
+        );
+      }
+
+      // Save metadata
+      const metadata = {
+        timestamp: new Date().toISOString(),
+        path: backupPath
+      };
+      fs.writeFileSync(
+        path.join(backupPath, 'metadata.json'),
+        JSON.stringify(metadata, null, 2)
+      );
+
+      // Clean old backups (keep last 5)
+      this.cleanOldBackups();
+
+      return backupPath;
+    } catch (error) {
+      console.error(chalk.yellow('Warning: Failed to create backup:'), error.message);
+      return null;
+    }
+  }
+
+  cleanOldBackups() {
+    try {
+      if (!fs.existsSync(this.backupDir)) return;
+
+      const backups = fs.readdirSync(this.backupDir)
+        .filter(file => file.startsWith('backup-'))
+        .map(file => ({
+          name: file,
+          path: path.join(this.backupDir, file),
+          time: fs.statSync(path.join(this.backupDir, file)).mtime.getTime()
+        }))
+        .sort((a, b) => b.time - a.time);
+
+      // Keep only the 5 most recent backups
+      const backupsToDelete = backups.slice(5);
+      backupsToDelete.forEach(backup => {
+        fs.rmSync(backup.path, { recursive: true, force: true });
+      });
+    } catch (error) {
+      // Silently fail - backup cleanup is not critical
+    }
+  }
+
+  listBackups() {
+    try {
+      if (!fs.existsSync(this.backupDir)) return [];
+
+      return fs.readdirSync(this.backupDir)
+        .filter(file => file.startsWith('backup-'))
+        .map(file => {
+          const metadataPath = path.join(this.backupDir, file, 'metadata.json');
+          let metadata = { timestamp: 'Unknown' };
+          
+          if (fs.existsSync(metadataPath)) {
+            metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+          }
+
+          return {
+            name: file,
+            path: path.join(this.backupDir, file),
+            timestamp: metadata.timestamp
+          };
+        })
+        .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
+module.exports = BackupManager;

package/src/utils/fix-report.js

@@ -0,0 +1,129 @@
+// src/utils/fix-report.js
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+class FixReport {
+  constructor() {
+    this.fixes = [];
+    this.errors = [];
+    this.skipped = [];
+    this.startTime = Date.now();
+    this.endTime = null;
+  }
+
+  addFix(type, packageName, action, details = {}) {
+    this.fixes.push({
+      type,
+      package: packageName,
+      action,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  addError(packageName, error, details = {}) {
+    this.errors.push({
+      package: packageName,
+      error: error.message || error,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  addSkipped(packageName, reason, details = {}) {
+    this.skipped.push({
+      package: packageName,
+      reason,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  finalize() {
+    this.endTime = Date.now();
+  }
+
+  getSummary() {
+    const duration = ((this.endTime || Date.now()) - this.startTime) / 1000;
+    
+    return {
+      totalFixes: this.fixes.length,
+      totalErrors: this.errors.length,
+      totalSkipped: this.skipped.length,
+      duration: `${duration.toFixed(2)}s`,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  async save(projectPath) {
+    try {
+      const reportPath = path.join(projectPath, 'devcompass-fix-report.json');
+      const report = {
+        summary: this.getSummary(),
+        fixes: this.fixes,
+        errors: this.errors,
+        skipped: this.skipped
+      };
+
+      fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+      return reportPath;
+    } catch (error) {
+      console.error(chalk.red('Failed to save fix report:'), error.message);
+      return null;
+    }
+  }
+
+  display() {
+    console.log('\n' + chalk.bold('━'.repeat(70)));
+    console.log(chalk.bold.cyan('📊 FIX REPORT'));
+    console.log(chalk.bold('━'.repeat(70)) + '\n');
+
+    const summary = this.getSummary();
+
+    // Summary
+    console.log(chalk.bold('Summary:'));
+    console.log(`  ${chalk.green('✓')} Fixes Applied: ${chalk.cyan(summary.totalFixes)}`);
+    if (summary.totalErrors > 0) {
+      console.log(`  ${chalk.red('✗')} Errors: ${chalk.red(summary.totalErrors)}`);
+    }
+    if (summary.totalSkipped > 0) {
+      console.log(`  ${chalk.yellow('⊘')} Skipped: ${chalk.yellow(summary.totalSkipped)}`);
+    }
+    console.log(`  ${chalk.gray('⏱')}  Duration: ${chalk.cyan(summary.duration)}`);
+
+    // Fixes
+    if (this.fixes.length > 0) {
+      console.log('\n' + chalk.bold('Fixes Applied:'));
+      this.fixes.forEach((fix, index) => {
+        console.log(`  ${index + 1}. ${chalk.cyan(fix.package)}`);
+        console.log(`     ${chalk.gray('→')} ${fix.action}`);
+        if (fix.details.from && fix.details.to) {
+          console.log(`     ${chalk.gray('Version:')} ${fix.details.from} → ${chalk.green(fix.details.to)}`);
+        }
+      });
+    }
+
+    // Errors
+    if (this.errors.length > 0) {
+      console.log('\n' + chalk.bold.red('Errors:'));
+      this.errors.forEach((error, index) => {
+        console.log(`  ${index + 1}. ${chalk.red(error.package)}`);
+        console.log(`     ${chalk.gray('→')} ${error.error}`);
+      });
+    }
+
+    // Skipped
+    if (this.skipped.length > 0) {
+      console.log('\n' + chalk.bold.yellow('Skipped:'));
+      this.skipped.forEach((skip, index) => {
+        console.log(`  ${index + 1}. ${chalk.yellow(skip.package)}`);
+        console.log(`     ${chalk.gray('→')} ${skip.reason}`);
+      });
+    }
+
+    console.log('\n' + chalk.bold('━'.repeat(70)) + '\n');
+  }
+}
+
+module.exports = FixReport;

package/src/utils/progress-tracker.js

@@ -0,0 +1,79 @@
+// src/utils/progress-tracker.js
+const ora = require('ora');
+const chalk = require('chalk');
+
+class ProgressTracker {
+  constructor(totalSteps) {
+    this.totalSteps = totalSteps;
+    this.currentStep = 0;
+    this.spinner = null;
+    this.startTime = Date.now();
+  }
+
+  start(message) {
+    this.spinner = ora({
+      text: this.formatMessage(message),
+      spinner: 'dots'
+    }).start();
+  }
+
+  update(message) {
+    this.currentStep++;
+    if (this.spinner) {
+      this.spinner.text = this.formatMessage(message);
+    }
+  }
+
+  succeed(message) {
+    if (this.spinner) {
+      this.spinner.succeed(this.formatMessage(message || 'Complete'));
+    }
+  }
+
+  fail(message) {
+    if (this.spinner) {
+      this.spinner.fail(chalk.red(message));
+    }
+  }
+
+  warn(message) {
+    if (this.spinner) {
+      this.spinner.warn(chalk.yellow(message));
+    }
+  }
+
+  info(message) {
+    if (this.spinner) {
+      this.spinner.info(chalk.cyan(message));
+    }
+  }
+
+  formatMessage(message) {
+    const percentage = Math.round((this.currentStep / this.totalSteps) * 100);
+    const elapsed = this.getElapsedTime();
+    const eta = this.getETA();
+    
+    return `${message} ${chalk.gray(`[${this.currentStep}/${this.totalSteps}]`)} ${chalk.cyan(`${percentage}%`)} ${chalk.gray(`• ${elapsed}s elapsed`)}${eta ? chalk.gray(` • ETA: ${eta}s`) : ''}`;
+  }
+
+  getElapsedTime() {
+    return ((Date.now() - this.startTime) / 1000).toFixed(1);
+  }
+
+  getETA() {
+    if (this.currentStep === 0) return null;
+    const elapsed = Date.now() - this.startTime;
+    const avgTimePerStep = elapsed / this.currentStep;
+    const remainingSteps = this.totalSteps - this.currentStep;
+    const eta = (avgTimePerStep * remainingSteps) / 1000;
+    return eta > 0 ? eta.toFixed(1) : null;
+  }
+
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+    }
+  }
+}
+
+module.exports = ProgressTracker;