@eduardbar/drift 1.0.0 → 1.2.0

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,46 @@ export interface ModuleBoundary {
 export interface DriftConfig {
   layers?: LayerDefinition[]
   modules?: ModuleBoundary[]
+  plugins?: string[]
+  architectureRules?: {
+    controllerNoDb?: boolean
+    serviceNoHttp?: boolean
+    maxFunctionLines?: number
+  }
+  saas?: {
+    freeUserThreshold?: number
+    maxRunsPerWorkspacePerMonth?: number
+    maxReposPerWorkspace?: number
+    retentionDays?: 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 +235,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,180 @@
+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('marks cycle and layer violation edges in architecture SVG', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-map-flags-'))
+    mkdirSync(join(tmpDir, 'ui'))
+    mkdirSync(join(tmpDir, 'api'))
+
+    writeFileSync(join(tmpDir, 'ui', 'a.ts'), "import { b } from '../api/b.js'\nexport const a = b\n")
+    writeFileSync(join(tmpDir, 'api', 'b.ts'), "import { a } from '../ui/a.js'\nexport const b = a\n")
+
+    const svg = generateArchitectureSvg(tmpDir, {
+      layers: [
+        {
+          name: 'ui',
+          patterns: [`${tmpDir.replace(/\\/g, '/')}/ui/**`],
+          canImportFrom: ['api'],
+        },
+        {
+          name: 'api',
+          patterns: [`${tmpDir.replace(/\\/g, '/')}/api/**`],
+          canImportFrom: [],
+        },
+      ],
+    })
+
+    expect(svg).toContain('data-kind="cycle"')
+    expect(svg).toContain('data-kind="violation"')
+  })
+
+  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')
+  })
+})

package/tests/saas-foundation.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { analyzeProject } from '../src/analyzer.js'
+import { buildReport } from '../src/reporter.js'
+import { ingestSnapshotFromReport, getSaasSummary } from '../src/saas.js'
+
+function createProjectDir(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix))
+  writeFileSync(join(dir, 'index.ts'), 'export const value = 1\n')
+  return dir
+}
+
+function createReport(projectDir: string) {
+  const files = analyzeProject(projectDir)
+  return buildReport(projectDir, files)
+}
+
+describe('saas foundations', () => {
+  const dirs: string[] = []
+
+  afterEach(() => {
+    for (const dir of dirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('ingest creates snapshot and summary stays consistent', () => {
+    const projectDir = createProjectDir('drift-saas-ingest-')
+    dirs.push(projectDir)
+    const storeFile = join(projectDir, '.drift-cloud', 'store.json')
+
+    const report = createReport(projectDir)
+    const snapshot = ingestSnapshotFromReport(report, {
+      workspaceId: 'ws-1',
+      userId: 'user-1',
+      repoName: 'repo-1',
+      storeFile,
+    })
+
+    const summary = getSaasSummary({ storeFile })
+
+    expect(snapshot.workspaceId).toBe('ws-1')
+    expect(summary.usersRegistered).toBe(1)
+    expect(summary.workspacesActive).toBe(1)
+    expect(summary.reposActive).toBe(1)
+    expect(summary.totalSnapshots).toBe(1)
+    expect(summary.phase).toBe('free')
+  })
+
+  it('blocks ingest when workspace exceeds repo limit', () => {
+    const projectDir = createProjectDir('drift-saas-repo-limit-')
+    dirs.push(projectDir)
+    const storeFile = join(projectDir, '.drift-cloud', 'store.json')
+    const report = createReport(projectDir)
+
+    ingestSnapshotFromReport(report, {
+      workspaceId: 'ws-2',
+      userId: 'user-1',
+      repoName: 'repo-a',
+      storeFile,
+      policy: { maxReposPerWorkspace: 1 },
+    })
+
+    expect(() => {
+      ingestSnapshotFromReport(report, {
+        workspaceId: 'ws-2',
+        userId: 'user-1',
+        repoName: 'repo-b',
+        storeFile,
+        policy: { maxReposPerWorkspace: 1 },
+      })
+    }).toThrow(/max repos/i)
+
+    const summary = getSaasSummary({ storeFile, policy: { maxReposPerWorkspace: 1 } })
+    expect(summary.totalSnapshots).toBe(1)
+  })
+
+  it('summary reflects free to paid threshold transition', () => {
+    const projectDir = createProjectDir('drift-saas-threshold-')
+    dirs.push(projectDir)
+    const storeFile = join(projectDir, '.drift-cloud', 'store.json')
+    const report = createReport(projectDir)
+
+    ingestSnapshotFromReport(report, {
+      workspaceId: 'ws-3',
+      userId: 'u-1',
+      repoName: 'repo-a',
+      storeFile,
+      policy: { freeUserThreshold: 2 },
+    })
+    ingestSnapshotFromReport(report, {
+      workspaceId: 'ws-4',
+      userId: 'u-2',
+      repoName: 'repo-b',
+      storeFile,
+      policy: { freeUserThreshold: 2 },
+    })
+
+    const summary = getSaasSummary({ storeFile, policy: { freeUserThreshold: 2 } })
+    expect(summary.usersRegistered).toBe(2)
+    expect(summary.thresholdReached).toBe(true)
+    expect(summary.phase).toBe('paid')
+    expect(summary.freeUsersRemaining).toBe(0)
+  })
+})