@eduardbar/drift 1.3.0 → 1.4.0

package/dist/init.js

@@ -0,0 +1,273 @@
+import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { analyzeProject } from './analyzer.js';
+import { buildReport } from './reporter.js';
+import { loadConfig } from './config.js';
+import { scoreToGrade } from './utils.js';
+export const INIT_PRESETS = ['node-backend', 'react-app', 'hexagonal', 'monorepo'];
+const CONFIG_PRESET_CONTENT = {
+    'node-backend': `import type { DriftConfig } from '@eduardbar/drift'
+
+export default {
+  layers: [
+    {
+      name: 'api',
+      patterns: ['src/routes/**', 'src/controllers/**'],
+      canImportFrom: ['services', 'middleware', 'types'],
+    },
+    {
+      name: 'services',
+      patterns: ['src/services/**'],
+      canImportFrom: ['db', 'types'],
+    },
+    {
+      name: 'db',
+      patterns: ['src/db/**', 'src/models/**'],
+      canImportFrom: ['types'],
+    },
+    {
+      name: 'types',
+      patterns: ['src/types/**'],
+      canImportFrom: [],
+    },
+  ],
+} satisfies DriftConfig
+`,
+    'react-app': `import type { DriftConfig } from '@eduardbar/drift'
+
+export default {
+  layers: [
+    {
+      name: 'pages',
+      patterns: ['src/pages/**', 'src/app/**'],
+      canImportFrom: ['components', 'hooks', 'services', 'types'],
+    },
+    {
+      name: 'components',
+      patterns: ['src/components/**'],
+      canImportFrom: ['hooks', 'types'],
+    },
+    {
+      name: 'hooks',
+      patterns: ['src/hooks/**'],
+      canImportFrom: ['services', 'types'],
+    },
+    {
+      name: 'services',
+      patterns: ['src/services/**', 'src/api/**'],
+      canImportFrom: ['types'],
+    },
+    {
+      name: 'types',
+      patterns: ['src/types/**'],
+      canImportFrom: [],
+    },
+  ],
+} satisfies DriftConfig
+`,
+    hexagonal: `import type { DriftConfig } from '@eduardbar/drift'
+
+export default {
+  layers: [
+    {
+      name: 'adapters',
+      patterns: ['src/adapters/**', 'src/infrastructure/**'],
+      canImportFrom: ['application', 'domain'],
+    },
+    {
+      name: 'application',
+      patterns: ['src/application/**', 'src/use-cases/**'],
+      canImportFrom: ['domain'],
+    },
+    {
+      name: 'domain',
+      patterns: ['src/domain/**'],
+      canImportFrom: [],
+    },
+  ],
+} satisfies DriftConfig
+`,
+    monorepo: `import type { DriftConfig } from '@eduardbar/drift'
+
+export default {
+  modules: [
+    {
+      name: 'shared',
+      root: 'packages/shared',
+      allowedExternalImports: [],
+    },
+    {
+      name: 'api',
+      root: 'packages/api',
+      allowedExternalImports: ['@myorg/shared'],
+    },
+    {
+      name: 'web',
+      root: 'packages/web',
+      allowedExternalImports: ['@myorg/shared'],
+    },
+  ],
+} satisfies DriftConfig
+`,
+};
+const GITHUB_WORKFLOW_TEMPLATE = `name: drift PR Review
+
+on:
+  pull_request:
+    branches: [main, master, develop]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  drift-review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - name: Install drift
+        run: npm install -g @eduardbar/drift
+
+      - name: Run drift review
+        id: drift
+        run: |
+          npx drift review --base origin/\${{ github.base_ref }} --comment > drift-comment.md
+          echo "score=$(cat drift-comment.md | grep 'Score:' | awk '{print $2}')" >> $GITHUB_OUTPUT
+
+      - name: Comment PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs')
+            const comment = fs.readFileSync('drift-comment.md', 'utf8')
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            })
+
+            const botComment = comments.find(c =>
+              c.user?.type === 'Bot' && c.body?.includes('<!-- drift-review -->')
+            )
+
+            const body = '<!-- drift-review -->\\n\\n' + comment
+
+            if (botComment) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: botComment.id,
+                body,
+              })
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body,
+              })
+            }
+`;
+function mapScoreToBaselineGrade(score) {
+    const { label } = scoreToGrade(score);
+    if (label === 'clean')
+        return 'CLEAN';
+    if (label === 'low')
+        return 'LOW';
+    if (label === 'moderate')
+        return 'MEDIUM';
+    if (label === 'high')
+        return 'HIGH';
+    return 'CRITICAL';
+}
+/**
+ * Initialize drift configuration with optional presets and scaffolding.
+ *
+ * @param projectRoot - Absolute path to project root
+ * @param options - Init options from CLI
+ */
+export async function runInit(projectRoot, options) {
+    const tasks = [];
+    maybeWritePresetConfig(projectRoot, options.preset, tasks);
+    maybeWriteCiWorkflow(projectRoot, options.ci, tasks);
+    await maybeWriteBaseline(projectRoot, options.baseline, tasks);
+    if (tasks.length === 0) {
+        process.stdout.write('\n  No actions taken. Use --preset, --ci, or --baseline flags.\n\n');
+    }
+    else {
+        process.stdout.write('\n  drift init complete:\n\n');
+        for (const task of tasks) {
+            process.stdout.write(`    ${task}\n`);
+        }
+        process.stdout.write('\n');
+    }
+}
+function isInitPreset(value) {
+    return INIT_PRESETS.includes(value);
+}
+function maybeWritePresetConfig(projectRoot, preset, tasks) {
+    if (!preset)
+        return;
+    if (!isInitPreset(preset)) {
+        throw new Error(`Invalid preset '${preset}'. Use one of: ${INIT_PRESETS.join(', ')}`);
+    }
+    const configPath = join(projectRoot, 'drift.config.ts');
+    if (existsSync(configPath)) {
+        process.stderr.write(`  ⚠️  drift.config.ts already exists, skipping config generation\n`);
+        return;
+    }
+    writeFileSync(configPath, generateConfigPreset(preset), 'utf8');
+    tasks.push('✅ Generated drift.config.ts');
+}
+function maybeWriteCiWorkflow(projectRoot, ci, tasks) {
+    if (!ci)
+        return;
+    const workflowDir = join(projectRoot, '.github', 'workflows');
+    const workflowPath = join(workflowDir, 'drift-review.yml');
+    if (existsSync(workflowPath)) {
+        process.stderr.write(`  ⚠️  .github/workflows/drift-review.yml already exists, skipping workflow generation\n`);
+        return;
+    }
+    if (!existsSync(workflowDir)) {
+        mkdirSync(workflowDir, { recursive: true });
+    }
+    writeFileSync(workflowPath, generateGitHubWorkflow(), 'utf8');
+    tasks.push('✅ Generated .github/workflows/drift-review.yml');
+}
+async function maybeWriteBaseline(projectRoot, baseline, tasks) {
+    if (!baseline)
+        return;
+    const baselinePath = join(projectRoot, 'drift-baseline.json');
+    if (existsSync(baselinePath)) {
+        process.stderr.write(`  ⚠️  drift-baseline.json already exists, skipping baseline creation\n`);
+        return;
+    }
+    process.stderr.write('  Scanning project to create baseline...\n');
+    const config = await loadConfig(projectRoot);
+    const files = analyzeProject(projectRoot, config);
+    const report = buildReport(projectRoot, files);
+    const baselineSnapshot = {
+        createdAt: new Date().toISOString(),
+        score: report.totalScore,
+        grade: mapScoreToBaselineGrade(report.totalScore),
+        totalIssues: report.totalIssues,
+        files: report.files.length,
+    };
+    writeFileSync(baselinePath, JSON.stringify(baselineSnapshot, null, 2), 'utf8');
+    tasks.push(`✅ Created drift-baseline.json (score: ${report.totalScore}/100, grade: ${baselineSnapshot.grade})`);
+}
+function generateConfigPreset(preset) {
+    return CONFIG_PRESET_CONTENT[preset];
+}
+function generateGitHubWorkflow() {
+    return GITHUB_WORKFLOW_TEMPLATE;
+}
+//# sourceMappingURL=init.js.map

