@eduardbar/drift 1.0.0 → 1.1.0

package/dist/ci.js

@@ -1,5 +1,12 @@
 import { writeFileSync } from 'node:fs';
 import { relative } from 'node:path';
+const GRADE_THRESHOLDS = {
+    A: 80,
+    B: 60,
+    C: 40,
+    D: 20,
+};
+const TOP_FILES_LIMIT = 10;
 function encodeMessage(msg) {
     return msg
         .replace(/%/g, '%25')
@@ -16,13 +23,13 @@ function severityToAnnotation(s) {
     return 'notice';
 }
 function scoreLabel(score) {
-    if (score >= 80)
+    if (score >= GRADE_THRESHOLDS.A)
         return 'A';
-    if (score >= 60)
+    if (score >= GRADE_THRESHOLDS.B)
         return 'B';
-    if (score >= 40)
+    if (score >= GRADE_THRESHOLDS.C)
         return 'C';
-    if (score >= 20)
+    if (score >= GRADE_THRESHOLDS.D)
         return 'D';
     return 'F';
 }
@@ -38,28 +45,35 @@ export function emitCIAnnotations(report) {
         }
     }
 }
+function countIssuesBySeverity(report) {
+    let errors = 0;
+    let warnings = 0;
+    let info = 0;
+    for (const file of report.files) {
+        countFileIssues(file, { errors: () => errors++, warnings: () => warnings++, info: () => info++ });
+    }
+    return { errors, warnings, info };
+}
+function countFileIssues(file, counters) {
+    for (const issue of file.issues) {
+        if (issue.severity === 'error')
+            counters.errors();
+        else if (issue.severity === 'warning')
+            counters.warnings();
+        else
+            counters.info();
+    }
+}
 export function printCISummary(report) {
     const summaryPath = process.env['GITHUB_STEP_SUMMARY'];
     if (!summaryPath)
         return;
     const score = report.totalScore;
     const grade = scoreLabel(score);
-    let errors = 0;
-    let warnings = 0;
-    let info = 0;
-    for (const file of report.files) {
-        for (const issue of file.issues) {
-            if (issue.severity === 'error')
-                errors++;
-            else if (issue.severity === 'warning')
-                warnings++;
-            else
-                info++;
-        }
-    }
+    const { errors, warnings, info } = countIssuesBySeverity(report);
     const sorted = [...report.files]
         .sort((a, b) => b.issues.length - a.issues.length)
-        .slice(0, 10);
+        .slice(0, TOP_FILES_LIMIT);
     const rows = sorted
         .map((f) => {
         const relPath = relative(process.cwd(), f.path).replace(/\\/g, '/');

package/dist/cli.js

@@ -16,6 +16,9 @@ import { generateHtmlReport } from './report.js';
 import { generateBadge } from './badge.js';
 import { emitCIAnnotations, printCISummary } from './ci.js';
 import { applyFixes } from './fix.js';
+import { loadHistory, saveSnapshot, printHistory, printSnapshotDiff } from './snapshot.js';
+import { generateReview } from './review.js';
+import { generateArchitectureMap } from './map.js';
 const program = new Command();
 program
     .name('drift')
@@ -103,6 +106,43 @@ program
             cleanupTempDir(tempDir);
     }
 });
