@eduardbar/drift 1.3.0 → 1.5.0

package/tests/cli-sarif.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+type CliResult = {
+  status: number | null
+  stdout: string
+  stderr: string
+}
+
+type SarifOutput = {
+  version: string
+  runs: Array<{
+    tool: {
+      driver: {
+        name: string
+      }
+    }
+    results?: Array<{
+      ruleId?: string
+      message?: {
+        text?: string
+      }
+    }>
+  }>
+}
+
+function runCli(args: string[]): CliResult {
+  const result = spawnSync(process.execPath, ['--import', 'tsx', 'src/cli.ts', ...args], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+  })
+
+  return {
+    status: result.status,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  }
+}
+
+function expectValidSarifFrom(result: CliResult): SarifOutput {
+  expect(result.status).toBe(0)
+  expect(result.stderr).not.toContain('Error:')
+
+  const sarif = JSON.parse(result.stdout) as SarifOutput
+  expect(sarif.version).toBe('2.1.0')
+  expect(Array.isArray(sarif.runs)).toBe(true)
+  expect(sarif.runs.length).toBeGreaterThan(0)
+  expect(sarif.runs[0]?.tool.driver.name).toBe('drift')
+  expect(Array.isArray(sarif.runs[0]?.results)).toBe(true)
+
+  return sarif
+}
+
+describe('cli sarif output', () => {
+  let tmpDir = ''
+
+  afterEach(() => {
+    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true })
+    tmpDir = ''
+  })
+
+  it('serializes scan --format sarif output as SARIF JSON', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-cli-sarif-scan-'))
+    writeFileSync(join(tmpDir, 'sample.ts'), 'console.log("debug")\n')
+
+    const result = runCli(['scan', tmpDir, '--format', 'sarif'])
+    const sarif = expectValidSarifFrom(result)
+    expect(sarif.runs[0]?.results?.some((entry) => entry.ruleId === 'debug-leftover')).toBe(true)
+  })
+
+  it('serializes ci --format sarif output as SARIF JSON', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-cli-sarif-ci-'))
+    writeFileSync(join(tmpDir, 'sample.ts'), 'console.log("debug")\n')
+
+    const result = runCli(['ci', tmpDir, '--format', 'sarif'])
+    const sarif = expectValidSarifFrom(result)
+    expect(sarif.runs[0]?.results?.some((entry) => entry.ruleId === 'debug-leftover')).toBe(true)
+  })
+
+  it('serializes trust --format sarif output as SARIF JSON without requiring git base', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'drift-cli-sarif-trust-'))
+    writeFileSync(join(tmpDir, 'sample.ts'), 'console.log("debug")\n')
+
+    const result = runCli(['trust', tmpDir, '--format', 'sarif'])
+    const sarif = expectValidSarifFrom(result)
+    expect(sarif.runs[0]?.results?.some((entry) => entry.ruleId === 'debug-leftover')).toBe(true)
+  })
+
+})

