@eduardbar/drift 1.0.0 → 1.2.0

package/dist/badge.js

@@ -1,23 +1,41 @@
 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) {
-    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) {
-    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) {
     return text.length * CHAR_WIDTH + PADDING;
@@ -29,10 +47,10 @@ export function generateBadge(score) {
     const totalWidth = LEFT_WIDTH + rWidth;
     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%">
     <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
@@ -47,10 +65,10 @@ export function generateBadge(score) {
     <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/dist/ci.js

@@ -1,5 +1,12 @@
 import { writeFileSync } from 'node:fs';
 import { relative } from 'node:path';
+const GRADE_THRESHOLDS = {
+    A: 80,
+    B: 60,
+    C: 40,
+    D: 20,
+};
+const TOP_FILES_LIMIT = 10;
 function encodeMessage(msg) {
     return msg
         .replace(/%/g, '%25')
@@ -16,13 +23,13 @@ function severityToAnnotation(s) {
     return 'notice';
 }
 function scoreLabel(score) {
-    if (score >= 80)
+    if (score >= GRADE_THRESHOLDS.A)
         return 'A';
-    if (score >= 60)
+    if (score >= GRADE_THRESHOLDS.B)
         return 'B';
-    if (score >= 40)
+    if (score >= GRADE_THRESHOLDS.C)
         return 'C';
-    if (score >= 20)
+    if (score >= GRADE_THRESHOLDS.D)
         return 'D';
     return 'F';
 }
@@ -38,28 +45,35 @@ export function emitCIAnnotations(report) {
         }
     }
 }
+function countIssuesBySeverity(report) {
+    let errors = 0;
+    let warnings = 0;
+    let info = 0;
+    for (const file of report.files) {
+        countFileIssues(file, { errors: () => errors++, warnings: () => warnings++, info: () => info++ });
+    }
+    return { errors, warnings, info };
+}
+function countFileIssues(file, counters) {
+    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) {
     const summaryPath = process.env['GITHUB_STEP_SUMMARY'];
     if (!summaryPath)
         return;
     const score = report.totalScore;
     const grade = scoreLabel(score);
-    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++;
-        }
-    }
+    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) => {
         const relPath = relative(process.cwd(), f.path).replace(/\\/g, '/');

package/dist/cli.js

@@ -2,8 +2,10 @@
 // drift-ignore-file
 import { Command } from 'commander';
 import { writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { basename, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
 const require = createRequire(import.meta.url);
 const { version: VERSION } = require('../package.json');
 import { analyzeProject, analyzeFile, TrendAnalyzer, BlameAnalyzer } from './analyzer.js';
@@ -16,6 +18,10 @@ import { generateHtmlReport } from './report.js';
 import { generateBadge } from './badge.js';
 import { emitCIAnnotations, printCISummary } from './ci.js';
 import { applyFixes } from './fix.js';
+import { loadHistory, saveSnapshot, printHistory, printSnapshotDiff } from './snapshot.js';
+import { generateReview } from './review.js';
+import { generateArchitectureMap } from './map.js';
+import { ingestSnapshotFromReport, getSaasSummary, generateSaasDashboardHtml } from './saas.js';
 const program = new Command();
 program
     .name('drift')
@@ -103,6 +109,44 @@ program
             cleanupTempDir(tempDir);
     }
 });
+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) => {
+    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, options) => {
+    const resolvedPath = resolve(targetPath ?? '.');
+    process.stderr.write(`\nBuilding architecture map for ${resolvedPath}...\n`);
+    const config = await loadConfig(resolvedPath);
+    const out = generateArchitectureMap(resolvedPath, options.output, config);
+    process.stderr.write(`  Architecture map saved to ${out}\n\n`);
+});
 program
     .command('report [path]')
     .description('Generate a self-contained HTML report')
