@eduardbar/drift 0.7.0 → 0.9.0

package/dist/analyzer.js

@@ -1,6 +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 },
@@ -34,6 +38,8 @@ export const RULE_WEIGHTS = {
     'inconsistent-error-handling': { severity: 'warning', weight: 8 },
     'unnecessary-abstraction': { severity: 'warning', weight: 7 },
     'naming-inconsistency': { severity: 'warning', weight: 6 },
+    // Phase 8: semantic duplication
+    'semantic-duplication': { severity: 'warning', weight: 12 },
 };
 function hasIgnoreComment(file, line) {
     const lines = file.getFullText().split('\n');
@@ -786,6 +792,105 @@ function calculateScore(issues) {
     }
     return Math.min(100, raw);
 }
+/** Normalize a function body to a canonical string (Type-2 clone detection).
+ *  Variable names, parameter names, and numeric/string literals are replaced
+ *  with canonical tokens so that two functions with identical logic but
+ *  different identifiers produce the same fingerprint.
+ */
+function normalizeFunctionBody(fn) {
+    // Build a substitution map: localName → canonical token
+    const subst = new Map();
+    // Map parameters first
+    for (const [i, param] of fn.getParameters().entries()) {
+        const name = param.getName();
+        if (name && name !== '_')
+            subst.set(name, `P${i}`);
+    }
+    // Map locally declared variables (VariableDeclaration)
+    let varIdx = 0;
+    fn.forEachDescendant(node => {
+        if (node.getKind() === SyntaxKind.VariableDeclaration) {
+            const nameNode = node.getNameNode();
+            // Support destructuring — getNameNode() may be a BindingPattern
+            if (nameNode.getKind() === SyntaxKind.Identifier) {
+                const name = nameNode.getText();
+                if (!subst.has(name))
+                    subst.set(name, `V${varIdx++}`);
+            }
+        }
+    });
+    function serializeNode(node) {
+        const kind = node.getKindName();
+        switch (node.getKind()) {
+            case SyntaxKind.Identifier: {
+                const text = node.getText();
+                return subst.get(text) ?? text; // external refs (Math, console) kept as-is
+            }
+            case SyntaxKind.NumericLiteral:
+                return 'NL';
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+                return 'SL';
+            case SyntaxKind.TrueKeyword:
+                return 'TRUE';
+            case SyntaxKind.FalseKeyword:
+                return 'FALSE';
+            case SyntaxKind.NullKeyword:
+                return 'NULL';
+        }
+        const children = node.getChildren();
+        if (children.length === 0)
+            return kind;
+        const childStr = children.map(serializeNode).join('|');
+        return `${kind}(${childStr})`;
+    }
+    const body = fn.getBody();
+    if (!body)
+        return '';
+    return serializeNode(body);
+}
+/** Return a SHA-256 fingerprint for a function body (normalized). */
+function fingerprintFunction(fn) {
+    const normalized = normalizeFunctionBody(fn);
+    return crypto.createHash('sha256').update(normalized).digest('hex');
+}
+/** Return all function-like nodes from a SourceFile that are worth comparing:
+ *  - At least MIN_LINES lines in their body
+ *  - Not test helpers (describe/it/test/beforeEach/afterEach)
+ */
+const MIN_LINES = 8;
+function collectFunctions(sf) {
+    const results = [];
+    const kinds = [
+        SyntaxKind.FunctionDeclaration,
+        SyntaxKind.FunctionExpression,
+        SyntaxKind.ArrowFunction,
+        SyntaxKind.MethodDeclaration,
+    ];
+    for (const kind of kinds) {
+        for (const node of sf.getDescendantsOfKind(kind)) {
+            const body = node.getBody();
+            if (!body)
+                continue;
+            const start = body.getStartLineNumber();
+            const end = body.getEndLineNumber();
+            if (end - start + 1 < MIN_LINES)
+                continue;
+            // Skip test-framework helpers
+            const name = node.getKind() === SyntaxKind.FunctionDeclaration
+                ? node.getName() ?? '<anonymous>'
+                : node.getKind() === SyntaxKind.MethodDeclaration
+                    ? node.getName()
+                    : '<anonymous>';
+            if (['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'].includes(name))
+                continue;
+            const pos = node.getStart();
+            const lineInfo = sf.getLineAndColumnAtPos(pos);
+            results.push({ fn: node, name, line: lineInfo.line, col: lineInfo.column });
+        }
+    }
+    return results;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -1162,6 +1267,448 @@ export function analyzeProject(targetPath, config) {
             }
         }
     }
