@eduardbar/drift 1.2.0 → 1.4.0

package/tests/diff.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest'
+import { computeDiff } from '../src/diff.js'
+import type { DriftIssue, DriftReport } from '../src/types.js'
+
+function createReport(pathPrefix: string): DriftReport {
+  return {
+    scannedAt: new Date().toISOString(),
+    targetPath: pathPrefix,
+    files: [
+      {
+        path: `${pathPrefix}/src/a.ts`,
+        score: 10,
+        issues: [
+          {
+            rule: 'magic-number',
+            severity: 'info',
+            message: 'Magic number 42 used directly in logic. Extract to a named constant.',
+            line: 4,
+            column: 10,
+            snippet: 'const answer = 42',
+          },
+        ],
+      },
+    ],
+    totalIssues: 1,
+    totalScore: 10,
+    totalFiles: 1,
+    summary: {
+      errors: 0,
+      warnings: 0,
+      infos: 1,
+      byRule: {
+        'magic-number': 1,
+      },
+    },
+    quality: {
+      overall: 90,
+      dimensions: {
+        architecture: 100,
+        complexity: 90,
+        'ai-patterns': 90,
+        testing: 100,
+      },
+    },
+    maintenanceRisk: {
+      score: 10,
+      level: 'low',
+      hotspots: [],
+      signals: {
+        highComplexityFiles: 0,
+        filesWithoutNearbyTests: 0,
+        frequentChangeFiles: 0,
+      },
+    },
+  }
+}
+
+function withIssues(report: DriftReport, issues: DriftIssue[]): DriftReport {
+  return {
+    ...report,
+    files: report.files.map((file, index) => {
+      if (index !== 0) return file
+      return {
+        ...file,
+        issues,
+      }
+    }),
+    totalIssues: issues.length,
+  }
+}
+
+describe('computeDiff', () => {
+  it('treats slash and backslash file paths as the same file', () => {
+    const base = createReport('C:/repo')
+    const current = createReport('C:\\repo')
+
+    const diff = computeDiff(base, current, 'origin/main')
+
+    expect(diff.files).toHaveLength(0)
+    expect(diff.newIssuesCount).toBe(0)
+    expect(diff.resolvedIssuesCount).toBe(0)
+    expect(diff.totalDelta).toBe(0)
+  })
+
+  it('does not create churn for LF vs CRLF snippets and column noise', () => {
+    const base = createReport('C:/repo')
+    const current = withIssues(createReport('C:/repo'), [
+      {
+        ...base.files[0].issues[0],
+        column: 12,
+        snippet: 'const answer = 42\r\n',
+      },
+    ])
+
+    const diff = computeDiff(base, current, 'origin/main')
+
+    expect(diff.files).toHaveLength(0)
+    expect(diff.newIssuesCount).toBe(0)
+    expect(diff.resolvedIssuesCount).toBe(0)
+    expect(diff.totalDelta).toBe(0)
+  })
+
+  it('still detects genuinely new issues', () => {
+    const base = createReport('C:/repo')
+    const current = withIssues(createReport('C:/repo'), [
+      ...base.files[0].issues,
+      {
+        rule: 'any-abuse',
+        severity: 'warning',
+        message: 'Avoid using any type. Use a specific type or unknown and narrow it safely.',
+        line: 6,
+        column: 9,
+        snippet: 'const value: any = source',
+      },
+    ])
+
+    const diff = computeDiff(base, current, 'origin/main')
+
+    expect(diff.files).toHaveLength(1)
+    expect(diff.newIssuesCount).toBe(1)
+    expect(diff.resolvedIssuesCount).toBe(0)
+    expect(diff.files[0]?.newIssues[0]?.rule).toBe('any-abuse')
+  })
+})