@@ -189,21 +233,49 @@ 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')
+    .option('-y, --yes', 'Skip interactive confirmation for --write')
     .action(async (targetPath, options) => {
     const resolvedPath = resolve(targetPath ?? '.');
     const config = await loadConfig(resolvedPath);
+    const previewMode = Boolean(options.preview || options.dryRun);
+    const writeMode = options.write ?? !previewMode;
+    if (writeMode && !options.yes) {
+        const previewResults = await applyFixes(resolvedPath, config, {
+            rule: options.rule,
+            dryRun: true,
+            preview: true,
+            write: false,
+        });
+        if (previewResults.length === 0) {
+            console.log('No fixable issues found.');
+            return;
+        }
+        const files = new Set(previewResults.map((result) => result.file)).size;
+        const prompt = `Apply ${previewResults.length} fix(es) across ${files} file(s)? [y/N] `;
+        const rl = createInterface({ input, output });
+        const answer = (await rl.question(prompt)).trim().toLowerCase();
+        rl.close();
+        if (answer !== 'y' && answer !== 'yes') {
+            console.log('Aborted. No files were modified.');
+            return;
+        }
+    }
     const results = await applyFixes(resolvedPath, config, {
         rule: options.rule,
-        dryRun: options.dryRun,
+        dryRun: previewMode,
+        preview: previewMode,
+        write: writeMode,
     });
     if (results.length === 0) {
         console.log('No fixable issues found.');
         return;
     }
     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`);
@@ -219,13 +291,114 @@ 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, opts) => {
+    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`);
+});
+const cloud = program
+    .command('cloud')
+    .description('Local SaaS foundations: ingest, summary, and dashboard');
+cloud
+    .command('ingest [path]')
+    .description('Scan path, build report, and store cloud snapshot')
+    .requiredOption('--workspace <id>', 'Workspace id')
+    .requiredOption('--user <id>', 'User id')
+    .option('--repo <name>', 'Repo name (default: basename of scanned path)')
+    .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+    .action(async (targetPath, options) => {
+    const resolvedPath = resolve(targetPath ?? '.');
+    process.stderr.write(`\nScanning ${resolvedPath} for cloud ingest...\n`);
+    const config = await loadConfig(resolvedPath);
+    const files = analyzeProject(resolvedPath, config);
+    const report = buildReport(resolvedPath, files);
+    const snapshot = ingestSnapshotFromReport(report, {
+        workspaceId: options.workspace,
+        userId: options.user,
+        repoName: options.repo ?? basename(resolvedPath),
+        storeFile: options.store,
+        policy: config?.saas,
+    });
+    process.stdout.write(`Ingested snapshot ${snapshot.id}\n`);
+    process.stdout.write(`Workspace: ${snapshot.workspaceId}  Repo: ${snapshot.repoName}\n`);
+    process.stdout.write(`Score: ${snapshot.totalScore}/100  Issues: ${snapshot.totalIssues}\n\n`);
+});
+cloud
+    .command('summary')
+    .description('Show SaaS usage metrics and free threshold status')
+    .option('--json', 'Output raw JSON summary')
+    .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+    .action((options) => {
+    const summary = getSaasSummary({ storeFile: options.store });
+    if (options.json) {
+        process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
+        return;
+    }
+    process.stdout.write('\n');
+    process.stdout.write(`Phase: ${summary.phase.toUpperCase()}\n`);
+    process.stdout.write(`Users registered: ${summary.usersRegistered}\n`);
+    process.stdout.write(`Active workspaces (30d): ${summary.workspacesActive}\n`);
+    process.stdout.write(`Active repos (30d): ${summary.reposActive}\n`);
+    process.stdout.write(`Total snapshots: ${summary.totalSnapshots}\n`);
+    process.stdout.write(`Free user threshold: ${summary.policy.freeUserThreshold}\n`);
+    process.stdout.write(`Threshold reached: ${summary.thresholdReached ? 'yes' : 'no'}\n`);
+    process.stdout.write(`Free users remaining: ${summary.freeUsersRemaining}\n`);
+    process.stdout.write('Runs per month:\n');
+    const monthly = Object.entries(summary.runsPerMonth).sort(([a], [b]) => a.localeCompare(b));
+    if (monthly.length === 0) {
+        process.stdout.write('  - none\n\n');
+        return;
+    }
+    for (const [month, runs] of monthly) {
+        process.stdout.write(`  - ${month}: ${runs}\n`);
+    }
+    process.stdout.write('\n');
+});
+cloud
+    .command('dashboard')
+    .description('Generate an HTML dashboard with trends and hotspots')
+    .option('-o, --output <file>', 'Output HTML file', 'drift-cloud-dashboard.html')
+    .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+    .action((options) => {
+    const html = generateSaasDashboardHtml({ storeFile: options.store });
+    const outPath = resolve(options.output);
+    writeFileSync(outPath, html, 'utf8');
+    process.stdout.write(`Dashboard saved to ${outPath}\n`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/diff.d.ts

@@ -1,10 +1,3 @@
 import type { DriftReport, DriftDiff } from './types.js';
-/**
- * Compute the diff between two DriftReports.
- *
- * Issues are matched by (rule + line + column) as a unique key within a file.
- * A "new" issue exists in `current` but not in `base`.
- * A "resolved" issue exists in `base` but not in `current`.
- */
 export declare function computeDiff(base: DriftReport, current: DriftReport, baseRef: string): DriftDiff;
 //# sourceMappingURL=diff.d.ts.map

package/dist/diff.js

@@ -5,12 +5,33 @@
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
+function computeFileDiff(filePath, baseFile, currentFile) {
+    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) => `${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, current, baseRef) {
     const fileDiffs = [];
-    // 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),
@@ -18,30 +39,10 @@ export function computeDiff(base, current, baseRef) {
     for (const filePath of allPaths) {
         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) => `${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 {
         baseRef,

package/dist/fix.d.ts

@@ -5,9 +5,13 @@ export interface FixResult {
     line: number;
     description: string;
     applied: boolean;
+    before?: string;
+    after?: string;
 }
 export declare function applyFixes(targetPath: string, config?: DriftConfig, options?: {
     rule?: string;
     dryRun?: boolean;
+    write?: boolean;
+    preview?: boolean;
 }): Promise<FixResult[]>;
 //# sourceMappingURL=fix.d.ts.map

package/dist/fix.js

@@ -50,10 +50,65 @@ function applyFixToLines(lines, issue) {
     }
     return null;
 }
+function collectFixableIssues(fileReports, options) {
+    const fixableByFile = new Map();
+    for (const report of fileReports) {
+        const fixableIssues = report.issues.filter(issue => {
+            if (!isFixable(issue))
+                return false;
+            if (options?.rule && issue.rule !== options.rule)
+                return false;
+            return true;
+        });
+        if (fixableIssues.length > 0) {
+            fixableByFile.set(report.path, fixableIssues);
+        }
+    }
+    return fixableByFile;
+}
+function processFile(filePath, issues, dryRun) {
+    const content = readFileSync(filePath, 'utf8');
+    let lines = content.split('\n');
+    const results = [];
+    const sortedIssues = [...issues].sort((a, b) => b.line - a.line);
+    for (const issue of sortedIssues) {
+        const before = lines[issue.line - 1]?.trim() ?? '';
+        const fixResult = applyFixToLines(lines, issue);
+        if (fixResult) {
+            const after = fixResult.newLines[issue.line - 1]?.trim() ?? '';
+            results.push({
+                file: filePath,
+                rule: issue.rule,
+                line: issue.line,
+                description: fixResult.description,
+                applied: true,
+                before,
+                after,
+            });
+            lines = fixResult.newLines;
+        }
+        else {
+            results.push({
+                file: filePath,
+                rule: issue.rule,
+                line: issue.line,
+                description: 'no fix available',
+                applied: false,
+            });
+        }
+    }
+    if (!dryRun) {
+        writeFileSync(filePath, lines.join('\n'), 'utf8');
+    }
+    return results;
+}
 export async function applyFixes(targetPath, config, options) {
     const resolvedPath = resolve(targetPath);
-    const dryRun = options?.dryRun ?? false;
-    // Determine if target is a file or directory
+    const dryRun = options?.write
+        ? false
+        : options?.preview || options?.dryRun
+            ? true
+            : false;
     let fileReports;
     const stat = statSync(resolvedPath);
     if (stat.isFile()) {
@@ -67,53 +122,10 @@ export async function applyFixes(targetPath, config, options) {
     else {
         fileReports = analyzeProject(resolvedPath, config);
     }
-    // Collect fixable issues, optionally filtered by rule
-    const fixableByFile = new Map();
-    for (const report of fileReports) {
-        const fixableIssues = report.issues.filter(issue => {
-            if (!isFixable(issue))
-                return false;
-            if (options?.rule && issue.rule !== options.rule)
-                return false;
-            return true;
-        });
-        if (fixableIssues.length > 0) {
-            fixableByFile.set(report.path, fixableIssues);
-        }
-    }
+    const fixableByFile = collectFixableIssues(fileReports, options);
     const results = [];
     for (const [filePath, issues] of fixableByFile) {
-        const content = readFileSync(filePath, 'utf8');
-        let lines = content.split('\n');
-        // Sort issues by line descending to avoid line number drift after fixes
-        const sortedIssues = [...issues].sort((a, b) => b.line - a.line);
-        // Track line offset caused by deletions (debug-leftover removes lines)
-        // We process top-to-bottom after sorting descending, so no offset needed per issue
-        for (const issue of sortedIssues) {
-            const fixResult = applyFixToLines(lines, issue);
-            if (fixResult) {
-                results.push({
-                    file: filePath,
-                    rule: issue.rule,
-                    line: issue.line,
-                    description: fixResult.description,
-                    applied: true,
-                });
-                lines = fixResult.newLines;
-            }
-            else {
-                results.push({
-                    file: filePath,
-                    rule: issue.rule,
-                    line: issue.line,
-                    description: 'no fix available',
-                    applied: false,
-                });
-            }
-        }
-        if (!dryRun) {
-            writeFileSync(filePath, lines.join('\n'), 'utf8');
-        }
+        results.push(...processFile(filePath, issues, dryRun));
     }
     return results;
 }

package/dist/git/trend.js

@@ -1,3 +1,4 @@
+// drift-ignore-file
 import { assertGitRepo, analyzeHistoricalCommits } from './helpers.js';
 import { buildReport } from '../reporter.js';
 export class TrendAnalyzer {

package/dist/git.d.ts

@@ -1,12 +1,3 @@
-/**
- * Extract all TypeScript files from the project at a given git ref into a
- * temporary directory. Returns the temp directory path.
- *
- * Uses `git ls-tree` to list files and `git show <ref>:<path>` to read each
- * file — no checkout, no stash, no repo state mutation.
- *
- * Throws if the directory is not a git repo or the ref is invalid.
- */
 export declare function extractFilesAtRef(projectPath: string, ref: string): string;
 /**
  * Clean up a temporary directory created by extractFilesAtRef.