@eduardbar/drift 0.9.1 → 1.1.0

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

package/dist/git/trend.d.ts

@@ -0,0 +1,21 @@
+import type { FileReport, DriftConfig, TrendDataPoint, DriftTrendReport } from '../types.js';
+export declare class TrendAnalyzer {
+    private readonly projectPath;
+    private readonly config;
+    private readonly analyzeProjectFn;
+    constructor(projectPath: string, analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[], config?: DriftConfig);
+    static calculateMovingAverage(data: TrendDataPoint[], windowSize: number): number[];
+    static linearRegression(data: TrendDataPoint[]): {
+        slope: number;
+        intercept: number;
+        r2: number;
+    };
+    /** Generate a simple horizontal ASCII bar chart (one bar per data point). */
+    static generateTrendChart(data: TrendDataPoint[]): string;
+    analyzeTrend(options: {
+        period?: 'week' | 'month' | 'quarter' | 'year';
+        since?: string;
+        until?: string;
+    }): Promise<DriftTrendReport>;
+}
+//# sourceMappingURL=trend.d.ts.map

package/dist/git/trend.js

@@ -0,0 +1,81 @@
+// drift-ignore-file
+import { assertGitRepo, analyzeHistoricalCommits } from './helpers.js';
+import { buildReport } from '../reporter.js';
+export class TrendAnalyzer {
+    projectPath;
+    config;
+    analyzeProjectFn;
+    constructor(projectPath, analyzeProjectFn, config) {
+        this.projectPath = projectPath;
+        this.analyzeProjectFn = analyzeProjectFn;
+        this.config = config;
+    }
+    // --- Static utility methods -----------------------------------------------
+    static calculateMovingAverage(data, windowSize) {
+        return data.map((_, i) => {
+            const start = Math.max(0, i - windowSize + 1);
+            const window = data.slice(start, i + 1);
+            return window.reduce((s, p) => s + p.score, 0) / window.length;
+        });
+    }
+    static linearRegression(data) {
+        const n = data.length;
+        if (n < 2)
+            return { slope: 0, intercept: data[0]?.score ?? 0, r2: 0 };
+        const xs = data.map((_, i) => i);
+        const ys = data.map(p => p.score);
+        const xMean = xs.reduce((s, x) => s + x, 0) / n;
+        const yMean = ys.reduce((s, y) => s + y, 0) / n;
+        const ssXX = xs.reduce((s, x) => s + (x - xMean) ** 2, 0);
+        const ssXY = xs.reduce((s, x, i) => s + (x - xMean) * (ys[i] - yMean), 0);
+        const ssYY = ys.reduce((s, y) => s + (y - yMean) ** 2, 0);
+        const slope = ssXX === 0 ? 0 : ssXY / ssXX;
+        const intercept = yMean - slope * xMean;
+        const r2 = ssYY === 0 ? 1 : (ssXY ** 2) / (ssXX * ssYY);
+        return { slope, intercept, r2 };
+    }
+    /** Generate a simple horizontal ASCII bar chart (one bar per data point). */
+    static generateTrendChart(data) {
+        if (data.length === 0)
+            return '(no data)';
+        const maxScore = Math.max(...data.map(p => p.score), 1);
+        const chartWidth = 40;
+        const lines = data.map(p => {
+            const barLen = Math.round((p.score / maxScore) * chartWidth);
+            const bar = '█'.repeat(barLen);
+            const dateStr = p.date.toISOString().slice(0, 10);
+            return `${dateStr} │${bar.padEnd(chartWidth)} ${p.score.toFixed(1)}`;
+        });
+        return lines.join('\n');
+    }
+    // --- Instance method -------------------------------------------------------
+    async analyzeTrend(options) {
+        assertGitRepo(this.projectPath);
+        const periodDays = {
+            week: 7, month: 30, quarter: 90, year: 365,
+        };
+        const days = periodDays[options.period ?? 'month'] ?? 30;
+        const sinceDate = options.since
+            ? new Date(options.since)
+            : new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const historicalAnalyses = await analyzeHistoricalCommits(sinceDate, this.projectPath, 100, this.analyzeProjectFn, this.config, 10);
+        const trendPoints = historicalAnalyses.map(h => ({
+            date: h.commitDate,
+            score: h.averageScore,
+            fileCount: h.files.length,
+            avgIssuesPerFile: h.files.length > 0
+                ? h.files.reduce((s, f) => s + f.issues.length, 0) / h.files.length
+                : 0,
+        }));
+        const regression = TrendAnalyzer.linearRegression(trendPoints);
+        // Current state report
+        const currentFiles = this.analyzeProjectFn(this.projectPath, this.config);
+        const baseReport = buildReport(this.projectPath, currentFiles);
+        return {
+            ...baseReport,
+            trend: trendPoints,
+            regression,
+        };
+    }
+}
+//# sourceMappingURL=trend.js.map

package/dist/git.d.ts

@@ -1,19 +1,6 @@
-/**
- * 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.
  */
 export declare function cleanupTempDir(tempDir: string): void;
