swynx-lite 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swynx-lite",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Dead code detection and cleanup for 35 languages",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -53,12 +53,28 @@ program
     process.exit(exitCode);
   });
 
+// ── quarantine ───────────────────────────────────────────────────────────────
+
+program
+  .command('quarantine')
+  .argument('[path]', 'Path to scan', '.')
+  .description('Safely move dead files to .swynx-quarantine/ (reversible)')
+  .option('--dry-run', 'Preview what would be quarantined')
+  .option('--yes', 'Skip confirmation prompt')
+  .option('--json', 'Output as JSON')
+  .option('--no-color', 'Disable ANSI colours')
+  .action(async (path, opts) => {
+    const { runQuarantine } = await import('./quarantine-cmd.mjs');
+    const { exitCode } = await runQuarantine(path, opts);
+    process.exit(exitCode);
+  });
+
 // ── clean ────────────────────────────────────────────────────────────────────
 
 program
   .command('clean')
   .argument('[path]', 'Path to clean', '.')
-  .description('Remove dead code with quarantine safety net')
+  .description('Quarantine dead files + clean dead imports and barrel exports')
   .option('--dry-run', 'Preview what would be removed')
   .option('--no-quarantine', 'Delete directly without quarantine backup')
   .option('--no-import-clean', 'Skip cleaning dead imports from live files')
