@keak/sdk 1.0.1

package/src/cli/revert-conversions.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+class ConversionReverter {
+  constructor() {
+    this.stats = {
+      filesProcessed: 0,
+      filesReverted: 0,
+      backupsFound: 0
+    };
+  }
+
+  // Find all .keak-backup files
+  findBackupFiles(dir) {
+    const backups = [];
+    
+    if (!fs.existsSync(dir)) return backups;
+    
+    const items = fs.readdirSync(dir);
+    
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      
+      // Skip common directories
+      if (['node_modules', '.git', 'dist', 'build', '.next', 'coverage'].includes(item)) {
+        continue;
+      }
+      
+      const stat = fs.statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        backups.push(...this.findBackupFiles(fullPath));
+      } else if (item.endsWith('.keak-backup')) {
+        backups.push(fullPath);
+      }
+    }
+    
+    return backups;
+  }
+
+  // Revert a single file
+  revertFile(backupPath) {
+    try {
+      const originalPath = backupPath.replace('.keak-backup', '');
+      
+      if (!fs.existsSync(backupPath)) {
+        return { success: false, error: 'Backup file not found' };
+      }
+      
+      // Read backup content
+      const backupContent = fs.readFileSync(backupPath, 'utf-8');
+      
+      // Write back to original file
+      fs.writeFileSync(originalPath, backupContent);
+      
+      // Remove backup file
+      fs.unlinkSync(backupPath);
+      
+      return { success: true, restored: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // Process all backup files in a directory
+  processDirectory(rootDir) {
+    console.log(`🔍 Scanning for backup files in ${rootDir}...`);
+    
+    const backupFiles = this.findBackupFiles(rootDir);
+    this.stats.backupsFound = backupFiles.length;
+    
+    console.log(`📁 Found ${backupFiles.length} backup files`);
+    
+    if (backupFiles.length === 0) {
+      console.log('✨ No backup files found - nothing to revert');
+      return [];
+    }
+    
+    const results = [];
+    
+    for (const backupPath of backupFiles) {
+      console.log(`🔄 Reverting ${path.relative(rootDir, backupPath)}...`);
+      
+      const result = this.revertFile(backupPath);
+      result.filePath = backupPath;
+      results.push(result);
+      
+      this.stats.filesProcessed++;
+      
+      if (result.success && result.restored) {
+        console.log(`✅ Reverted ${path.relative(rootDir, backupPath.replace('.keak-backup', ''))}`);
+        this.stats.filesReverted++;
+      } else {
+        console.log(`❌ Failed to revert ${path.relative(rootDir, backupPath)}: ${result.error}`);
+      }
+    }
+    
+    return results;
+  }
+
+  // Remove any remaining Conversion imports and components
+  cleanupConversionCode(rootDir) {
+    console.log(`🧹 Cleaning up remaining Conversion components...`);
+    
+    const reactFiles = this.findReactFiles(rootDir);
+    let cleanedFiles = 0;
+    
+    for (const filePath of reactFiles) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        let modified = content;
+        
+        // Remove Conversion imports
+        modified = modified.replace(/import\s*{\s*Conversion\s*}\s*from\s*['"]keak-sdk['"];\s*\n?/g, '');
+        
+        // Remove orphaned Conversion wrapper tags (in case of partial cleanup)
+        modified = modified.replace(/]*\s*\n?/g, '');
+        modified = modified.replace(/<\/Conversion\s*\n?/g, '');
+        
+        // Clean up any malformed JSX from failed transformations
+        modified = this.fixMalformedJSX(modified);
+        
+        if (modified !== content) {
+          fs.writeFileSync(filePath, modified);
+          cleanedFiles++;
+          console.log(`🧹 Cleaned ${path.relative(rootDir, filePath)}`);
+        }
+      } catch (error) {
+        console.warn(`⚠️  Could not clean ${path.relative(rootDir, filePath)}: ${error.message}`);
+      }
+    }
+    
+    if (cleanedFiles 0) {
+      console.log(`✅ Cleaned ${cleanedFiles} files`);
+    } else {
+      console.log('✨ No cleanup needed');
+    }
+  }
+
+  // Fix malformed JSX patterns
+  fixMalformedJSX(content) {
+    let fixed = content;
+    
+    // Fix broken JSX elements that start with numbers (from failed transforms)
+    fixed = fixed.replace(/<(\d+)[^]*/g, '');
+    fixed = fixed.replace(/<\/(\d+)/g, '');
+    
+    // Fix malformed attribute values
+    fixed = fixed.replace(/label="[^"]*&[^;]*;[^"]*"/g, 'label=""');
+    
+    // Remove empty Conversion components
+    fixed = fixed.replace(/]*\s*<\/Conversion/g, '');
+    
+    return fixed;
+  }
+
+  // Find React files (same as transformer)
+  findReactFiles(dir) {
+    const files = [];
+    
+    if (!fs.existsSync(dir)) return files;
+    
+    const items = fs.readdirSync(dir);
+    
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      
+      // Skip directories we don't want to process
+      if (['node_modules', '.git', 'dist', 'build', '.next', 'coverage'].includes(item)) {
+        continue;
+      }
+      
+      const stat = fs.statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        files.push(...this.findReactFiles(fullPath));
+      } else if (this.isReactFile(item, fullPath)) {
+        files.push(fullPath);
+      }
+    }
+    
+    return files;
+  }
+
+  // Check if file is a React file
+  isReactFile(filename, fullPath) {
+    // Check extension
+    if (!/\.(jsx|tsx|js|ts)$/.test(filename)) return false;
+    
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      
+      // Must contain JSX or React imports
+      return (
+        content.includes('import') && (
+          content.includes('react') || 
+          content.includes('React') ||
+          /\s*<\w+/.test(content) // JSX elements
+        )
+      );
+    } catch (error) {
+      return false;
+    }
+  }
+
+  // Generate report
+  generateReport() {
+    return {
+      summary: `
+🔄 Conversion Tracking Reverted!
+
+📊 Summary:
+• Backup files found: ${this.stats.backupsFound}
+• Files processed: ${this.stats.filesProcessed}
+• Files reverted: ${this.stats.filesReverted}
+
+✅ All conversion tracking changes have been reverted.
+🗑️  Backup files have been removed.
+🧹 Cleanup completed.
+      `,
+      stats: this.stats
+    };
+  }
+}
+
+export default ConversionReverter;
+
+// CLI execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const reverter = new ConversionReverter();
+  const targetDir = process.argv[2] || process.cwd();
+  
+  console.log('🔄 Reverting conversion tracking changes...\n');
+  
+  const results = reverter.processDirectory(targetDir);
+  
+  // Also clean up any remaining conversion code
+  reverter.cleanupConversionCode(targetDir);
+  
+  const report = reverter.generateReport();
+  
+  console.log(report.summary);
+  
+  // Show any errors
+  const errors = results.filter(r =!r.success);
+  if (errors.length 0) {
+    console.log('\n⚠️  Some files had issues:');
+    errors.forEach(error ={
+      console.log(`❌ ${path.relative(targetDir, error.filePath)}: ${error.error}`);
+    });
+  }
+  
+  console.log(`
+🔧 What was done:
+1. All backup files (.keak-backup) were restored to original files
+2. Conversion component imports were removed
+3. Malformed JSX was cleaned up
+4. Your codebase is back to its original state
+
+💡 You can now run 'npx keak-setup conversions' again if you want to retry
+  `);
+}