package/dist/map-cycles.d.ts

@@ -0,0 +1,2 @@
+export declare function detectCycleEdges(adjacency: Map<string, Set<string>>): Set<string>;
+//# sourceMappingURL=map-cycles.d.ts.map

package/dist/map-cycles.js

@@ -0,0 +1,34 @@
+export function detectCycleEdges(adjacency) {
+    const visited = new Set();
+    const inStack = new Set();
+    const stack = [];
+    const cycleEdges = new Set();
+    function dfs(node) {
+        visited.add(node);
+        inStack.add(node);
+        stack.push(node);
+        for (const neighbor of adjacency.get(node) ?? []) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+                continue;
+            }
+            if (!inStack.has(neighbor))
+                continue;
+            const startIndex = stack.indexOf(neighbor);
+            if (startIndex >= 0) {
+                for (let i = startIndex; i < stack.length - 1; i++) {
+                    cycleEdges.add(`${stack[i]}->${stack[i + 1]}`);
+                }
+            }
+            cycleEdges.add(`${node}->${neighbor}`);
+        }
+        stack.pop();
+        inStack.delete(node);
+    }
+    for (const node of adjacency.keys()) {
+        if (!visited.has(node))
+            dfs(node);
+    }
+    return cycleEdges;
+}
+//# sourceMappingURL=map-cycles.js.map

