@eduardbar/drift 1.3.0 → 1.4.0

package/src/init.ts

@@ -0,0 +1,298 @@
+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'
+
+interface InitOptions {
+  preset?: string
+  ci?: boolean
+  baseline?: boolean
+}
+
+export const INIT_PRESETS = ['node-backend', 'react-app', 'hexagonal', 'monorepo'] as const
+type InitPreset = (typeof INIT_PRESETS)[number]
+
+type InitBaselineGrade = 'CLEAN' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
+
+const CONFIG_PRESET_CONTENT: Record<InitPreset, string> = {
+  '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: number): InitBaselineGrade {
+  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: string, options: InitOptions): Promise<void> {
+  const tasks: string[] = []
+
+  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: string): value is InitPreset {
+  return INIT_PRESETS.includes(value as InitPreset)
+}
+
+function maybeWritePresetConfig(projectRoot: string, preset: string | undefined, tasks: string[]): void {
+  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: string, ci: boolean | undefined, tasks: string[]): void {
+  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: string, baseline: boolean | undefined, tasks: string[]): Promise<void> {
+  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: InitPreset): string {
+  return CONFIG_PRESET_CONTENT[preset]
+}
+
+function generateGitHubWorkflow(): string {
+  return GITHUB_WORKFLOW_TEMPLATE
+}

package/src/map-cycles.ts

@@ -0,0 +1,38 @@
+export function detectCycleEdges(adjacency: Map<string, Set<string>>): Set<string> {
+  const visited = new Set<string>()
+  const inStack = new Set<string>()
+  const stack: string[] = []
+  const cycleEdges = new Set<string>()
+
+  function dfs(node: string): void {
+    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
+}

package/src/map-svg.ts

@@ -0,0 +1,124 @@
+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
+
+interface LayerNode {
+  name: string
+  files: Set<string>
+}
+
+interface MapEdge {
+  key: string
+  from: string
+  to: string
+  count: number
+  kind: 'normal' | 'cycle' | 'violation'
+}
+
+function esc(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+function buildSvgLayout(layers: Map<string, LayerNode>): { width: number; height: number; boxes: Array<LayerNode & { x: number; y: number }> } {
+  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: MapEdge['kind']): string {
+  if (kind === 'violation') return '#ef4444'
+  if (kind === 'cycle') return '#f59e0b'
+  return '#64748b'
+}
+
+function edgeStrokeWidth(kind: MapEdge['kind']): number {
+  return kind === 'normal' ? NORMAL_EDGE_WIDTH : HIGHLIGHT_EDGE_WIDTH
+}
+
+function renderEdges(edgeList: MapEdge[], boxByName: Map<string, LayerNode & { x: number; y: number }>): string {
+  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: Array<LayerNode & { x: number; y: number }>): string {
+  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: {
+  layers: Map<string, LayerNode>
+  edgeList: MapEdge[]
+  cycleCount: number
+  violationCount: number
+}): string {
+  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>`
+}