package/tests/format.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it, vi } from 'vitest'
+import { resolveOutputFormat } from '../src/format.js'
+
+describe('resolveOutputFormat', () => {
+  it('defaults to console when no format flags are passed', () => {
+    const format = resolveOutputFormat({
+      command: 'scan',
+      supported: ['console', 'json', 'markdown', 'ai', 'sarif'],
+    })
+
+    expect(format).toBe('console')
+  })
+
+  it('resolves from --format when supported', () => {
+    const format = resolveOutputFormat({
+      command: 'trust',
+      format: 'markdown',
+      supported: ['console', 'json', 'markdown'],
+    })
+
+    expect(format).toBe('markdown')
+  })
+
+  it('maps legacy aliases and emits deprecation warnings', () => {
+    const onWarning = vi.fn()
+
+    const format = resolveOutputFormat({
+      command: 'review',
+      supported: ['console', 'json', 'markdown'],
+      legacyAliases: [{ flag: 'comment', used: true, mapsTo: 'markdown' }],
+      onWarning,
+    })
+
+    expect(format).toBe('markdown')
+    expect(onWarning).toHaveBeenCalledWith("Warning: --comment is deprecated for 'review'. Use --format markdown instead.")
+  })
+
+  it('covers legacy alias mapping per phase-1.4 command', () => {
+    expect(
+      resolveOutputFormat({
+        command: 'scan',
+        supported: ['console', 'json', 'markdown', 'ai', 'sarif'],
+        legacyAliases: [{ flag: 'ai', used: true, mapsTo: 'ai' }],
+      }),
+    ).toBe('ai')
+
+    expect(
+      resolveOutputFormat({
+        command: 'trust',
+        supported: ['console', 'json', 'markdown', 'sarif'],
+        legacyAliases: [{ flag: 'markdown', used: true, mapsTo: 'markdown' }],
+      }),
+    ).toBe('markdown')
+
+    expect(
+      resolveOutputFormat({
+        command: 'diff',
+        supported: ['console', 'json', 'sarif'],
+        legacyAliases: [{ flag: 'json', used: true, mapsTo: 'json' }],
+      }),
+    ).toBe('json')
+
+    expect(
+      resolveOutputFormat({
+        command: 'ci',
+        supported: ['console', 'json', 'sarif'],
+        legacyAliases: [{ flag: 'json', used: true, mapsTo: 'json' }],
+      }),
+    ).toBe('json')
+  })
+
+  it('allows sarif when command supports it', () => {
+    expect(
+      resolveOutputFormat({
+        command: 'scan',
+        format: 'sarif',
+        supported: ['console', 'json', 'markdown', 'ai', 'sarif'],
+      }),
+    ).toBe('sarif')
+
+    expect(
+      resolveOutputFormat({
+        command: 'ci',
+        format: 'sarif',
+        supported: ['console', 'json', 'sarif'],
+      }),
+    ).toBe('sarif')
+
+    expect(
+      resolveOutputFormat({
+        command: 'diff',
+        format: 'sarif',
+        supported: ['console', 'json', 'sarif'],
+      }),
+    ).toBe('sarif')
+
+    expect(
+      resolveOutputFormat({
+        command: 'review',
+        format: 'sarif',
+        supported: ['console', 'json', 'markdown', 'sarif'],
+      }),
+    ).toBe('sarif')
+
+    expect(
+      resolveOutputFormat({
+        command: 'trust',
+        format: 'sarif',
+        supported: ['console', 'json', 'markdown', 'sarif'],
+      }),
+    ).toBe('sarif')
+  })
+
+  it('fails on unsupported format per command', () => {
+    expect(() =>
+      resolveOutputFormat({
+        command: 'diff',
+        format: 'markdown',
+        supported: ['console', 'json', 'sarif'],
+      }),
+    ).toThrow("Format 'markdown' is not supported for 'diff'. Supported formats: console, json, sarif.")
+  })
+
+  it('fails when sarif is not supported by the command', () => {
+    expect(() =>
+      resolveOutputFormat({
+        command: 'guard',
+        format: 'sarif',
+        supported: ['console', 'json'],
+      }),
+    ).toThrow("Format 'sarif' is not supported for 'guard'. Supported formats: console, json.")
+  })
+
+  it('fails when legacy aliases conflict', () => {
+    expect(() =>
+      resolveOutputFormat({
+        command: 'scan',
+        supported: ['console', 'json', 'markdown', 'ai', 'sarif'],
+        legacyAliases: [
+          { flag: 'json', used: true, mapsTo: 'json' },
+          { flag: 'ai', used: true, mapsTo: 'ai' },
+        ],
+      }),
+    ).toThrow("Conflicting legacy format flags for 'scan': json vs ai. Use a single format option.")
+  })
+
+  it('fails when --format conflicts with a legacy alias', () => {
+    expect(() =>
+      resolveOutputFormat({
+        command: 'trust',
+        format: 'json',
+        supported: ['console', 'json', 'markdown', 'sarif'],
+        legacyAliases: [{ flag: 'markdown', used: true, mapsTo: 'markdown' }],
+      }),
+    ).toThrow("Conflicting format flags for 'trust': --format json and legacy alias for markdown.")
+  })
+})

