@eduardbar/drift 1.0.0 → 1.1.0

package/packages/vscode-drift/src/statusbar.ts

@@ -1,13 +1,21 @@
 import * as vscode from 'vscode'
 import type { FileReport } from '@eduardbar/drift'
 
+const STATUSBAR_PRIORITY = 100
+
+const SCORE_THRESHOLDS = {
+  WARNING: 50,
+  ERROR: 30,
+  WARNING_BG: 60,
+}
+
 export class DriftStatusBarItem {
   private item: vscode.StatusBarItem
 
   constructor() {
-    this.item = vscode.window.createStatusBarItem(
+    this.item = vscode.createStatusBarItem(
       vscode.StatusBarAlignment.Right,
-      100
+      STATUSBAR_PRIORITY
     )
     this.item.command = 'drift.scanWorkspace'
     this.item.tooltip = 'Click to scan workspace'
@@ -27,12 +35,12 @@ export class DriftStatusBarItem {
     const totalIssues = reports.reduce((sum, r) => sum + r.issues.length, 0)
     const hasErrors = reports.some(r => r.issues.some(i => i.severity === 'error'))
 
-    const icon = hasErrors ? '$(error)' : totalScore < 50 ? '$(warning)' : '$(check)'
+    const icon = hasErrors ? '$(error)' : totalScore < SCORE_THRESHOLDS.WARNING ? '$(warning)' : '$(check)'
     this.item.text = `${icon} drift ${totalScore}/100 · ${totalIssues} issues`
 
-    if (hasErrors || totalScore < 30) {
+    if (hasErrors || totalScore < SCORE_THRESHOLDS.ERROR) {
       this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground')
-    } else if (totalScore < 60) {
+    } else if (totalScore < SCORE_THRESHOLDS.WARNING_BG) {
       this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground')
     } else {
       this.item.backgroundColor = undefined

package/packages/vscode-drift/src/treeview.ts

@@ -1,3 +1,5 @@
+// drift-ignore-file
+
 import * as vscode from 'vscode'
 import * as path from 'path'
 import type { FileReport } from '@eduardbar/drift'

package/src/analyzer.ts

@@ -1,7 +1,7 @@
 // drift-ignore-file
 import * as path from 'node:path'
 import { Project } from 'ts-morph'
-import type { DriftIssue, FileReport, DriftConfig } from './types.js'
+import type { DriftIssue, FileReport, DriftConfig, LoadedPlugin, PluginRuleContext } from './types.js'
 
 // Rules
 import { isFileIgnored } from './rules/shared.js'
@@ -15,15 +15,12 @@ import {
   detectCatchSwallow,
   detectMissingReturnTypes,
 } from './rules/phase0-basic.js'
-import {
-  detectHighComplexity,
-  detectDeepNesting,
-  detectTooManyParams,
-  detectHighCoupling,
-  detectPromiseStyleMix,
-  detectMagicNumbers,
-  detectCommentContradiction,
-} from './rules/phase1-complexity.js'
+import { detectHighComplexity } from './rules/complexity.js'
+import { detectDeepNesting, detectTooManyParams } from './rules/nesting.js'
+import { detectHighCoupling } from './rules/coupling.js'
+import { detectPromiseStyleMix } from './rules/promise.js'
+import { detectMagicNumbers } from './rules/magic.js'
+import { detectCommentContradiction } from './rules/comments.js'
 import {
   detectDeadFiles,
   detectUnusedExports,
@@ -34,6 +31,11 @@ import {
   detectLayerViolations,
   detectCrossBoundaryImports,
 } from './rules/phase3-arch.js'
+import {
+  detectControllerNoDb,
+  detectServiceNoHttp,
+  detectMaxFunctionLines,
+} from './rules/phase3-configurable.js'
 import {
   detectOverCommented,
   detectHardcodedConfig,
@@ -46,6 +48,7 @@ import {
   fingerprintFunction,
   calculateScore,
 } from './rules/phase8-semantic.js'
+import { loadPlugins } from './plugins.js'
 
 // Git analyzers (re-exported as part of the public API)
 export { TrendAnalyzer } from './git/trend.js'
@@ -81,21 +84,113 @@ export const RULE_WEIGHTS: Record<string, { severity: DriftIssue['severity']; we
   // Phase 3b/c: layer and module boundary enforcement (require drift.config.ts)
   'layer-violation':          { severity: 'error',   weight: 16 },
   'cross-boundary-import':    { severity: 'warning', weight: 10 },
+  'controller-no-db':         { severity: 'warning', weight: 11 },
+  'service-no-http':          { severity: 'warning', weight: 11 },
+  'max-function-lines':       { severity: 'warning', weight: 9 },
   // Phase 5: AI authorship heuristics
   'over-commented':                { severity: 'info',    weight: 4  },
   'hardcoded-config':              { severity: 'warning', weight: 10 },
   'inconsistent-error-handling':   { severity: 'warning', weight: 8  },
   'unnecessary-abstraction':       { severity: 'warning', weight: 7  },
   'naming-inconsistency':          { severity: 'warning', weight: 6  },
+  'ai-code-smell':                 { severity: 'warning', weight: 12 },
   // Phase 8: semantic duplication
   'semantic-duplication':          { severity: 'warning', weight: 12 },
+  'plugin-error':                  { severity: 'warning', weight: 4  },
+}
+
+const AI_SMELL_SIGNALS = new Set([
+  'over-commented',
+  'hardcoded-config',
+  'inconsistent-error-handling',
+  'unnecessary-abstraction',
+  'naming-inconsistency',
+  'comment-contradiction',
+  'promise-style-mix',
+  'any-abuse',
+])
+
+function detectAICodeSmell(issues: DriftIssue[], filePath: string): DriftIssue[] {
+  const signalCounts = new Map<string, number>()
+  for (const issue of issues) {
+    if (!AI_SMELL_SIGNALS.has(issue.rule)) continue
+    signalCounts.set(issue.rule, (signalCounts.get(issue.rule) ?? 0) + 1)
+  }
+
+  const totalSignals = [...signalCounts.values()].reduce((sum, count) => sum + count, 0)
+  if (totalSignals < 3) return []
+
+  const triggers = [...signalCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3)
+    .map(([rule, count]) => `${rule} x${count}`)
+
+  return [{
+    rule: 'ai-code-smell',
+    severity: 'warning',
+    message: `Aggregated AI smell signals detected (${totalSignals}): ${triggers.join(', ')}`,
+    line: 1,
+    column: 1,
+    snippet: path.basename(filePath),
+  }]
+}
+
+function runPluginRules(
+  file: import('ts-morph').SourceFile,
+  loadedPlugins: LoadedPlugin[],
+  config: DriftConfig | undefined,
+  projectRoot: string,
+): DriftIssue[] {
+  if (loadedPlugins.length === 0) return []
+  const context: PluginRuleContext = {
+    projectRoot,
+    filePath: file.getFilePath(),
+    config,
+  }
+
+  const issues: DriftIssue[] = []
+  for (const loaded of loadedPlugins) {
+    for (const rule of loaded.plugin.rules) {
+      try {
+        const detected = rule.detect(file, context) ?? []
+        for (const issue of detected) {
+          issues.push({
+            ...issue,
+            rule: issue.rule || `${loaded.plugin.name}/${rule.name}`,
+            severity: issue.severity ?? (rule.severity ?? 'warning'),
+          })
+        }
+      } catch (error) {
+        issues.push({
+          rule: 'plugin-error',
+          severity: 'warning',
+          message: `Plugin '${loaded.id}' rule '${rule.name}' failed: ${error instanceof Error ? error.message : String(error)}`,
+          line: 1,
+          column: 1,
+          snippet: file.getBaseName(),
+        })
+      }
+    }
+  }
+  return issues
 }
 
 // ---------------------------------------------------------------------------
 // Per-file analysis
 // ---------------------------------------------------------------------------
 
-export function analyzeFile(file: import('ts-morph').SourceFile): FileReport {
+export function analyzeFile(
+  file: import('ts-morph').SourceFile,
+  options?: DriftConfig | {
+    config?: DriftConfig
+    loadedPlugins?: LoadedPlugin[]
+    projectRoot?: string
+  },
+): FileReport {
+  const normalizedOptions = (options && typeof options === 'object' && ('config' in options || 'loadedPlugins' in options || 'projectRoot' in options))
+    ? options
+    : { config: (options && typeof options === 'object' ? options : undefined) as DriftConfig | undefined }
+
   if (isFileIgnored(file)) {
     return {
       path: file.getFilePath(),
@@ -127,8 +222,21 @@ export function analyzeFile(file: import('ts-morph').SourceFile): FileReport {
     ...detectInconsistentErrorHandling(file),
     ...detectUnnecessaryAbstraction(file),
     ...detectNamingInconsistency(file),
+    // Configurable architecture rules
+    ...detectControllerNoDb(file, normalizedOptions?.config),
+    ...detectServiceNoHttp(file, normalizedOptions?.config),
+    ...detectMaxFunctionLines(file, normalizedOptions?.config),
+    // Plugin rules
+    ...runPluginRules(
+      file,
+      normalizedOptions?.loadedPlugins ?? [],
+      normalizedOptions?.config,
+      normalizedOptions?.projectRoot ?? path.dirname(file.getFilePath()),
+    ),
   ]
 
+  issues.push(...detectAICodeSmell(issues, file.getFilePath()))
+
   return {
     path: file.getFilePath(),
     issues,
@@ -161,9 +269,14 @@ export function analyzeProject(targetPath: string, config?: DriftConfig): FileRe
   ])
 
   const sourceFiles = project.getSourceFiles()
+  const pluginRuntime = loadPlugins(targetPath, config?.plugins)
 
   // Phase 1: per-file analysis
-  const reports: FileReport[] = sourceFiles.map(analyzeFile)
+  const reports: FileReport[] = sourceFiles.map((file) => analyzeFile(file, {
+    config,
+    loadedPlugins: pluginRuntime.plugins,
+    projectRoot: targetPath,
+  }))
   const reportByPath = new Map<string, FileReport>()
   for (const r of reports) reportByPath.set(r.path, r)
 
@@ -227,6 +340,25 @@ export function analyzeProject(targetPath: string, config?: DriftConfig): FileRe
     }
   }
 
+  // Plugin load failures are surfaced as synthetic report entries.
+  if (pluginRuntime.errors.length > 0) {
+    for (const err of pluginRuntime.errors) {
+      const pluginIssue: DriftIssue = {
+        rule: 'plugin-error',
+        severity: 'warning',
+        message: `Failed to load plugin '${err.pluginId}': ${err.message}`,
+        line: 1,
+        column: 1,
+        snippet: err.pluginId,
+      }
+      reports.push({
+        path: path.join(targetPath, '.drift-plugin-errors', `${err.pluginId}.plugin`),
+        issues: [pluginIssue],
+        score: calculateScore([pluginIssue], RULE_WEIGHTS),
+      })
+    }
+  }
+
   // ── Phase 2: dead-file + unused-export + unused-dependency ─────────────────
   const deadFiles = detectDeadFiles(sourceFiles, allImportedPaths, RULE_WEIGHTS)
   for (const [sfPath, issue] of deadFiles) {

package/src/badge.ts

@@ -3,19 +3,40 @@ import type {} from './types.js'
 const LEFT_WIDTH = 47
 const CHAR_WIDTH = 7
 const PADDING = 16
+const SVG_SCALE = 10
+
+const GRADE_THRESHOLDS = {
+  LOW: 20,
+  MODERATE: 45,
+  HIGH: 70,
+}
+
+const GRADE_COLORS = {
+  LOW: '#4c1',
+  MODERATE: '#dfb317',
+  HIGH: '#fe7d37',
+  CRITICAL: '#e05d44',
+}
+
+const GRADE_LABELS = {
+  LOW: 'LOW',
+  MODERATE: 'MODERATE',
+  HIGH: 'HIGH',
+  CRITICAL: 'CRITICAL',
+}
 
 function scoreColor(score: number): string {
-  if (score < 20) return '#4c1'
-  if (score < 45) return '#dfb317'
-  if (score < 70) return '#fe7d37'
-  return '#e05d44'
+  if (score < GRADE_THRESHOLDS.LOW) return GRADE_COLORS.LOW
+  if (score < GRADE_THRESHOLDS.MODERATE) return GRADE_COLORS.MODERATE
+  if (score < GRADE_THRESHOLDS.HIGH) return GRADE_COLORS.HIGH
+  return GRADE_COLORS.CRITICAL
 }
 
 function scoreLabel(score: number): string {
-  if (score < 20) return 'LOW'
-  if (score < 45) return 'MODERATE'
-  if (score < 70) return 'HIGH'
-  return 'CRITICAL'
+  if (score < GRADE_THRESHOLDS.LOW) return GRADE_LABELS.LOW
+  if (score < GRADE_THRESHOLDS.MODERATE) return GRADE_LABELS.MODERATE
+  if (score < GRADE_THRESHOLDS.HIGH) return GRADE_LABELS.HIGH
+  return GRADE_LABELS.CRITICAL
 }
 
 function rightWidth(text: string): number {
@@ -32,10 +53,11 @@ export function generateBadge(score: number): string {
   const leftCenterX = LEFT_WIDTH / 2
   const rightCenterX = LEFT_WIDTH + rWidth / 2
 
-  // shields.io pattern: font-size="110" + scale(.1) = effective 11px
-  // all X/Y coords are ×10
-  const leftTextWidth = (LEFT_WIDTH - 10) * 10
-  const rightTextWidth = (rWidth - PADDING) * 10
+  const leftTextWidth = (LEFT_WIDTH - PADDING) * SVG_SCALE
+  const rightTextWidth = (rWidth - PADDING) * SVG_SCALE
+
+  const leftCenterXScaled = leftCenterX * SVG_SCALE
+  const rightCenterXScaled = rightCenterX * SVG_SCALE
 
   return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${totalWidth}" height="20">
   <linearGradient id="s" x2="0" y2="100%">
@@ -51,10 +73,10 @@ export function generateBadge(score: number): string {
     <rect width="${totalWidth}" height="20" fill="url(#s)"/>
   </g>
   <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
-    <text x="${leftCenterX * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
-    <text x="${leftCenterX * 10}" y="140" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
-    <text x="${rightCenterX * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
-    <text x="${rightCenterX * 10}" y="140" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
+    <text x="${leftCenterXScaled}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
+    <text x="${leftCenterXScaled}" y="140" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
+    <text x="${rightCenterXScaled}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
+    <text x="${rightCenterXScaled}" y="140" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
   </g>
 </svg>`
 }

package/src/ci.ts

@@ -2,6 +2,15 @@ import { writeFileSync } from 'node:fs'
 import { relative } from 'node:path'
 import type { DriftReport } from './types.js'
 
+const GRADE_THRESHOLDS = {
+  A: 80,
+  B: 60,
+  C: 40,
+  D: 20,
+}
+
+const TOP_FILES_LIMIT = 10
+
 function encodeMessage(msg: string): string {
   return msg
     .replace(/%/g, '%25')
@@ -18,10 +27,10 @@ function severityToAnnotation(s: string): 'error' | 'warning' | 'notice' {
 }
 
 function scoreLabel(score: number): string {
-  if (score >= 80) return 'A'
-  if (score >= 60) return 'B'
-  if (score >= 40) return 'C'
-  if (score >= 20) return 'D'
+  if (score >= GRADE_THRESHOLDS.A) return 'A'
+  if (score >= GRADE_THRESHOLDS.B) return 'B'
+  if (score >= GRADE_THRESHOLDS.C) return 'C'
+  if (score >= GRADE_THRESHOLDS.D) return 'D'
   return 'F'
 }
 
@@ -38,28 +47,40 @@ export function emitCIAnnotations(report: DriftReport): void {
   }
 }
 
-export function printCISummary(report: DriftReport): void {
-  const summaryPath = process.env['GITHUB_STEP_SUMMARY']
-  if (!summaryPath) return
-
-  const score = report.totalScore
-  const grade = scoreLabel(score)
-
+function countIssuesBySeverity(report: DriftReport): { errors: number; warnings: number; info: number } {
   let errors = 0
   let warnings = 0
   let info = 0
 
   for (const file of report.files) {
-    for (const issue of file.issues) {
-      if (issue.severity === 'error') errors++
-      else if (issue.severity === 'warning') warnings++
-      else info++
-    }
+    countFileIssues(file, { errors: () => errors++, warnings: () => warnings++, info: () => info++ })
   }
 
+  return { errors, warnings, info }
+}
+
+function countFileIssues(
+  file: { issues: Array<{ severity: string }> },
+  counters: { errors: () => void; warnings: () => void; info: () => void },
+): void {
+  for (const issue of file.issues) {
+    if (issue.severity === 'error') counters.errors()
+    else if (issue.severity === 'warning') counters.warnings()
+    else counters.info()
+  }
+}
+
+export function printCISummary(report: DriftReport): void {
+  const summaryPath = process.env['GITHUB_STEP_SUMMARY']
+  if (!summaryPath) return
+
+  const score = report.totalScore
+  const grade = scoreLabel(score)
+  const { errors, warnings, info } = countIssuesBySeverity(report)
+
   const sorted = [...report.files]
     .sort((a, b) => b.issues.length - a.issues.length)
-    .slice(0, 10)
+    .slice(0, TOP_FILES_LIMIT)
 
   const rows = sorted
     .map((f) => {

package/src/cli.ts

@@ -16,6 +16,9 @@ import { generateHtmlReport } from './report.js'
 import { generateBadge } from './badge.js'
 import { emitCIAnnotations, printCISummary } from './ci.js'
 import { applyFixes, type FixResult } from './fix.js'
+import { loadHistory, saveSnapshot, printHistory, printSnapshotDiff } from './snapshot.js'
+import { generateReview } from './review.js'
+import { generateArchitectureMap } from './map.js'
 
 const program = new Command()
 
@@ -117,6 +120,45 @@ program
     }
   })
 
+program
+  .command('review')
+  .description('Review drift against a base ref and output PR markdown')
+  .option('--base <ref>', 'Git base ref to compare against', 'origin/main')
+  .option('--json', 'Output structured review JSON')
+  .option('--comment', 'Output markdown comment body')
+  .option('--fail-on <n>', 'Exit with code 1 if score delta is >= n')
+  .action(async (options: { base: string; json?: boolean; comment?: boolean; failOn?: string }) => {
+    try {
+      const review = await generateReview(resolve('.'), options.base)
+
+      if (options.json) {
+        process.stdout.write(JSON.stringify(review, null, 2) + '\n')
+      } else {
+        process.stdout.write((options.comment ? review.markdown : `${review.summary}\n\n${review.markdown}`) + '\n')
+      }
+
+      const failOn = options.failOn ? Number(options.failOn) : undefined
+      if (typeof failOn === 'number' && !Number.isNaN(failOn) && review.totalDelta >= failOn) {
+        process.exit(1)
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      process.stderr.write(`\n  Error: ${message}\n\n`)
+      process.exit(1)
+    }
+  })
+
+program
+  .command('map [path]')
+  .description('Generate architecture.svg with simple layer dependencies')
+  .option('-o, --output <file>', 'Output SVG path (default: architecture.svg)', 'architecture.svg')
+  .action(async (targetPath: string | undefined, options: { output: string }) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+    process.stderr.write(`\nBuilding architecture map for ${resolvedPath}...\n`)
+    const out = generateArchitectureMap(resolvedPath, options.output)
+    process.stderr.write(`  Architecture map saved to ${out}\n\n`)
+  })
+
 program
   .command('report [path]')
   .description('Generate a self-contained HTML report')
@@ -214,14 +256,20 @@ program
   .command('fix [path]')
   .description('Auto-fix safe issues (debug-leftover console.*, catch-swallow)')
   .option('--rule <rule>', 'Fix only a specific rule')
+  .option('--preview', 'Preview changes without writing files')
+  .option('--write', 'Write fixes to disk')
   .option('--dry-run', 'Show what would change without writing files')
-  .action(async (targetPath: string | undefined, options: { rule?: string; dryRun?: boolean }) => {
+  .action(async (targetPath: string | undefined, options: { rule?: string; dryRun?: boolean; preview?: boolean; write?: boolean }) => {
     const resolvedPath = resolve(targetPath ?? '.')
     const config = await loadConfig(resolvedPath)
+    const previewMode = Boolean(options.preview || options.dryRun)
+    const writeMode = options.write ?? !previewMode
 
     const results = await applyFixes(resolvedPath, config, {
       rule: options.rule,
-      dryRun: options.dryRun,
+      dryRun: previewMode,
+      preview: previewMode,
+      write: writeMode,
     })
 
     if (results.length === 0) {
@@ -231,8 +279,8 @@ program
 
     const applied = results.filter(r => r.applied)
 
-    if (options.dryRun) {
-      console.log(`\ndrift fix --dry-run: ${results.length} fixable issues found\n`)
+    if (previewMode) {
+      console.log(`\ndrift fix --preview: ${results.length} fixable issues found\n`)
     } else {
       console.log(`\ndrift fix: ${applied.length} fixes applied\n`)
     }
@@ -248,14 +296,56 @@ program
       const relPath = file.replace(resolvedPath + '/', '').replace(resolvedPath + '\\', '')
       console.log(`  ${relPath}`)
       for (const r of fileResults) {
-        const status = r.applied ? (options.dryRun ? 'would fix' : 'fixed') : 'skipped'
+        const status = r.applied ? (previewMode ? 'would fix' : 'fixed') : 'skipped'
         console.log(`    [${r.rule}] line ${r.line}: ${r.description} — ${status}`)
+        if (r.before || r.after) {
+          console.log(`      before: ${r.before ?? '(empty)'}`)
+          console.log(`      after : ${r.after ?? '(empty)'}`)
+        }
       }
     }
 
-    if (!options.dryRun && applied.length > 0) {
+    if (!previewMode && applied.length > 0) {
       console.log(`\n${applied.length} issue(s) fixed. Re-run drift scan to verify.`)
     }
   })
 
+program
+  .command('snapshot [path]')
+  .description('Record a score snapshot to drift-history.json')
+  .option('-l, --label <label>', 'label for this snapshot (e.g. sprint name, version)')
+  .option('--history', 'show all recorded snapshots')
+  .option('--diff', 'compare current score vs last snapshot')
+  .action(async (
+    targetPath: string | undefined,
+    opts: { label?: string; history?: boolean; diff?: boolean },
+  ) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+
+    if (opts.history) {
+      const history = loadHistory(resolvedPath)
+      printHistory(history)
+      return
+    }
+
+    process.stderr.write(`\nScanning ${resolvedPath}...\n`)
+    const config = await loadConfig(resolvedPath)
+    const files = analyzeProject(resolvedPath, config)
+    process.stderr.write(`  Found ${files.length} TypeScript file(s)\n\n`)
+    const report = buildReport(resolvedPath, files)
+
+    if (opts.diff) {
+      const history = loadHistory(resolvedPath)
+      printSnapshotDiff(history, report.totalScore)
+      return
+    }
+
+    const entry = saveSnapshot(resolvedPath, report, opts.label)
+    const labelStr = entry.label ? ` [${entry.label}]` : ''
+    process.stdout.write(
+      `  Snapshot recorded${labelStr}: score ${entry.score} (${entry.grade}) — ${entry.totalIssues} issues across ${entry.files} files\n`,
+    )
+    process.stdout.write(`  Saved to drift-history.json\n\n`)
+  })
+
 program.parse()

package/src/diff.ts

@@ -7,6 +7,40 @@ import type { DriftReport, DriftDiff, FileDiff, DriftIssue } from './types.js'
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
+function computeFileDiff(
+  filePath: string,
+  baseFile: { score: number; issues: DriftIssue[] } | undefined,
+  currentFile: { score: number; issues: DriftIssue[] } | undefined,
+): FileDiff | null {
+  const scoreBefore = baseFile?.score ?? 0
+  const scoreAfter = currentFile?.score ?? 0
+  const scoreDelta = scoreAfter - scoreBefore
+
+  const baseIssues = baseFile?.issues ?? []
+  const currentIssues = currentFile?.issues ?? []
+
+  const issueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
+
+  const baseKeys = new Set(baseIssues.map(issueKey))
+  const currentKeys = new Set(currentIssues.map(issueKey))
+
+  const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)))
+  const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)))
+
+  if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
+    return {
+      path: filePath,
+      scoreBefore,
+      scoreAfter,
+      scoreDelta,
+      newIssues,
+      resolvedIssues,
+    }
+  }
+
+  return null
+}
+
 export function computeDiff(
   base: DriftReport,
   current: DriftReport,
@@ -14,11 +48,9 @@ export function computeDiff(
 ): DriftDiff {
   const fileDiffs: FileDiff[] = []
 
-  // Build a map of base files by path for O(1) lookup
   const baseByPath = new Map(base.files.map(f => [f.path, f]))
   const currentByPath = new Map(current.files.map(f => [f.path, f]))
 
-  // All unique paths across both reports
   const allPaths = new Set([
     ...base.files.map(f => f.path),
     ...current.files.map(f => f.path),
@@ -28,36 +60,10 @@ export function computeDiff(
     const baseFile = baseByPath.get(filePath)
     const currentFile = currentByPath.get(filePath)
 
-    const scoreBefore = baseFile?.score ?? 0
-    const scoreAfter = currentFile?.score ?? 0
-    const scoreDelta = scoreAfter - scoreBefore
-
-    const baseIssues = baseFile?.issues ?? []
-    const currentIssues = currentFile?.issues ?? []
-
-    // Issue identity key: rule + line + column
-    const issueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
-
-    const baseKeys = new Set(baseIssues.map(issueKey))
-    const currentKeys = new Set(currentIssues.map(issueKey))
-
-    const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)))
-    const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)))
-
-    // Only include files that have actual changes
-    if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
-      fileDiffs.push({
-        path: filePath,
-        scoreBefore,
-        scoreAfter,
-        scoreDelta,
-        newIssues,
-        resolvedIssues,
-      })
-    }
+    const diff = computeFileDiff(filePath, baseFile, currentFile)
+    if (diff) fileDiffs.push(diff)
   }
 
-  // Sort: most regressed first, then most improved last
   fileDiffs.sort((a, b) => b.scoreDelta - a.scoreDelta)
 
   return {