@eduardbar/drift 0.8.0 → 0.9.1

package/dist/analyzer.js

@@ -1,7 +1,10 @@
 import * as fs from 'node:fs';
 import * as crypto from 'node:crypto';
 import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
 import { Project, SyntaxKind, } from 'ts-morph';
+import { buildReport } from './reporter.js';
 // Rules and their drift score weight
 export const RULE_WEIGHTS = {
     'large-file': { severity: 'error', weight: 20 },
@@ -1306,4 +1309,439 @@ export function analyzeProject(targetPath, config) {
     }
     return reports;
 }
+// ---------------------------------------------------------------------------
+// Git helpers
+// ---------------------------------------------------------------------------
+/** Analyse a file given its absolute path string (wraps analyzeFile). */
+function analyzeFilePath(filePath) {
+    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.
+ */
+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.
+ */
+function assertGitRepo(cwd) {
+    try {
+        execGit('git rev-parse --is-inside-work-tree', cwd);
+    }
+    catch {
+        throw new Error(`Directory is not a git repository: ${cwd}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Historical analysis helpers
+// ---------------------------------------------------------------------------
+/**
+ * Analyse a single file as it existed at a given commit hash.
+ * Writes the blob to a temp file, runs analyzeFile, then cleans up.
+ */
+async function analyzeFileAtCommit(filePath, commitHash, projectRoot) {
+    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);
+        // Replace temp path with original for readable output
+        return { ...report, path: filePath };
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* ignore cleanup errors */ }
+    }
+}
+/**
+ * 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 so that
+ * the resulting `averageScore` reflects the complete project health rather
+ * than only the files touched in that diff.
+ */
+async function analyzeSingleCommit(commitHash, targetPath, 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('.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 {
+            // 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 {
+        // 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).
+ */
+async function analyzeHistoricalCommits(sinceDate, targetPath, maxCommits, 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
+    // E.g. 122 commits, maxSamples=10 → pick index 0, 13, 26, 39, 52, 65, 78, 91, 104, 121
+    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, config).catch(() => null)));
+    return analyses
+        .filter((a) => a !== null)
+        .sort((a, b) => a.commitDate.getTime() - b.commitDate.getTime());
+}
+// ---------------------------------------------------------------------------
+// TrendAnalyzer
+// ---------------------------------------------------------------------------
+export class TrendAnalyzer {
+    projectPath;
+    config;
+    constructor(projectPath, config) {
+        this.projectPath = projectPath;
+        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.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 = analyzeProject(this.projectPath, this.config);
+        const baseReport = buildReport(this.projectPath, currentFiles);
+        return {
+            ...baseReport,
+            trend: trendPoints,
+            regression,
+        };
+    }
+}
+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;
+    constructor(projectPath, config) {
+        this.projectPath = projectPath;
+        this.config = config;
+    }
+    /** Blame a single file: returns per-author attribution. */
+    static async analyzeFileBlame(filePath) {
+        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);
+        // 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) {
+        assertGitRepo(targetPath);
+        const tsFiles = fs
+            .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.tsx')) && !f.includes('node_modules'))
+            .map(f => path.join(targetPath, f));
+        const combined = new Map();
+        for (const file of tsFiles) {
+            const report = analyzeFilePath(file);
+            const ruleIssues = report.issues.filter(i => i.rule === rule);
+            if (ruleIssues.length === 0)
+                continue;
+            let blameEntries = [];
+            try {
+                const blameOutput = execGit(`git blame --porcelain "${file}"`, targetPath);
+                blameEntries = parseGitBlame(blameOutput);
+            }
+            catch {
+                continue;
+            }
+            for (const issue of ruleIssues) {
+                const entry = blameEntries[issue.line - 1];
+                if (!entry)
+                    continue;
+                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,
+                    });
+                }
+                const attr = combined.get(key);
+                attr.issuesIntroduced++;
+                attr.avgScoreImpact += RULE_WEIGHTS[rule]?.weight ?? 5;
+            }
+        }
+        return Array.from(combined.values()).sort((a, b) => b.issuesIntroduced - a.issuesIntroduced);
+    }
+    /** Overall blame across all files and rules. */
+    static async analyzeOverallBlame(targetPath) {
+        assertGitRepo(targetPath);
+        const tsFiles = fs
+            .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.tsx')) && !f.includes('node_modules'))
+            .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);
+            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);
+        }
+        else if (mode === 'rule' && options.rule) {
+            blame = await BlameAnalyzer.analyzeRuleBlame(options.rule, this.projectPath);
+        }
+        else {
+            blame = await BlameAnalyzer.analyzeOverallBlame(this.projectPath);
+        }
+        if (options.top) {
+            blame = blame.slice(0, options.top);
+        }
+        const currentFiles = analyzeProject(this.projectPath, this.config);
+        const baseReport = buildReport(this.projectPath, currentFiles);
+        return { ...baseReport, blame };
+    }
+}
 //# sourceMappingURL=analyzer.js.map

package/dist/cli.js

@@ -2,6 +2,9 @@
 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 { buildReport, formatMarkdown, formatAIOutput } from './reporter.js';
 import { printConsole, printDiff } from './printer.js';
@@ -11,11 +14,12 @@ 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';
 const program = new Command();
 program
     .name('drift')
     .description('Detect silent technical debt left by AI-generated code')
-    .version('0.6.0');
+    .version(VERSION);
 program
     .command('scan [path]', { isDefault: true })
     .description('Scan a directory for vibe coding drift')
@@ -146,5 +150,39 @@ program
         process.exit(1);
     }
 });
+program
+    .command('trend [period]')
+    .description('Analyze trend of technical debt over time')
+    .option('--since <date>', 'Start date for trend analysis (ISO format)')
+    .option('--until <date>', 'End date for trend analysis (ISO format)')
+    .action(async (period, options) => {
+    const resolvedPath = resolve('.');
+    process.stderr.write(`\nAnalyzing trend in ${resolvedPath}...\n`);
+    const config = await loadConfig(resolvedPath);
+    const analyzer = new TrendAnalyzer(resolvedPath, config);
+    const trendData = await analyzer.analyzeTrend({
+        period: period,
+        since: options.since,
+        until: options.until
+    });
+    process.stderr.write(`\nTrend analysis complete:\n`);
+    process.stdout.write(JSON.stringify(trendData, null, 2) + '\n');
+});
+program
+    .command('blame [target]')
+    .description('Analyze which files/rules contribute most to technical debt')
+    .option('--top <n>', 'Number of top contributors to show (default: 10)', '10')
+    .action(async (target, options) => {
+    const resolvedPath = resolve('.');
+    process.stderr.write(`\nAnalyzing blame in ${resolvedPath}...\n`);
+    const config = await loadConfig(resolvedPath);
+    const analyzer = new BlameAnalyzer(resolvedPath, config);
+    const blameData = await analyzer.analyzeBlame({
+        target: target,
+        top: Number(options.top)
+    });
+    process.stderr.write(`\nBlame analysis complete:\n`);
+    process.stdout.write(JSON.stringify(blameData, null, 2) + '\n');
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/report.js

@@ -1,5 +1,7 @@
 import { basename } from 'node:path';
-const VERSION = '0.6.0';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require('../package.json');
 function severityColor(severity) {
     switch (severity) {
         case 'error': return '#ef4444';

package/dist/types.d.ts

@@ -95,4 +95,43 @@ export interface DriftDiff {
     newIssuesCount: number;
     resolvedIssuesCount: number;
 }
+/** Historical analysis data for a single commit */
+export interface HistoricalAnalysis {
+    commitHash: string;
+    commitDate: Date;
+    author: string;
+    message: string;
+    files: FileReport[];
+    totalScore: number;
+    averageScore: number;
+}
+/** Trend data point for score evolution */
+export interface TrendDataPoint {
+    date: Date;
+    score: number;
+    fileCount: number;
+    avgIssuesPerFile: number;
+}
+/** Blame attribution data */
+export interface BlameAttribution {
+    author: string;
+    email: string;
+    commits: number;
+    linesChanged: number;
+    issuesIntroduced: number;
+    avgScoreImpact: number;
+}
+/** Extended DriftReport with historical context */
+export interface DriftTrendReport extends DriftReport {
+    trend: TrendDataPoint[];
+    regression: {
+        slope: number;
+        intercept: number;
+        r2: number;
+    };
+}
+/** Extended DriftReport with blame data */
+export interface DriftBlameReport extends DriftReport {
+    blame: BlameAttribution[];
+}
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eduardbar/drift",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Detect silent technical debt left by AI-generated code",
   "type": "module",
   "main": "dist/index.js",