@eduardbar/drift 1.0.0 → 1.1.0

package/dist/rules/phase2-crossfile.js

@@ -1,5 +1,9 @@
+// drift-ignore-file
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+const SNIPPET_LENGTH = 80;
+// drift-ignore
+const BIN_DIR = '/bin/';
 /**
  * Detect files that are never imported by any other file in the project.
  * Entry-point files (index, main, cli, app, bin/) are excluded.
@@ -9,7 +13,7 @@ export function detectDeadFiles(sourceFiles, allImportedPaths, ruleWeights) {
     for (const sf of sourceFiles) {
         const sfPath = sf.getFilePath();
         const basename = path.basename(sfPath);
-        const isBinFile = sfPath.replace(/\\/g, '/').includes('/bin/');
+        const isBinFile = sfPath.replace(/\\/g, '/').includes(BIN_DIR);
         const isEntryPoint = /^(index|main|cli|app)\.(ts|tsx|js|jsx)$/.test(basename) || isBinFile;
         if (!isEntryPoint && !allImportedPaths.has(sfPath)) {
             issues.set(sfPath, {
@@ -28,6 +32,49 @@ export function detectDeadFiles(sourceFiles, allImportedPaths, ruleWeights) {
  * Detect named exports that are never imported by any other file.
  * Barrel files (index.*) are excluded since their entire surface is the public API.
  */