package/tests/new-features.test.ts

@@ -4,10 +4,12 @@ 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 { formatReviewMarkdown } from '../src/review.js'
 import { generateArchitectureSvg } from '../src/map.js'
 import { applyFixes } from '../src/fix.js'
 
+type DriftReview = Parameters<typeof formatReviewMarkdown>[0]
+
 describe('new feature MVP', () => {
   let tmpDir = ''
 
@@ -36,6 +38,12 @@ describe('new feature MVP', () => {
     expect(Array.isArray(ai.files_suspected)).toBe(true)
     expect(ai.maintenance_risk).toBeDefined()
     expect(ai.quality).toBeDefined()
+    expect(ai.$schema).toBe('schemas/drift-ai-output.v1.json')
+    expect(typeof ai.toolVersion).toBe('string')
+    expect(ai.toolVersion.length).toBeGreaterThan(0)
+    expect(report.$schema).toBe('schemas/drift-report.v1.json')
+    expect(typeof report.toolVersion).toBe('string')
+    expect(report.toolVersion.length).toBeGreaterThan(0)
   })
 
   it('formats review markdown for PR comments', () => {
@@ -177,4 +185,75 @@ describe('new feature MVP', () => {
     expect(write.length).toBeGreaterThan(0)
     expect(readFileSync(file, 'utf8')).not.toContain('console.log')
   })
+
+  it('supports low-memory chunked analysis with cross-file rules', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-low-memory-'))
+    writeFileSync(join(tmpDir, 'a.ts'), "import { b } from './b.js'\nexport const a = b\n")
+    writeFileSync(join(tmpDir, 'b.ts'), "import { a } from './a.js'\nexport const b = a\n")
+
+    const fullRules = new Set(analyzeProject(tmpDir).flatMap((report) => report.issues.map((issue) => issue.rule)))
+    const lowMemoryRules = new Set(
+      analyzeProject(tmpDir, undefined, { lowMemory: true, chunkSize: 1, includeSemanticDuplication: true })
+        .flatMap((report) => report.issues.map((issue) => issue.rule)),
+    )
+
+    expect(fullRules.has('circular-dependency')).toBe(true)
+    expect(lowMemoryRules.has('circular-dependency')).toBe(true)
+  }, 15000)
+
+  it('adds diagnostics when max file size guardrail skips files', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-max-file-size-'))
+    writeFileSync(join(tmpDir, 'small.ts'), 'export const ok = 1\n')
+    writeFileSync(join(tmpDir, 'big.ts'), `export const payload = '${'x'.repeat(5000)}'\n`)
+
+    const reports = analyzeProject(tmpDir, undefined, { maxFileSizeKb: 1 })
+    const skipIssues = reports.flatMap((report) => report.issues.filter((issue) => issue.rule === 'analysis-skip-file-size'))
+
+    expect(skipIssues.length).toBeGreaterThan(0)
+    expect(skipIssues[0].message).toContain('maxFileSizeKb')
+  })
+
+  it('adds diagnostics when max files guardrail skips files', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-max-files-'))
+    writeFileSync(join(tmpDir, 'a.ts'), 'export const a = 1\n')
+    writeFileSync(join(tmpDir, 'b.ts'), 'export const b = 2\n')
+    writeFileSync(join(tmpDir, 'c.ts'), 'export const c = 3\n')
+
+    const reports = analyzeProject(tmpDir, undefined, { maxFiles: 1 })
+    const skipped = reports.flatMap((report) => report.issues.filter((issue) => issue.rule === 'analysis-skip-max-files'))
+
+    expect(skipped).toHaveLength(2)
+  })
+
+  it('disables semantic duplication by default in low-memory mode but keeps opt-in', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-low-memory-semantic-'))
+    const functionA = [
+      'export function same(x: number): number {',
+      '  const a = x + 1',
+      '  const b = a * 2',
+      '  const c = b - 3',
+      '  const d = c + 4',
+      '  const e = d * 5',
+      '  const f = e - 6',
+      '  const g = f + 7',
+      '  return g',
+      '}',
+    ].join('\n')
+    const functionB = functionA
+      .replace('same', 'same2')
+      .replace(/\bx\b/g, 'n')
+
+    writeFileSync(join(tmpDir, 'a.ts'), `${functionA}\n`)
+    writeFileSync(join(tmpDir, 'b.ts'), `${functionB}\n`)
+
+    const lowMemoryDefault = analyzeProject(tmpDir, undefined, { lowMemory: true })
+      .flatMap((report) => report.issues.map((issue) => issue.rule))
+    const lowMemoryWithSemantic = analyzeProject(tmpDir, undefined, {
+      lowMemory: true,
+      includeSemanticDuplication: true,
+    }).flatMap((report) => report.issues.map((issue) => issue.rule))
+
+    expect(lowMemoryDefault).not.toContain('semantic-duplication')
+    expect(lowMemoryWithSemantic).toContain('semantic-duplication')
+  })
 })

