@eduardbar/drift 0.9.1 → 1.1.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

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+// drift-ignore-file
 import { Command } from 'commander';
 import { writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const { version: VERSION } = require('../package.json');
-import { analyzeProject } from './analyzer.js';
+import { analyzeProject, analyzeFile, TrendAnalyzer, BlameAnalyzer } from './analyzer.js';
 import { buildReport, formatMarkdown, formatAIOutput } from './reporter.js';
 import { printConsole, printDiff } from './printer.js';
 import { loadConfig } from './config.js';
@@ -14,7 +15,10 @@ import { computeDiff } from './diff.js';
 import { generateHtmlReport } from './report.js';
 import { generateBadge } from './badge.js';
 import { emitCIAnnotations, printCISummary } from './ci.js';
-import { TrendAnalyzer, BlameAnalyzer } from './analyzer.js';
+import { applyFixes } 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();
 program
     .name('drift')
@@ -102,6 +106,43 @@ 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 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')
@@ -159,7 +200,7 @@ program
     const resolvedPath = resolve('.');
     process.stderr.write(`\nAnalyzing trend in ${resolvedPath}...\n`);
     const config = await loadConfig(resolvedPath);
-    const analyzer = new TrendAnalyzer(resolvedPath, config);
+    const analyzer = new TrendAnalyzer(resolvedPath, analyzeProject, config);
     const trendData = await analyzer.analyzeTrend({
         period: period,
         since: options.since,
@@ -176,7 +217,7 @@ program
     const resolvedPath = resolve('.');
     process.stderr.write(`\nAnalyzing blame in ${resolvedPath}...\n`);
     const config = await loadConfig(resolvedPath);
-    const analyzer = new BlameAnalyzer(resolvedPath, config);
+    const analyzer = new BlameAnalyzer(resolvedPath, analyzeProject, analyzeFile, config);
     const blameData = await analyzer.analyzeBlame({
         target: target,
         top: Number(options.top)
@@ -184,5 +225,85 @@ program
     process.stderr.write(`\nBlame analysis complete:\n`);
     process.stdout.write(JSON.stringify(blameData, null, 2) + '\n');
 });
+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, options) => {
+    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: previewMode,
+        preview: previewMode,
+        write: writeMode,
+    });
+    if (results.length === 0) {
+        console.log('No fixable issues found.');
+        return;
+    }
+    const applied = results.filter(r => r.applied);
+    if (previewMode) {
+        console.log(`\ndrift fix --preview: ${results.length} fixable issues found\n`);
+    }
+    else {
+        console.log(`\ndrift fix: ${applied.length} fixes applied\n`);
+    }
+    // Group by file for clean output
+    const byFile = new Map();
+    for (const r of results) {
+        if (!byFile.has(r.file))
+            byFile.set(r.file, []);
+        byFile.get(r.file).push(r);
+    }
+    for (const [file, fileResults] of byFile) {
+        const relPath = file.replace(resolvedPath + '/', '').replace(resolvedPath + '\\', '');
+        console.log(`  ${relPath}`);
+        for (const r of fileResults) {
+            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 (!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`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/config.js

@@ -31,7 +31,7 @@ export async function loadConfig(projectRoot) {
             const config = mod.default ?? mod;
             return config;
         }
-        catch {
+        catch { // drift-ignore
             // drift-ignore: catch-swallow — config is optional; load failure is non-fatal
         }
     }

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

@@ -0,0 +1,17 @@
+import type { DriftConfig } from './types.js';
+export interface FixResult {
+    file: string;
+    rule: string;
+    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

@@ -0,0 +1,132 @@
+import { readFileSync, writeFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { analyzeProject, analyzeFile } from './analyzer.js';
+import { Project } from 'ts-morph';
+const FIXABLE_RULES = new Set(['debug-leftover', 'catch-swallow']);
+function isConsoleDebug(issue) {
+    // debug-leftover for console.* has messages like "console.log left in production code."
+    // Unresolved markers start with "Unresolved marker"
+    return issue.rule === 'debug-leftover' && !issue.message.startsWith('Unresolved marker');
+}
+function isFixable(issue) {
+    if (issue.rule === 'debug-leftover')
+        return isConsoleDebug(issue);
+    return FIXABLE_RULES.has(issue.rule);
+}
+function fixDebugLeftover(lines, line) {
+    // line is 1-based, lines is 0-based
+    return [...lines.slice(0, line - 1), ...lines.slice(line)];
+}
+function fixCatchSwallow(lines, line) {
+    // line is 1-based — points to the catch (...) line
+    let openBraceLine = line - 1; // convert to 0-based index
+    // Find the opening { of the catch block (same line or next few lines)
+    for (let i = openBraceLine; i < Math.min(openBraceLine + 3, lines.length); i++) { // drift-ignore
+        if (lines[i].includes('{')) {
+            openBraceLine = i;
+            break;
+        }
+    }
+    const indentMatch = lines[openBraceLine].match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1] + '  ' : '  ';
+    return [
+        ...lines.slice(0, openBraceLine + 1),
+        `${indent}// TODO: handle error`, // drift-ignore
+        ...lines.slice(openBraceLine + 1),
+    ];
+}
+function applyFixToLines(lines, issue) {
+    if (issue.rule === 'debug-leftover' && isConsoleDebug(issue)) {
+        return {
+            newLines: fixDebugLeftover(lines, issue.line),
+            description: `remove ${issue.message.split(' ')[0]} statement`,
+        };
+    }
+    if (issue.rule === 'catch-swallow') {
+        return {
+            newLines: fixCatchSwallow(lines, issue.line),
+            description: 'add TODO comment to empty catch block',
+        };
+    }
+    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?.write
+        ? false
+        : options?.preview || options?.dryRun
+            ? true
+            : false;
+    let fileReports;
+    const stat = statSync(resolvedPath);
+    if (stat.isFile()) {
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+            compilerOptions: { allowJs: true, jsx: 1 },
+        });
+        const sourceFile = project.addSourceFileAtPath(resolvedPath);
+        fileReports = [analyzeFile(sourceFile)];
+    }
+    else {
+        fileReports = analyzeProject(resolvedPath, config);
+    }
+    const fixableByFile = collectFixableIssues(fileReports, options);
+    const results = [];
+    for (const [filePath, issues] of fixableByFile) {
+        results.push(...processFile(filePath, issues, dryRun));
+    }
+    return results;
+}
+//# sourceMappingURL=fix.js.map

