swynx-lite 1.0.0

package/src/shared/fixer/import-cleaner.mjs

@@ -0,0 +1,237 @@
+// src/fixer/import-cleaner.mjs
+// Clean up import statements in live files that reference deleted files
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname, relative, basename, extname } from 'path';
+
+/**
+ * Find and clean imports that reference deleted files
+ * @param {string} projectPath - Project root
+ * @param {string[]} deletedFiles - List of deleted file paths (relative)
+ * @param {string[]} liveFiles - List of live files to check (relative)
+ * @param {object} options - Options
+ */
+export async function cleanDeadImports(projectPath, deletedFiles, liveFiles, options = {}) {
+  const { dryRun = false } = options;
+
+  const result = {
+    filesModified: [],
+    importsRemoved: [],
+    errors: []
+  };
+
+  // Build a set of deleted file patterns (without extensions for matching)
+  const deletedPatterns = new Set();
+  for (const file of deletedFiles) {
+    // Add full path
+    deletedPatterns.add(file);
+    // Add without extension
+    const ext = extname(file);
+    if (ext) {
+      deletedPatterns.add(file.slice(0, -ext.length));
+    }
+    // Add just the basename without extension
+    const base = basename(file, ext);
+    deletedPatterns.add(base);
+  }
+
+  // Process each live file
+  for (const liveFile of liveFiles) {
+    const fullPath = join(projectPath, liveFile);
+
+    if (!existsSync(fullPath)) continue;
+
+    // Only process JS/TS files
+    const ext = extname(liveFile).toLowerCase();
+    if (!['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.vue'].includes(ext)) {
+      continue;
+    }
+
+    try {
+      const content = readFileSync(fullPath, 'utf-8');
+      const { modified, changes } = cleanImportsInFile(content, liveFile, deletedFiles, deletedPatterns);
+
+      if (changes.length > 0) {
+        if (!dryRun) {
+          writeFileSync(fullPath, modified, 'utf-8');
+        }
+
+        result.filesModified.push(liveFile);
+        result.importsRemoved.push({
+          file: liveFile,
+          imports: changes,
+          dryRun
+        });
+      }
+    } catch (error) {
+      result.errors.push({ file: liveFile, error: error.message });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Clean imports in a single file's content
+ */
+function cleanImportsInFile(content, filePath, deletedFiles, deletedPatterns) {
+  const lines = content.split('\n');
+  const changes = [];
+  const newLines = [];
+  const fileDir = dirname(filePath);
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const importMatch = matchImportStatement(line);
+
+    if (importMatch) {
+      const { importPath, fullMatch } = importMatch;
+
+      // Resolve the import path relative to the file
+      const resolvedPath = resolveImportPath(fileDir, importPath, deletedFiles);
+
+      if (resolvedPath && isDeletedImport(resolvedPath, deletedFiles, deletedPatterns)) {
+        changes.push({
+          line: i + 1,
+          removed: line.trim(),
+          importPath
+        });
+        // Skip this line (don't add to newLines)
+        // Also skip empty lines that follow import blocks
+        continue;
+      }
+    }
+
+    newLines.push(line);
+  }
+
+  // Clean up consecutive empty lines that might be left
+  const cleaned = cleanEmptyLines(newLines);
+
+  return {
+    modified: cleaned.join('\n'),
+    changes
+  };
+}
+
+/**
+ * Match import/require statements
+ */
+function matchImportStatement(line) {
+  const trimmed = line.trim();
+
+  // ES6 import
+  // import X from 'path'
+  // import { X } from 'path'
+  // import * as X from 'path'
+  // import 'path'
+  const esImportMatch = trimmed.match(/^import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/);
+  if (esImportMatch) {
+    return { importPath: esImportMatch[1], fullMatch: esImportMatch[0] };
+  }
+
+  // Dynamic import (inline - harder to remove safely, skip for now)
+  // const X = await import('path')
+
+  // CommonJS require
+  // const X = require('path')
+  // require('path')
+  const requireMatch = trimmed.match(/(?:const|let|var)?\s*\w*\s*=?\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+  if (requireMatch) {
+    return { importPath: requireMatch[1], fullMatch: requireMatch[0] };
+  }
+
+  return null;
+}
+
+/**
+ * Resolve an import path relative to the importing file
+ */
+function resolveImportPath(fileDir, importPath, deletedFiles) {
+  // Skip node_modules and absolute imports
+  if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+    return null;
+  }
+
+  // Resolve relative path
+  const resolved = join(fileDir, importPath);
+
+  // Try with common extensions
+  const extensions = ['', '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.vue', '/index.js', '/index.ts'];
+
+  for (const ext of extensions) {
+    const withExt = resolved + ext;
+    // Normalize the path
+    const normalized = withExt.replace(/\\/g, '/').replace(/^\.\//, '');
+
+    for (const deleted of deletedFiles) {
+      const deletedNorm = deleted.replace(/\\/g, '/').replace(/^\.\//, '');
+      if (normalized === deletedNorm) {
+        return normalized;
+      }
+      // Check without extension
+      const deletedNoExt = deletedNorm.replace(/\.[^/.]+$/, '');
+      const resolvedNoExt = normalized.replace(/\.[^/.]+$/, '');
+      if (resolvedNoExt === deletedNoExt) {
+        return normalized;
+      }
+    }
+  }
+
+  return resolved;
+}
+
+/**
+ * Check if an import path matches a deleted file
+ */
+function isDeletedImport(resolvedPath, deletedFiles, deletedPatterns) {
+  const normalized = resolvedPath.replace(/\\/g, '/').replace(/^\.\//, '');
+
+  // Direct match
+  if (deletedPatterns.has(normalized)) {
+    return true;
+  }
+
+  // Without extension match
+  const withoutExt = normalized.replace(/\.[^/.]+$/, '');
+  if (deletedPatterns.has(withoutExt)) {
+    return true;
+  }
+
+  // Check against full deleted paths
+  for (const deleted of deletedFiles) {
+    const deletedNorm = deleted.replace(/\\/g, '/').replace(/^\.\//, '');
+    const deletedNoExt = deletedNorm.replace(/\.[^/.]+$/, '');
+
+    if (normalized === deletedNorm || withoutExt === deletedNoExt) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Clean up consecutive empty lines
+ */
+function cleanEmptyLines(lines) {
+  const result = [];
+  let lastWasEmpty = false;
+
+  for (const line of lines) {
+    const isEmpty = line.trim() === '';
+
+    if (isEmpty && lastWasEmpty) {
+      continue; // Skip consecutive empty lines
+    }
+
+    result.push(line);
+    lastWasEmpty = isEmpty;
+  }
+
+  return result;
+}
+
+export default {
+  cleanDeadImports
+};

package/src/shared/fixer/quarantine.mjs

@@ -0,0 +1,218 @@
+// src/fixer/quarantine.mjs
+// Quarantine manager for safe file removal
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, unlinkSync, rmSync, readdirSync, statSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { randomUUID } from 'crypto';
+
+const QUARANTINE_DIR = '.swynx-quarantine';
+
+/**
+ * Create a new quarantine session
+ */
+export function createSession(projectPath, reason = 'manual') {
+  const sessionId = `${Date.now()}-${randomUUID().slice(0, 8)}`;
+  const sessionDir = join(projectPath, QUARANTINE_DIR, sessionId);
+
+  mkdirSync(sessionDir, { recursive: true });
+
+  const manifest = {
+    sessionId,
+    reason,
+    createdAt: new Date().toISOString(),
+    projectPath,
+    files: [],
+    status: 'active',
+    fileCount: 0,
+    totalSize: 0
+  };
+
+  writeFileSync(join(sessionDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+  return { sessionId, sessionDir, manifest };
+}
+
+/**
+ * Quarantine a file (move to quarantine directory)
+ */
+export function quarantineFile(projectPath, sessionId, filePath) {
+  const sessionDir = join(projectPath, QUARANTINE_DIR, sessionId);
+  const manifestPath = join(sessionDir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Quarantine session ${sessionId} not found`);
+  }
+
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+
+  // Get relative path from project root
+  const relativePath = relative(projectPath, filePath);
+  const quarantinePath = join(sessionDir, 'files', relativePath);
+
+  // Ensure directory exists
+  mkdirSync(dirname(quarantinePath), { recursive: true });
+
+  // Get file size before moving
+  let fileSize = 0;
+  if (existsSync(filePath)) {
+    fileSize = statSync(filePath).size;
+    // Copy file to quarantine
+    copyFileSync(filePath, quarantinePath);
+    // Delete original
+    unlinkSync(filePath);
+  }
+
+  // Update manifest
+  manifest.files.push({
+    originalPath: relativePath,
+    quarantinePath: relative(sessionDir, quarantinePath),
+    quarantinedAt: new Date().toISOString(),
+    size: fileSize
+  });
+  manifest.fileCount = manifest.files.length;
+  manifest.totalSize = manifest.files.reduce((sum, f) => sum + (f.size || 0), 0);
+
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+  return { quarantinePath, relativePath };
+}
+
+/**
+ * List all quarantine sessions for a project
+ */
+export function listSessions(projectPath) {
+  const quarantineDir = join(projectPath, QUARANTINE_DIR);
+
+  if (!existsSync(quarantineDir)) {
+    return [];
+  }
+
+  const sessions = [];
+  const entries = readdirSync(quarantineDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const manifestPath = join(quarantineDir, entry.name, 'manifest.json');
+      if (existsSync(manifestPath)) {
+        try {
+          const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+          sessions.push(manifest);
+        } catch (e) {
+          // Skip invalid sessions
+        }
+      }
+    }
+  }
+
+  // Sort by creation date (newest first)
+  return sessions.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+}
+
+/**
+ * Get a specific session
+ */
+export function getSession(projectPath, sessionId) {
+  const manifestPath = join(projectPath, QUARANTINE_DIR, sessionId, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+
+  return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+}
+
+/**
+ * Restore files from quarantine (undo)
+ */
+export function restoreSession(projectPath, sessionId) {
+  const sessionDir = join(projectPath, QUARANTINE_DIR, sessionId);
+  const manifestPath = join(sessionDir, 'manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Quarantine session ${sessionId} not found`);
+  }
+
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const restored = [];
+  const errors = [];
+
+  for (const file of manifest.files) {
+    try {
+      const quarantinePath = join(sessionDir, file.quarantinePath || join('files', file.originalPath));
+      const originalPath = join(projectPath, file.originalPath);
+
+      if (existsSync(quarantinePath)) {
+        // Ensure directory exists
+        mkdirSync(dirname(originalPath), { recursive: true });
+        // Copy back
+        copyFileSync(quarantinePath, originalPath);
+        restored.push(file.originalPath);
+      } else {
+        errors.push({ file: file.originalPath, error: 'Quarantine file not found' });
+      }
+    } catch (error) {
+      errors.push({ file: file.originalPath, error: error.message });
+    }
+  }
+
+  // Update manifest status
+  manifest.status = 'restored';
+  manifest.restoredAt = new Date().toISOString();
+  manifest.restoredFiles = restored.length;
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+  return {
+    success: true,
+    sessionId,
+    restored,
+    errors: errors.length > 0 ? errors : undefined,
+    message: `Restored ${restored.length} file(s)`
+  };
+}
+
+/**
+ * Permanently delete quarantined files
+ */
+export function purgeSession(projectPath, sessionId) {
+  const sessionDir = join(projectPath, QUARANTINE_DIR, sessionId);
+
+  if (!existsSync(sessionDir)) {
+    throw new Error(`Quarantine session ${sessionId} not found`);
+  }
+
+  // Read manifest for logging
+  const manifestPath = join(sessionDir, 'manifest.json');
+  let fileCount = 0;
+  if (existsSync(manifestPath)) {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    fileCount = manifest.fileCount || manifest.files?.length || 0;
+  }
+
+  // Remove entire session directory
+  rmSync(sessionDir, { recursive: true, force: true });
+
+  return {
+    success: true,
+    sessionId,
+    purgedFiles: fileCount,
+    message: `Permanently deleted quarantine session with ${fileCount} file(s)`
+  };
+}
+
+/**
+ * Get total quarantine size for a project
+ */
+export function getQuarantineSize(projectPath) {
+  const sessions = listSessions(projectPath);
+  return sessions.reduce((sum, s) => sum + (s.totalSize || 0), 0);
+}
+
+export default {
+  createSession,
+  quarantineFile,
+  listSessions,
+  getSession,
+  restoreSession,
+  purgeSession,
+  getQuarantineSize
+};