swynx-lite 1.0.0

package/src/cli.mjs

@@ -0,0 +1,264 @@
+// src/cli.mjs
+// Commander-based CLI for swynx-lite
+
+import { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+const VERSION = '1.0.0';
+
+// ── First-run detection ──────────────────────────────────────────────────────
+
+function checkFirstRun() {
+  const marker = join(
+    process.env.HOME || process.env.USERPROFILE || '/tmp',
+    '.swynx-lite-init'
+  );
+  if (!existsSync(marker)) {
+    try { writeFileSync(marker, Date.now().toString()); } catch { /* */ }
+    return true;
+  }
+  return false;
+}
+
+// ── CLI Setup ────────────────────────────────────────────────────────────────
+
+const program = new Command();
+
+program
+  .name('swynx-lite')
+  .description('Dead code detection and cleanup for 35 languages')
+  .version(VERSION, '-v, --version');
+
+// ── scan ─────────────────────────────────────────────────────────────────────
+
+program
+  .command('scan')
+  .argument('[path]', 'Path to scan', '.')
+  .description('Scan for dead code and security issues')
+  .option('--json', 'Output as JSON instead of console')
+  .option('--ci', 'CI mode: exit code 1 if dead code found')
+  .option('--threshold <n>', 'In CI mode, only fail if dead rate > n%', parseFloat)
+  .option('--no-security', 'Skip security scanning')
+  .option('--ignore <glob>', 'Additional paths to ignore (repeatable)', collect, [])
+  .option('--verbose', 'Show detailed progress')
+  .option('--no-color', 'Disable ANSI colours')
+  .action(async (path, opts) => {
+    if (checkFirstRun() && !opts.json && !opts.ci) {
+      console.log(`\n  ${dim('swynx lite — no telemetry, no tracking, fully offline.')}`);
+    }
+
+    const { runScan } = await import('./scan.mjs');
+    const { exitCode } = await runScan(path, opts);
+    process.exit(exitCode);
+  });
+
+// ── clean ────────────────────────────────────────────────────────────────────
+
+program
+  .command('clean')
+  .argument('[path]', 'Path to clean', '.')
+  .description('Remove dead code with quarantine safety net')
+  .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')
+  .option('--no-barrel-clean', 'Skip cleaning dead re-exports from barrel files')
+  .option('--yes', 'Skip confirmation prompt')
+  .option('--json', 'Output as JSON')
+  .option('--no-color', 'Disable ANSI colours')
+  .action(async (path, opts) => {
+    const { runClean } = await import('./clean.mjs');
+    const { exitCode } = await runClean(path, opts);
+    process.exit(exitCode);
+  });
+
+// ── restore ──────────────────────────────────────────────────────────────────
+
+program
+  .command('restore')
+  .description('Undo the last clean operation')
+  .option('--list', 'List all available restore points')
+  .option('--id <id>', 'Restore a specific quarantine session')
+  .option('--no-color', 'Disable ANSI colours')
+  .action(async (opts) => {
+    const { listSessions, restoreSession } = await import('./shared/fixer/quarantine.mjs');
+    const { renderRestoreOutput, renderSessionList } = await import('./output/console.mjs');
+    const noColor = opts.color === false || !!process.env.NO_COLOR;
+    const projectPath = resolve('.');
+
+    if (opts.list) {
+      const sessions = listSessions(projectPath);
+      console.log(renderSessionList(sessions, { noColor }));
+      process.exit(0);
+    }
+
+    const sessions = listSessions(projectPath);
+    if (sessions.length === 0) {
+      console.log('\n  No quarantine sessions found.\n');
+      process.exit(0);
+    }
+
+    // Restore specific or most recent active session
+    const sessionId = opts.id || sessions.find(s => s.status === 'active')?.sessionId || sessions[0].sessionId;
+
+    try {
+      const result = restoreSession(projectPath, sessionId);
+      console.log(renderRestoreOutput(result, { noColor }));
+    } catch (e) {
+      console.error(`  Error: ${e.message}\n`);
+      process.exit(2);
+    }
+  });
+
+// ── purge ────────────────────────────────────────────────────────────────────
+
+program
+  .command('purge')
+  .description('Permanently delete quarantined files')
+  .option('--id <id>', 'Purge a specific session only')
+  .option('--yes', 'Skip confirmation')
+  .option('--no-color', 'Disable ANSI colours')
+  .action(async (opts) => {
+    const { listSessions, purgeSession } = await import('./shared/fixer/quarantine.mjs');
+    const { renderPurgeOutput } = await import('./output/console.mjs');
+    const noColor = opts.color === false || !!process.env.NO_COLOR;
+    const projectPath = resolve('.');
+
+    const sessions = listSessions(projectPath);
+    if (sessions.length === 0) {
+      console.log('\n  No quarantine sessions to purge.\n');
+      process.exit(0);
+    }
+
+    const autoYes = opts.yes || false;
+
+    if (!autoYes) {
+      const totalSize = sessions.reduce((sum, s) => sum + (s.totalSize || 0), 0);
+      const totalFiles = sessions.reduce((sum, s) => sum + (s.fileCount || 0), 0);
+      console.log(`\n  ${sessions.length} quarantine session${sessions.length === 1 ? '' : 's'} found (${formatBytes(totalSize)} total)\n`);
+
+      const ok = await confirmPrompt(`  Permanently delete all quarantined files? (y/N) `);
+      if (!ok) {
+        console.log('  Cancelled.\n');
+        process.exit(0);
+      }
+    }
+
+    let purged = 0;
+    let totalFiles = 0;
+    let totalSize = 0;
+
+    if (opts.id) {
+      const result = purgeSession(projectPath, opts.id);
+      purged = 1;
+      totalFiles = result.purgedFiles;
+    } else {
+      for (const s of sessions) {
+        try {
+          purgeSession(projectPath, s.sessionId);
+          purged++;
+          totalFiles += s.fileCount || 0;
+          totalSize += s.totalSize || 0;
+        } catch { /* skip */ }
+      }
+    }
+
+    console.log(renderPurgeOutput({ purged, totalFiles, totalSize }, { noColor }));
+  });
+
+// ── init ─────────────────────────────────────────────────────────────────────
+
+program
+  .command('init')
+  .description('Create a .swynx-lite.json config file')
+  .action(async () => {
+    const configPath = join(resolve('.'), '.swynx-lite.json');
+    if (existsSync(configPath)) {
+      console.log('\n  .swynx-lite.json already exists.\n');
+      process.exit(0);
+    }
+
+    const { generateConfigTemplate } = await import('./config.mjs');
+    writeFileSync(configPath, generateConfigTemplate() + '\n');
+
+    console.log('\n  Created .swynx-lite.json');
+    console.log('');
+    console.log('  Edit this file to:');
+    console.log('   \u2022 Ignore specific paths or patterns');
+    console.log('   \u2022 Set CI thresholds');
+    console.log('   \u2022 Configure security scanning');
+    console.log('');
+  });
+
+// ── --pro flag ───────────────────────────────────────────────────────────────
+
+program.option('--pro', 'Show Swynx Pro features');
+
+program.on('option:pro', () => {
+  const d = process.env.NO_COLOR ? (t) => t : (t) => `\x1b[2m${t}\x1b[0m`;
+  const b = process.env.NO_COLOR ? (t) => t : (t) => `\x1b[1m${t}\x1b[0m`;
+  const c = process.env.NO_COLOR ? (t) => t : (t) => `\x1b[1;96m${t}\x1b[0m`;
+
+  console.log('');
+  console.log(`  ${c('swynx lite')} ${d(`v${VERSION}`)} — Free forever`);
+  console.log('');
+  console.log(`  ${b('Swynx Pro')} is built for engineering teams:`);
+  console.log('   \u2022 Web dashboard with historical trends');
+  console.log('   \u2022 Predictive intelligence (decay signals)');
+  console.log('   \u2022 Per-export dead code detection');
+  console.log('   \u2022 Emissions and waste analysis');
+  console.log('   \u2022 Dependency and license scanning');
+  console.log('   \u2022 SARIF, Markdown, and PDF reports');
+  console.log('   \u2022 Enterprise reporting suite');
+  console.log('   \u2022 Air-gapped deployment');
+  console.log('   \u2022 Priority support');
+  console.log('');
+  console.log(`  From \u00a32,000/year \u00b7 https://swynx.io/pro`);
+  console.log('');
+  process.exit(0);
+});
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function collect(val, arr) {
+  arr.push(val);
+  return arr;
+}
+
+function dim(text) {
+  return process.env.NO_COLOR ? text : `\x1b[2m${text}\x1b[0m`;
+}
+
+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 confirmPrompt(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');
+    });
+  });
+}
+
+// ── Default action: scan when no command given ──────────────────────────────
+
+// 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 hasCommand = args.some(a => commands.includes(a));
+const hasHelpOrVersion = args.some(a => ['-h', '--help', '-v', '--version', '--pro'].includes(a));
+
+if (args.length === 0 || (!hasCommand && !hasHelpOrVersion)) {
+  // Inject 'scan' as default command, pass remaining args as flags
+  process.argv.splice(2, 0, 'scan');
+}
+
+program.parse();