package/dist/git/blame.d.ts

@@ -0,0 +1,22 @@
+import type { SourceFile } from 'ts-morph';
+import type { FileReport, DriftConfig, BlameAttribution, DriftBlameReport } from '../types.js';
+export declare class BlameAnalyzer {
+    private readonly projectPath;
+    private readonly config;
+    private readonly analyzeProjectFn;
+    private readonly analyzeFileFn;
+    constructor(projectPath: string, analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[], analyzeFileFn: (sf: SourceFile) => FileReport, config?: DriftConfig);
+    /** Blame a single file: returns per-author attribution. */
+    static analyzeFileBlame(filePath: string, analyzeFileFn: (sf: SourceFile) => FileReport): Promise<BlameAttribution[]>;
+    /** Blame for a specific rule across all files in targetPath. */
+    static analyzeRuleBlame(rule: string, targetPath: string, analyzeFileFn: (sf: SourceFile) => FileReport): Promise<BlameAttribution[]>;
+    /** Overall blame across all files and rules. */
+    static analyzeOverallBlame(targetPath: string, analyzeFileFn: (sf: SourceFile) => FileReport): Promise<BlameAttribution[]>;
+    analyzeBlame(options: {
+        target?: 'file' | 'rule' | 'overall';
+        top?: number;
+        filePath?: string;
+        rule?: string;
+    }): Promise<DriftBlameReport>;
+}
+//# sourceMappingURL=blame.d.ts.map