-/**
- * Get the short hash of a git ref for display purposes.
- */
-export declare function resolveRefHash(projectPath: string, ref: string): string;
 //# sourceMappingURL=git.d.ts.map

package/dist/git.js

@@ -12,22 +12,23 @@ import { randomUUID } from 'node:crypto';
  *
  * Throws if the directory is not a git repo or the ref is invalid.
  */
-export function extractFilesAtRef(projectPath, ref) {
-    // Verify git repo
+function verifyGitRepo(projectPath) {
     try {
         execSync('git rev-parse --git-dir', { cwd: projectPath, stdio: 'pipe' });
     }
     catch {
         throw new Error(`Not a git repository: ${projectPath}`);
     }
-    // Verify ref exists
+}
+function verifyRefExists(projectPath, ref) {
     try {
         execSync(`git rev-parse --verify ${ref}`, { cwd: projectPath, stdio: 'pipe' });
     }
     catch {
         throw new Error(`Invalid git ref: '${ref}'. Run 'git log --oneline' to see available commits.`);
     }
-    // List all .ts files tracked at this ref (excluding .d.ts)
+}
+function listTsFilesAtRef(projectPath, ref) {
     let fileList;
     try {
         fileList = execSync(`git ls-tree -r --name-only ${ref}`, { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' });
@@ -35,30 +36,35 @@ export function extractFilesAtRef(projectPath, ref) {
     catch {
         throw new Error(`Failed to list files at ref '${ref}'`);
     }
-    const tsFiles = fileList
+    return fileList
         .split('\n')
         .map(f => f.trim())
-        .filter(f => f.endsWith('.ts') && !f.endsWith('.d.ts'));
+        .filter(f => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.endsWith('.d.ts'));
+}
+function extractFile(projectPath, ref, filePath, tempDir) {
+    let content;
+    try {
+        content = execSync(`git show ${ref}:${filePath}`, { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' });
+    }
+    catch {
+        return;
+    }
+    const destPath = join(tempDir, filePath.split('/').join(sep));
+    const destDir = destPath.substring(0, destPath.lastIndexOf(sep));
+    mkdirSync(destDir, { recursive: true });
+    writeFileSync(destPath, content, 'utf-8');
+}
+export function extractFilesAtRef(projectPath, ref) {
+    verifyGitRepo(projectPath);
+    verifyRefExists(projectPath, ref);
+    const tsFiles = listTsFilesAtRef(projectPath, ref);
     if (tsFiles.length === 0) {
         throw new Error(`No TypeScript files found at ref '${ref}'`);
     }
-    // Create temp directory
     const tempDir = join(tmpdir(), `drift-diff-${randomUUID()}`);
     mkdirSync(tempDir, { recursive: true });
-    // Extract each file
     for (const filePath of tsFiles) {
-        let content;
-        try {
-            content = execSync(`git show ${ref}:${filePath}`, { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' });
-        }
-        catch {
-            // File may not exist at this ref — skip
-            continue;
-        }
-        const destPath = join(tempDir, filePath.split('/').join(sep));
-        const destDir = destPath.substring(0, destPath.lastIndexOf(sep));
-        mkdirSync(destDir, { recursive: true });
-        writeFileSync(destPath, content, 'utf-8');
+        extractFile(projectPath, ref, filePath, tempDir);
     }
     return tempDir;
 }
@@ -73,7 +79,7 @@ export function cleanupTempDir(tempDir) {
 /**
  * Get the short hash of a git ref for display purposes.
  */
-export function resolveRefHash(projectPath, ref) {
+function resolveRefHash(projectPath, ref) {
     try {
         return execSync(`git rev-parse --short ${ref}`, { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' }).trim();
     }

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js';
 export { buildReport, formatMarkdown } from './reporter.js';
 export { computeDiff } from './diff.js';
-export type { DriftReport, FileReport, DriftIssue, DriftDiff, FileDiff, DriftConfig } from './types.js';
+export { generateReview, formatReviewMarkdown } from './review.js';
+export { generateArchitectureMap, generateArchitectureSvg } from './map.js';
+export type { DriftReport, FileReport, DriftIssue, DriftDiff, FileDiff, DriftConfig, RepoQualityScore, MaintenanceRiskMetrics, DriftPlugin, DriftPluginRule, } from './types.js';
+export { loadHistory, saveSnapshot } from './snapshot.js';
+export type { SnapshotEntry, SnapshotHistory } from './snapshot.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,7 @@
 export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js';
 export { buildReport, formatMarkdown } from './reporter.js';
 export { computeDiff } from './diff.js';
+export { generateReview, formatReviewMarkdown } from './review.js';
+export { generateArchitectureMap, generateArchitectureSvg } from './map.js';
+export { loadHistory, saveSnapshot } from './snapshot.js';
 //# sourceMappingURL=index.js.map

package/dist/map.d.ts

@@ -0,0 +1,3 @@
+export declare function generateArchitectureSvg(targetPath: string): string;
+export declare function generateArchitectureMap(targetPath: string, outputFile?: string): string;
+//# sourceMappingURL=map.d.ts.map