@eduardbar/drift 0.9.1 → 1.1.0

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/helpers.ts

@@ -0,0 +1,45 @@
+// drift-ignore-file
+import { Project } from 'ts-morph'
+import { analyzeFile } from '../src/analyzer.js'
+import type { DriftConfig } from '../src/types.js'
+import type { FileReport } from '../src/types.js'
+
+/**
+ * Crea un SourceFile temporal en memoria y corre analyzeFile sobre él.
+ * El filePath por defecto es 'test.ts' (no en test/spec para que
+ * hardcoded-config NO lo skip automáticamente).
+ * Acepta un filename opcional para testear .js/.jsx/.tsx.
+ */
+export function analyzeCode(code: string, config?: Partial<DriftConfig>, filename = 'test.ts'): FileReport {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: { allowJs: true, jsx: 1 },  // 1 = JsxEmit.Preserve
+  })
+  const sourceFile = project.createSourceFile(filename, code)
+  return analyzeFile(sourceFile, config as DriftConfig)
+}
+
+/** Extrae solo los nombres de reglas que dispararon */
+export function getRules(code: string, config?: Partial<DriftConfig>, filename = 'test.ts'): string[] {
+  return analyzeCode(code, config, filename).issues.map(i => i.rule)
+}
+
+/** Cuenta cuántas veces disparó una regla específica */
+export function countRule(code: string, rule: string, filePath = 'test.ts'): number {
+  return analyzeCode(code, undefined, filePath).issues.filter(i => i.rule === rule).length
+}
+
+/** Genera N líneas de código válido TypeScript (para large-file) */
+export function generateLines(n: number): string {
+  const lines: string[] = []
+  for (let i = 0; i < n; i++) {
+    lines.push(`const _v${i} = ${i}`)
+  }
+  return lines.join('\n')
+}
+
+/** Genera una función con N líneas de cuerpo (para large-function) */
+export function generateFunction(bodyLines: number): string {
+  const body = Array.from({ length: bodyLines }, (_, i) => `  const _x${i} = ${i}`).join('\n')
+  return `function bigFn(): void {\n${body}\n}`
+}

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')
+  })
+})