@@ -252,7 +268,7 @@ function confirmPrompt(message) {
 // If no command provided, default to `scan .`
 // This makes `npx swynx-lite` work like `npx knip`
 const args = process.argv.slice(2);
-const commands = ['scan', 'clean', 'restore', 'purge', 'init', 'help'];
+const commands = ['scan', 'quarantine', 'clean', 'restore', 'purge', 'init', 'help'];
 const hasCommand = args.some(a => commands.includes(a));
 const hasHelpOrVersion = args.some(a => ['-h', '--help', '-v', '--version', '--pro'].includes(a));
 

package/src/output/console.mjs

@@ -183,7 +183,7 @@ export function renderScanOutput(results, options = {}) {
       lines.push(`  ${c(DIM, '──', nc)} ${c(BOLD, 'What Next', nc)} ${c(DIM, hr, nc)}`);
       lines.push('');
       if (deadCount > 0) {
-        lines.push(`   Run  ${c(BRIGHT_CYAN, 'swynx-lite clean', nc)}  to remove ${formatNumber(deadCount)} dead file${deadCount === 1 ? '' : 's'} ${c(DIM, `(saves ${formatBytes(summary.totalDeadBytes)})`, nc)}`);
+        lines.push(`   Run  ${c(BRIGHT_CYAN, 'swynx-lite quarantine', nc)}  to safely move ${formatNumber(deadCount)} dead file${deadCount === 1 ? '' : 's'} to .swynx-quarantine/ ${c(DIM, `(${formatBytes(summary.totalDeadBytes)})`, nc)}`);
       }
       if (partialFiles.length > 0) {
         const totalDeadExports = partialFiles.reduce((sum, f) => sum + (f.deadExports || []).length, 0);
@@ -268,6 +268,49 @@ export function renderCleanOutput(results, options = {}) {
   return lines.join('\n');
 }
 
+/**
+ * Render quarantine results to the console
+ */
+export function renderQuarantineOutput(results, options = {}) {
+  const { noColor = false } = options;
+  const lines = [];
+  const nc = noColor;
+
+  lines.push('');
+  lines.push(`  ${c(BOLD + BRIGHT_CYAN, 'swynx lite', nc)} ${c(DIM, 'v1.0.0', nc)}${results.dryRun ? c(DIM, ' — dry run (no files will be moved)', nc) : ''}`);
+  lines.push('');
+
+  if (results.dryRun) {
+    lines.push(`  Would quarantine ${c(BOLD, formatNumber(results.filesQuarantined), nc)} file${results.filesQuarantined === 1 ? '' : 's'} ${c(DIM, `(${formatBytes(results.bytesRemoved)})`, nc)}:`);
+    lines.push('');
+
+    const files = results.files || [];
+    const showCount = Math.min(10, files.length);
+    for (let i = 0; i < showCount; i++) {
+      const f = files[i];
+      const path = typeof f === 'string' ? f : (f.file || f.path || '');
+      const size = typeof f === 'object' && f.size ? formatBytes(f.size) : '';
+      lines.push(`   ${c(WHITE, pad(path, 42), nc)} ${c(DIM, rpad(size, 10), nc)}`);
+    }
+    if (files.length > 10) {
+      lines.push(`   ${c(DIM, `... and ${files.length - 10} more`, nc)}`);
+    }
+    lines.push('');
+  } else {
+    lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Quarantined ${formatNumber(results.filesQuarantined)} file${results.filesQuarantined === 1 ? '' : 's'} to .swynx-quarantine/ ${c(DIM, `(${formatBytes(results.bytesRemoved)})`, nc)}`);
+    lines.push('');
+    lines.push(`  ${c(BOLD, 'Test your app now.', nc)} If anything breaks:`);
+    lines.push(`   Run  ${c(BRIGHT_CYAN, 'swynx-lite restore', nc)}  to bring everything back`);
+    lines.push('');
+    lines.push(`  If everything works:`);
+    lines.push(`   Run  ${c(BRIGHT_CYAN, 'swynx-lite purge', nc)}  to permanently delete the quarantined files`);
+    lines.push(`   Run  ${c(BRIGHT_CYAN, 'swynx-lite clean', nc)}  to also clean dead imports and barrel exports`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
 /**
  * Render restore result
  */

package/src/quarantine-cmd.mjs

@@ -0,0 +1,201 @@
+// src/quarantine-cmd.mjs
+// Quarantine orchestrator — scan, move dead files to .swynx-quarantine/, done.
+// No import/barrel cleanup — just the safe move-and-test flow.
+
+import { resolve, join } from 'path';
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
+import { loadConfig } from './config.mjs';
+import { scanDeadCode } from './shared/scanner/scan-dead-code.mjs';
+import { createSession, quarantineFile } from './shared/fixer/quarantine.mjs';
+import { ProgressSpinner } from './output/progress.mjs';
+import { renderQuarantineOutput } from './output/console.mjs';
+import { formatCleanJSON } from './output/json.mjs';
+
+/**
+ * Run the quarantine command
+ */
+export async function runQuarantine(targetPath, cliOptions = {}) {
+  const projectPath = resolve(targetPath || '.');
+
+  if (!existsSync(projectPath)) {
+    console.error(`  Error: path not found — ${projectPath}`);
+    return { exitCode: 2 };
+  }
+
+  const config = loadConfig(projectPath, cliOptions);
+  const isJSON = cliOptions.json || false;
+  const noColor = cliOptions.color === false || !!process.env.NO_COLOR;
+  const dryRun = cliOptions.dryRun || false;
+  const autoYes = cliOptions.yes || false;
+
+  const spinner = new ProgressSpinner({
+    enabled: !isJSON,
+    noColor,
+  });
+
+  // Step 1: Scan
+  spinner.start('Scanning for dead code...');
+
+  let scanResults;
+  try {
+    scanResults = await scanDeadCode(projectPath, {
+      onProgress: (p) => spinner.update(p),
+    });
+  } catch (e) {
+    spinner.stop();
+    console.error(`  Error during scan: ${e.message}`);
+    return { exitCode: 2 };
+  }
+
+  spinner.stop();
+
+  // Apply ignore filters
+  if (config.ignore.length > 0) {
+    let minimatch;
+    try {
+      const mod = await import('minimatch');
+      minimatch = mod.minimatch || mod.default;
+    } catch {
+      try {
+        const g = await import('glob');
+        minimatch = g.minimatch;
+      } catch { /* skip */ }
+    }
+
+    if (minimatch) {
+      const ignoreFilter = f => {
+        const filePath = f.file || f.path || '';
+        return !config.ignore.some(pattern => minimatch(filePath, pattern, { dot: true }));
+      };
+      scanResults.deadFiles = scanResults.deadFiles.filter(ignoreFilter);
+      if (scanResults.partialFiles) {
+        scanResults.partialFiles = scanResults.partialFiles.filter(ignoreFilter);
+      }
+      const deadCount = scanResults.deadFiles.length;
+      const totalDeadBytes = scanResults.deadFiles.reduce((sum, f) => sum + (f.size || 0), 0);
+      const deadRate = scanResults.summary.totalFiles > 0
+        ? ((deadCount / scanResults.summary.totalFiles) * 100).toFixed(2)
+        : '0.00';
+      scanResults.summary.deadFiles = deadCount;
+      scanResults.summary.partialFiles = (scanResults.partialFiles || []).length;
+      scanResults.summary.totalDeadBytes = totalDeadBytes;
+      scanResults.summary.deadRate = `${deadRate}%`;
+    }
+  }
+
+  const deadFiles = scanResults.deadFiles || [];
+  if (deadFiles.length === 0) {
+    if (isJSON) {
+      console.log(formatCleanJSON({ dryRun, filesRemoved: 0, bytesRemoved: 0, files: [] }));
+    } else {
+      console.log('\n  No dead code found. Your codebase is clean!\n');
+    }
+    return { exitCode: 0 };
+  }
+
+  const totalBytes = deadFiles.reduce((sum, f) => sum + (f.size || 0), 0);
+
+  // Step 2: Confirmation
+  if (!dryRun && !autoYes && !isJSON) {
+    console.log('');
+    console.log(`  ${deadFiles.length} dead file${deadFiles.length === 1 ? '' : 's'} found (${formatBytes(totalBytes)})`);
+    console.log('');
+
+    const showCount = Math.min(5, deadFiles.length);
+    for (let i = 0; i < showCount; i++) {
+      const f = deadFiles[i];
+      console.log(`   ${(f.file || '').padEnd(42)} ${formatBytes(f.size).padStart(10)}`);
+    }
+    if (deadFiles.length > 5) {
+      console.log(`   ... and ${deadFiles.length - 5} more`);
+    }
+    console.log('');
+    console.log(`  Files will be moved to .swynx-quarantine/ (reversible)`);
+    console.log('');
+
+    const ok = await confirm(`  Quarantine ${deadFiles.length} file${deadFiles.length === 1 ? '' : 's'}? (y/N) `);
+    if (!ok) {
+      console.log('  Cancelled.\n');
+      return { exitCode: 0 };
+    }
+  }
+
+  // Step 3: Quarantine
+  const quarantinedFiles = [];
+  let sessionId = null;
+  let bytesRemoved = 0;
+
+  if (!dryRun) {
+    const session = createSession(projectPath, 'quarantine');
+    sessionId = session.sessionId;
+
+    spinner.start('Quarantining files...');
+    for (const f of deadFiles) {
+      const filePath = f.file || f.path || '';
+      const fullPath = join(projectPath, filePath);
+      try {
+        quarantineFile(projectPath, sessionId, fullPath);
+        quarantinedFiles.push(filePath);
+        bytesRemoved += f.size || 0;
+      } catch {
+        // Skip files that can't be quarantined
+      }
+    }
+    spinner.stop();
+
+    // Auto-add .swynx-quarantine/ to .gitignore
+    ensureGitignore(projectPath);
+  }
+
+  const result = {
+    dryRun,
+    filesQuarantined: dryRun ? deadFiles.length : quarantinedFiles.length,
+    bytesRemoved: dryRun ? totalBytes : bytesRemoved,
+    sessionId,
+    files: deadFiles.map(f => ({ file: f.file, size: f.size })),
+  };
+
+  if (isJSON) {
+    console.log(formatCleanJSON({ ...result, filesRemoved: result.filesQuarantined }));
+  } else {
+    console.log(renderQuarantineOutput(result, { noColor }));
+  }
+
+  return { exitCode: 0, result };
+}
+
+/**
+ * Add .swynx-quarantine/ to .gitignore if not already there
+ */
+function ensureGitignore(projectPath) {
+  const gitignorePath = join(projectPath, '.gitignore');
+  const entry = '.swynx-quarantine/';
+
+  try {
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, 'utf-8');
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `\n# Swynx quarantine\n${entry}\n`);
+    } else {
+      writeFileSync(gitignorePath, `# Swynx quarantine\n${entry}\n`);
+    }
+  } catch { /* best effort */ }
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function confirm(message) {
+  return new Promise((resolve) => {
+    process.stdout.write(message);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.resume();
+    process.stdin.once('data', (data) => {
+      process.stdin.pause();
+      resolve(data.trim().toLowerCase() === 'y');
+    });
+  });
+}