package/src/config.mjs

@@ -0,0 +1,121 @@
+// src/config.mjs
+// Config file loading: .swynx-lite.json + .swynxignore
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const DEFAULTS = {
+  ignore: [],
+  ci: {
+    threshold: 0,
+    failOnSecurity: true,
+    securitySeverity: 'HIGH',
+  },
+  security: {
+    enabled: true,
+  },
+  clean: {
+    quarantine: true,
+    importClean: true,
+    barrelClean: true,
+  },
+};
+
+/**
+ * Load .swynx-lite.json from project root
+ */
+function loadConfigFile(projectPath) {
+  const configPath = join(projectPath, '.swynx-lite.json');
+  if (!existsSync(configPath)) return {};
+
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (e) {
+    console.error(`  Warning: invalid .swynx-lite.json — ${e.message}`);
+    return {};
+  }
+}
+
+/**
+ * Load .swynxignore from project root (gitignore-style lines)
+ */
+function loadIgnoreFile(projectPath) {
+  const ignorePath = join(projectPath, '.swynxignore');
+  if (!existsSync(ignorePath)) return [];
+
+  try {
+    const content = readFileSync(ignorePath, 'utf-8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load config, merging: defaults < .swynx-lite.json < .swynxignore < CLI options
+ */
+export function loadConfig(projectPath, cliOptions = {}) {
+  const fileConfig = loadConfigFile(projectPath);
+  const ignorePatterns = loadIgnoreFile(projectPath);
+
+  // Merge ignore patterns: file config + .swynxignore + CLI --ignore
+  const ignore = [
+    ...(DEFAULTS.ignore),
+    ...(fileConfig.ignore || []),
+    ...ignorePatterns,
+    ...(cliOptions.ignore || []),
+  ];
+
+  const config = {
+    ignore,
+    ci: {
+      ...DEFAULTS.ci,
+      ...(fileConfig.ci || {}),
+    },
+    security: {
+      ...DEFAULTS.security,
+      ...(fileConfig.security || {}),
+    },
+    clean: {
+      ...DEFAULTS.clean,
+      ...(fileConfig.clean || {}),
+    },
+  };
+
+  // CLI overrides
+  if (cliOptions.threshold !== undefined) config.ci.threshold = cliOptions.threshold;
+  if (cliOptions.security === false) config.security.enabled = false;
+
+  return config;
+}
+
+/**
+ * Generate a default .swynx-lite.json template
+ */
+export function generateConfigTemplate() {
+  return JSON.stringify({
+    ignore: [
+      '**/__tests__/**',
+      '**/*.test.*',
+      '**/*.spec.*',
+      'scripts/**',
+      'docs/**',
+    ],
+    ci: {
+      threshold: 5,
+      failOnSecurity: true,
+      securitySeverity: 'HIGH',
+    },
+    security: {
+      enabled: true,
+    },
+    clean: {
+      quarantine: true,
+      importClean: true,
+      barrelClean: true,
+    },
+  }, null, 2);
+}

package/src/output/console.mjs

@@ -0,0 +1,298 @@
+// src/output/console.mjs
+// Terminal output formatter — raw ANSI codes (no chalk)
+
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+const DIM = `${ESC}2m`;
+const RED = `${ESC}31m`;
+const GREEN = `${ESC}32m`;
+const YELLOW = `${ESC}33m`;
+const CYAN = `${ESC}36m`;
+const WHITE = `${ESC}37m`;
+const BRIGHT_RED = `${ESC}91m`;
+const BRIGHT_GREEN = `${ESC}92m`;
+const BRIGHT_YELLOW = `${ESC}93m`;
+const BRIGHT_CYAN = `${ESC}96m`;
+
+function c(style, text, noColor) {
+  if (noColor) return text;
+  return `${style}${text}${RESET}`;
+}
+
+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 formatNumber(n) {
+  return n.toLocaleString('en-US');
+}
+
+function pad(str, len) {
+  return str + ' '.repeat(Math.max(0, len - str.length));
+}
+
+function rpad(str, len) {
+  return ' '.repeat(Math.max(0, len - str.length)) + str;
+}
+
+/**
+ * Render scan results to the console
+ */
+export function renderScanOutput(results, options = {}) {
+  const { noColor = false, verbose = false, ci = false, security = null } = options;
+  const lines = [];
+
+  const nc = noColor;
+  const hr = '─'.repeat(48);
+
+  // ── Header ──
+  lines.push('');
+  lines.push(`  ${c(BOLD + BRIGHT_CYAN, 'swynx lite', nc)} ${c(DIM, `v1.0.0`, nc)}`);
+  lines.push('');
+
+  // ── Summary ──
+  lines.push(`  ${c(DIM, '──', nc)} ${c(BOLD, 'Summary', nc)} ${c(DIM, hr, nc)}`);
+  lines.push('');
+
+  const summary = results.summary;
+
+  const summaryRows = [
+    ['Files scanned', formatNumber(summary.totalFiles)],
+    ['Entry points', formatNumber(summary.entryPoints)],
+    ['Reachable', formatNumber(summary.reachableFiles)],
+  ];
+
+  // Dead files — highlight red if > 0
+  const deadLabel = 'Dead files';
+  const deadCount = summary.deadFiles;
+  const deadRate = summary.deadRate;
+  const deadValue = deadCount > 0
+    ? `${c(BRIGHT_RED, formatNumber(deadCount), nc)}  ${c(DIM, `(${deadRate})`, nc)}`
+    : `${c(BRIGHT_GREEN, '0', nc)}`;
+  summaryRows.push([deadLabel, deadValue]);
+
+  // Dead size
+  if (summary.totalDeadBytes > 0) {
+    summaryRows.push(['Dead code size', formatBytes(summary.totalDeadBytes)]);
+  }
+
+  for (const [label, value] of summaryRows) {
+    lines.push(`   ${c(DIM, pad(label, 18), nc)}${value}`);
+  }
+
+  lines.push('');
+
+  // ── Dead Files ──
+  if (deadCount > 0) {
+    lines.push(`  ${c(DIM, '──', nc)} ${c(BOLD, 'Dead Files', nc)} ${c(DIM, hr, nc)}`);
+    lines.push('');
+
+    const deadFiles = results.deadFiles || [];
+    const showCount = verbose ? deadFiles.length : Math.min(5, deadFiles.length);
+
+    for (let i = 0; i < showCount; i++) {
+      const f = deadFiles[i];
+      const path = f.file || f.path || '';
+      const size = formatBytes(f.size);
+      const lineCount = f.lines ? `${formatNumber(f.lines)} lines` : '';
+      lines.push(`   ${c(WHITE, pad(path, 42), nc)} ${c(DIM, rpad(size, 10), nc)}   ${c(DIM, lineCount, nc)}`);
+    }
+
+    if (!verbose && deadFiles.length > 5) {
+      lines.push(`   ${c(DIM, `... and ${deadFiles.length - 5} more`, nc)}`);
+    }
+
+    lines.push('');
+  }
+
+  // ── Security ──
+  if (security && security.summary && security.summary.total > 0) {
+    lines.push(`  ${c(DIM, '──', nc)} ${c(BOLD, 'Security', nc)} ${c(DIM, hr, nc)}`);
+    lines.push('');
+
+    const secSummary = security.summary;
+    const inDeadLabel = secSummary.inDeadCode > 0
+      ? `${secSummary.inDeadCode} finding${secSummary.inDeadCode === 1 ? '' : 's'} in dead code`
+      : '';
+    const inLiveLabel = secSummary.inLiveCode > 0
+      ? `${secSummary.inLiveCode} finding${secSummary.inLiveCode === 1 ? '' : 's'} in live code`
+      : '';
+    if (inDeadLabel) lines.push(`   ${c(YELLOW, inDeadLabel, nc)}`);
+    if (inLiveLabel) lines.push(`   ${c(RED, inLiveLabel, nc)}`);
+    lines.push('');
+
+    // Show top findings
+    const findings = security.findings || [];
+    const showSecCount = verbose ? findings.length : Math.min(5, findings.length);
+
+    for (let i = 0; i < showSecCount; i++) {
+      const f = findings[i];
+      const sevColor = f.severity === 'CRITICAL' ? BRIGHT_RED
+        : f.severity === 'HIGH' ? RED
+        : f.severity === 'MEDIUM' ? YELLOW
+        : DIM;
+
+      lines.push(`   ${c(BOLD + sevColor, pad(f.severity, 10), nc)}${c(WHITE, f.file, nc)}${c(DIM, `:${f.line}`, nc)}`);
+      lines.push(`             ${c(DIM, `${f.cwe} ${f.cweName}`, nc)} ${c(DIM, '—', nc)} ${f.description}`);
+      if (f.risk) {
+        lines.push(`             ${c(DIM, f.risk, nc)}`);
+      }
+      lines.push('');
+    }
+
+    if (!verbose && findings.length > 5) {
+      lines.push(`   ${c(DIM, `... and ${findings.length - 5} more findings`, nc)}`);
+      lines.push('');
+    }
+  }
+
+  // ── What Next ── (interactive only)
+  if (!ci) {
+    if (deadCount > 0) {
+      lines.push(`  ${c(DIM, '──', nc)} ${c(BOLD, 'What Next', nc)} ${c(DIM, hr, nc)}`);
+      lines.push('');
+      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 scan --json', nc)}  for machine-readable output`);
+      lines.push('');
+    }
+
+    // Pro footer — dim, unobtrusive
+    lines.push(`  ${c(DIM, 'Dashboard, predictions, and more → swynx.io/pro', nc)}`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Render clean results to the console
+ */
+export function renderCleanOutput(results, options = {}) {
+  const { noColor = false, dryRun = false } = options;
+  const lines = [];
+  const nc = noColor;
+
+  lines.push('');
+  lines.push(`  ${c(BOLD + BRIGHT_CYAN, 'swynx lite', nc)} ${c(DIM, 'v1.0.0', nc)}${dryRun ? c(DIM, ' — dry run (no files will be modified)', nc) : ''}`);
+  lines.push('');
+
+  if (dryRun) {
+    lines.push(`  Would remove ${c(BOLD, formatNumber(results.filesRemoved), nc)} file${results.filesRemoved === 1 ? '' : 's'} ${c(DIM, `(${formatBytes(results.bytesRemoved)})`, nc)}:`);
+  } else {
+    lines.push(`  ${formatNumber(results.deadCount || 0)} dead files found ${c(DIM, `(${formatBytes(results.bytesRemoved)})`, nc)}`);
+  }
+
+  lines.push('');
+
+  // File list
+  const files = results.files || [];
+  const showCount = Math.min(5, 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 > 5) {
+    lines.push(`   ${c(DIM, `... and ${files.length - 5} more`, nc)}`);
+  }
+
+  lines.push('');
+
+  if (results.importsRemoved > 0 || results.barrelExportsRemoved > 0) {
+    if (dryRun) {
+      lines.push(`  Would clean:`);
+    } else {
+      lines.push(`  Also cleaned:`);
+    }
+    if (results.importsRemoved > 0) {
+      lines.push(`   ${formatNumber(results.importsRemoved)} dead import${results.importsRemoved === 1 ? '' : 's'} from live files`);
+    }
+    if (results.barrelExportsRemoved > 0) {
+      lines.push(`   ${formatNumber(results.barrelExportsRemoved)} dead re-export${results.barrelExportsRemoved === 1 ? '' : 's'} from barrel files`);
+    }
+    lines.push('');
+  }
+
+  if (!dryRun && results.sessionId) {
+    lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Quarantined ${formatNumber(results.filesRemoved)} file${results.filesRemoved === 1 ? '' : 's'} to .swynx-quarantine/`);
+    if (results.importsRemoved > 0 || results.barrelExportsRemoved > 0) {
+      lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Cleaned ${formatNumber(results.importsRemoved)} import${results.importsRemoved === 1 ? '' : 's'}, ${formatNumber(results.barrelExportsRemoved)} barrel export${results.barrelExportsRemoved === 1 ? '' : 's'}`);
+    }
+    lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Removed ${formatBytes(results.bytesRemoved)} of dead code`);
+    lines.push('');
+    lines.push(`  Undo with  ${c(BRIGHT_CYAN, 'swynx-lite restore', nc)}`);
+    lines.push(`  Finalise with  ${c(BRIGHT_CYAN, 'swynx-lite purge', nc)}`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Render restore result
+ */
+export function renderRestoreOutput(result, options = {}) {
+  const nc = options.noColor || false;
+  const lines = [];
+
+  lines.push('');
+  if (result.restored && result.restored.length > 0) {
+    lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Restored ${result.restored.length} file${result.restored.length === 1 ? '' : 's'} from quarantine session ${c(DIM, result.sessionId, nc)}`);
+    lines.push('');
+    lines.push(`  Restored files are back in their original locations.`);
+    lines.push(`  Quarantine session kept — run  ${c(BRIGHT_CYAN, 'swynx-lite purge', nc)}  to clean up.`);
+  } else {
+    lines.push(`  No files to restore.`);
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Render session list
+ */
+export function renderSessionList(sessions, options = {}) {
+  const nc = options.noColor || false;
+  const lines = [];
+
+  lines.push('');
+  if (sessions.length === 0) {
+    lines.push(`  No quarantine sessions found.`);
+  } else {
+    lines.push(`  ${sessions.length} quarantine session${sessions.length === 1 ? '' : 's'}:`);
+    lines.push('');
+    for (const s of sessions) {
+      const date = new Date(s.createdAt).toLocaleString();
+      const status = s.status === 'restored' ? c(YELLOW, '[restored]', nc) : c(GREEN, '[active]', nc);
+      lines.push(`   ${c(DIM, s.sessionId, nc)}  ${pad(date, 22)}  ${formatNumber(s.fileCount)} file${s.fileCount === 1 ? '' : 's'}  ${formatBytes(s.totalSize)}  ${status}`);
+    }
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Render purge result
+ */
+export function renderPurgeOutput(results, options = {}) {
+  const nc = options.noColor || false;
+  const lines = [];
+
+  lines.push('');
+  if (results.purged > 0) {
+    lines.push(`  ${c(BRIGHT_GREEN, '\u2713', nc)} Purged ${results.purged} session${results.purged === 1 ? '' : 's'} (${formatNumber(results.totalFiles)} file${results.totalFiles === 1 ? '' : 's'}, ${formatBytes(results.totalSize)})`);
+  } else {
+    lines.push(`  No quarantine sessions to purge.`);
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}