package/dist/map-svg.d.ts

@@ -0,0 +1,19 @@
+interface LayerNode {
+    name: string;
+    files: Set<string>;
+}
+interface MapEdge {
+    key: string;
+    from: string;
+    to: string;
+    count: number;
+    kind: 'normal' | 'cycle' | 'violation';
+}
+export declare function renderArchitectureSvg(input: {
+    layers: Map<string, LayerNode>;
+    edgeList: MapEdge[];
+    cycleCount: number;
+    violationCount: number;
+}): string;
+export {};
+//# sourceMappingURL=map-svg.d.ts.map

package/dist/map-svg.js

@@ -0,0 +1,97 @@
+const SVG_WIDTH = 960;
+const ROW_HEIGHT = 90;
+const MIN_CANVAS_HEIGHT = 180;
+const BOTTOM_PADDING = 120;
+const BOX_WIDTH = 240;
+const BOX_HEIGHT = 50;
+const BOX_LEFT = 100;
+const BOX_TOP_OFFSET = 60;
+const NORMAL_EDGE_WIDTH = 2;
+const HIGHLIGHT_EDGE_WIDTH = 3;
+const EDGE_LABEL_Y_OFFSET = 4;
+const NODE_TITLE_X_OFFSET = 12;
+const NODE_TITLE_Y_OFFSET = 22;
+const NODE_META_X_OFFSET = 12;
+const NODE_META_Y_OFFSET = 38;
+const LEGEND_CYCLE_START_X = 520;
+const LEGEND_CYCLE_END_X = 560;
+const LEGEND_CYCLE_LABEL_X = 567;
+const LEGEND_VIOLATION_START_X = 630;
+const LEGEND_VIOLATION_END_X = 670;
+const LEGEND_VIOLATION_LABEL_X = 677;
+const LEGEND_LINE_Y = 66;
+const LEGEND_LABEL_Y = 69;
+function esc(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function buildSvgLayout(layers) {
+    const layerList = [...layers.values()].sort((a, b) => a.name.localeCompare(b.name));
+    const height = Math.max(MIN_CANVAS_HEIGHT, layerList.length * ROW_HEIGHT + BOTTOM_PADDING);
+    const boxes = layerList.map((layer, index) => ({
+        ...layer,
+        x: BOX_LEFT,
+        y: BOX_TOP_OFFSET + index * ROW_HEIGHT,
+    }));
+    return {
+        width: SVG_WIDTH,
+        height,
+        boxes,
+    };
+}
+function edgeStroke(kind) {
+    if (kind === 'violation')
+        return '#ef4444';
+    if (kind === 'cycle')
+        return '#f59e0b';
+    return '#64748b';
+}
+function edgeStrokeWidth(kind) {
+    return kind === 'normal' ? NORMAL_EDGE_WIDTH : HIGHLIGHT_EDGE_WIDTH;
+}
+function renderEdges(edgeList, boxByName) {
+    return edgeList.map((edge) => {
+        const a = boxByName.get(edge.from);
+        const b = boxByName.get(edge.to);
+        if (!a || !b)
+            return '';
+        const startX = a.x + BOX_WIDTH;
+        const startY = a.y + BOX_HEIGHT / 2;
+        const endX = b.x;
+        const endY = b.y + BOX_HEIGHT / 2;
+        const stroke = edgeStroke(edge.kind);
+        const widthPx = edgeStrokeWidth(edge.kind);
+        return `
+      <line x1="${startX}" y1="${startY}" x2="${endX}" y2="${endY}" stroke="${stroke}" stroke-width="${widthPx}" marker-end="url(#arrow)" data-edge="${esc(edge.key)}" data-kind="${edge.kind}" />
+      <text x="${(startX + endX) / 2}" y="${(startY + endY) / 2 - EDGE_LABEL_Y_OFFSET}" fill="#94a3b8" font-size="11" text-anchor="middle">${edge.count}</text>`;
+    }).join('');
+}
+function renderNodes(boxes) {
+    return boxes.map((box) => `
+    <g>
+      <rect x="${box.x}" y="${box.y}" width="${BOX_WIDTH}" height="${BOX_HEIGHT}" rx="8" fill="#0f172a" stroke="#334155" />
+      <text x="${box.x + NODE_TITLE_X_OFFSET}" y="${box.y + NODE_TITLE_Y_OFFSET}" fill="#e2e8f0" font-size="13" font-family="monospace">${esc(box.name)}</text>
+      <text x="${box.x + NODE_META_X_OFFSET}" y="${box.y + NODE_META_Y_OFFSET}" fill="#94a3b8" font-size="11" font-family="monospace">${box.files.size} file(s)</text>
+    </g>`).join('');
+}
+export function renderArchitectureSvg(input) {
+    const { width, height, boxes } = buildSvgLayout(input.layers);
+    const boxByName = new Map(boxes.map((box) => [box.name, box]));
+    const lines = renderEdges(input.edgeList, boxByName);
+    const nodes = renderNodes(boxes);
+    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>
+  <text x="28" y="72" fill="#94a3b8" font-size="11" font-family="monospace">Cycle edges: ${input.cycleCount} | Layer violations: ${input.violationCount}</text>
+  <line x1="${LEGEND_CYCLE_START_X}" y1="${LEGEND_LINE_Y}" x2="${LEGEND_CYCLE_END_X}" y2="${LEGEND_LINE_Y}" stroke="#f59e0b" stroke-width="${HIGHLIGHT_EDGE_WIDTH}" /><text x="${LEGEND_CYCLE_LABEL_X}" y="${LEGEND_LABEL_Y}" fill="#94a3b8" font-size="11" font-family="monospace">cycle</text>
+  <line x1="${LEGEND_VIOLATION_START_X}" y1="${LEGEND_LINE_Y}" x2="${LEGEND_VIOLATION_END_X}" y2="${LEGEND_LINE_Y}" stroke="#ef4444" stroke-width="${HIGHLIGHT_EDGE_WIDTH}" /><text x="${LEGEND_VIOLATION_LABEL_X}" y="${LEGEND_LABEL_Y}" fill="#94a3b8" font-size="11" font-family="monospace">violation</text>
+  ${lines}
+  ${nodes}
+</svg>`;
+}
+//# sourceMappingURL=map-svg.js.map

package/dist/map.js

@@ -3,15 +3,54 @@ import { resolve, relative } from 'node:path';
 import { Project } from 'ts-morph';
 import { detectLayerViolations } from './rules/phase3-arch.js';
 import { RULE_WEIGHTS } from './analyzer.js';
+import { detectCycleEdges } from './map-cycles.js';
+import { renderArchitectureSvg } from './map-svg.js';
 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;');
+function appendFileLayerContext(filePath, targetPath, layers, fileImportGraph) {
+    const rel = relative(targetPath, filePath).replace(/\\/g, '/');
+    const layerName = detectLayer(rel);
+    if (!layers.has(layerName)) {
+        layers.set(layerName, { name: layerName, files: new Set() });
+    }
+    layers.get(layerName).files.add(rel);
+    if (!fileImportGraph.has(filePath)) {
+        fileImportGraph.set(filePath, new Set());
+    }
+    return { rel, layerName };
 }
-export function generateArchitectureSvg(targetPath, config) {
+function registerImportEdge(layerName, importedLayer, edges, layerAdjacency) {
+    if (importedLayer === layerName)
+        return;
+    const key = `${layerName}->${importedLayer}`;
+    edges.set(key, (edges.get(key) ?? 0) + 1);
+    if (!layerAdjacency.has(layerName)) {
+        layerAdjacency.set(layerName, new Set());
+    }
+    layerAdjacency.get(layerName).add(importedLayer);
+}
+function buildEdgeList(edges, cycleEdges, violationEdges) {
+    const edgeList = [...edges.entries()].map(([key, count]) => {
+        const [from, to] = key.split('->');
+        const kind = violationEdges.has(key)
+            ? 'violation'
+            : cycleEdges.has(key)
+                ? 'cycle'
+                : 'normal';
+        return { key, from, to, count, kind };
+    });
+    for (const key of violationEdges) {
+        if (edges.has(key))
+            continue;
+        const [from, to] = key.split('->');
+        edgeList.push({ key, from, to, count: 1, kind: 'violation' });
+    }
+    return edgeList;
+}
+function createArchitectureProject(targetPath) {
     const project = new Project({
         skipAddingFilesFromTsConfig: true,
         compilerOptions: { allowJs: true, jsx: 1 },
@@ -26,19 +65,16 @@ export function generateArchitectureSvg(targetPath, config) {
         `!${targetPath}/**/.next/**`,
         `!${targetPath}/**/*.d.ts`,
     ]);
+    return project;
+}
+function collectArchitectureGraph(project, targetPath) {
     const layers = new Map();
     const edges = new Map();
     const layerAdjacency = new Map();
     const fileImportGraph = new Map();
     for (const file of project.getSourceFiles()) {
         const filePath = file.getFilePath();
-        const rel = relative(targetPath, filePath).replace(/\\/g, '/');
-        const layerName = detectLayer(rel);
-        if (!layers.has(layerName))
-            layers.set(layerName, { name: layerName, files: new Set() });
-        layers.get(layerName).files.add(rel);
-        if (!fileImportGraph.has(filePath))
-            fileImportGraph.set(filePath, new Set());
+        const { layerName } = appendFileLayerContext(filePath, targetPath, layers, fileImportGraph);
         for (const decl of file.getImportDeclarations()) {
             const imported = decl.getModuleSpecifierSourceFile();
             if (!imported)
@@ -46,140 +82,44 @@ export function generateArchitectureSvg(targetPath, config) {
             fileImportGraph.get(filePath).add(imported.getFilePath());
             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);
-            if (!layerAdjacency.has(layerName))
-                layerAdjacency.set(layerName, new Set());
-            layerAdjacency.get(layerName).add(importedLayer);
-        }
-    }
-    const cycleEdges = detectCycleEdges(layerAdjacency);
-    const violationEdges = new Set();
-    if (config?.layers && config.layers.length > 0) {
-        const violations = detectLayerViolations(fileImportGraph, config.layers, targetPath, RULE_WEIGHTS);
-        for (const issues of violations.values()) {
-            for (const issue of issues) {
-                const match = issue.message.match(/Layer '([^']+)' must not import from layer '([^']+)'/);
-                if (!match)
-                    continue;
-                const from = match[1];
-                const to = match[2];
-                violationEdges.add(`${from}->${to}`);
-                if (!layers.has(from))
-                    layers.set(from, { name: from, files: new Set() });
-                if (!layers.has(to))
-                    layers.set(to, { name: to, files: new Set() });
-            }
+            registerImportEdge(layerName, importedLayer, edges, layerAdjacency);
         }
     }
-    const edgeList = [...edges.entries()].map(([key, count]) => {
-        const [from, to] = key.split('->');
-        const kind = violationEdges.has(key)
-            ? 'violation'
-            : cycleEdges.has(key)
-                ? 'cycle'
-                : 'normal';
-        return { key, from, to, count, kind };
-    });
-    for (const key of violationEdges) {
-        if (edges.has(key))
-            continue;
-        const [from, to] = key.split('->');
-        edgeList.push({ key, from, to, count: 1, kind: 'violation' });
-    }
-    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 = edgeList.map((edge) => {
-        const a = boxByName.get(edge.from);
-        const b = boxByName.get(edge.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;
-        const stroke = edge.kind === 'violation'
-            ? '#ef4444'
-            : edge.kind === 'cycle'
-                ? '#f59e0b'
-                : '#64748b';
-        const widthPx = edge.kind === 'normal' ? 2 : 3;
-        return `
-      <line x1="${startX}" y1="${startY}" x2="${endX}" y2="${endY}" stroke="${stroke}" stroke-width="${widthPx}" marker-end="url(#arrow)" data-edge="${esc(edge.key)}" data-kind="${edge.kind}" />
-      <text x="${(startX + endX) / 2}" y="${(startY + endY) / 2 - 4}" fill="#94a3b8" font-size="11" text-anchor="middle">${edge.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('');
-    const cycleCount = edgeList.filter((edge) => edge.kind === 'cycle').length;
-    const violationCount = edgeList.filter((edge) => edge.kind === 'violation').length;
-    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>
-  <text x="28" y="72" fill="#94a3b8" font-size="11" font-family="monospace">Cycle edges: ${cycleCount} | Layer violations: ${violationCount}</text>
-  <line x1="520" y1="66" x2="560" y2="66" stroke="#f59e0b" stroke-width="3" /><text x="567" y="69" fill="#94a3b8" font-size="11" font-family="monospace">cycle</text>
-  <line x1="630" y1="66" x2="670" y2="66" stroke="#ef4444" stroke-width="3" /><text x="677" y="69" fill="#94a3b8" font-size="11" font-family="monospace">violation</text>
-  ${lines}
-  ${nodes}
-</svg>`;
+    return { layers, edges, layerAdjacency, fileImportGraph };
 }
-function detectCycleEdges(adjacency) {
-    const visited = new Set();
-    const inStack = new Set();
-    const stack = [];
-    const cycleEdges = new Set();
-    function dfs(node) {
-        visited.add(node);
-        inStack.add(node);
-        stack.push(node);
-        for (const neighbor of adjacency.get(node) ?? []) {
-            if (!visited.has(neighbor)) {
-                dfs(neighbor);
-                continue;
-            }
-            if (!inStack.has(neighbor))
+function collectViolationEdges(config, fileImportGraph, targetPath, layers) {
+    const violationEdges = new Set();
+    if (!config?.layers?.length)
+        return violationEdges;
+    const violations = detectLayerViolations(fileImportGraph, config.layers, targetPath, RULE_WEIGHTS);
+    for (const issues of violations.values()) {
+        for (const issue of issues) {
+            const match = issue.message.match(/Layer '([^']+)' must not import from layer '([^']+)'/);
+            if (!match)
                 continue;
-            const startIndex = stack.indexOf(neighbor);
-            if (startIndex >= 0) {
-                for (let i = startIndex; i < stack.length - 1; i++) {
-                    cycleEdges.add(`${stack[i]}->${stack[i + 1]}`);
-                }
-            }
-            cycleEdges.add(`${node}->${neighbor}`);
+            const from = match[1];
+            const to = match[2];
+            violationEdges.add(`${from}->${to}`);
+            if (!layers.has(from))
+                layers.set(from, { name: from, files: new Set() });
+            if (!layers.has(to))
+                layers.set(to, { name: to, files: new Set() });
         }
-        stack.pop();
-        inStack.delete(node);
-    }
-    for (const node of adjacency.keys()) {
-        if (!visited.has(node))
-            dfs(node);
     }
-    return cycleEdges;
+    return violationEdges;
+}
+export function generateArchitectureSvg(targetPath, config) {
+    const project = createArchitectureProject(targetPath);
+    const { layers, edges, layerAdjacency, fileImportGraph } = collectArchitectureGraph(project, targetPath);
+    const cycleEdges = detectCycleEdges(layerAdjacency);
+    const violationEdges = collectViolationEdges(config, fileImportGraph, targetPath, layers);
+    const edgeList = buildEdgeList(edges, cycleEdges, violationEdges);
+    return renderArchitectureSvg({
+        layers,
+        edgeList,
+        cycleCount: edgeList.filter((edge) => edge.kind === 'cycle').length,
+        violationCount: edgeList.filter((edge) => edge.kind === 'violation').length,
+    });
 }
 export function generateArchitectureMap(targetPath, outputFile = 'architecture.svg', config) {
     const resolvedTarget = resolve(targetPath);