+program
+    .command('review')
+    .description('Review drift against a base ref and output PR markdown')
+    .option('--base <ref>', 'Git base ref to compare against', 'origin/main')
+    .option('--json', 'Output structured review JSON')
+    .option('--comment', 'Output markdown comment body')
+    .option('--fail-on <n>', 'Exit with code 1 if score delta is >= n')
+    .action(async (options) => {
+    try {
+        const review = await generateReview(resolve('.'), options.base);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(review, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((options.comment ? review.markdown : `${review.summary}\n\n${review.markdown}`) + '\n');
+        }
+        const failOn = options.failOn ? Number(options.failOn) : undefined;
+        if (typeof failOn === 'number' && !Number.isNaN(failOn) && review.totalDelta >= failOn) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\n  Error: ${message}\n\n`);
+        process.exit(1);
+    }
+});
+program
+    .command('map [path]')
+    .description('Generate architecture.svg with simple layer dependencies')
+    .option('-o, --output <file>', 'Output SVG path (default: architecture.svg)', 'architecture.svg')
+    .action(async (targetPath, options) => {
+    const resolvedPath = resolve(targetPath ?? '.');
+    process.stderr.write(`\nBuilding architecture map for ${resolvedPath}...\n`);
+    const out = generateArchitectureMap(resolvedPath, options.output);
+    process.stderr.write(`  Architecture map saved to ${out}\n\n`);
+});
 program
     .command('report [path]')
     .description('Generate a self-contained HTML report')
@@ -189,21 +229,27 @@ program
     .command('fix [path]')
     .description('Auto-fix safe issues (debug-leftover console.*, catch-swallow)')
     .option('--rule <rule>', 'Fix only a specific rule')
+    .option('--preview', 'Preview changes without writing files')
+    .option('--write', 'Write fixes to disk')
     .option('--dry-run', 'Show what would change without writing files')
     .action(async (targetPath, options) => {
     const resolvedPath = resolve(targetPath ?? '.');
     const config = await loadConfig(resolvedPath);
+    const previewMode = Boolean(options.preview || options.dryRun);
+    const writeMode = options.write ?? !previewMode;
     const results = await applyFixes(resolvedPath, config, {
         rule: options.rule,
-        dryRun: options.dryRun,
+        dryRun: previewMode,
+        preview: previewMode,
+        write: writeMode,
     });
     if (results.length === 0) {
         console.log('No fixable issues found.');
         return;
     }
     const applied = results.filter(r => r.applied);
-    if (options.dryRun) {
-        console.log(`\ndrift fix --dry-run: ${results.length} fixable issues found\n`);
+    if (previewMode) {
+        console.log(`\ndrift fix --preview: ${results.length} fixable issues found\n`);
     }
     else {
         console.log(`\ndrift fix: ${applied.length} fixes applied\n`);
@@ -219,13 +265,45 @@ program
         const relPath = file.replace(resolvedPath + '/', '').replace(resolvedPath + '\\', '');
         console.log(`  ${relPath}`);
         for (const r of fileResults) {
-            const status = r.applied ? (options.dryRun ? 'would fix' : 'fixed') : 'skipped';
+            const status = r.applied ? (previewMode ? 'would fix' : 'fixed') : 'skipped';
             console.log(`    [${r.rule}] line ${r.line}: ${r.description} — ${status}`);
+            if (r.before || r.after) {
+                console.log(`      before: ${r.before ?? '(empty)'}`);
+                console.log(`      after : ${r.after ?? '(empty)'}`);
+            }
         }
     }
-    if (!options.dryRun && applied.length > 0) {
+    if (!previewMode && applied.length > 0) {
         console.log(`\n${applied.length} issue(s) fixed. Re-run drift scan to verify.`);
     }
 });
+program
+    .command('snapshot [path]')
+    .description('Record a score snapshot to drift-history.json')
+    .option('-l, --label <label>', 'label for this snapshot (e.g. sprint name, version)')
+    .option('--history', 'show all recorded snapshots')
+    .option('--diff', 'compare current score vs last snapshot')
+    .action(async (targetPath, opts) => {
+    const resolvedPath = resolve(targetPath ?? '.');
+    if (opts.history) {
+        const history = loadHistory(resolvedPath);
+        printHistory(history);
+        return;
+    }
+    process.stderr.write(`\nScanning ${resolvedPath}...\n`);
+    const config = await loadConfig(resolvedPath);
+    const files = analyzeProject(resolvedPath, config);
+    process.stderr.write(`  Found ${files.length} TypeScript file(s)\n\n`);
+    const report = buildReport(resolvedPath, files);
+    if (opts.diff) {
+        const history = loadHistory(resolvedPath);
+        printSnapshotDiff(history, report.totalScore);
+        return;
+    }
+    const entry = saveSnapshot(resolvedPath, report, opts.label);
+    const labelStr = entry.label ? ` [${entry.label}]` : '';
+    process.stdout.write(`  Snapshot recorded${labelStr}: score ${entry.score} (${entry.grade}) — ${entry.totalIssues} issues across ${entry.files} files\n`);
+    process.stdout.write(`  Saved to drift-history.json\n\n`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/diff.d.ts

@@ -1,10 +1,3 @@
 import type { DriftReport, DriftDiff } from './types.js';
-/**
- * Compute the diff between two DriftReports.
- *
- * Issues are matched by (rule + line + column) as a unique key within a file.
- * A "new" issue exists in `current` but not in `base`.
- * A "resolved" issue exists in `base` but not in `current`.
- */
 export declare function computeDiff(base: DriftReport, current: DriftReport, baseRef: string): DriftDiff;
 //# sourceMappingURL=diff.d.ts.map

package/dist/diff.js

@@ -5,12 +5,33 @@
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
+function computeFileDiff(filePath, baseFile, currentFile) {
+    const scoreBefore = baseFile?.score ?? 0;
+    const scoreAfter = currentFile?.score ?? 0;
+    const scoreDelta = scoreAfter - scoreBefore;
+    const baseIssues = baseFile?.issues ?? [];
+    const currentIssues = currentFile?.issues ?? [];
+    const issueKey = (i) => `${i.rule}:${i.line}:${i.column}`;
+    const baseKeys = new Set(baseIssues.map(issueKey));
+    const currentKeys = new Set(currentIssues.map(issueKey));
+    const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)));
+    const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)));
+    if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
+        return {
+            path: filePath,
+            scoreBefore,
+            scoreAfter,
+            scoreDelta,
+            newIssues,
+            resolvedIssues,
+        };
+    }
+    return null;
+}
 export function computeDiff(base, current, baseRef) {
     const fileDiffs = [];
-    // Build a map of base files by path for O(1) lookup
     const baseByPath = new Map(base.files.map(f => [f.path, f]));
     const currentByPath = new Map(current.files.map(f => [f.path, f]));
-    // All unique paths across both reports
     const allPaths = new Set([
         ...base.files.map(f => f.path),
         ...current.files.map(f => f.path),
@@ -18,30 +39,10 @@ export function computeDiff(base, current, baseRef) {
     for (const filePath of allPaths) {
         const baseFile = baseByPath.get(filePath);
         const currentFile = currentByPath.get(filePath);
-        const scoreBefore = baseFile?.score ?? 0;
-        const scoreAfter = currentFile?.score ?? 0;
-        const scoreDelta = scoreAfter - scoreBefore;
-        const baseIssues = baseFile?.issues ?? [];
-        const currentIssues = currentFile?.issues ?? [];
-        // Issue identity key: rule + line + column
-        const issueKey = (i) => `${i.rule}:${i.line}:${i.column}`;
-        const baseKeys = new Set(baseIssues.map(issueKey));
-        const currentKeys = new Set(currentIssues.map(issueKey));
-        const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)));
-        const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)));
-        // Only include files that have actual changes
-        if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
-            fileDiffs.push({
-                path: filePath,
-                scoreBefore,
-                scoreAfter,
-                scoreDelta,
-                newIssues,
-                resolvedIssues,
-            });
-        }
+        const diff = computeFileDiff(filePath, baseFile, currentFile);
+        if (diff)
+            fileDiffs.push(diff);
     }
-    // Sort: most regressed first, then most improved last
     fileDiffs.sort((a, b) => b.scoreDelta - a.scoreDelta);
     return {
         baseRef,

package/dist/fix.d.ts

@@ -5,9 +5,13 @@ export interface FixResult {
     line: number;
     description: string;
     applied: boolean;
+    before?: string;
+    after?: string;
 }
 export declare function applyFixes(targetPath: string, config?: DriftConfig, options?: {
     rule?: string;
     dryRun?: boolean;
+    write?: boolean;
+    preview?: boolean;
 }): Promise<FixResult[]>;
 //# sourceMappingURL=fix.d.ts.map

package/dist/fix.js

@@ -50,10 +50,65 @@ function applyFixToLines(lines, issue) {
     }
     return null;
 }
+function collectFixableIssues(fileReports, options) {
+    const fixableByFile = new Map();
+    for (const report of fileReports) {
+        const fixableIssues = report.issues.filter(issue => {
+            if (!isFixable(issue))
+                return false;
+            if (options?.rule && issue.rule !== options.rule)
+                return false;
+            return true;
+        });
+        if (fixableIssues.length > 0) {
+            fixableByFile.set(report.path, fixableIssues);
+        }
+    }
+    return fixableByFile;
+}
+function processFile(filePath, issues, dryRun) {
+    const content = readFileSync(filePath, 'utf8');
+    let lines = content.split('\n');
+    const results = [];
+    const sortedIssues = [...issues].sort((a, b) => b.line - a.line);
+    for (const issue of sortedIssues) {
+        const before = lines[issue.line - 1]?.trim() ?? '';
+        const fixResult = applyFixToLines(lines, issue);
+        if (fixResult) {
+            const after = fixResult.newLines[issue.line - 1]?.trim() ?? '';
+            results.push({
+                file: filePath,
+                rule: issue.rule,
+                line: issue.line,
+                description: fixResult.description,
+                applied: true,
+                before,
+                after,
+            });
+            lines = fixResult.newLines;
+        }
+        else {
+            results.push({
+                file: filePath,
+                rule: issue.rule,
+                line: issue.line,
+                description: 'no fix available',
+                applied: false,
+            });
+        }
+    }
+    if (!dryRun) {
+        writeFileSync(filePath, lines.join('\n'), 'utf8');
+    }
+    return results;
+}
 export async function applyFixes(targetPath, config, options) {
     const resolvedPath = resolve(targetPath);
-    const dryRun = options?.dryRun ?? false;
-    // Determine if target is a file or directory
+    const dryRun = options?.write
+        ? false
+        : options?.preview || options?.dryRun
+            ? true
+            : false;
     let fileReports;
     const stat = statSync(resolvedPath);
     if (stat.isFile()) {
@@ -67,53 +122,10 @@ export async function applyFixes(targetPath, config, options) {
     else {
         fileReports = analyzeProject(resolvedPath, config);
     }
-    // Collect fixable issues, optionally filtered by rule
-    const fixableByFile = new Map();
-    for (const report of fileReports) {
-        const fixableIssues = report.issues.filter(issue => {
-            if (!isFixable(issue))
-                return false;
-            if (options?.rule && issue.rule !== options.rule)
-                return false;
-            return true;
-        });
-        if (fixableIssues.length > 0) {
-            fixableByFile.set(report.path, fixableIssues);
-        }
-    }
+    const fixableByFile = collectFixableIssues(fileReports, options);
     const results = [];
     for (const [filePath, issues] of fixableByFile) {
-        const content = readFileSync(filePath, 'utf8');
-        let lines = content.split('\n');
-        // Sort issues by line descending to avoid line number drift after fixes
-        const sortedIssues = [...issues].sort((a, b) => b.line - a.line);
-        // Track line offset caused by deletions (debug-leftover removes lines)
-        // We process top-to-bottom after sorting descending, so no offset needed per issue
-        for (const issue of sortedIssues) {
-            const fixResult = applyFixToLines(lines, issue);
-            if (fixResult) {
-                results.push({
-                    file: filePath,
-                    rule: issue.rule,
-                    line: issue.line,
-                    description: fixResult.description,
-                    applied: true,
-                });
-                lines = fixResult.newLines;
-            }
-            else {
-                results.push({
-                    file: filePath,
-                    rule: issue.rule,
-                    line: issue.line,
-                    description: 'no fix available',
-                    applied: false,
-                });
-            }
-        }
-        if (!dryRun) {
-            writeFileSync(filePath, lines.join('\n'), 'utf8');
-        }
+        results.push(...processFile(filePath, issues, dryRun));
     }
     return results;
 }

package/dist/git/trend.js

@@ -1,3 +1,4 @@
+// drift-ignore-file
 import { assertGitRepo, analyzeHistoricalCommits } from './helpers.js';
 import { buildReport } from '../reporter.js';
 export class TrendAnalyzer {

package/dist/git.d.ts

@@ -1,12 +1,3 @@
-/**
- * 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.

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('.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;
 }

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

package/dist/map.js

@@ -0,0 +1,103 @@
+import { writeFileSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import { Project } from 'ts-morph';
+function detectLayer(relPath) {
+    const normalized = relPath.replace(/\\/g, '/').replace(/^\.\//, '');
+    const first = normalized.split('/')[0] || 'root';
+    return first;
+}
+function esc(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function generateArchitectureSvg(targetPath) {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: { allowJs: true, jsx: 1 },
+    });
+    project.addSourceFilesAtPaths([
+        `${targetPath}/**/*.ts`,
+        `${targetPath}/**/*.tsx`,
+        `${targetPath}/**/*.js`,
+        `${targetPath}/**/*.jsx`,
+        `!${targetPath}/**/node_modules/**`,
+        `!${targetPath}/**/dist/**`,
+        `!${targetPath}/**/.next/**`,
+        `!${targetPath}/**/*.d.ts`,
+    ]);
+    const layers = new Map();
+    const edges = new Map();
+    for (const file of project.getSourceFiles()) {
+        const rel = relative(targetPath, file.getFilePath()).replace(/\\/g, '/');
+        const layerName = detectLayer(rel);
+        if (!layers.has(layerName))
+            layers.set(layerName, { name: layerName, files: new Set() });
+        layers.get(layerName).files.add(rel);
+        for (const decl of file.getImportDeclarations()) {
+            const imported = decl.getModuleSpecifierSourceFile();
+            if (!imported)
+                continue;
+            const importedRel = relative(targetPath, imported.getFilePath()).replace(/\\/g, '/');
+            const importedLayer = detectLayer(importedRel);
+            if (importedLayer === layerName)
+                continue;
+            const key = `${layerName}->${importedLayer}`;
+            edges.set(key, (edges.get(key) ?? 0) + 1);
+        }
+    }
+    const layerList = [...layers.values()].sort((a, b) => a.name.localeCompare(b.name));
+    const width = 960;
+    const rowHeight = 90;
+    const height = Math.max(180, layerList.length * rowHeight + 120);
+    const boxWidth = 240;
+    const boxHeight = 50;
+    const left = 100;
+    const boxes = layerList.map((layer, index) => {
+        const y = 60 + index * rowHeight;
+        return {
+            ...layer,
+            x: left,
+            y,
+        };
+    });
+    const boxByName = new Map(boxes.map((box) => [box.name, box]));
+    const lines = [...edges.entries()].map(([key, count]) => {
+        const [from, to] = key.split('->');
+        const a = boxByName.get(from);
+        const b = boxByName.get(to);
+        if (!a || !b)
+            return '';
+        const startX = a.x + boxWidth;
+        const startY = a.y + boxHeight / 2;
+        const endX = b.x;
+        const endY = b.y + boxHeight / 2;
+        return `
+      <line x1="${startX}" y1="${startY}" x2="${endX}" y2="${endY}" stroke="#64748b" stroke-width="2" marker-end="url(#arrow)" />
+      <text x="${(startX + endX) / 2}" y="${(startY + endY) / 2 - 4}" fill="#94a3b8" font-size="11" text-anchor="middle">${count}</text>`;
+    }).join('');
+    const nodes = boxes.map((box) => `
+    <g>
+      <rect x="${box.x}" y="${box.y}" width="${boxWidth}" height="${boxHeight}" rx="8" fill="#0f172a" stroke="#334155" />
+      <text x="${box.x + 12}" y="${box.y + 22}" fill="#e2e8f0" font-size="13" font-family="monospace">${esc(box.name)}</text>
+      <text x="${box.x + 12}" y="${box.y + 38}" fill="#94a3b8" font-size="11" font-family="monospace">${box.files.size} file(s)</text>
+    </g>`).join('');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <defs>
+    <marker id="arrow" markerWidth="10" markerHeight="10" refX="6" refY="3" orient="auto">
+      <path d="M0,0 L0,6 L7,3 z" fill="#64748b"/>
+    </marker>
+  </defs>
+  <rect x="0" y="0" width="${width}" height="${height}" fill="#020617" />
+  <text x="28" y="34" fill="#f8fafc" font-size="16" font-family="monospace">drift architecture map</text>
+  <text x="28" y="54" fill="#94a3b8" font-size="11" font-family="monospace">Layers inferred from top-level directories</text>
+  ${lines}
+  ${nodes}
+</svg>`;
+}
+export function generateArchitectureMap(targetPath, outputFile = 'architecture.svg') {
+    const resolvedTarget = resolve(targetPath);
+    const svg = generateArchitectureSvg(resolvedTarget);
+    const outPath = resolve(outputFile);
+    writeFileSync(outPath, svg, 'utf8');
+    return outPath;
+}
+//# sourceMappingURL=map.js.map

package/dist/metrics.d.ts

@@ -0,0 +1,4 @@
+import type { DriftReport, FileReport, MaintenanceRiskMetrics, RepoQualityScore } from './types.js';
+export declare function computeRepoQuality(targetPath: string, files: FileReport[]): RepoQualityScore;
+export declare function computeMaintenanceRisk(report: DriftReport): MaintenanceRiskMetrics;
+//# sourceMappingURL=metrics.d.ts.map