@eduardbar/drift 1.0.0 → 1.1.0

package/src/rules/phase8-semantic.ts

@@ -1,3 +1,5 @@
+// drift-ignore-file
+
 import * as crypto from 'node:crypto'
 import {
   SourceFile,
@@ -17,22 +19,18 @@ export type FunctionLikeNode = FunctionDeclaration | ArrowFunction | FunctionExp
  *  with canonical tokens so that two functions with identical logic but
  *  different identifiers produce the same fingerprint.
  */
-export function normalizeFunctionBody(fn: FunctionLikeNode): string {
-  // Build a substitution map: localName → canonical token
+function buildSubstitutionMap(fn: FunctionLikeNode): Map<string, string> {
   const subst = new Map<string, string>()
 
-  // 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 as import('ts-morph').VariableDeclaration).getNameNode()
-      // Support destructuring — getNameNode() may be a BindingPattern
       if (nameNode.getKind() === SyntaxKind.Identifier) {
         const name = nameNode.getText()
         if (!subst.has(name)) subst.set(name, `V${varIdx++}`)
@@ -40,37 +38,43 @@ export function normalizeFunctionBody(fn: FunctionLikeNode): string {
     }
   })
 
-  function serializeNode(node: Node): string {
-    const kind = node.getKindName()
+  return subst
+}
 
-    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'
+function serializeNode(node: Node, subst: Map<string, string>): string {
+  const kind = node.getKindName()
+
+  switch (node.getKind()) {
+    case SyntaxKind.Identifier: {
+      const text = node.getText()
+      return subst.get(text) ?? text
     }
+    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 children = node.getChildren()
+  if (children.length === 0) return kind
 
-    const childStr = children.map(serializeNode).join('|')
-    return `${kind}(${childStr})`
-  }
+  const childStr = children.map(c => serializeNode(c, subst)).join('|')
+  return `${kind}(${childStr})`
+}
+
+export function normalizeFunctionBody(fn: FunctionLikeNode): string {
+  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). */

package/src/rules/promise.ts

@@ -0,0 +1,29 @@
+import { SourceFile, SyntaxKind } from 'ts-morph'
+import type { DriftIssue } from '../types.js'
+
+export function detectPromiseStyleMix(file: SourceFile): DriftIssue[] {
+  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 []
+}

package/src/snapshot.ts

@@ -0,0 +1,175 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import kleur from 'kleur'
+import type { DriftReport } from './types.js'
+import { scoreToGradeText } from './utils.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[]
+}
+
+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: string): SnapshotHistory {
+  const filePath = path.join(targetPath, HISTORY_FILE)
+  if (fs.existsSync(filePath)) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8')) as SnapshotHistory
+  }
+  return { project: targetPath, snapshots: [] }
+}
+
+export function saveSnapshot(
+  targetPath: string,
+  report: DriftReport,
+  label?: string,
+): SnapshotEntry {
+  const history = loadHistory(targetPath)
+
+  const entry: SnapshotEntry = {
+    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: SnapshotEntry, prev: SnapshotEntry | null): string {
+  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: SnapshotHistory): void {
+  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: SnapshotHistory,
+  currentScore: number,
+): void {
+  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: string, score: number): string {
+  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)
+}

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { SourceFile } from 'ts-morph'
+
 export interface DriftIssue {
   rule: string
   severity: 'error' | 'warning' | 'info'
@@ -26,6 +28,39 @@ export interface DriftReport {
     infos: number
     byRule: Record<string, number>
   }
+  quality: RepoQualityScore
+  maintenanceRisk: MaintenanceRiskMetrics
+}
+
+export interface RepoQualityScore {
+  overall: number
+  dimensions: {
+    architecture: number
+    complexity: number
+    'ai-patterns': number
+    testing: number
+  }
+}
+
+export interface RiskHotspot {
+  file: string
+  driftScore: number
+  complexityIssues: number
+  hasNearbyTests: boolean
+  changeFrequency: number
+  risk: number
+  reasons: string[]
+}
+
+export interface MaintenanceRiskMetrics {
+  score: number
+  level: 'low' | 'medium' | 'high' | 'critical'
+  hotspots: RiskHotspot[]
+  signals: {
+    highComplexityFiles: number
+    filesWithoutNearbyTests: number
+    frequentChangeFiles: number
+  }
 }
 
 export interface AIOutput {
@@ -35,8 +70,13 @@ export interface AIOutput {
     total_issues: number
     files_affected: number
     files_clean: number
+    ai_likelihood: number
+    ai_code_smell_score: number
   }
+  files_suspected: Array<{ path: string; ai_likelihood: number; triggers: string[] }>
   priority_order: AIIssue[]
+  maintenance_risk: MaintenanceRiskMetrics
+  quality: RepoQualityScore
   context_for_ai: {
     project_type: string
     scan_path: string
@@ -86,6 +126,40 @@ export interface ModuleBoundary {
 export interface DriftConfig {
   layers?: LayerDefinition[]
   modules?: ModuleBoundary[]
+  plugins?: string[]
+  architectureRules?: {
+    controllerNoDb?: boolean
+    serviceNoHttp?: boolean
+    maxFunctionLines?: number
+  }
+}
+
+export interface PluginRuleContext {
+  projectRoot: string
+  filePath: string
+  config?: DriftConfig
+}
+
+export interface DriftPluginRule {
+  name: string
+  severity?: DriftIssue['severity']
+  weight?: number
+  detect: (file: SourceFile, context: PluginRuleContext) => DriftIssue[]
+}
+
+export interface DriftPlugin {
+  name: string
+  rules: DriftPluginRule[]
+}
+
+export interface LoadedPlugin {
+  id: string
+  plugin: DriftPlugin
+}
+
+export interface PluginLoadError {
+  pluginId: string
+  message: string
 }
 
 // ---------------------------------------------------------------------------
@@ -155,4 +229,4 @@ export interface DriftTrendReport extends DriftReport {
 /** Extended DriftReport with blame data */
 export interface DriftBlameReport extends DriftReport {
   blame: BlameAttribution[];
-}
+}

package/src/utils.ts

@@ -1,7 +1,9 @@
+// drift-ignore-file
+
 import kleur from 'kleur'
 import type { DriftIssue } from './types.js'
 
-export interface Grade {
+interface Grade {
   badge: string
   label: string
 }

package/tests/new-features.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { analyzeProject } from '../src/analyzer.js'
+import { buildReport, formatAIOutput } from '../src/reporter.js'
+import { formatReviewMarkdown, type DriftReview } from '../src/review.js'
+import { generateArchitectureSvg } from '../src/map.js'
+import { applyFixes } from '../src/fix.js'
+
+describe('new feature MVP', () => {
+  let tmpDir = ''
+
+  afterEach(() => {
+    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true })
+    tmpDir = ''
+  })
+
+  it('includes ai_likelihood and suspected files in --ai output', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-ai-output-'))
+    writeFileSync(join(tmpDir, 'bad.ts'), [
+      'function x(a: any) {',
+      '  // return value',
+      '  if (a) return 1',
+      '  return 0',
+      '}',
+      'const URL = "https://api.example.com"',
+    ].join('\n'))
+
+    const files = analyzeProject(tmpDir)
+    const report = buildReport(tmpDir, files)
+    const ai = formatAIOutput(report)
+
+    expect(ai.summary.ai_likelihood).toBeGreaterThanOrEqual(0)
+    expect(typeof ai.summary.ai_code_smell_score).toBe('number')
+    expect(Array.isArray(ai.files_suspected)).toBe(true)
+    expect(ai.maintenance_risk).toBeDefined()
+    expect(ai.quality).toBeDefined()
+  })
+
+  it('formats review markdown for PR comments', () => {
+    const review: DriftReview = {
+      baseRef: 'origin/main',
+      scannedAt: new Date().toISOString(),
+      totalDelta: 12,
+      newIssues: 3,
+      resolvedIssues: 1,
+      status: 'regressed',
+      summary: 'Drift regressed.',
+      markdown: '',
+      diff: {
+        baseRef: 'origin/main',
+        projectPath: '/tmp/repo',
+        scannedAt: new Date().toISOString(),
+        files: [{
+          path: 'src/a.ts',
+          scoreBefore: 10,
+          scoreAfter: 20,
+          scoreDelta: 10,
+          newIssues: [],
+          resolvedIssues: [],
+        }],
+        totalScoreBefore: 20,
+        totalScoreAfter: 32,
+        totalDelta: 12,
+        newIssuesCount: 3,
+        resolvedIssuesCount: 1,
+      },
+    }
+
+    const md = formatReviewMarkdown(review)
+    expect(md).toContain('## drift review')
+    expect(md).toContain('Base ref: `origin/main`')
+    expect(md).toContain('src/a.ts')
+  })
+
+  it('detects configurable architecture rules', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-arch-rules-'))
+    mkdirSync(join(tmpDir, 'controllers'))
+    mkdirSync(join(tmpDir, 'services'))
+
+    writeFileSync(join(tmpDir, 'controllers', 'user.controller.ts'), [
+      "import { prisma } from '../db/prisma.js'",
+      'export function getUser() { return prisma.user.findMany() }',
+    ].join('\n'))
+
+    writeFileSync(join(tmpDir, 'services', 'mail.service.ts'), [
+      "import express from 'express'",
+      'export function sendMail() {',
+      '  return express()',
+      '}',
+    ].join('\n'))
+
+    writeFileSync(join(tmpDir, 'services', 'long.service.ts'), [
+      'export function veryLong() {',
+      ...Array.from({ length: 25 }, (_, i) => `  const v${i} = ${i}`),
+      '  return 1',
+      '}',
+    ].join('\n'))
+
+    const reports = analyzeProject(tmpDir, {
+      architectureRules: {
+        controllerNoDb: true,
+        serviceNoHttp: true,
+        maxFunctionLines: 8,
+      },
+    })
+
+    const rules = reports.flatMap((report) => report.issues.map((issue) => issue.rule))
+    expect(rules).toContain('controller-no-db')
+    expect(rules).toContain('service-no-http')
+    expect(rules).toContain('max-function-lines')
+  })
+
+  it('generates architecture SVG map', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-map-'))
+    mkdirSync(join(tmpDir, 'api'))
+    mkdirSync(join(tmpDir, 'domain'))
+    writeFileSync(join(tmpDir, 'domain', 'user.ts'), 'export const x = 1\n')
+    writeFileSync(join(tmpDir, 'api', 'controller.ts'), "import { x } from '../domain/user.js'\nexport const y = x\n")
+
+    const svg = generateArchitectureSvg(tmpDir)
+    expect(svg.startsWith('<svg')).toBe(true)
+    expect(svg).toContain('api')
+    expect(svg).toContain('domain')
+  })
+
+  it('falls back safely when plugin cannot be loaded', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-plugin-fallback-'))
+    writeFileSync(join(tmpDir, 'index.ts'), 'export const x = 1\n')
+
+    const reports = analyzeProject(tmpDir, {
+      plugins: ['./does-not-exist-plugin.js'],
+    })
+
+    const rules = reports.flatMap((report) => report.issues.map((issue) => issue.rule))
+    expect(rules).toContain('plugin-error')
+  })
+
+  it('supports fix preview and write modes', async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-fix-modes-'))
+    const file = join(tmpDir, 'sample.ts')
+    writeFileSync(file, "const x = 1\nconsole.log(x)\n")
+
+    const preview = await applyFixes(file, undefined, { preview: true })
+    expect(preview.length).toBeGreaterThan(0)
+    expect(readFileSync(file, 'utf8')).toContain('console.log')
+
+    const write = await applyFixes(file, undefined, { write: true })
+    expect(write.length).toBeGreaterThan(0)
+    expect(readFileSync(file, 'utf8')).not.toContain('console.log')
+  })
+})