vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runClassify.js

@@ -0,0 +1,928 @@
+/**
+ * vibecheck classify - Inventory Authority Command
+ * 
+ * Produces duplication maps, legacy code maps, and risk classifications.
+ * Available on FREE tier - read-only analysis with no enforcement.
+ * 
+ * Output:
+ * - Duplication map (exact, near, semantic duplicates)
+ * - Legacy map (deprecated, backup, obsolete, dead code)
+ * - Risk classifications (LOW, MEDIUM, HIGH, CRITICAL)
+ * 
+ * Part of the Authority System - "The AI That Says No"
+ */
+
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const { withErrorHandling, createUserError } = require("./lib/error-handler");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+
+// Engine V2 support (when VIBECHECK_ENGINE_V2=1)
+let createIndex = null;
+try {
+  createIndex = require("./lib/engine").createIndex;
+} catch {
+  // Engine V2 not available, use legacy file walking
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL UI
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const {
+  ansi,
+  colors,
+  Spinner,
+} = require("./lib/terminal-ui");
+
+const BANNER = `
+${ansi.rgb(0, 200, 255)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${ansi.reset}
+${ansi.rgb(30, 180, 255)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${ansi.reset}
+${ansi.rgb(60, 160, 255)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${ansi.reset}
+${ansi.rgb(90, 140, 255)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${ansi.reset}
+${ansi.rgb(120, 120, 255)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${ansi.reset}
+${ansi.rgb(150, 100, 255)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${ansi.reset}
+
+${ansi.dim}  ┌─────────────────────────────────────────────────────────────────────┐${ansi.reset}
+${ansi.dim}  │${ansi.reset}  ${ansi.rgb(255, 255, 255)}${ansi.bold}Authority System${ansi.reset} ${ansi.dim}•${ansi.reset} ${ansi.rgb(200, 200, 200)}Inventory${ansi.reset} ${ansi.dim}•${ansi.reset} ${ansi.rgb(150, 150, 150)}Read-Only Classification${ansi.reset}  ${ansi.dim}│${ansi.reset}
+${ansi.dim}  └─────────────────────────────────────────────────────────────────────┘${ansi.reset}
+`;
+
+function printBanner() {
+  console.log(BANNER);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ARGS PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const opts = {
+    path: globalFlags.path || process.cwd(),
+    json: globalFlags.json || false,
+    verbose: globalFlags.verbose || false,
+    help: globalFlags.help || false,
+    noBanner: globalFlags.noBanner || false,
+    ci: globalFlags.ci || false,
+    quiet: globalFlags.quiet || false,
+    // Classification options
+    includeNear: true,      // Include near-duplicates
+    includeSemantic: false, // Include semantic duplicates (slower)
+    threshold: 0.8,         // Similarity threshold (0-1)
+    maxFiles: 5000,         // Max files to analyze
+    // Output options
+    output: null,           // Output file path
+    format: 'table',        // table, json, markdown
+  };
+
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const arg = cleanArgs[i];
+    
+    if (arg === '--include-semantic' || arg === '-s') opts.includeSemantic = true;
+    else if (arg === '--no-near') opts.includeNear = false;
+    else if (arg === '--threshold' || arg === '-t') opts.threshold = parseFloat(cleanArgs[++i]) || 0.8;
+    else if (arg === '--max-files') opts.maxFiles = parseInt(cleanArgs[++i], 10) || 5000;
+    else if (arg === '--output' || arg === '-o') opts.output = cleanArgs[++i];
+    else if (arg === '--format' || arg === '-f') opts.format = cleanArgs[++i] || 'table';
+    else if (arg === '--path' || arg === '-p') opts.path = cleanArgs[++i] || process.cwd();
+    else if (arg.startsWith('--path=')) opts.path = arg.split('=')[1];
+    else if (!arg.startsWith('-')) opts.path = path.resolve(arg);
+  }
+  
+  return opts;
+}
+
+function printHelp(showBanner = true) {
+  if (showBanner && shouldShowBanner({})) {
+    printBanner();
+  }
+  console.log(`
+  ${ansi.bold}USAGE${ansi.reset}
+    ${colors.accent}vibecheck classify${ansi.reset} [path] [options]
+
+  ${ansi.dim}Authority: inventory (FREE tier)${ansi.reset}
+
+  Produces a read-only inventory of your codebase:
+  - Duplication map (exact, near, semantic duplicates)
+  - Legacy code map (deprecated, backup, obsolete, dead)
+  - Risk classifications (LOW, MEDIUM, HIGH, CRITICAL)
+
+  ${ansi.bold}OPTIONS${ansi.reset}
+    ${colors.accent}--include-semantic, -s${ansi.reset}  Include semantic duplicates ${ansi.dim}(slower)${ansi.reset}
+    ${colors.accent}--no-near${ansi.reset}               Skip near-duplicate detection
+    ${colors.accent}--threshold, -t <n>${ansi.reset}     Similarity threshold 0-1 ${ansi.dim}(default: 0.8)${ansi.reset}
+    ${colors.accent}--max-files <n>${ansi.reset}         Max files to analyze ${ansi.dim}(default: 5000)${ansi.reset}
+
+  ${ansi.bold}OUTPUT OPTIONS${ansi.reset}
+    ${colors.accent}--json${ansi.reset}                  Output as JSON
+    ${colors.accent}--output, -o <file>${ansi.reset}     Save output to file
+    ${colors.accent}--format, -f <fmt>${ansi.reset}      Format: table, json, markdown
+
+  ${ansi.bold}GLOBAL OPTIONS${ansi.reset}
+    ${colors.accent}--path, -p <dir>${ansi.reset}        Run in specified directory
+    ${colors.accent}--verbose, -v${ansi.reset}           Show detailed progress
+    ${colors.accent}--quiet, -q${ansi.reset}             Suppress non-essential output
+    ${colors.accent}--ci${ansi.reset}                    CI mode
+    ${colors.accent}--help, -h${ansi.reset}              Show this help
+
+  ${ansi.bold}💡 EXAMPLES${ansi.reset}
+
+    ${ansi.dim}# Quick inventory of current directory${ansi.reset}
+    vibecheck classify
+
+    ${ansi.dim}# JSON output for processing${ansi.reset}
+    vibecheck classify --json > inventory.json
+
+    ${ansi.dim}# Include semantic duplicates (deeper analysis)${ansi.reset}
+    vibecheck classify --include-semantic
+
+    ${ansi.dim}# Classify specific directory${ansi.reset}
+    vibecheck classify ./packages/core
+
+  ${ansi.bold}📊 OUTPUT${ansi.reset}
+    Results include:
+    - duplicationMap: Files with duplicated code
+    - legacyMap: Deprecated/obsolete code locations
+    - riskClassifications: Per-file risk levels
+    - summary: Statistics overview
+
+  ${ansi.bold}🔗 RELATED COMMANDS${ansi.reset}
+    ${colors.accent}vibecheck approve${ansi.reset}      Get authority verdicts ${ansi.cyan}[STARTER]${ansi.reset}
+    ${colors.accent}vibecheck scan${ansi.reset}         Full code analysis
+
+  ${ansi.dim}─────────────────────────────────────────────────────────────${ansi.reset}
+  ${ansi.dim}Documentation: https://docs.vibecheckai.dev/cli/classify${ansi.reset}
+  `);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INVENTORY ANALYSIS ENGINE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Legacy code indicators
+ */
+const LEGACY_INDICATORS = [
+  { pattern: /\.old\.(js|ts|tsx|jsx)$/i, type: 'backup', confidence: 0.9 },
+  { pattern: /\.bak\.(js|ts|tsx|jsx)$/i, type: 'backup', confidence: 0.95 },
+  { pattern: /\.backup\.(js|ts|tsx|jsx)$/i, type: 'backup', confidence: 0.95 },
+  { pattern: /\.deprecated\.(js|ts|tsx|jsx)$/i, type: 'deprecated', confidence: 0.9 },
+  { pattern: /\.legacy\.(js|ts|tsx|jsx)$/i, type: 'obsolete', confidence: 0.85 },
+  { pattern: /_old\.(js|ts|tsx|jsx)$/i, type: 'backup', confidence: 0.8 },
+  { pattern: /-old\.(js|ts|tsx|jsx)$/i, type: 'backup', confidence: 0.8 },
+  { pattern: /\/deprecated\//i, type: 'deprecated', confidence: 0.85 },
+  { pattern: /\/legacy\//i, type: 'obsolete', confidence: 0.8 },
+  { pattern: /\/old\//i, type: 'backup', confidence: 0.7 },
+];
+
+/**
+ * Content patterns indicating deprecated code
+ */
+const DEPRECATED_CONTENT_PATTERNS = [
+  { regex: /@deprecated/gi, type: 'deprecated', confidence: 0.95 },
+  { regex: /TODO:\s*remove/gi, type: 'obsolete', confidence: 0.7 },
+  { regex: /FIXME:\s*delete/gi, type: 'obsolete', confidence: 0.7 },
+  { regex: /\/\/\s*LEGACY/gi, type: 'obsolete', confidence: 0.75 },
+  { regex: /\/\/\s*DEPRECATED/gi, type: 'deprecated', confidence: 0.9 },
+  { regex: /\/\*\*?\s*@deprecated/gi, type: 'deprecated', confidence: 0.95 },
+];
+
+/**
+ * High-risk path patterns
+ */
+const HIGH_RISK_PATHS = [
+  { pattern: /\/auth\//i, reason: 'Authentication code', level: 'HIGH' },
+  { pattern: /\/security\//i, reason: 'Security-related code', level: 'HIGH' },
+  { pattern: /\/migrations?\//i, reason: 'Database migrations', level: 'CRITICAL' },
+  { pattern: /\/billing\//i, reason: 'Billing/payment code', level: 'CRITICAL' },
+  { pattern: /\/stripe\//i, reason: 'Payment processing', level: 'CRITICAL' },
+  { pattern: /\.env/i, reason: 'Environment configuration', level: 'CRITICAL' },
+  { pattern: /secrets?\.(js|ts|json)/i, reason: 'Secrets configuration', level: 'CRITICAL' },
+  { pattern: /\/prisma\//i, reason: 'Database schema', level: 'HIGH' },
+  { pattern: /\/middleware\//i, reason: 'Request middleware', level: 'MEDIUM' },
+];
+
+/**
+ * Excluded directories
+ */
+const EXCLUDED_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  'coverage',
+  '.vibecheck',
+  '__pycache__',
+  '.cache',
+  'vendor',
+]);
+
+/**
+ * Find all source files using RepoIndex (V2) or legacy walk
+ */
+async function findSourceFiles(rootPath, maxFiles) {
+  const extensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+  
+  // Use RepoIndex if V2 is enabled and available
+  if (process.env.VIBECHECK_ENGINE_V2 === "1" && createIndex) {
+    const index = await createIndex(rootPath);
+    const jsFiles = index.getJsFiles();
+    
+    const files = jsFiles
+      .slice(0, maxFiles)
+      .map(f => ({
+        path: f.abs,
+        relativePath: f.rel,
+        name: path.basename(f.abs),
+        ext: f.ext,
+        _indexContent: index.getContent(f.abs), // Cache content from index
+      }));
+    
+    // Store index reference for cleanup
+    files._index = index;
+    return files;
+  }
+  
+  // Legacy file walking
+  const files = [];
+  
+  async function walk(dir, depth = 0) {
+    if (depth > 20 || files.length >= maxFiles) return;
+    
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (files.length >= maxFiles) break;
+        
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(rootPath, fullPath);
+        
+        if (entry.isDirectory()) {
+          if (!EXCLUDED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+            await walk(fullPath, depth + 1);
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          if (extensions.has(ext)) {
+            files.push({
+              path: fullPath,
+              relativePath,
+              name: entry.name,
+              ext,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      // Skip inaccessible directories
+    }
+  }
+  
+  await walk(rootPath);
+  return files;
+}
+
+/**
+ * Calculate file hash for duplicate detection
+ */
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * Normalize content for near-duplicate detection
+ */
+function normalizeContent(content) {
+  return content
+    .replace(/\/\/.*$/gm, '')           // Remove single-line comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')   // Remove multi-line comments
+    .replace(/\s+/g, ' ')               // Normalize whitespace
+    .replace(/['"`]/g, '"')             // Normalize quotes
+    .trim();
+}
+
+/**
+ * Calculate Jaccard similarity between two sets
+ */
+function jaccardSimilarity(set1, set2) {
+  const intersection = new Set([...set1].filter(x => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+
+/**
+ * Tokenize content for similarity comparison
+ */
+function tokenize(content) {
+  return new Set(
+    content
+      .split(/[\s\(\)\{\}\[\];,.:=<>!&|?]+/)
+      .filter(t => t.length > 2)
+      .map(t => t.toLowerCase())
+  );
+}
+
+/**
+ * Detect legacy code indicators
+ */
+function detectLegacyIndicators(filePath, content) {
+  const indicators = [];
+  
+  // Check file path patterns
+  for (const { pattern, type, confidence } of LEGACY_INDICATORS) {
+    if (pattern.test(filePath)) {
+      indicators.push({ type, confidence, evidence: `File path matches: ${pattern}` });
+    }
+  }
+  
+  // Check content patterns
+  for (const { regex, type, confidence } of DEPRECATED_CONTENT_PATTERNS) {
+    const matches = content.match(regex);
+    if (matches) {
+      indicators.push({ 
+        type, 
+        confidence, 
+        evidence: `Found ${matches.length}x: ${regex.source}`,
+        count: matches.length,
+      });
+    }
+  }
+  
+  return indicators;
+}
+
+/**
+ * Classify file risk level
+ */
+function classifyRisk(filePath, content) {
+  // Check path patterns
+  for (const { pattern, reason, level } of HIGH_RISK_PATHS) {
+    if (pattern.test(filePath)) {
+      return { level, reason, tags: [reason.toLowerCase().replace(/\s+/g, '-')] };
+    }
+  }
+  
+  // Check content indicators
+  const indicators = [];
+  
+  if (/process\.env\./i.test(content)) {
+    indicators.push('uses-env-vars');
+  }
+  if (/import.*['"](crypto|bcrypt|argon2|jose)['"]/i.test(content)) {
+    indicators.push('cryptography');
+  }
+  if (/sql|query|execute/i.test(content) && /where|select|insert|update|delete/i.test(content)) {
+    indicators.push('database-operations');
+  }
+  if (/(Bearer|Authorization|api[_-]?key|secret|token)/i.test(content)) {
+    indicators.push('auth-related');
+  }
+  
+  if (indicators.includes('cryptography') || indicators.includes('auth-related')) {
+    return { level: 'HIGH', reason: 'Security-sensitive operations', tags: indicators };
+  }
+  if (indicators.includes('database-operations')) {
+    return { level: 'MEDIUM', reason: 'Database operations', tags: indicators };
+  }
+  if (indicators.includes('uses-env-vars')) {
+    return { level: 'MEDIUM', reason: 'Environment-dependent', tags: indicators };
+  }
+  
+  return { level: 'LOW', reason: 'Standard code', tags: [] };
+}
+
+/**
+ * Run inventory analysis
+ */
+async function runInventoryAnalysis(projectPath, opts, spinner) {
+  const startTime = Date.now();
+  
+  // Find source files
+  if (spinner) spinner.update('Discovering source files...');
+  const files = await findSourceFiles(projectPath, opts.maxFiles);
+  
+  if (files.length === 0) {
+    return {
+      duplicationMap: [],
+      legacyMap: [],
+      riskClassifications: [],
+      summary: {
+        totalFiles: 0,
+        duplicatedFiles: 0,
+        legacyFiles: 0,
+        highRiskFiles: 0,
+        totalDuplicateLines: 0,
+      },
+    };
+  }
+  
+  if (spinner) spinner.update(`Analyzing ${files.length} files...`);
+  
+  // Read all file contents (use cached content from RepoIndex when available)
+  const fileContents = new Map();
+  const fileHashes = new Map();
+  const normalizedHashes = new Map();
+  
+  for (const file of files) {
+    try {
+      // Use cached content from RepoIndex if available (V2 optimization)
+      const content = file._indexContent || await fs.promises.readFile(file.path, 'utf-8');
+      const lines = content.split('\n').length;
+      fileContents.set(file.relativePath, { content, lines });
+      
+      // Calculate hashes
+      const hash = hashContent(content);
+      const normalizedHash = hashContent(normalizeContent(content));
+      
+      fileHashes.set(file.relativePath, hash);
+      normalizedHashes.set(file.relativePath, normalizedHash);
+    } catch (err) {
+      // Skip unreadable files
+    }
+  }
+  
+  // Cleanup RepoIndex cache if used
+  if (files._index) {
+    files._index.clearContentCache();
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DUPLICATE DETECTION
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  if (spinner) spinner.update('Detecting duplicates...');
+  
+  const duplicationMap = [];
+  const exactDuplicates = new Map(); // hash -> [files]
+  const nearDuplicates = new Map();  // normalizedHash -> [files]
+  
+  // Group by exact hash
+  for (const [filePath, hash] of fileHashes.entries()) {
+    if (!exactDuplicates.has(hash)) {
+      exactDuplicates.set(hash, []);
+    }
+    exactDuplicates.get(hash).push(filePath);
+  }
+  
+  // Find exact duplicates
+  for (const [hash, files] of exactDuplicates.entries()) {
+    if (files.length > 1) {
+      const primary = files[0];
+      const duplicates = files.slice(1);
+      const { lines } = fileContents.get(primary) || { lines: 0 };
+      
+      duplicationMap.push({
+        primary,
+        duplicates,
+        similarity: 1.0,
+        type: 'exact',
+        lineCount: lines,
+      });
+    }
+  }
+  
+  // Group by normalized hash for near-duplicates
+  if (opts.includeNear) {
+    for (const [filePath, hash] of normalizedHashes.entries()) {
+      if (!nearDuplicates.has(hash)) {
+        nearDuplicates.set(hash, []);
+      }
+      nearDuplicates.get(hash).push(filePath);
+    }
+    
+    // Find near-duplicates (not already exact)
+    const exactPairs = new Set();
+    for (const entry of duplicationMap) {
+      for (const dup of entry.duplicates) {
+        exactPairs.add(`${entry.primary}:${dup}`);
+        exactPairs.add(`${dup}:${entry.primary}`);
+      }
+    }
+    
+    for (const [hash, files] of nearDuplicates.entries()) {
+      if (files.length > 1) {
+        const primary = files[0];
+        const potentialDups = files.slice(1).filter(f => !exactPairs.has(`${primary}:${f}`));
+        
+        if (potentialDups.length > 0) {
+          const { lines } = fileContents.get(primary) || { lines: 0 };
+          duplicationMap.push({
+            primary,
+            duplicates: potentialDups,
+            similarity: 0.95, // High similarity due to normalized match
+            type: 'near',
+            lineCount: lines,
+          });
+        }
+      }
+    }
+  }
+  
+  // Semantic duplicates (token-based similarity)
+  if (opts.includeSemantic) {
+    if (spinner) spinner.update('Computing semantic similarity...');
+    
+    const tokenSets = new Map();
+    for (const [filePath, { content }] of fileContents.entries()) {
+      tokenSets.set(filePath, tokenize(content));
+    }
+    
+    const processedPairs = new Set();
+    const filePaths = Array.from(fileContents.keys());
+    
+    for (let i = 0; i < filePaths.length && i < 500; i++) {
+      for (let j = i + 1; j < filePaths.length && j < 500; j++) {
+        const file1 = filePaths[i];
+        const file2 = filePaths[j];
+        const pairKey = `${file1}:${file2}`;
+        
+        if (processedPairs.has(pairKey)) continue;
+        processedPairs.add(pairKey);
+        
+        const tokens1 = tokenSets.get(file1);
+        const tokens2 = tokenSets.get(file2);
+        
+        const similarity = jaccardSimilarity(tokens1, tokens2);
+        
+        if (similarity >= opts.threshold) {
+          // Check not already in duplicationMap
+          const existing = duplicationMap.find(d => 
+            (d.primary === file1 && d.duplicates.includes(file2)) ||
+            (d.primary === file2 && d.duplicates.includes(file1))
+          );
+          
+          if (!existing) {
+            const { lines } = fileContents.get(file1) || { lines: 0 };
+            duplicationMap.push({
+              primary: file1,
+              duplicates: [file2],
+              similarity: Math.round(similarity * 100) / 100,
+              type: 'semantic',
+              lineCount: lines,
+            });
+          }
+        }
+      }
+    }
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // LEGACY CODE DETECTION
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  if (spinner) spinner.update('Detecting legacy code...');
+  
+  const legacyMap = [];
+  
+  for (const [filePath, { content }] of fileContents.entries()) {
+    const indicators = detectLegacyIndicators(filePath, content);
+    
+    if (indicators.length > 0) {
+      // Use highest confidence indicator
+      const bestIndicator = indicators.reduce((a, b) => a.confidence > b.confidence ? a : b);
+      
+      legacyMap.push({
+        file: filePath,
+        type: bestIndicator.type,
+        evidence: indicators.map(i => i.evidence),
+        confidence: bestIndicator.confidence,
+      });
+    }
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RISK CLASSIFICATION
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  if (spinner) spinner.update('Classifying risk levels...');
+  
+  const riskClassifications = [];
+  
+  for (const [filePath, { content }] of fileContents.entries()) {
+    const risk = classifyRisk(filePath, content);
+    
+    if (risk.level !== 'LOW' || opts.verbose) {
+      riskClassifications.push({
+        file: filePath,
+        level: risk.level,
+        reason: risk.reason,
+        tags: risk.tags,
+      });
+    }
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  const duplicatedFiles = new Set();
+  let totalDuplicateLines = 0;
+  
+  for (const entry of duplicationMap) {
+    duplicatedFiles.add(entry.primary);
+    for (const dup of entry.duplicates) {
+      duplicatedFiles.add(dup);
+    }
+    totalDuplicateLines += entry.lineCount * entry.duplicates.length;
+  }
+  
+  const summary = {
+    totalFiles: files.length,
+    duplicatedFiles: duplicatedFiles.size,
+    legacyFiles: legacyMap.length,
+    highRiskFiles: riskClassifications.filter(r => r.level === 'HIGH' || r.level === 'CRITICAL').length,
+    totalDuplicateLines,
+    analysisTimeMs: Date.now() - startTime,
+  };
+  
+  return {
+    duplicationMap,
+    legacyMap,
+    riskClassifications,
+    summary,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTPUT FORMATTERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function formatTableOutput(result, projectPath) {
+  const lines = [];
+  const { duplicationMap, legacyMap, riskClassifications, summary } = result;
+  
+  lines.push('');
+  lines.push('┌────────────────────────────────────────────────────────────────────┐');
+  lines.push('│  Authority Verdict: INVENTORY (Read-Only)                          │');
+  lines.push('├────────────────────────────────────────────────────────────────────┤');
+  lines.push(`│  Project: ${path.basename(projectPath).padEnd(55)}│`);
+  lines.push(`│  Files analyzed: ${String(summary.totalFiles).padEnd(48)}│`);
+  lines.push(`│  Analysis time: ${String(summary.analysisTimeMs + 'ms').padEnd(49)}│`);
+  lines.push('└────────────────────────────────────────────────────────────────────┘');
+  lines.push('');
+  
+  // Summary stats
+  lines.push('┌─────────────────────────────────────────┐');
+  lines.push('│  Summary                                │');
+  lines.push('├─────────────────────────────────────────┤');
+  lines.push(`│  Duplicated files:    ${String(summary.duplicatedFiles).padStart(5)}            │`);
+  lines.push(`│  Legacy files:        ${String(summary.legacyFiles).padStart(5)}            │`);
+  lines.push(`│  High-risk files:     ${String(summary.highRiskFiles).padStart(5)}            │`);
+  lines.push(`│  Duplicate lines:     ${String(summary.totalDuplicateLines).padStart(5)}            │`);
+  lines.push('└─────────────────────────────────────────┘');
+  lines.push('');
+  
+  // Duplications
+  if (duplicationMap.length > 0) {
+    lines.push(`${ansi.bold}Duplications (${duplicationMap.length})${ansi.reset}`);
+    lines.push('');
+    
+    for (const entry of duplicationMap.slice(0, 15)) {
+      const typeIcon = entry.type === 'exact' ? '=' : entry.type === 'near' ? '≈' : '~';
+      const similarity = Math.round(entry.similarity * 100);
+      lines.push(`  ${typeIcon} ${ansi.dim}[${similarity}%]${ansi.reset} ${colors.accent}${entry.primary}${ansi.reset}`);
+      for (const dup of entry.duplicates.slice(0, 3)) {
+        lines.push(`    └─ ${dup}`);
+      }
+      if (entry.duplicates.length > 3) {
+        lines.push(`    ${ansi.dim}... and ${entry.duplicates.length - 3} more${ansi.reset}`);
+      }
+    }
+    
+    if (duplicationMap.length > 15) {
+      lines.push(`  ${ansi.dim}... and ${duplicationMap.length - 15} more duplicate groups${ansi.reset}`);
+    }
+    lines.push('');
+  }
+  
+  // Legacy code
+  if (legacyMap.length > 0) {
+    lines.push(`${ansi.bold}Legacy Code (${legacyMap.length})${ansi.reset}`);
+    lines.push('');
+    
+    for (const entry of legacyMap.slice(0, 15)) {
+      const typeIcon = entry.type === 'deprecated' ? '⚠' : entry.type === 'backup' ? '📦' : '👻';
+      const conf = Math.round(entry.confidence * 100);
+      lines.push(`  ${typeIcon} ${ansi.dim}[${conf}%]${ansi.reset} ${colors.warning}${entry.file}${ansi.reset}`);
+      lines.push(`    ${ansi.dim}Type: ${entry.type}${ansi.reset}`);
+    }
+    
+    if (legacyMap.length > 15) {
+      lines.push(`  ${ansi.dim}... and ${legacyMap.length - 15} more legacy files${ansi.reset}`);
+    }
+    lines.push('');
+  }
+  
+  // High-risk files
+  const highRisk = riskClassifications.filter(r => r.level === 'HIGH' || r.level === 'CRITICAL');
+  if (highRisk.length > 0) {
+    lines.push(`${ansi.bold}High-Risk Files (${highRisk.length})${ansi.reset}`);
+    lines.push('');
+    
+    for (const entry of highRisk.slice(0, 15)) {
+      const levelIcon = entry.level === 'CRITICAL' ? '🔴' : '🟠';
+      lines.push(`  ${levelIcon} ${colors.error}${entry.file}${ansi.reset}`);
+      lines.push(`    ${ansi.dim}${entry.reason}${ansi.reset}`);
+    }
+    
+    if (highRisk.length > 15) {
+      lines.push(`  ${ansi.dim}... and ${highRisk.length - 15} more high-risk files${ansi.reset}`);
+    }
+    lines.push('');
+  }
+  
+  // Footer
+  lines.push('─────────────────────────────────────────────────────────────────────');
+  lines.push(`${ansi.dim}This is a read-only inventory. Use 'vibecheck approve' to get verdicts.${ansi.reset}`);
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+function formatMarkdownOutput(result, projectPath) {
+  const { duplicationMap, legacyMap, riskClassifications, summary } = result;
+  const lines = [];
+  
+  lines.push(`# Inventory Report`);
+  lines.push('');
+  lines.push(`**Project:** ${path.basename(projectPath)}`);
+  lines.push(`**Authority:** inventory (read-only)`);
+  lines.push(`**Generated:** ${new Date().toISOString()}`);
+  lines.push('');
+  
+  lines.push('## Summary');
+  lines.push('');
+  lines.push('| Metric | Count |');
+  lines.push('|--------|-------|');
+  lines.push(`| Total files analyzed | ${summary.totalFiles} |`);
+  lines.push(`| Duplicated files | ${summary.duplicatedFiles} |`);
+  lines.push(`| Legacy files | ${summary.legacyFiles} |`);
+  lines.push(`| High-risk files | ${summary.highRiskFiles} |`);
+  lines.push(`| Duplicate lines | ${summary.totalDuplicateLines} |`);
+  lines.push('');
+  
+  if (duplicationMap.length > 0) {
+    lines.push('## Duplications');
+    lines.push('');
+    for (const entry of duplicationMap) {
+      lines.push(`### ${entry.primary}`);
+      lines.push(`- Type: ${entry.type}`);
+      lines.push(`- Similarity: ${Math.round(entry.similarity * 100)}%`);
+      lines.push(`- Lines: ${entry.lineCount}`);
+      lines.push(`- Duplicates:`);
+      for (const dup of entry.duplicates) {
+        lines.push(`  - \`${dup}\``);
+      }
+      lines.push('');
+    }
+  }
+  
+  if (legacyMap.length > 0) {
+    lines.push('## Legacy Code');
+    lines.push('');
+    lines.push('| File | Type | Confidence |');
+    lines.push('|------|------|------------|');
+    for (const entry of legacyMap) {
+      lines.push(`| \`${entry.file}\` | ${entry.type} | ${Math.round(entry.confidence * 100)}% |`);
+    }
+    lines.push('');
+  }
+  
+  const highRisk = riskClassifications.filter(r => r.level === 'HIGH' || r.level === 'CRITICAL');
+  if (highRisk.length > 0) {
+    lines.push('## High-Risk Files');
+    lines.push('');
+    lines.push('| File | Level | Reason |');
+    lines.push('|------|-------|--------|');
+    for (const entry of highRisk) {
+      lines.push(`| \`${entry.file}\` | ${entry.level} | ${entry.reason} |`);
+    }
+    lines.push('');
+  }
+  
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN COMMAND
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runClassify(args) {
+  const opts = parseArgs(args);
+  
+  // Show help
+  if (opts.help) {
+    printHelp(shouldShowBanner(opts));
+    return 0;
+  }
+  
+  // CRITICAL: Check for JSON output FIRST - skip all banners/output if this flag is set
+  if (opts.json) {
+    process.env.NO_COLOR = '1';
+    // Skip all banner/output until we output JSON
+  }
+  
+  // Print banner (skip if JSON mode)
+  if (shouldShowBanner(opts) && !opts.json) {
+    printBanner();
+  }
+  
+  const projectPath = path.resolve(opts.path);
+  
+  // Validate project path
+  if (!fs.existsSync(projectPath)) {
+    throw createUserError(`Project path does not exist: ${projectPath}`, "ValidationError");
+  }
+  
+  if (!opts.quiet && !opts.json) {
+    console.log(`  ${ansi.dim}Project:${ansi.reset}   ${ansi.bold}${path.basename(projectPath)}${ansi.reset}`);
+    console.log(`  ${ansi.dim}Authority:${ansi.reset} ${colors.accent}inventory${ansi.reset} (FREE tier)`);
+    console.log();
+  }
+  
+  // Run analysis (skip spinner if JSON mode)
+  const spinner = !opts.json ? new Spinner({ color: colors.primary }) : null;
+  if (spinner) spinner.start('Starting inventory analysis...');
+  
+  try {
+    const result = await runInventoryAnalysis(projectPath, opts, spinner);
+    
+    if (spinner) {
+      spinner.succeed(`Analysis complete (${result.summary.analysisTimeMs}ms)`);
+    }
+    
+    // Construct full output
+    const output = {
+      authority: 'inventory',
+      version: '1.0.0',
+      timestamp: new Date().toISOString(),
+      action: 'PROCEED', // Inventory is read-only, always PROCEED
+      projectPath: projectPath,
+      ...result,
+    };
+    
+    // Output based on format
+    if (opts.json) {
+      // CRITICAL: Output ONLY JSON, no banners/colors
+      process.env.NO_COLOR = '1';
+      console.log(JSON.stringify(output, null, 2));
+      // Exit immediately after JSON output
+      return EXIT.SUCCESS;
+    } else if (opts.format === 'markdown') {
+      console.log(formatMarkdownOutput(result, projectPath));
+    } else {
+      // Use Mission Control format
+      const { formatClassifyOutput } = require('./lib/classify-output');
+      console.log(formatClassifyOutput(result, { projectPath, version: 'v3.5.5' }));
+    }
+    
+    // Save to file if requested
+    if (opts.output) {
+      const outputPath = path.resolve(opts.output);
+      const content = opts.format === 'markdown' 
+        ? formatMarkdownOutput(result, projectPath)
+        : JSON.stringify(output, null, 2);
+      
+      await fs.promises.writeFile(outputPath, content);
+      
+      if (!opts.quiet && !opts.json) {
+        console.log(`  ${colors.success}✓${ansi.reset} Output saved to: ${outputPath}`);
+      }
+    }
+    
+    return EXIT.SUCCESS;
+    
+  } catch (error) {
+    if (spinner && !opts.json) {
+      spinner.fail(`Analysis failed: ${error.message}`);
+    }
+    
+    // JSON error output
+    if (opts.json) {
+      process.env.NO_COLOR = '1';
+      const errorOutput = {
+        success: false,
+        error: {
+          code: error.code || 'CLASSIFY_ERROR',
+          message: error.message,
+        },
+        exitCode: error.code === 'VALIDATION_ERROR' ? EXIT.USER_ERROR : EXIT.INTERNAL_ERROR
+      };
+      console.log(JSON.stringify(errorOutput, null, 2));
+      process.exit(errorOutput.exitCode);
+      return errorOutput.exitCode;
+    }
+    
+    throw error;
+  }
+}
+
+module.exports = {
+  runClassify: withErrorHandling(runClassify, "Classify failed"),
+};