@eduardbar/drift 0.9.0 → 1.0.0

package/src/rules/phase3-arch.ts

@@ -0,0 +1,179 @@
+import * as path from 'node:path'
+import type { DriftIssue, LayerDefinition, ModuleBoundary } from '../types.js'
+
+/**
+ * DFS cycle detection in a directed import graph.
+ * Returns arrays of file paths that form cycles.
+ */
+export function findCycles(graph: Map<string, Set<string>>): Array<string[]> {
+  const visited = new Set<string>()
+  const inStack = new Set<string>()
+  const cycles: Array<string[]> = []
+
+  function dfs(node: string, stack: string[]): void {
+    visited.add(node)
+    inStack.add(node)
+    stack.push(node)
+
+    for (const neighbor of graph.get(node) ?? []) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor, stack)
+      } else if (inStack.has(neighbor)) {
+        // Found a cycle — extract the cycle portion from the stack
+        const cycleStart = stack.indexOf(neighbor)
+        cycles.push(stack.slice(cycleStart))
+      }
+    }
+
+    stack.pop()
+    inStack.delete(node)
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, [])
+    }
+  }
+
+  return cycles
+}
+
+/**
+ * Detect circular dependencies from the import graph.
+ * Returns a map of filePath → issue (one per unique cycle).
+ */
+export function detectCircularDependencies(
+  importGraph: Map<string, Set<string>>,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue> {
+  const cycles = findCycles(importGraph)
+  const reportedCycleKeys = new Set<string>()
+  const result = new Map<string, DriftIssue>()
+
+  for (const cycle of cycles) {
+    const cycleKey = [...cycle].sort().join('|')
+    if (reportedCycleKeys.has(cycleKey)) continue
+    reportedCycleKeys.add(cycleKey)
+
+    const firstFile = cycle[0]
+    if (!firstFile) continue
+
+    const cycleDisplay = cycle
+      .map(p => path.basename(p))
+      .concat(path.basename(cycle[0])) // close the loop visually: A → B → C → A
+      .join(' → ')
+
+    result.set(firstFile, {
+      rule: 'circular-dependency',
+      severity: ruleWeights['circular-dependency'].severity,
+      message: `Circular dependency detected: ${cycleDisplay}`,
+      line: 1,
+      column: 1,
+      snippet: cycleDisplay,
+    })
+  }
+
+  return result
+}
+
+/**
+ * Detect layer violations based on user-defined layer configuration.
+ * Returns a map of filePath → issues[].
+ */
+export function detectLayerViolations(
+  importGraph: Map<string, Set<string>>,
+  layers: LayerDefinition[],
+  targetPath: string,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue[]> {
+  const result = new Map<string, DriftIssue[]>()
+
+  function getLayer(filePath: string): LayerDefinition | undefined {
+    const rel = filePath.replace(/\\/g, '/')
+    return layers.find(layer =>
+      layer.patterns.some(pattern => {
+        const regexStr = pattern
+          .replace(/\\/g, '/')
+          .replace(/[.+^${}()|[\]]/g, '\\$&')
+          .replace(/\*\*/g, '###DOUBLESTAR###')
+          .replace(/\*/g, '[^/]*')
+          .replace(/###DOUBLESTAR###/g, '.*')
+        return new RegExp(`^${regexStr}`).test(rel)
+      })
+    )
+  }
+
+  for (const [filePath, imports] of importGraph.entries()) {
+    const fileLayer = getLayer(filePath)
+    if (!fileLayer) continue
+
+    for (const importedPath of imports) {
+      const importedLayer = getLayer(importedPath)
+      if (!importedLayer) continue
+      if (importedLayer.name === fileLayer.name) continue
+
+      if (!fileLayer.canImportFrom.includes(importedLayer.name)) {
+        if (!result.has(filePath)) result.set(filePath, [])
+        result.get(filePath)!.push({
+          rule: 'layer-violation',
+          severity: 'error',
+          message: `Layer '${fileLayer.name}' must not import from layer '${importedLayer.name}'`,
+          line: 1,
+          column: 1,
+          snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+        })
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Detect cross-boundary imports based on user-defined module boundary configuration.
+ * Returns a map of filePath → issues[].
+ */
+export function detectCrossBoundaryImports(
+  importGraph: Map<string, Set<string>>,
+  modules: ModuleBoundary[],
+  targetPath: string,
+  ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>,
+): Map<string, DriftIssue[]> {
+  const result = new Map<string, DriftIssue[]>()
+
+  function getModule(filePath: string): ModuleBoundary | undefined {
+    const rel = filePath.replace(/\\/g, '/')
+    return modules.find(m => rel.startsWith(m.root.replace(/\\/g, '/')))
+  }
+
+  for (const [filePath, imports] of importGraph.entries()) {
+    const fileModule = getModule(filePath)
+    if (!fileModule) continue
+
+    for (const importedPath of imports) {
+      const importedModule = getModule(importedPath)
+      if (!importedModule) continue
+      if (importedModule.name === fileModule.name) continue
+
+      const allowedImports = fileModule.allowedExternalImports ?? []
+      const relImported = importedPath.replace(/\\/g, '/')
+      const isAllowed = allowedImports.some(allowed =>
+        relImported.startsWith(allowed.replace(/\\/g, '/'))
+      )
+
+      if (!isAllowed) {
+        if (!result.has(filePath)) result.set(filePath, [])
+        result.get(filePath)!.push({
+          rule: 'cross-boundary-import',
+          severity: 'warning',
+          message: `Module '${fileModule.name}' must not import from module '${importedModule.name}'`,
+          line: 1,
+          column: 1,
+          snippet: `import from '${path.relative(targetPath, importedPath).replace(/\\/g, '/')}'`,
+        })
+      }
+    }
+  }
+
+  return result
+}

package/src/rules/phase5-ai.ts

@@ -0,0 +1,292 @@
+// drift-ignore-file
+import { SourceFile, SyntaxKind } from 'ts-morph'
+import type { DriftIssue } from '../types.js'
+
+export function detectOverCommented(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  for (const fn of file.getFunctions()) {
+    const body = fn.getBody()
+    if (!body) continue
+
+    const bodyText = body.getText()
+    const lines = bodyText.split('\n')
+    const totalLines = lines.length
+
+    if (totalLines < 6) continue
+
+    let commentLines = 0
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*') || trimmed.startsWith('*/')) {
+        commentLines++
+      }
+    }
+
+    const ratio = commentLines / totalLines
+    if (ratio >= 0.4) {
+      issues.push({
+        rule: 'over-commented',
+        severity: 'info',
+        message: `Function has ${Math.round(ratio * 100)}% comment density (${commentLines}/${totalLines} lines). AI documents the obvious instead of the why.`,
+        line: fn.getStartLineNumber(),
+        column: fn.getStartLinePos(),
+        snippet: fn.getName() ? `function ${fn.getName()}` : '(anonymous function)',
+      })
+    }
+  }
+
+  for (const cls of file.getClasses()) {
+    for (const method of cls.getMethods()) {
+      const body = method.getBody()
+      if (!body) continue
+
+      const bodyText = body.getText()
+      const lines = bodyText.split('\n')
+      const totalLines = lines.length
+
+      if (totalLines < 6) continue
+
+      let commentLines = 0
+      for (const line of lines) {
+        const trimmed = line.trim()
+        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*') || trimmed.startsWith('*/')) {
+          commentLines++
+        }
+      }
+
+      const ratio = commentLines / totalLines
+      if (ratio >= 0.4) {
+        issues.push({
+          rule: 'over-commented',
+          severity: 'info',
+          message: `Method '${method.getName()}' has ${Math.round(ratio * 100)}% comment density (${commentLines}/${totalLines} lines). AI documents the obvious instead of the why.`,
+          line: method.getStartLineNumber(),
+          column: method.getStartLinePos(),
+          snippet: `${cls.getName()}.${method.getName()}`,
+        })
+      }
+    }
+  }
+
+  return issues
+}
+
+export function detectHardcodedConfig(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  const CONFIG_PATTERNS: Array<{ pattern: RegExp; label: string }> = [
+    { pattern: /^https?:\/\//i,                          label: 'HTTP/HTTPS URL' },
+    { pattern: /^wss?:\/\//i,                            label: 'WebSocket URL' },
+    { pattern: /^mongodb(\+srv)?:\/\//i,                 label: 'MongoDB connection string' },
+    { pattern: /^postgres(?:ql)?:\/\//i,                 label: 'PostgreSQL connection string' },
+    { pattern: /^mysql:\/\//i,                           label: 'MySQL connection string' },
+    { pattern: /^redis:\/\//i,                           label: 'Redis connection string' },
+    { pattern: /^amqps?:\/\//i,                          label: 'AMQP connection string' },
+    { pattern: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/,  label: 'IP address' },
+    { pattern: /^:[0-9]{2,5}$/,                          label: 'Port number in string' },
+    { pattern: /^\/[a-z]/i,                              label: 'Absolute file path' },
+    { pattern: /localhost(:[0-9]+)?/i,                   label: 'localhost reference' },
+  ]
+
+  const filePath = file.getFilePath().replace(/\\/g, '/')
+  if (filePath.includes('.test.') || filePath.includes('.spec.') || filePath.includes('__tests__')) {
+    return issues
+  }
+
+  for (const node of file.getDescendantsOfKind(SyntaxKind.StringLiteral)) {
+    const value = node.getLiteralValue()
+    if (!value || value.length < 4) continue
+
+    const parent = node.getParent()
+    if (!parent) continue
+    const parentKind = parent.getKindName()
+    if (
+      parentKind === 'ImportDeclaration' ||
+      parentKind === 'ExportDeclaration' ||
+      (parentKind === 'CallExpression' && parent.getText().startsWith('import('))
+    ) continue
+
+    for (const { pattern, label } of CONFIG_PATTERNS) {
+      if (pattern.test(value)) {
+        issues.push({
+          rule: 'hardcoded-config',
+          severity: 'warning',
+          message: `Hardcoded ${label} detected. AI skips environment variables — extract to process.env or a config module.`,
+          line: node.getStartLineNumber(),
+          column: node.getStartLinePos(),
+          snippet: value.length > 60 ? value.slice(0, 60) + '...' : value,
+        })
+        break
+      }
+    }
+  }
+
+  return issues
+}
+
+export function detectInconsistentErrorHandling(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  let hasTryCatch = false
+  let hasDotCatch = false
+  let hasThenErrorHandler = false
+  let firstLine = 0
+
+  // Detectar try/catch
+  const tryCatches = file.getDescendantsOfKind(SyntaxKind.TryStatement)
+  if (tryCatches.length > 0) {
+    hasTryCatch = true
+    firstLine = firstLine || tryCatches[0].getStartLineNumber()
+  }
+
+  // Detectar .catch(handler) en call expressions
+  for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const expr = call.getExpression()
+    if (expr.getKindName() === 'PropertyAccessExpression') {
+      const propAccess = expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression)
+      const propName = propAccess.getName()
+      if (propName === 'catch') {
+        // Verificar que tiene al menos un argumento (handler real, no .catch() vacío)
+        if (call.getArguments().length > 0) {
+          hasDotCatch = true
+          if (!firstLine) firstLine = call.getStartLineNumber()
+        }
+      }
+      // Detectar .then(onFulfilled, onRejected) — segundo argumento = error handler
+      if (propName === 'then' && call.getArguments().length >= 2) {
+        hasThenErrorHandler = true
+        if (!firstLine) firstLine = call.getStartLineNumber()
+      }
+    }
+  }
+
+  const stylesUsed = [hasTryCatch, hasDotCatch, hasThenErrorHandler].filter(Boolean).length
+
+  if (stylesUsed >= 2) {
+    const styles: string[] = []
+    if (hasTryCatch) styles.push('try/catch')
+    if (hasDotCatch) styles.push('.catch()')
+    if (hasThenErrorHandler) styles.push('.then(_, handler)')
+
+    issues.push({
+      rule: 'inconsistent-error-handling',
+      severity: 'warning',
+      message: `Mixed error handling styles: ${styles.join(', ')}. AI uses whatever pattern it saw last — pick one and stick to it.`,
+      line: firstLine || 1,
+      column: 1,
+      snippet: styles.join(' + '),
+    })
+  }
+
+  return issues
+}
+
+export function detectUnnecessaryAbstraction(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+  const fileText = file.getFullText()
+
+  // Interfaces con un solo método
+  for (const iface of file.getInterfaces()) {
+    const methods = iface.getMethods()
+    const properties = iface.getProperties()
+
+    // Solo reportar si tiene exactamente 1 método y 0 propiedades (abstracción pura de comportamiento)
+    if (methods.length !== 1 || properties.length !== 0) continue
+
+    const ifaceName = iface.getName()
+
+    // Contar cuántas veces aparece el nombre en el archivo (excluyendo la declaración misma)
+    const usageCount = (fileText.match(new RegExp(`\\b${ifaceName}\\b`, 'g')) ?? []).length
+    // La declaración misma cuenta como 1 uso, implementaciones cuentan como 1 cada una
+    // Si usageCount <= 2 (declaración + 1 uso), es candidata a innecesaria
+    if (usageCount <= 2) {
+      issues.push({
+        rule: 'unnecessary-abstraction',
+        severity: 'warning',
+        message: `Interface '${ifaceName}' has 1 method and is used only once. AI creates abstractions preemptively — YAGNI.`,
+        line: iface.getStartLineNumber(),
+        column: iface.getStartLinePos(),
+        snippet: `interface ${ifaceName} { ${methods[0].getName()}(...) }`,
+      })
+    }
+  }
+
+  // Clases abstractas con un solo método abstracto y sin implementaciones en el archivo
+  for (const cls of file.getClasses()) {
+    if (!cls.isAbstract()) continue
+
+    const abstractMethods = cls.getMethods().filter(m => m.isAbstract())
+    const concreteMethods = cls.getMethods().filter(m => !m.isAbstract())
+
+    if (abstractMethods.length !== 1 || concreteMethods.length !== 0) continue
+
+    const clsName = cls.getName() ?? ''
+    const usageCount = (fileText.match(new RegExp(`\\b${clsName}\\b`, 'g')) ?? []).length
+
+    if (usageCount <= 2) {
+      issues.push({
+        rule: 'unnecessary-abstraction',
+        severity: 'warning',
+        message: `Abstract class '${clsName}' has 1 abstract method and is extended nowhere in this file. AI over-engineers single-use code.`,
+        line: cls.getStartLineNumber(),
+        column: cls.getStartLinePos(),
+        snippet: `abstract class ${clsName}`,
+      })
+    }
+  }
+
+  return issues
+}
+
+export function detectNamingInconsistency(file: SourceFile): DriftIssue[] {
+  const issues: DriftIssue[] = []
+
+  const isCamelCase = (name: string) => /^[a-z][a-zA-Z0-9]*$/.test(name) && /[A-Z]/.test(name)
+  const isSnakeCase = (name: string) => /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/.test(name)
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function checkFunction(fn: any): void {
+    const vars = fn.getVariableDeclarations()
+    if (vars.length < 3) return  // muy pocas vars para ser significativo
+
+    let camelCount = 0
+    let snakeCount = 0
+    const snakeExamples: string[] = []
+    const camelExamples: string[] = []
+
+    for (const v of vars) {
+      const name = v.getName()
+      if (isCamelCase(name)) {
+        camelCount++
+        if (camelExamples.length < 2) camelExamples.push(name)
+      } else if (isSnakeCase(name)) {
+        snakeCount++
+        if (snakeExamples.length < 2) snakeExamples.push(name)
+      }
+    }
+
+    if (camelCount >= 1 && snakeCount >= 1) {
+      issues.push({
+        rule: 'naming-inconsistency',
+        severity: 'warning',
+        message: `Mixed naming conventions: camelCase (${camelExamples.join(', ')}) and snake_case (${snakeExamples.join(', ')}) in the same scope. AI mixes conventions from different training examples.`,
+        line: fn.getStartLineNumber(),
+        column: fn.getStartLinePos(),
+        snippet: `camelCase: ${camelExamples[0]} / snake_case: ${snakeExamples[0]}`,
+      })
+    }
+  }
+
+  for (const fn of file.getFunctions()) {
+    checkFunction(fn)
+  }
+
+  for (const cls of file.getClasses()) {
+    for (const method of cls.getMethods()) {
+      checkFunction(method)
+    }
+  }
+
+  return issues
+}

package/src/rules/phase8-semantic.ts

@@ -0,0 +1,132 @@
+import * as crypto from 'node:crypto'
+import {
+  SourceFile,
+  SyntaxKind,
+  Node,
+  FunctionDeclaration,
+  ArrowFunction,
+  FunctionExpression,
+  MethodDeclaration,
+} from 'ts-morph'
+import type { DriftIssue } from '../types.js'
+
+export type FunctionLikeNode = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration
+
+/** Normalize a function body to a canonical string (Type-2 clone detection).
+ *  Variable names, parameter names, and numeric/string literals are replaced
+ *  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
+  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++}`)
+      }
+    }
+  })
+
+  function serializeNode(node: Node): string {
+    const kind = node.getKindName()
+
+    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'
+    }
+
+    const children = node.getChildren()
+    if (children.length === 0) return kind
+
+    const childStr = children.map(serializeNode).join('|')
+    return `${kind}(${childStr})`
+  }
+
+  const body = fn.getBody()
+  if (!body) return ''
+  return serializeNode(body)
+}
+
+/** Return a SHA-256 fingerprint for a function body (normalized). */
+export function fingerprintFunction(fn: FunctionLikeNode): string {
+  const normalized = normalizeFunctionBody(fn)
+  return crypto.createHash('sha256').update(normalized).digest('hex')
+}
+
+/** Return all function-like nodes from a SourceFile that are worth comparing:
+ *  - At least MIN_LINES lines in their body
+ *  - Not test helpers (describe/it/test/beforeEach/afterEach)
+ */
+const MIN_LINES = 8
+
+export function collectFunctions(sf: SourceFile): Array<{ fn: FunctionLikeNode; name: string; line: number; col: number }> {
+  const results: Array<{ fn: FunctionLikeNode; name: string; line: number; col: number }> = []
+
+  const kinds = [
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.ArrowFunction,
+    SyntaxKind.MethodDeclaration,
+  ] as const
+
+  for (const kind of kinds) {
+    for (const node of sf.getDescendantsOfKind(kind)) {
+      const body = (node as FunctionLikeNode).getBody()
+      if (!body) continue
+
+      const start = body.getStartLineNumber()
+      const end = body.getEndLineNumber()
+      if (end - start + 1 < MIN_LINES) continue
+
+      // Skip test-framework helpers
+      const name = node.getKind() === SyntaxKind.FunctionDeclaration
+        ? (node as FunctionDeclaration).getName() ?? '<anonymous>'
+        : node.getKind() === SyntaxKind.MethodDeclaration
+          ? (node as MethodDeclaration).getName()
+          : '<anonymous>'
+
+      if (['describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'].includes(name)) continue
+
+      const pos = node.getStart()
+      const lineInfo = sf.getLineAndColumnAtPos(pos)
+
+      results.push({ fn: node as FunctionLikeNode, name, line: lineInfo.line, col: lineInfo.column })
+    }
+  }
+
+  return results
+}
+
+export function calculateScore(issues: DriftIssue[], ruleWeights: Record<string, { severity: DriftIssue['severity']; weight: number }>): number {
+  let raw = 0
+  for (const issue of issues) {
+    raw += ruleWeights[issue.rule]?.weight ?? 5
+  }
+  return Math.min(100, raw)
+}

package/src/rules/shared.ts

@@ -0,0 +1,39 @@
+import {
+  SourceFile,
+  Node,
+  FunctionDeclaration,
+  ArrowFunction,
+  FunctionExpression,
+  MethodDeclaration,
+} from 'ts-morph'
+
+export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration
+
+export function hasIgnoreComment(file: SourceFile, line: number): boolean {
+  const lines = file.getFullText().split('\n')
+  const currentLine = lines[line - 1] ?? ''
+  const prevLine = lines[line - 2] ?? ''
+
+  if (/\/\/\s*drift-ignore\b/.test(currentLine)) return true
+  if (/\/\/\s*drift-ignore\b/.test(prevLine)) return true
+  return false
+}
+
+export function isFileIgnored(file: SourceFile): boolean {
+  const firstLines = file.getFullText().split('\n').slice(0, 10).join('\n') // drift-ignore
+  return /\/\/\s*drift-ignore-file\b/.test(firstLines)
+}
+
+export function getSnippet(node: Node, file: SourceFile): string {
+  const startLine = node.getStartLineNumber()
+  const lines = file.getFullText().split('\n')
+  return lines
+    .slice(Math.max(0, startLine - 1), startLine + 1)
+    .join('\n')
+    .trim()
+    .slice(0, 120) // drift-ignore
+}
+
+export function getFunctionLikeLines(node: FunctionLike): number {
+  return node.getEndLineNumber() - node.getStartLineNumber()
+}

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}`
+}