+function checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights) {
+    const issues = [];
+    for (const exportDecl of sf.getExportDeclarations()) {
+        for (const namedExport of exportDecl.getNamedExports()) {
+            const name = namedExport.getName();
+            if (!importedNamesForFile?.has(name)) {
+                issues.push({
+                    rule: 'unused-export',
+                    severity: ruleWeights['unused-export'].severity,
+                    message: `'${name}' is exported but never imported`,
+                    line: namedExport.getStartLineNumber(),
+                    column: 1,
+                    snippet: namedExport.getText().slice(0, SNIPPET_LENGTH),
+                });
+            }
+        }
+    }
+    return issues;
+}
+function checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights) {
+    const issues = [];
+    for (const exportSymbol of sf.getExportedDeclarations()) {
+        const [exportName, declarations] = [exportSymbol[0], exportSymbol[1]];
+        if (exportName === 'default')
+            continue;
+        if (importedNamesForFile?.has(exportName))
+            continue;
+        for (const decl of declarations) {
+            if (decl.getSourceFile().getFilePath() !== sfPath)
+                continue;
+            issues.push({
+                rule: 'unused-export',
+                severity: ruleWeights['unused-export'].severity,
+                message: `'${exportName}' is exported but never imported`,
+                line: decl.getStartLineNumber(),
+                column: 1,
+                snippet: decl.getText().split('\n')[0].slice(0, SNIPPET_LENGTH),
+            });
+            break;
+        }
+    }
+    return issues;
+}
 export function detectUnusedExports(sourceFiles, allImportedNames, ruleWeights) {
     const result = new Map();
     for (const sf of sourceFiles) {
@@ -38,44 +85,10 @@ export function detectUnusedExports(sourceFiles, allImportedNames, ruleWeights)
         const hasNamespaceImport = importedNamesForFile?.has('*') ?? false;
         if (isBarrel || hasNamespaceImport)
             continue;
-        const issues = [];
-        for (const exportDecl of sf.getExportDeclarations()) {
-            for (const namedExport of exportDecl.getNamedExports()) {
-                const name = namedExport.getName();
-                if (!importedNamesForFile?.has(name)) {
-                    issues.push({
-                        rule: 'unused-export',
-                        severity: ruleWeights['unused-export'].severity,
-                        message: `'${name}' is exported but never imported`,
-                        line: namedExport.getStartLineNumber(),
-                        column: 1,
-                        snippet: namedExport.getText().slice(0, 80),
-                    });
-                }
-            }
-        }
-        // Also check inline export declarations (export function foo, export const bar)
-        for (const exportSymbol of sf.getExportedDeclarations()) {
-            const [exportName, declarations] = [exportSymbol[0], exportSymbol[1]];
-            if (exportName === 'default')
-                continue;
-            if (importedNamesForFile?.has(exportName))
-                continue;
-            for (const decl of declarations) {
-                // Skip if this is a re-export from another file
-                if (decl.getSourceFile().getFilePath() !== sfPath)
-                    continue;
-                issues.push({
-                    rule: 'unused-export',
-                    severity: ruleWeights['unused-export'].severity,
-                    message: `'${exportName}' is exported but never imported`,
-                    line: decl.getStartLineNumber(),
-                    column: 1,
-                    snippet: decl.getText().split('\n')[0].slice(0, 80),
-                });
-                break; // one issue per export name is enough
-            }
-        }
+        const issues = [
+            ...checkExportDeclarations(sf, sfPath, importedNamesForFile, ruleWeights),
+            ...checkInlineExports(sf, sfPath, importedNamesForFile, ruleWeights),
+        ];
         if (issues.length > 0) {
             result.set(sfPath, issues);
         }

package/dist/rules/phase3-arch.d.ts

@@ -12,18 +12,10 @@ export declare function detectCircularDependencies(importGraph: Map<string, Set<
     severity: DriftIssue['severity'];
     weight: number;
 }>): Map<string, DriftIssue>;
-/**
- * Detect layer violations based on user-defined layer configuration.
- * Returns a map of filePath → issues[].
- */
 export declare function detectLayerViolations(importGraph: Map<string, Set<string>>, layers: LayerDefinition[], targetPath: string, ruleWeights: Record<string, {
     severity: DriftIssue['severity'];
     weight: number;
 }>): Map<string, DriftIssue[]>;
-/**
- * Detect cross-boundary imports based on user-defined module boundary configuration.
- * Returns a map of filePath → issues[].
- */
 export declare function detectCrossBoundaryImports(importGraph: Map<string, Set<string>>, modules: ModuleBoundary[], targetPath: string, ruleWeights: Record<string, {
     severity: DriftIssue['severity'];
     weight: number;

package/dist/rules/phase3-arch.js

@@ -1,3 +1,4 @@
+// drift-ignore-file
 import * as path from 'node:path';
 /**
  * DFS cycle detection in a directed import graph.
@@ -66,26 +67,26 @@ export function detectCircularDependencies(importGraph, ruleWeights) {
  * Detect layer violations based on user-defined layer configuration.
  * Returns a map of filePath → issues[].
  */
+function matchLayer(filePath, layers) {
+    const rel = filePath.replace(/\\/g, '/');
+    return layers.find(layer => layer.patterns.some(pattern => {
+        const regexStr = pattern
+            .replace(/\\/g, '/')
+            .replace(/[.+^${}()|[\]]/g, '\\$&')
+            .replace(/\*\*/g, '###DOUBLESTAR###')
+            .replace(/\*/g, '[^/]*')
+            .replace(/###DOUBLESTAR###/g, '.*');
+        return new RegExp(`^${regexStr}`).test(rel);
+    }));
+}
 export function detectLayerViolations(importGraph, layers, targetPath, ruleWeights) {
     const result = new Map();
-    function getLayer(filePath) {
-        const rel = filePath.replace(/\\/g, '/');
-        return layers.find(layer => layer.patterns.some(pattern => {
-            const regexStr = pattern
-                .replace(/\\/g, '/')
-                .replace(/[.+^${}()|[\]]/g, '\\$&')
-                .replace(/\*\*/g, '###DOUBLESTAR###')
-                .replace(/\*/g, '[^/]*')
-                .replace(/###DOUBLESTAR###/g, '.*');
-            return new RegExp(`^${regexStr}`).test(rel);
-        }));
-    }
     for (const [filePath, imports] of importGraph.entries()) {
-        const fileLayer = getLayer(filePath);
+        const fileLayer = matchLayer(filePath, layers);
         if (!fileLayer)
             continue;
         for (const importedPath of imports) {
-            const importedLayer = getLayer(importedPath);
+            const importedLayer = matchLayer(importedPath, layers);
             if (!importedLayer)
                 continue;
             if (importedLayer.name === fileLayer.name)
@@ -110,26 +111,28 @@ export function detectLayerViolations(importGraph, layers, targetPath, ruleWeigh
  * Detect cross-boundary imports based on user-defined module boundary configuration.
  * Returns a map of filePath → issues[].
  */
+function matchModule(filePath, modules) {
+    const rel = filePath.replace(/\\/g, '/');
+    return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')));
+}
+function isAllowedImport(importedPath, allowedImports) {
+    const relImported = importedPath.replace(/\\/g, '/');
+    return allowedImports.some(allowed => relImported.startsWith(allowed.replace(/\\/g, '/')));
+}
 export function detectCrossBoundaryImports(importGraph, modules, targetPath, ruleWeights) {
     const result = new Map();
-    function getModule(filePath) {
-        const rel = filePath.replace(/\\/g, '/');
-        return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')));
-    }
     for (const [filePath, imports] of importGraph.entries()) {
-        const fileModule = getModule(filePath);
+        const fileModule = matchModule(filePath, modules);
         if (!fileModule)
             continue;
         for (const importedPath of imports) {
-            const importedModule = getModule(importedPath);
+            const importedModule = matchModule(importedPath, modules);
             if (!importedModule)
                 continue;
             if (importedModule.name === fileModule.name)
                 continue;
             const allowedImports = fileModule.allowedExternalImports ?? [];
-            const relImported = importedPath.replace(/\\/g, '/');
-            const isAllowed = allowedImports.some(allowed => relImported.startsWith(allowed.replace(/\\/g, '/')));
-            if (!isAllowed) {
+            if (!isAllowedImport(importedPath, allowedImports)) {
                 if (!result.has(filePath))
                     result.set(filePath, []);
                 result.get(filePath).push({

package/dist/rules/phase3-configurable.d.ts

@@ -0,0 +1,6 @@
+import { type SourceFile } from 'ts-morph';
+import type { DriftConfig, DriftIssue } from '../types.js';
+export declare function detectControllerNoDb(file: SourceFile, config?: DriftConfig): DriftIssue[];
+export declare function detectServiceNoHttp(file: SourceFile, config?: DriftConfig): DriftIssue[];
+export declare function detectMaxFunctionLines(file: SourceFile, config?: DriftConfig): DriftIssue[];
+//# sourceMappingURL=phase3-configurable.d.ts.map

package/dist/rules/phase3-configurable.js

@@ -0,0 +1,97 @@
+import { SyntaxKind } from 'ts-morph';
+const DB_IMPORT_PATTERNS = [
+    /\bprisma\b/i,
+    /\btypeorm\b/i,
+    /\bsequelize\b/i,
+    /\bmongoose\b/i,
+    /\bknex\b/i,
+    /\brepository\b/i,
+    /\/db\//i,
+    /\/database\//i,
+];
+const HTTP_IMPORT_PATTERNS = [
+    /\bexpress\b/i,
+    /\bfastify\b/i,
+    /\bkoa\b/i,
+    /\bhono\b/i,
+    /^http$/i,
+    /^https$/i,
+];
+function isControllerFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+    return normalized.includes('/controller/') || normalized.includes('/controllers/') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js');
+}
+function isServiceFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+    return normalized.includes('/service/') || normalized.includes('/services/') || normalized.endsWith('service.ts') || normalized.endsWith('service.js');
+}
+function createIssue(rule, message, line, snippet) {
+    return {
+        rule,
+        severity: 'warning',
+        message,
+        line,
+        column: 1,
+        snippet,
+    };
+}
+export function detectControllerNoDb(file, config) {
+    if (!config?.architectureRules?.controllerNoDb)
+        return [];
+    if (!isControllerFile(file.getFilePath()))
+        return [];
+    const issues = [];
+    for (const decl of file.getImportDeclarations()) {
+        const value = decl.getModuleSpecifierValue();
+        if (DB_IMPORT_PATTERNS.some((pattern) => pattern.test(value))) {
+            issues.push(createIssue('controller-no-db', `Controller imports database module '${value}'. Controllers should delegate persistence through services.`, decl.getStartLineNumber(), value));
+        }
+    }
+    return issues;
+}
+export function detectServiceNoHttp(file, config) {
+    if (!config?.architectureRules?.serviceNoHttp)
+        return [];
+    if (!isServiceFile(file.getFilePath()))
+        return [];
+    const issues = [];
+    for (const decl of file.getImportDeclarations()) {
+        const value = decl.getModuleSpecifierValue();
+        if (HTTP_IMPORT_PATTERNS.some((pattern) => pattern.test(value))) {
+            issues.push(createIssue('service-no-http', `Service imports HTTP framework '${value}'. Keep transport concerns outside service layer.`, decl.getStartLineNumber(), value));
+        }
+    }
+    for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expressionText = call.getExpression().getText();
+        if (/\bfetch\b/.test(expressionText)) {
+            issues.push(createIssue('service-no-http', 'Service executes HTTP call directly (fetch). Move this to an adapter/client.', call.getStartLineNumber(), expressionText));
+        }
+    }
+    return issues;
+}
+export function detectMaxFunctionLines(file, config) {
+    const maxLines = config?.architectureRules?.maxFunctionLines;
+    if (!maxLines || maxLines <= 0)
+        return [];
+    const issues = [];
+    for (const fn of file.getFunctions()) {
+        const body = fn.getBody();
+        if (!body)
+            continue;
+        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
+        if (lines > maxLines) {
+            issues.push(createIssue('max-function-lines', `Function '${fn.getName() ?? '(anonymous)'}' has ${lines} lines (max: ${maxLines}).`, fn.getStartLineNumber(), fn.getName() ?? '(anonymous)'));
+        }
+    }
+    for (const method of file.getDescendantsOfKind(SyntaxKind.MethodDeclaration)) {
+        const body = method.getBody();
+        if (!body)
+            continue;
+        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
+        if (lines > maxLines) {
+            issues.push(createIssue('max-function-lines', `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`, method.getStartLineNumber(), method.getName()));
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=phase3-configurable.js.map

package/dist/rules/phase8-semantic.d.ts

@@ -1,11 +1,6 @@
 import { SourceFile, FunctionDeclaration, ArrowFunction, FunctionExpression, MethodDeclaration } from 'ts-morph';
 import type { DriftIssue } from '../types.js';
 export type FunctionLikeNode = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
-/** 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.
- */
 export declare function normalizeFunctionBody(fn: FunctionLikeNode): string;
 /** Return a SHA-256 fingerprint for a function body (normalized). */
 export declare function fingerprintFunction(fn: FunctionLikeNode): string;

package/dist/rules/phase8-semantic.js

@@ -1,3 +1,4 @@
+// drift-ignore-file
 import * as crypto from 'node:crypto';
 import { SyntaxKind, } from 'ts-morph';
 /** Normalize a function body to a canonical string (Type-2 clone detection).
@@ -5,21 +6,17 @@ import { SyntaxKind, } from 'ts-morph';
  *  with canonical tokens so that two functions with identical logic but
  *  different identifiers produce the same fingerprint.
  */
-export function normalizeFunctionBody(fn) {
-    // Build a substitution map: localName → canonical token
+function buildSubstitutionMap(fn) {
     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))
@@ -27,35 +24,39 @@ export function normalizeFunctionBody(fn) {
             }
         }
     });
-    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';
+    return subst;
+}
+function serializeNode(node, subst) {
+    const kind = node.getKindName();
+    switch (node.getKind()) {
+        case SyntaxKind.Identifier: {
+            const text = node.getText();
+            return subst.get(text) ?? text;
         }
-        const children = node.getChildren();
-        if (children.length === 0)
-            return kind;
-        const childStr = children.map(serializeNode).join('|');
-        return `${kind}(${childStr})`;
+        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(c => serializeNode(c, subst)).join('|');
+    return `${kind}(${childStr})`;
+}
+export function normalizeFunctionBody(fn) {
+    const subst = buildSubstitutionMap(fn);
     const body = fn.getBody();
     if (!body)
         return '';
-    return serializeNode(body);
+    return serializeNode(body, subst);
 }
 /** Return a SHA-256 fingerprint for a function body (normalized). */
 export function fingerprintFunction(fn) {

package/dist/rules/promise.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+import type { DriftIssue } from '../types.js';
+export declare function detectPromiseStyleMix(file: SourceFile): DriftIssue[];
+//# sourceMappingURL=promise.d.ts.map

package/dist/rules/promise.js

@@ -0,0 +1,24 @@
+import { SyntaxKind } from 'ts-morph';
+export function detectPromiseStyleMix(file) {
+    const text = file.getFullText();
+    const hasThen = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).some((node) => {
+        const name = node.getName();
+        return name === 'then' || name === 'catch';
+    });
+    const hasAsync = file.getDescendantsOfKind(SyntaxKind.AsyncKeyword).length > 0 ||
+        /\bawait\b/.test(text);
+    if (hasThen && hasAsync) {
+        return [
+            {
+                rule: 'promise-style-mix',
+                severity: 'warning',
+                message: `File mixes async/await with .then()/.catch(). AI generates both styles without picking one.`,
+                line: 1,
+                column: 1,
+                snippet: `// mixed promise styles detected`,
+            },
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=promise.js.map

package/dist/snapshot.d.ts

@@ -0,0 +1,19 @@
+import type { DriftReport } from './types.js';
+export interface SnapshotEntry {
+    timestamp: string;
+    label: string;
+    score: number;
+    grade: string;
+    totalIssues: number;
+    files: number;
+    byRule: Record<string, number>;
+}
+export interface SnapshotHistory {
+    project: string;
+    snapshots: SnapshotEntry[];
+}
+export declare function loadHistory(targetPath: string): SnapshotHistory;
+export declare function saveSnapshot(targetPath: string, report: DriftReport, label?: string): SnapshotEntry;
+export declare function printHistory(history: SnapshotHistory): void;
+export declare function printSnapshotDiff(history: SnapshotHistory, currentScore: number): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/snapshot.js

@@ -0,0 +1,119 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import kleur from 'kleur';
+import { scoreToGradeText } from './utils.js';
+const HISTORY_FILE = 'drift-history.json';
+const HEADER_PAD = {
+    INDEX: 4,
+    DATE: 26,
+    LABEL: 20,
+    SCORE: 8,
+    GRADE: 12,
+    ISSUES: 8,
+    DELTA: 6,
+};
+const GRADE_THRESHOLDS = {
+    LOW: 20,
+    MODERATE: 45,
+    HIGH: 70,
+};
+export function loadHistory(targetPath) {
+    const filePath = path.join(targetPath, HISTORY_FILE);
+    if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    return { project: targetPath, snapshots: [] };
+}
+export function saveSnapshot(targetPath, report, label) {
+    const history = loadHistory(targetPath);
+    const entry = {
+        timestamp: new Date().toISOString(),
+        label: label ?? '',
+        score: report.totalScore,
+        grade: scoreToGradeText(report.totalScore).label.toUpperCase(),
+        totalIssues: report.totalIssues,
+        files: report.totalFiles,
+        byRule: { ...report.summary.byRule },
+    };
+    history.snapshots.push(entry);
+    const filePath = path.join(targetPath, HISTORY_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(history, null, 2), 'utf8');
+    return entry;
+}
+function formatDelta(current, prev) {
+    if (!prev)
+        return '—';
+    const delta = current.score - prev.score;
+    if (delta > 0)
+        return kleur.red(`+${delta}`);
+    if (delta < 0)
+        return kleur.green(String(delta));
+    return kleur.gray('0');
+}
+export function printHistory(history) {
+    const { snapshots } = history;
+    if (snapshots.length === 0) {
+        process.stdout.write('\n  No snapshots recorded yet.\n\n');
+        return;
+    }
+    process.stdout.write('\n');
+    process.stdout.write(kleur.bold(`  ${'#'.padEnd(HEADER_PAD.INDEX)} ${'Date'.padEnd(HEADER_PAD.DATE)} ${'Label'.padEnd(HEADER_PAD.LABEL)} ${'Score'.padEnd(HEADER_PAD.SCORE)} ${'Grade'.padEnd(HEADER_PAD.GRADE)} ${'Issues'.padEnd(HEADER_PAD.ISSUES)} ${'Delta'}\n`));
+    process.stdout.write(`  ${'─'.repeat(HEADER_PAD.INDEX)} ${'─'.repeat(HEADER_PAD.DATE)} ${'─'.repeat(HEADER_PAD.LABEL)} ${'─'.repeat(HEADER_PAD.SCORE)} ${'─'.repeat(HEADER_PAD.GRADE)} ${'─'.repeat(HEADER_PAD.ISSUES)} ${'─'.repeat(HEADER_PAD.DELTA)}\n`);
+    for (let i = 0; i < snapshots.length; i++) {
+        const s = snapshots[i];
+        const date = new Date(s.timestamp).toLocaleString('en-US', {
+            year: 'numeric',
+            month: 'short',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+        const deltaStr = formatDelta(s, i > 0 ? snapshots[i - 1] : null);
+        const gradeColored = colorGrade(s.grade, s.score);
+        process.stdout.write(`  ${String(i + 1).padEnd(HEADER_PAD.INDEX)} ${date.padEnd(HEADER_PAD.DATE)} ${(s.label || '—').padEnd(HEADER_PAD.LABEL)} ${String(s.score).padEnd(HEADER_PAD.SCORE)} ${gradeColored.padEnd(HEADER_PAD.GRADE)} ${String(s.totalIssues).padEnd(HEADER_PAD.ISSUES)} ${deltaStr}\n`);
+    }
+    process.stdout.write('\n');
+}
+export function printSnapshotDiff(history, currentScore) {
+    const { snapshots } = history;
+    if (snapshots.length === 0) {
+        process.stdout.write('\n  No previous snapshot to compare against.\n\n');
+        return;
+    }
+    const last = snapshots[snapshots.length - 1];
+    const delta = currentScore - last.score;
+    const lastDate = new Date(last.timestamp).toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+    const lastLabel = last.label ? ` (${last.label})` : '';
+    process.stdout.write('\n');
+    process.stdout.write(`  Last snapshot: ${kleur.bold(lastDate)}${lastLabel} — score ${kleur.bold(String(last.score))}\n`);
+    process.stdout.write(`  Current score: ${kleur.bold(String(currentScore))}\n`);
+    process.stdout.write('\n');
+    if (delta > 0) {
+        process.stdout.write(`  Delta: ${kleur.bold().red(`+${delta}`)} — technical debt increased\n`);
+    }
+    else if (delta < 0) {
+        process.stdout.write(`  Delta: ${kleur.bold().green(String(delta))} — technical debt decreased\n`);
+    }
+    else {
+        process.stdout.write(`  Delta: ${kleur.gray('0')} — no change since last snapshot\n`);
+    }
+    process.stdout.write('\n');
+}
+function colorGrade(grade, score) {
+    if (score === 0)
+        return kleur.green(grade);
+    if (score < GRADE_THRESHOLDS.LOW)
+        return kleur.green(grade);
+    if (score < GRADE_THRESHOLDS.MODERATE)
+        return kleur.yellow(grade);
+    if (score < GRADE_THRESHOLDS.HIGH)
+        return kleur.red(grade);
+    return kleur.bold().red(grade);
+}
+//# sourceMappingURL=snapshot.js.map