package/tests/phase1-init-doctor-guard.test.ts

@@ -0,0 +1,199 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { runDoctor } from '../src/doctor.js'
+import { runInit } from '../src/init.js'
+import { evaluateGuard, runGuard } from '../src/guard.js'
+import { analyzeProject } from '../src/analyzer.js'
+import { buildReport } from '../src/reporter.js'
+
+function createTempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix))
+}
+
+describe('phase 1: doctor/init/guard', () => {
+  const tempDirs: string[] = []
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs.length = 0
+  })
+
+  describe('runDoctor', () => {
+    it('prints a basic diagnostic report and exits with code 0', async () => {
+      const projectDir = createTempDir('drift-doctor-basic-')
+      tempDirs.push(projectDir)
+      writeFileSync(join(projectDir, 'index.ts'), 'export const value = 1\n')
+
+      const output: string[] = []
+      vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+        output.push(String(chunk))
+        return true
+      })
+
+      const exitCode = await runDoctor(projectDir)
+      const text = output.join('')
+
+      expect(exitCode).toBe(0)
+      expect(text).toContain('drift doctor')
+      expect(text).toContain('Source files (.ts/.tsx/.js/.jsx): 1')
+    })
+
+    it('prints valid JSON output with expected shape', async () => {
+      const projectDir = createTempDir('drift-doctor-json-')
+      tempDirs.push(projectDir)
+      mkdirSync(join(projectDir, 'src'))
+      writeFileSync(join(projectDir, 'package.json'), JSON.stringify({ type: 'module' }, null, 2))
+      writeFileSync(join(projectDir, 'tsconfig.json'), '{"compilerOptions":{}}\n')
+      writeFileSync(join(projectDir, 'drift.config.ts'), 'export default {}\n')
+      writeFileSync(join(projectDir, 'src', 'app.ts'), 'export const answer = 42\n')
+
+      const output: string[] = []
+      vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+        output.push(String(chunk))
+        return true
+      })
+
+      await runDoctor(projectDir, { json: true })
+      const report = JSON.parse(output.join('')) as {
+        targetPath: string
+        node: { version: string; major: number; supported: boolean }
+        project: {
+          packageJsonFound: boolean
+          esm: boolean
+          tsconfigFound: boolean
+          sourceFilesCount: number
+          lowMemorySuggested: boolean
+          driftConfigFile: string | null
+        }
+      }
+
+      expect(report.targetPath).toBe(projectDir)
+      expect(typeof report.node.version).toBe('string')
+      expect(typeof report.node.major).toBe('number')
+      expect(typeof report.node.supported).toBe('boolean')
+      expect(report.project.packageJsonFound).toBe(true)
+      expect(report.project.esm).toBe(true)
+      expect(report.project.tsconfigFound).toBe(true)
+      expect(report.project.sourceFilesCount).toBe(2)
+      expect(report.project.driftConfigFile).toBe('drift.config.ts')
+      expect(typeof report.project.lowMemorySuggested).toBe('boolean')
+    })
+  })
+
+  describe('runInit', () => {
+    it('creates drift.config.ts when using a valid preset', async () => {
+      const projectDir = createTempDir('drift-init-preset-')
+      tempDirs.push(projectDir)
+
+      await runInit(projectDir, { preset: 'node-backend' })
+
+      const generated = readFileSync(join(projectDir, 'drift.config.ts'), 'utf8')
+      expect(generated).toContain('satisfies DriftConfig')
+      expect(generated).toContain("name: 'api'")
+    })
+
+    it('throws on invalid preset', async () => {
+      const projectDir = createTempDir('drift-init-invalid-')
+      tempDirs.push(projectDir)
+
+      await expect(runInit(projectDir, { preset: 'invalid-preset' })).rejects.toThrow("Invalid preset 'invalid-preset'")
+    })
+
+    it('creates ci workflow when --ci flag is enabled', async () => {
+      const projectDir = createTempDir('drift-init-ci-')
+      tempDirs.push(projectDir)
+
+      await runInit(projectDir, { ci: true })
+
+      const workflowPath = join(projectDir, '.github', 'workflows', 'drift-review.yml')
+      const workflow = readFileSync(workflowPath, 'utf8')
+      expect(workflow).toContain('name: drift PR Review')
+      expect(workflow).toContain('npx drift review --base')
+    })
+
+    it('prints no-actions message when no flags are provided', async () => {
+      const projectDir = createTempDir('drift-init-empty-')
+      tempDirs.push(projectDir)
+
+      const output: string[] = []
+      vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+        output.push(String(chunk))
+        return true
+      })
+
+      await runInit(projectDir, {})
+
+      expect(output.join('')).toContain('No actions taken. Use --preset, --ci, or --baseline flags.')
+    })
+  })
+
+  describe('guard', () => {
+    it('evaluateGuard applies no-regression, budget and severity checks', () => {
+      const evaluation = evaluateGuard({
+        metrics: {
+          scoreDelta: 3,
+          totalIssuesDelta: 1,
+          severityDelta: { error: 1, warning: 0, info: 0 },
+        },
+        budget: 2,
+        bySeverity: { error: 0, warning: 1, info: 0 },
+        enforceNoRegression: {
+          score: true,
+          totalIssues: true,
+        },
+      })
+
+      expect(evaluation.passed).toBe(false)
+      expect(evaluation.checks.some((check) => check.id === 'no-regression-score' && !check.passed)).toBe(true)
+      expect(evaluation.checks.some((check) => check.id === 'no-regression-total-issues' && !check.passed)).toBe(true)
+      expect(evaluation.checks.some((check) => check.id === 'budget-total-delta' && !check.passed)).toBe(true)
+      expect(evaluation.checks.some((check) => check.id === 'severity-error' && !check.passed)).toBe(true)
+    })
+
+    it('runs in baseline mode with inline baseline fixture', async () => {
+      const projectDir = createTempDir('drift-guard-baseline-')
+      tempDirs.push(projectDir)
+      writeFileSync(join(projectDir, 'main.ts'), 'export const value: any = 42\n')
+
+      const reports = analyzeProject(projectDir)
+      const current = buildReport(projectDir, reports)
+
+      const result = await runGuard(projectDir, {
+        baseline: {
+          score: current.totalScore,
+          totalIssues: current.totalIssues,
+          bySeverity: {
+            error: current.summary.errors,
+            warning: current.summary.warnings,
+            info: current.summary.infos,
+          },
+        },
+        budget: 0,
+        bySeverity: { error: 0, warning: 0, info: 0 },
+      })
+
+      expect(result.mode).toBe('baseline')
+      expect(result.passed).toBe(true)
+      expect(result.metrics.scoreDelta).toBe(0)
+      expect(result.metrics.totalIssuesDelta).toBe(0)
+      expect(result.metrics.severityDelta).toEqual({ error: 0, warning: 0, info: 0 })
+      expect(result.checks.some((check) => check.id === 'no-regression-score')).toBe(true)
+      expect(result.checks.some((check) => check.id === 'no-regression-total-issues')).toBe(true)
+    })
+
+    it('throws when guard has no baseRef and no baseline', async () => {
+      const projectDir = createTempDir('drift-guard-missing-anchor-')
+      tempDirs.push(projectDir)
+      writeFileSync(join(projectDir, 'main.ts'), 'export const value = 1\n')
+
+      await expect(runGuard(projectDir, {})).rejects.toThrow(
+        'Guard requires a comparison point: provide baseRef or a baseline (inline or file).',
+      )
+    })
+  })
+})