package/tests/docs-drift-check.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const checkScriptPath = join(repoRoot, 'scripts/check-docs-drift.mjs')
+const tempDirs: string[] = []
+
+function runCheck(cwd: string) {
+  return spawnSync(process.execPath, [checkScriptPath], {
+    cwd,
+    encoding: 'utf8',
+  })
+}
+
+function writeFixtureFile(root: string, relativePath: string, content: string) {
+  const filePath = join(root, relativePath)
+  const directory = dirname(filePath)
+  mkdirSync(directory, { recursive: true })
+  writeFileSync(filePath, content, 'utf8')
+}
+
+function createFixture(options?: { agentsVersion?: string; catalogMissingRule?: boolean; readmeCount?: number }) {
+  const fixtureRoot = mkdtempSync(join(tmpdir(), 'drift-docs-check-'))
+  tempDirs.push(fixtureRoot)
+
+  const agentsVersion = options?.agentsVersion ?? '1.4.0'
+  const catalogMissingRule = options?.catalogMissingRule ?? false
+  const readmeCount = options?.readmeCount ?? 2
+
+  writeFixtureFile(fixtureRoot, 'package.json', JSON.stringify({ version: '1.4.0' }, null, 2))
+  writeFixtureFile(
+    fixtureRoot,
+    'src/analyzer.ts',
+    `export const RULE_WEIGHTS = {\n  'large-file': { severity: 'error', weight: 20 },\n  'dead-code': { severity: 'warning', weight: 8 },\n}\n`,
+  )
+
+  const catalogTableRows = catalogMissingRule
+    ? "| `large-file` | error | 20 | phase0-basic | sample |"
+    : [
+      '| `large-file` | error | 20 | phase0-basic | sample |',
+      '| `dead-code` | warning | 8 | phase0-basic | sample |',
+    ].join('\n')
+
+  const catalogTotal = catalogMissingRule ? 1 : 2
+  writeFixtureFile(
+    fixtureRoot,
+    'docs/rules-catalog.md',
+    [
+      '# drift rules catalog (current)',
+      '',
+      'Source of truth: `RULE_WEIGHTS` in `src/analyzer.ts`.',
+      '',
+      '| id | severity | weight | phase/origin | note |',
+      '|---|---|---:|---|---|',
+      catalogTableRows,
+      '',
+      `- Total rule IDs currently defined: **${catalogTotal}**.`,
+      '',
+    ].join('\n'),
+  )
+
+  writeFixtureFile(fixtureRoot, 'README.md', `drift currently defines **${readmeCount} rule IDs** in RULE_WEIGHTS.`)
+  writeFixtureFile(
+    fixtureRoot,
+    'AGENTS.md',
+    [
+      '# AGENTS.md — drift',
+      `- Versión del paquete: \`${agentsVersion}\` (\`package.json\`)`,
+      '- Estado actual: **2 rule IDs** (sample).',
+      '',
+    ].join('\n'),
+  )
+
+  return fixtureRoot
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop()
+    if (!dir) continue
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('docs drift checker', () => {
+  it('passes against the real repository contract', () => {
+    const result = runCheck(repoRoot)
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Docs drift check passed')
+    expect(result.stderr).toBe('')
+  })
+
+  it('fails when AGENTS package version diverges from package.json', () => {
+    const fixtureRoot = createFixture({ agentsVersion: '9.9.9' })
+
+    const result = runCheck(fixtureRoot)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Docs drift check failed:')
+    expect(result.stderr).toContain('AGENTS.md package version (9.9.9) does not match package.json (1.4.0)')
+  })
+
+  it('fails when catalog rule IDs diverge from RULE_WEIGHTS', () => {
+    const fixtureRoot = createFixture({ catalogMissingRule: true, readmeCount: 1 })
+
+    const result = runCheck(fixtureRoot)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('rules missing in docs/rules-catalog.md: dead-code')
+    expect(result.stderr).toContain('README.md rule ID count (1) does not match RULE_WEIGHTS (2)')
+  })
+})

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', () => {
@@ -110,7 +118,7 @@ describe('new feature MVP', () => {
     expect(rules).toContain('controller-no-db')
     expect(rules).toContain('service-no-http')
     expect(rules).toContain('max-function-lines')
-  })
+  }, 15000)
 
   it('generates architecture SVG map', () => {
     tmpDir = mkdtempSync(join(tmpdir(), 'drift-map-'))
@@ -191,7 +199,7 @@ describe('new feature MVP', () => {
 
     expect(fullRules.has('circular-dependency')).toBe(true)
     expect(lowMemoryRules.has('circular-dependency')).toBe(true)
-  })
+  }, 30000)
 
   it('adds diagnostics when max file size guardrail skips files', () => {
     tmpDir = mkdtempSync(join(tmpdir(), 'drift-max-file-size-'))

package/tests/perf-budget-check.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const checkScriptPath = join(repoRoot, 'scripts/check-performance-budget.mjs')
+const tempDirs: string[] = []
+
+function runCheck(cwd: string, args: string[]) {
+  return spawnSync(process.execPath, [checkScriptPath, ...args], {
+    cwd,
+    encoding: 'utf8',
+  })
+}
+
+function writeFixtureFile(root: string, relativePath: string, content: string) {
+  const filePath = join(root, relativePath)
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, content, 'utf8')
+}
+
+function createFixture(options?: {
+  schemaVersion?: string
+  scanMedianMs?: number
+  reviewMedianMs?: number
+  trustMedianMs?: number
+  measuredRuns?: number
+  includeTrustResult?: boolean
+}) {
+  const fixtureRoot = mkdtempSync(join(tmpdir(), 'drift-perf-check-'))
+  tempDirs.push(fixtureRoot)
+
+  const budget = {
+    schemaVersion: options?.schemaVersion ?? 'drift-perf-budget/v1',
+    budgetVersion: 'test-budget',
+    benchmark: {
+      scanPath: 'benchmarks/fixtures/critical',
+      reviewPath: 'benchmarks/fixtures/critical',
+      trustPath: 'benchmarks/fixtures/critical',
+      baseRef: 'HEAD',
+      warmupRuns: 1,
+      measuredRuns: options?.measuredRuns ?? 5,
+    },
+    tolerance: {
+      runtimePct: 10,
+      memoryPct: 10,
+    },
+    tasks: {
+      scan: { maxMedianMs: 1000, maxRssMb: 400 },
+      review: { maxMedianMs: 1200, maxRssMb: 450 },
+      trust: { maxMedianMs: 1400, maxRssMb: 500 },
+    },
+  }
+
+  const benchmarkResult = {
+    meta: {
+      scannedAt: new Date().toISOString(),
+      node: process.version,
+      platform: process.platform,
+      cwd: fixtureRoot,
+    },
+    options: budget.benchmark,
+    results: [
+      {
+        name: 'scan',
+        medianMs: options?.scanMedianMs ?? 800,
+        maxRssMb: 320,
+      },
+      {
+        name: 'review',
+        medianMs: options?.reviewMedianMs ?? 900,
+        maxRssMb: 360,
+      },
+      ...(options?.includeTrustResult === false
+        ? []
+        : [{
+          name: 'trust',
+          medianMs: options?.trustMedianMs ?? 1100,
+          maxRssMb: 390,
+        }]),
+    ],
+  }
+
+  writeFixtureFile(fixtureRoot, 'benchmarks/perf-budget.v1.json', `${JSON.stringify(budget, null, 2)}\n`)
+  writeFixtureFile(fixtureRoot, '.drift-perf/benchmark-sample.json', `${JSON.stringify(benchmarkResult, null, 2)}\n`)
+
+  return fixtureRoot
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop()
+    if (!dir) continue
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('performance budget checker', () => {
+  it('passes when benchmark result stays within budget and tolerance', () => {
+    const fixtureRoot = createFixture()
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Performance budget check passed.')
+  })
+
+  it('fails when runtime budget is exceeded', () => {
+    const fixtureRoot = createFixture({ scanMedianMs: 1300 })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Performance budget check failed:')
+    expect(result.stderr).toContain('scan: median runtime')
+  })
+
+  it('fails when budget schema version is invalid', () => {
+    const fixtureRoot = createFixture({ schemaVersion: 'drift-perf-budget/v0' })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Unsupported budget schemaVersion')
+  })
+
+  it('fails when benchmark output does not include all required tasks', () => {
+    const fixtureRoot = createFixture({ includeTrustResult: false })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain("Benchmark output is missing task 'trust'")
+  })
+
+  it('fails when benchmark measuredRuns is invalid', () => {
+    const fixtureRoot = createFixture({ measuredRuns: 0 })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('benchmark.measuredRuns must be at least 1')
+  })
+})