+    // ── Phase 8: semantic-duplication ────────────────────────────────────────
+    // Build a fingerprint → [{filePath, fnName, line, col}] map across all files
+    const fingerprintMap = new Map();
+    for (const sf of sourceFiles) {
+        const sfPath = sf.getFilePath();
+        for (const { fn, name, line, col } of collectFunctions(sf)) {
+            const fp = fingerprintFunction(fn);
+            if (!fingerprintMap.has(fp))
+                fingerprintMap.set(fp, []);
+            fingerprintMap.get(fp).push({ filePath: sfPath, name, line, col });
+        }
+    }
+    // For each fingerprint with 2+ functions: report each as a duplicate of the others
+    for (const [, entries] of fingerprintMap) {
+        if (entries.length < 2)
+            continue;
+        for (const entry of entries) {
+            const report = reportByPath.get(entry.filePath);
+            if (!report)
+                continue;
+            // Build the "duplicated in" list (all other locations)
+            const others = entries
+                .filter(e => e !== entry)
+                .map(e => {
+                const rel = path.relative(targetPath, e.filePath).replace(/\\/g, '/');
+                return `${rel}:${e.line} (${e.name})`;
+            })
+                .join(', ');
+            const weight = RULE_WEIGHTS['semantic-duplication']?.weight ?? 12;
+            report.issues.push({
+                rule: 'semantic-duplication',
+                severity: 'warning',
+                message: `Function '${entry.name}' is semantically identical to: ${others}`,
+                line: entry.line,
+                column: entry.col,
+                snippet: `function ${entry.name} — duplicated in ${entries.length - 1} other location${entries.length > 2 ? 's' : ''}`,
+            });
+            report.score = Math.min(100, report.score + weight);
+        }
+    }
     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 changed in a single commit.
+ */
+async function analyzeSingleCommit(commitHash, targetPath) {
+    // --name-only lists changed files; format gives metadata
+    const raw = execGit(`git show --name-only --format="%H|%ai|%an|%s" ${commitHash}`, targetPath);
+    const lines = raw.split('\n');
+    // First non-empty line is the metadata line
+    const metaLine = lines[0] ?? '';
+    const [hash, dateStr, author, ...msgParts] = metaLine.split('|');
+    const message = msgParts.join('|').trim();
+    const commitDate = new Date(dateStr ?? '');
+    // Collect changed .ts/.tsx files (lines after the empty separator)
+    const changedFiles = [];
+    let pastSeparator = false;
+    for (const line of lines.slice(1)) {
+        if (!pastSeparator && line.trim() === '') {
+            pastSeparator = true;
+            continue;
+        }
+        if (pastSeparator && (line.endsWith('.ts') || line.endsWith('.tsx'))) {
+            changedFiles.push(path.join(targetPath, line.trim()));
+        }
+    }
+    const fileReports = await Promise.all(changedFiles.map(f => analyzeFileAtCommit(f, hash ?? commitHash, targetPath).catch(() => null)));
+    const validReports = fileReports.filter((r) => r !== null);
+    const totalScore = validReports.reduce((s, r) => s + r.score, 0);
+    const averageScore = validReports.length > 0 ? totalScore / validReports.length : 0;
+    return {
+        commitHash: hash ?? commitHash,
+        commitDate,
+        author: author ?? '',
+        message,
+        files: validReports,
+        totalScore,
+        averageScore,
+    };
+}
+/**
+ * Run historical analysis over all commits since a given date.
+ * Returns results ordered chronologically (oldest first).
+ */
+async function analyzeHistoricalCommits(sinceDate, targetPath, maxCommits) {
+    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);
+    const analyses = await Promise.all(hashes.map(h => analyzeSingleCommit(h, targetPath).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);
+        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