@eduardbar/drift 0.9.0 → 1.0.0

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,7 @@ 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';
 const program = new Command();
 program
     .name('drift')
@@ -159,7 +160,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 +177,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 +185,47 @@ 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('--dry-run', 'Show what would change without writing files')
+    .action(async (targetPath, options) => {
+    const resolvedPath = resolve(targetPath ?? '.');
+    const config = await loadConfig(resolvedPath);
+    const results = await applyFixes(resolvedPath, config, {
+        rule: options.rule,
+        dryRun: options.dryRun,
+    });
+    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`);
+    }
+    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 ? (options.dryRun ? 'would fix' : 'fixed') : 'skipped';
+            console.log(`    [${r.rule}] line ${r.line}: ${r.description} — ${status}`);
+        }
+    }
+    if (!options.dryRun && applied.length > 0) {
+        console.log(`\n${applied.length} issue(s) fixed. Re-run drift scan to verify.`);
+    }
+});
 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/fix.d.ts

@@ -0,0 +1,13 @@
+import type { DriftConfig } from './types.js';
+export interface FixResult {
+    file: string;
+    rule: string;
+    line: number;
+    description: string;
+    applied: boolean;
+}
+export declare function applyFixes(targetPath: string, config?: DriftConfig, options?: {
+    rule?: string;
+    dryRun?: boolean;
+}): Promise<FixResult[]>;
+//# sourceMappingURL=fix.d.ts.map

package/dist/fix.js

@@ -0,0 +1,120 @@
+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;
+}
+export async function applyFixes(targetPath, config, options) {
+    const resolvedPath = resolve(targetPath);
+    const dryRun = options?.dryRun ?? false;
+    // Determine if target is a file or directory
+    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);
+    }
+    // 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 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');
+        }
+    }
+    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

package/dist/git/blame.js

@@ -0,0 +1,227 @@
+// drift-ignore-file
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { assertGitRepo, execGit, analyzeFilePath } from './helpers.js';
+import { buildReport } from '../reporter.js';
+function parseGitBlame(blameOutput) {
+    const entries = [];
+    const lines = blameOutput.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const headerLine = lines[i];
+        if (!headerLine || headerLine.trim() === '') {
+            i++;
+            continue;
+        }
+        // Porcelain blame format: first line is "<hash> <orig-line> <final-line> [<num-lines>]"
+        const headerMatch = headerLine.match(/^([0-9a-f]{40})\s/);
+        if (!headerMatch) {
+            i++;
+            continue;
+        }
+        const hash = headerMatch[1];
+        let author = '';
+        let email = '';
+        let codeLine = '';
+        i++;
+        while (i < lines.length && !lines[i].match(/^[0-9a-f]{40}\s/)) {
+            const l = lines[i];
+            if (l.startsWith('author '))
+                author = l.slice(7).trim();
+            else if (l.startsWith('author-mail '))
+                email = l.slice(12).replace(/[<>]/g, '').trim();
+            else if (l.startsWith('\t'))
+                codeLine = l.slice(1);
+            i++;
+        }
+        entries.push({ hash, author, email, line: codeLine });
+    }
+    return entries;
+}
+export class BlameAnalyzer {
+    projectPath;
+    config;
+    analyzeProjectFn;
+    analyzeFileFn;
+    constructor(projectPath, analyzeProjectFn, analyzeFileFn, config) {
+        this.projectPath = projectPath;
+        this.analyzeProjectFn = analyzeProjectFn;
+        this.analyzeFileFn = analyzeFileFn;
+        this.config = config;
+    }
+    /** Blame a single file: returns per-author attribution. */
+    static async analyzeFileBlame(filePath, analyzeFileFn) {
+        const dir = path.dirname(filePath);
+        assertGitRepo(dir);
+        const blameOutput = execGit(`git blame --porcelain "${filePath}"`, dir);
+        const entries = parseGitBlame(blameOutput);
+        // Analyse issues in the file
+        const report = analyzeFilePath(filePath, analyzeFileFn);
+        // Map line numbers of issues to authors
+        const issuesByLine = new Map();
+        for (const issue of report.issues) {
+            issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1);
+        }
+        // Aggregate by author
+        const byAuthor = new Map();
+        entries.forEach((entry, idx) => {
+            const key = entry.email || entry.author;
+            if (!byAuthor.has(key)) {
+                byAuthor.set(key, {
+                    author: entry.author,
+                    email: entry.email,
+                    commits: 0,
+                    linesChanged: 0,
+                    issuesIntroduced: 0,
+                    avgScoreImpact: 0,
+                });
+            }
+            const attr = byAuthor.get(key);
+            attr.linesChanged++;
+            const lineNum = idx + 1;
+            if (issuesByLine.has(lineNum)) {
+                attr.issuesIntroduced += issuesByLine.get(lineNum);
+            }
+        });
+        // Count unique commits per author
+        const commitsByAuthor = new Map();
+        for (const entry of entries) {
+            const key = entry.email || entry.author;
+            if (!commitsByAuthor.has(key))
+                commitsByAuthor.set(key, new Set());
+            commitsByAuthor.get(key).add(entry.hash);
+        }
+        const total = entries.length || 1;
+        const results = [];
+        for (const [key, attr] of byAuthor) {
+            attr.commits = commitsByAuthor.get(key)?.size ?? 0;
+            attr.avgScoreImpact = (attr.linesChanged / total) * report.score;
+            results.push(attr);
+        }
+        return results.sort((a, b) => b.issuesIntroduced - a.issuesIntroduced);
+    }
+    /** Blame for a specific rule across all files in targetPath. */
+    static async analyzeRuleBlame(rule, targetPath, analyzeFileFn) {
+        assertGitRepo(targetPath);
+        const tsFiles = fs
+            .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.includes('node_modules') && !f.endsWith('.d.ts'))
+            .map(f => path.join(targetPath, f));
+        const combined = new Map();
+        const commitsByAuthor = new Map();
+        for (const file of tsFiles) {
+            let blameEntries = [];
+            try {
+                const blameOutput = execGit(`git blame --porcelain "${file}"`, targetPath);
+                blameEntries = parseGitBlame(blameOutput);
+            }
+            catch {
+                continue;
+            }
+            const report = analyzeFilePath(file, analyzeFileFn);
+            const issuesByLine = new Map();
+            for (const issue of report.issues) {
+                issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1);
+            }
+            blameEntries.forEach((entry, idx) => {
+                const key = entry.email || entry.author;
+                if (!combined.has(key)) {
+                    combined.set(key, {
+                        author: entry.author,
+                        email: entry.email,
+                        commits: 0,
+                        linesChanged: 0,
+                        issuesIntroduced: 0,
+                        avgScoreImpact: 0,
+                    });
+                    commitsByAuthor.set(key, new Set());
+                }
+                const attr = combined.get(key);
+                attr.linesChanged++;
+                commitsByAuthor.get(key).add(entry.hash);
+                const lineNum = idx + 1;
+                if (issuesByLine.has(lineNum)) {
+                    attr.issuesIntroduced += issuesByLine.get(lineNum);
+                    attr.avgScoreImpact += report.score * (1 / (blameEntries.length || 1));
+                }
+            });
+        }
+        for (const [key, attr] of combined) {
+            attr.commits = commitsByAuthor.get(key)?.size ?? 0;
+        }
+        return Array.from(combined.values()).sort((a, b) => b.issuesIntroduced - a.issuesIntroduced);
+    }
+    /** Overall blame across all files and rules. */
+    static async analyzeOverallBlame(targetPath, analyzeFileFn) {
+        assertGitRepo(targetPath);
+        const tsFiles = fs
+            .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.includes('node_modules') && !f.endsWith('.d.ts'))
+            .map(f => path.join(targetPath, f));
+        const combined = new Map();
+        const commitsByAuthor = new Map();
+        for (const file of tsFiles) {
+            let blameEntries = [];
+            try {
+                const blameOutput = execGit(`git blame --porcelain "${file}"`, targetPath);
+                blameEntries = parseGitBlame(blameOutput);
+            }
+            catch {
+                continue;
+            }
+            const report = analyzeFilePath(file, analyzeFileFn);
+            const issuesByLine = new Map();
+            for (const issue of report.issues) {
+                issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1);
+            }
+            blameEntries.forEach((entry, idx) => {
+                const key = entry.email || entry.author;
+                if (!combined.has(key)) {
+                    combined.set(key, {
+                        author: entry.author,
+                        email: entry.email,
+                        commits: 0,
+                        linesChanged: 0,
+                        issuesIntroduced: 0,
+                        avgScoreImpact: 0,
+                    });
+                    commitsByAuthor.set(key, new Set());
+                }
+                const attr = combined.get(key);
+                attr.linesChanged++;
+                commitsByAuthor.get(key).add(entry.hash);
+                const lineNum = idx + 1;
+                if (issuesByLine.has(lineNum)) {
+                    attr.issuesIntroduced += issuesByLine.get(lineNum);
+                    attr.avgScoreImpact += report.score * (1 / (blameEntries.length || 1));
+                }
+            });
+        }
+        for (const [key, attr] of combined) {
+            attr.commits = commitsByAuthor.get(key)?.size ?? 0;
+        }
+        return Array.from(combined.values()).sort((a, b) => b.issuesIntroduced - a.issuesIntroduced);
+    }
+    // --- Instance method -------------------------------------------------------
+    async analyzeBlame(options) {
+        assertGitRepo(this.projectPath);
+        let blame = [];
+        const mode = options.target ?? 'overall';
+        if (mode === 'file' && options.filePath) {
+            blame = await BlameAnalyzer.analyzeFileBlame(options.filePath, this.analyzeFileFn);
+        }
+        else if (mode === 'rule' && options.rule) {
+            blame = await BlameAnalyzer.analyzeRuleBlame(options.rule, this.projectPath, this.analyzeFileFn);
+        }
+        else {
+            blame = await BlameAnalyzer.analyzeOverallBlame(this.projectPath, this.analyzeFileFn);
+        }
+        if (options.top) {
+            blame = blame.slice(0, options.top);
+        }
+        const currentFiles = this.analyzeProjectFn(this.projectPath, this.config);
+        const baseReport = buildReport(this.projectPath, currentFiles);
+        return { ...baseReport, blame };
+    }
+}
+//# sourceMappingURL=blame.js.map

package/dist/git/helpers.d.ts

@@ -0,0 +1,36 @@
+import type { SourceFile } from 'ts-morph';
+import type { FileReport, DriftConfig, HistoricalAnalysis } from '../types.js';
+/**
+ * Analyse a file given its absolute path string.
+ * Accepts analyzeFile as a parameter to avoid circular dependency.
+ */
+export declare function analyzeFilePath(filePath: string, analyzeFile: (sf: SourceFile) => FileReport): FileReport;
+/**
+ * Execute a git command synchronously and return stdout.
+ * Throws a descriptive error if the command fails or git is not available.
+ */
+export declare function execGit(cmd: string, cwd: string): string;
+/**
+ * Verify the given directory is a git repository.
+ * Throws if git is not available or the directory is not a repo.
+ */
+export declare function assertGitRepo(cwd: string): void;
+/**
+ * Analyse a single file as it existed at a given commit hash.
+ * Writes the blob to a temp file, runs analyzeFile, then cleans up.
+ */
+export declare function analyzeFileAtCommit(// drift-ignore
+filePath: string, commitHash: string, projectRoot: string, analyzeFile: (sf: SourceFile) => FileReport): Promise<FileReport>;
+/**
+ * Analyse ALL TypeScript files in the project snapshot at a given commit.
+ * Uses `git ls-tree` to enumerate every file in the tree, writes them to a
+ * temp directory, then runs `analyzeProject` on that full snapshot.
+ */
+export declare function analyzeSingleCommit(// drift-ignore
+commitHash: string, targetPath: string, analyzeProject: (targetPath: string, config?: DriftConfig) => FileReport[], config?: DriftConfig): Promise<HistoricalAnalysis>;
+/**
+ * Run historical analysis over all commits since a given date.
+ * Returns results ordered chronologically (oldest first).
+ */
+export declare function analyzeHistoricalCommits(sinceDate: Date, targetPath: string, maxCommits: number, analyzeProject: (targetPath: string, config?: DriftConfig) => FileReport[], config?: DriftConfig, maxSamples?: number): Promise<HistoricalAnalysis[]>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/git/helpers.js

@@ -0,0 +1,152 @@
+// drift-ignore-file
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as crypto from 'node:crypto';
+import { execSync } from 'node:child_process';
+import { Project } from 'ts-morph';
+/**
+ * Analyse a file given its absolute path string.
+ * Accepts analyzeFile as a parameter to avoid circular dependency.
+ */
+export function analyzeFilePath(filePath, analyzeFile) {
+    const proj = new Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: { allowJs: true },
+    });
+    const sf = proj.addSourceFileAtPath(filePath);
+    return analyzeFile(sf);
+}
+/**
+ * Execute a git command synchronously and return stdout.
+ * Throws a descriptive error if the command fails or git is not available.
+ */
+export function execGit(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Git command failed: ${cmd}\n${msg}`);
+    }
+}
+/**
+ * Verify the given directory is a git repository.
+ * Throws if git is not available or the directory is not a repo.
+ */
+export function assertGitRepo(cwd) {
+    try {
+        execGit('git rev-parse --is-inside-work-tree', cwd);
+    }
+    catch {
+        throw new Error(`Directory is not a git repository: ${cwd}`);
+    }
+}
+/**
+ * Analyse a single file as it existed at a given commit hash.
+ * Writes the blob to a temp file, runs analyzeFile, then cleans up.
+ */
+export async function analyzeFileAtCommit(// drift-ignore
+filePath, commitHash, projectRoot, analyzeFile) {
+    const relPath = path.relative(projectRoot, filePath).replace(/\\/g, '/');
+    const blob = execGit(`git show ${commitHash}:${relPath}`, projectRoot);
+    const tmpFile = path.join(os.tmpdir(), `drift-${crypto.randomBytes(8).toString('hex')}.ts`);
+    try {
+        fs.writeFileSync(tmpFile, blob, 'utf8');
+        const report = analyzeFilePath(tmpFile, analyzeFile);
+        // Replace temp path with original for readable output
+        return { ...report, path: filePath };
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* ignore cleanup errors */ } // drift-ignore
+    }
+}
+/**
+ * Analyse ALL TypeScript files in the project snapshot at a given commit.
+ * Uses `git ls-tree` to enumerate every file in the tree, writes them to a
+ * temp directory, then runs `analyzeProject` on that full snapshot.
+ */
+export async function analyzeSingleCommit(// drift-ignore
+commitHash, targetPath, analyzeProject, config) {
+    // 1. Commit metadata
+    const meta = execGit(`git show --no-patch --format="%H|%aI|%an|%s" ${commitHash}`, targetPath);
+    const [hash, dateStr, author, ...msgParts] = meta.split('|');
+    const message = msgParts.join('|').trim();
+    const commitDate = new Date(dateStr ?? '');
+    // 2. All .ts/.tsx files tracked at this commit (no diffs, full tree)
+    const allFiles = execGit(`git ls-tree -r ${commitHash} --name-only`, targetPath)
+        .split('\n')
+        .filter(f => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) &&
+        !f.endsWith('.d.ts') &&
+        !f.includes('node_modules') &&
+        !f.startsWith('dist/'));
+    if (allFiles.length === 0) {
+        return {
+            commitHash: hash ?? commitHash,
+            commitDate,
+            author: author ?? '',
+            message,
+            files: [],
+            totalScore: 0,
+            averageScore: 0,
+        };
+    }
+    // 3. Write snapshot to temp directory
+    const tmpDir = path.join(os.tmpdir(), `drift-${(hash ?? commitHash).slice(0, 8)}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+    for (const relPath of allFiles) {
+        try {
+            const content = execGit(`git show ${commitHash}:${relPath}`, targetPath);
+            const destPath = path.join(tmpDir, relPath);
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.writeFileSync(destPath, content, 'utf-8');
+        }
+        catch { // drift-ignore
+            // skip files that can't be read (binary, deleted in partial clone, etc.)
+        }
+    }
+    // 4. Analyse the full project snapshot
+    const fileReports = analyzeProject(tmpDir, config);
+    const totalScore = fileReports.reduce((sum, r) => sum + r.score, 0);
+    const averageScore = fileReports.length > 0 ? totalScore / fileReports.length : 0;
+    // 5. Cleanup
+    try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    catch { // drift-ignore
+        // non-fatal — temp dirs are cleaned by the OS eventually
+    }
+    return {
+        commitHash: hash ?? commitHash,
+        commitDate,
+        author: author ?? '',
+        message,
+        files: fileReports,
+        totalScore,
+        averageScore,
+    };
+}
+/**
+ * Run historical analysis over all commits since a given date.
+ * Returns results ordered chronologically (oldest first).
+ */
+export async function analyzeHistoricalCommits(sinceDate, targetPath, maxCommits, analyzeProject, config, maxSamples = 10) {
+    assertGitRepo(targetPath);
+    const isoDate = sinceDate.toISOString();
+    const raw = execGit(`git log --since="${isoDate}" --format="%H" --max-count=${maxCommits}`, targetPath);
+    if (!raw)
+        return [];
+    const hashes = raw.split('\n').filter(Boolean);
+    // Sample: distribute evenly across the range
+    const sampled = hashes.length <= maxSamples
+        ? hashes
+        : Array.from({ length: maxSamples }, (_, i) => hashes[Math.floor(i * (hashes.length - 1) / (maxSamples - 1))]);
+    const analyses = await Promise.all(sampled.map(h => analyzeSingleCommit(h, targetPath, analyzeProject, config).catch(() => null)));
+    return analyses
+        .filter((a) => a !== null)
+        .sort((a, b) => a.commitDate.getTime() - b.commitDate.getTime());
+}
+//# sourceMappingURL=helpers.js.map