@eduardbar/drift 1.3.0 → 1.5.0

package/scripts/smoke-repo.mjs

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const SMOKE_SCHEMA_VERSION = 'drift-smoke/v1'
+const SMOKE_SCRIPT_VERSION = '1.0.0'
+const DEFAULT_BASE_REF = 'HEAD~1'
+const SNIPPET_MAX_LINES = 24
+const SNIPPET_MAX_CHARS = 2400
+const LOG_MAX_BUFFER = 32 * 1024 * 1024
+
+function printHelp() {
+  process.stdout.write(
+    [
+      'drift repo smoke',
+      '',
+      'Usage:',
+      '  node ./scripts/smoke-repo.mjs <target-path> [--base <ref>] [--out <dir>] [--dry-run]',
+      '',
+      'Options:',
+      `  --base <ref>   Git base ref for review/trust (default: ${DEFAULT_BASE_REF})`,
+      '  --out <dir>    Output directory (default: .drift-smoke/<repo>-<timestamp>)',
+      '  --dry-run      Print planned commands and exit without running them',
+      '  --help         Show this help',
+      '',
+      'Examples:',
+      '  npm run smoke:repo -- ../my-repo',
+      '  npm run smoke:repo -- ../my-repo --base origin/main',
+      '  npm run smoke:repo -- ../my-repo --dry-run',
+      '',
+      'This script is non-destructive for target repos.',
+    ].join('\n') + '\n',
+  )
+}
+
+function nowStamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').replace('Z', '')
+}
+
+function toSnippet(text) {
+  const lines = String(text || '').split(/\r?\n/).slice(0, SNIPPET_MAX_LINES)
+  const joined = lines.join('\n').trim()
+  if (joined.length <= SNIPPET_MAX_CHARS) return joined
+  return `${joined.slice(0, SNIPPET_MAX_CHARS)}...`
+}
+
+function parseArgs(argv) {
+  const options = {
+    targetPath: '.',
+    baseRef: DEFAULT_BASE_REF,
+    outDir: undefined,
+    dryRun: false,
+    help: false,
+  }
+  let targetPathSet = false
+
+  let index = 0
+  while (index < argv.length) {
+    const token = argv[index]
+
+    if (token === '--help' || token === '-h') {
+      options.help = true
+      index += 1
+      continue
+    }
+
+    if (token === '--dry-run') {
+      options.dryRun = true
+      index += 1
+      continue
+    }
+
+    if (token === '--base') {
+      const next = argv[index + 1]
+      if (!next) throw new Error('--base requires a value')
+      options.baseRef = next
+      index += 2
+      continue
+    }
+
+    if (token === '--out') {
+      const next = argv[index + 1]
+      if (!next) throw new Error('--out requires a value')
+      options.outDir = next
+      index += 2
+      continue
+    }
+
+    if (token.startsWith('--')) {
+      throw new Error(`Unknown option: ${token}`)
+    }
+
+    if (!targetPathSet) {
+      options.targetPath = token
+      targetPathSet = true
+    } else {
+      throw new Error(`Unexpected positional argument: ${token}`)
+    }
+
+    index += 1
+  }
+
+  return options
+}
+
+function runGit(cwd, args) {
+  return spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    maxBuffer: LOG_MAX_BUFFER,
+  })
+}
+
+function runDriftCommand({ id, description, args, cwd, logsDir, expectFailure, cliPath, tsxLoaderSpecifier }) {
+  const start = Date.now()
+  const startedAt = new Date(start).toISOString()
+  const child = spawnSync(process.execPath, ['--import', tsxLoaderSpecifier, cliPath, ...args], {
+    cwd,
+    encoding: 'utf8',
+    maxBuffer: LOG_MAX_BUFFER,
+  })
+  const end = Date.now()
+  const finishedAt = new Date(end).toISOString()
+
+  const stdout = child.stdout ?? ''
+  const spawnError = child.error ? `${child.error.name}: ${child.error.message}` : ''
+  const stderr = `${child.stderr ?? ''}${spawnError ? `\n${spawnError}\n` : ''}`
+  const stdoutFile = resolve(logsDir, `${id}.stdout.log`)
+  const stderrFile = resolve(logsDir, `${id}.stderr.log`)
+  writeFileSync(stdoutFile, stdout, 'utf8')
+  writeFileSync(stderrFile, stderr, 'utf8')
+
+  const exitCode = child.status == null ? -1 : child.status
+  const signal = child.signal ?? null
+
+  let status = 'fail'
+  if (expectFailure) {
+    status = exitCode === 0 ? 'fail' : 'expected-fail'
+  } else {
+    status = exitCode === 0 ? 'pass' : 'fail'
+  }
+
+  return {
+    id,
+    description,
+    command: `node --import ${tsxLoaderSpecifier} ${cliPath} ${args.join(' ')}`,
+    args,
+    status,
+    expectedFailure: expectFailure,
+    exitCode,
+    signal,
+    durationMs: end - start,
+    startedAt,
+    finishedAt,
+    stdoutSnippet: toSnippet(stdout),
+    stderrSnippet: toSnippet(stderr),
+    stdoutLog: stdoutFile,
+    stderrLog: stderrFile,
+  }
+}
+
+function markdownForSummary(report) {
+  const lines = []
+  lines.push('# drift repository smoke summary')
+  lines.push('')
+  lines.push(`- schema: ${report.schemaVersion}`)
+  lines.push(`- generated_at: ${report.generatedAt}`)
+  lines.push(`- target_repo: ${report.targetPath}`)
+  lines.push(`- base_ref: ${report.baseRef}`)
+  lines.push(`- overall_status: ${report.overallStatus}`)
+  lines.push(`- pass: ${report.totals.pass} | expected-fail: ${report.totals.expectedFail} | fail: ${report.totals.fail}`)
+  lines.push('')
+  lines.push('## Commands')
+  lines.push('')
+  lines.push('| id | status | duration_ms | exit | notes |')
+  lines.push('|---|---|---:|---:|---|')
+
+  for (const result of report.commands) {
+    const note = result.expectedFailure ? 'expected non-zero exit' : 'expected zero exit'
+    lines.push(`| ${result.id} | ${result.status} | ${result.durationMs} | ${result.exitCode} | ${note} |`)
+  }
+
+  lines.push('')
+  lines.push('## Artifacts')
+  lines.push('')
+  lines.push(`- report_json: ${report.artifacts.reportJson}`)
+  lines.push(`- summary_md: ${report.artifacts.summaryMarkdown}`)
+  lines.push(`- trust_json: ${report.artifacts.trustJson}`)
+  lines.push(`- architecture_svg: ${report.artifacts.architectureSvg}`)
+  lines.push(`- html_report: ${report.artifacts.htmlReport}`)
+  lines.push(`- kpi_json: ${report.artifacts.kpiJson}`)
+
+  return `${lines.join('\n')}\n`
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2))
+  if (opts.help) {
+    printHelp()
+    return
+  }
+
+  const scriptPath = fileURLToPath(import.meta.url)
+  const repoRoot = resolve(scriptPath, '..', '..')
+  const cliPath = resolve(repoRoot, 'src', 'cli.ts')
+  const packageJsonPath = resolve(repoRoot, 'package.json')
+  const tsxLoaderPath = resolve(repoRoot, 'node_modules', 'tsx', 'dist', 'loader.mjs')
+  if (!existsSync(tsxLoaderPath)) {
+    throw new Error(`Missing tsx loader at ${tsxLoaderPath}. Run npm ci in drift repository first.`)
+  }
+  const tsxLoaderSpecifier = pathToFileURL(tsxLoaderPath).href
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+
+  const targetPath = resolve(process.cwd(), opts.targetPath)
+  const targetStat = statSync(targetPath)
+  if (!targetStat.isDirectory()) {
+    throw new Error(`Target path must be a directory: ${targetPath}`)
+  }
+  const outputDir = opts.outDir
+    ? resolve(process.cwd(), opts.outDir)
+    : resolve(repoRoot, '.drift-smoke', `${basename(targetPath) || 'repo'}-${nowStamp()}`)
+
+  const logsDir = resolve(outputDir, 'logs')
+  const artifactsDir = resolve(outputDir, 'artifacts')
+  const trustDir = resolve(artifactsDir, 'trust')
+
+  const trustJson = resolve(trustDir, 'drift-trust.json')
+  const architectureSvg = resolve(artifactsDir, 'architecture.svg')
+  const htmlReport = resolve(artifactsDir, 'drift-report.html')
+  const kpiJson = resolve(artifactsDir, 'trust-kpi.json')
+  const reportJson = resolve(outputDir, 'smoke-report.json')
+  const summaryMarkdown = resolve(outputDir, 'smoke-summary.md')
+
+  const gitRepoProbe = runGit(targetPath, ['rev-parse', '--is-inside-work-tree'])
+  const isGitRepo = gitRepoProbe.status === 0
+  const gitBaseProbe = isGitRepo ? runGit(targetPath, ['rev-parse', '--verify', `${opts.baseRef}^{commit}`]) : null
+  const baseRefResolvable = Boolean(gitBaseProbe && gitBaseProbe.status === 0)
+  const gitReady = isGitRepo && baseRefResolvable
+
+  const plan = [
+    {
+      id: 'scan-json',
+      description: 'scan output as JSON',
+      args: ['scan', '.', '--json'],
+      expectFailure: false,
+    },
+    {
+      id: 'scan-ai',
+      description: 'scan output as AI JSON',
+      args: ['scan', '.', '--ai'],
+      expectFailure: false,
+    },
+    {
+      id: 'review-base-json',
+      description: 'review against base ref as JSON',
+      args: ['review', '--base', opts.baseRef, '--json'],
+      expectFailure: !gitReady,
+    },
+    {
+      id: 'trust-base-json-output',
+      description: 'trust JSON + trust artifact output',
+      args: ['trust', '.', '--base', opts.baseRef, '--json', '--json-output', trustJson],
+      expectFailure: !gitReady,
+    },
+    {
+      id: 'trust-gate-strict',
+      description: 'strict trust gate expected to fail',
+      args: ['trust-gate', trustJson, '--min-trust', '101', '--max-risk', 'LOW'],
+      expectFailure: true,
+    },
+    {
+      id: 'trust-gate-relaxed',
+      description: 'relaxed trust gate expected to pass',
+      args: ['trust-gate', trustJson, '--min-trust', '0', '--max-risk', 'CRITICAL'],
+      expectFailure: !gitReady,
+    },
+    {
+      id: 'fix-preview',
+      description: 'fix preview mode only',
+      args: ['fix', '.', '--preview'],
+      expectFailure: false,
+    },
+    {
+      id: 'map-output',
+      description: 'generate architecture map artifact',
+      args: ['map', '.', '--output', architectureSvg],
+      expectFailure: false,
+    },
+    {
+      id: 'report-output',
+      description: 'generate html report artifact',
+      args: ['report', '.', '--output', htmlReport],
+      expectFailure: false,
+    },
+    {
+      id: 'kpi-trust-artifacts',
+      description: 'compute trust KPIs from artifacts',
+      args: ['kpi', trustDir],
+      expectFailure: false,
+      captureStdoutAs: kpiJson,
+    },
+  ]
+
+  if (opts.dryRun) {
+    process.stdout.write(`drift smoke dry-run (${SMOKE_SCHEMA_VERSION})\n`)
+    process.stdout.write(`target: ${targetPath}\n`)
+    process.stdout.write(`base: ${opts.baseRef}\n`)
+    process.stdout.write(`output: ${outputDir}\n`)
+    process.stdout.write(`git_ready: ${gitReady}\n\n`)
+    for (const item of plan) {
+        process.stdout.write(`- ${item.id}: node --import ${tsxLoaderSpecifier} ${cliPath} ${item.args.join(' ')}\n`)
+    }
+    return
+  }
+
+  mkdirSync(logsDir, { recursive: true })
+  mkdirSync(trustDir, { recursive: true })
+
+  const commandResults = []
+
+  for (const item of plan) {
+    const result = runDriftCommand({
+      id: item.id,
+      description: item.description,
+      args: item.args,
+      cwd: targetPath,
+      logsDir,
+      expectFailure: item.expectFailure,
+      cliPath,
+      tsxLoaderSpecifier,
+    })
+
+    if (item.captureStdoutAs) {
+      writeFileSync(item.captureStdoutAs, readFileSync(result.stdoutLog, 'utf8'), 'utf8')
+    }
+
+    commandResults.push(result)
+  }
+
+  const totals = {
+    pass: commandResults.filter((result) => result.status === 'pass').length,
+    expectedFail: commandResults.filter((result) => result.status === 'expected-fail').length,
+    fail: commandResults.filter((result) => result.status === 'fail').length,
+  }
+
+  const overallStatus = totals.fail > 0 ? 'fail' : 'pass'
+
+  const report = {
+    schemaVersion: SMOKE_SCHEMA_VERSION,
+    smokeScriptVersion: SMOKE_SCRIPT_VERSION,
+    driftVersion: packageJson.version,
+    generatedAt: new Date().toISOString(),
+    targetPath,
+    baseRef: opts.baseRef,
+    outputDir,
+    overallStatus,
+    gitContext: {
+      isGitRepo,
+      baseRefResolvable,
+      gitReady,
+    },
+    totals,
+    artifacts: {
+      reportJson,
+      summaryMarkdown,
+      trustJson,
+      architectureSvg,
+      htmlReport,
+      kpiJson,
+    },
+    commands: commandResults,
+  }
+
+  writeFileSync(reportJson, `${JSON.stringify(report, null, 2)}\n`, 'utf8')
+  writeFileSync(summaryMarkdown, markdownForSummary(report), 'utf8')
+
+  process.stdout.write(`drift smoke complete: ${overallStatus.toUpperCase()}\n`)
+  process.stdout.write(`report: ${reportJson}\n`)
+  process.stdout.write(`summary: ${summaryMarkdown}\n`)
+
+  if (overallStatus === 'fail') {
+    process.exitCode = 1
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error)
+  process.stderr.write(`Error: ${message}\n`)
+  process.exit(1)
+}

package/src/benchmark.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs'
 import * as path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { analyzeProject } from './analyzer.js'
 import { loadConfig } from './config.js'
 import { buildReport } from './reporter.js'
@@ -23,10 +24,14 @@ interface TaskResult {
   warmupRuns: number
   measuredRuns: number
   samplesMs: number[]
+  samplesRssMb: number[]
   medianMs: number
   meanMs: number
   minMs: number
   maxMs: number
+  medianRssMb: number
+  meanRssMb: number
+  maxRssMb: number
 }
 
 interface BenchmarkOutput {
@@ -40,6 +45,33 @@ interface BenchmarkOutput {
   results: TaskResult[]
 }
 
+const DEFAULT_SCAN_PATH = '.'
+const DEFAULT_REVIEW_PATH = '.'
+const DEFAULT_TRUST_PATH = '.'
+const DEFAULT_BASE_REF = 'HEAD~1'
+const DEFAULT_WARMUP_RUNS = 1
+const DEFAULT_MEASURED_RUNS = 5
+
+const TABLE_WIDTHS = {
+  task: 10,
+  warmup: 8,
+  runs: 6,
+  median: 13,
+  mean: 11,
+  min: 10,
+  max: 10,
+} as const
+
+const TABLE_COLUMNS = [
+  { key: 'task', header: 'task' },
+  { key: 'warmup', header: 'warmup' },
+  { key: 'runs', header: 'runs' },
+  { key: 'median', header: 'median(ms)' },
+  { key: 'mean', header: 'mean(ms)' },
+  { key: 'min', header: 'min(ms)' },
+  { key: 'max', header: 'max(ms)' },
+] as const
+
 function parseNumberFlag(value: string, flagName: string): number {
   const parsed = Number(value)
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -50,55 +82,31 @@ function parseNumberFlag(value: string, flagName: string): number {
 
 function parseOptions(argv: string[]): BenchmarkOptions {
   const options: BenchmarkOptions = {
-    scanPath: '.',
-    reviewPath: '.',
-    trustPath: '.',
-    baseRef: 'HEAD~1',
-    warmupRuns: 1,
-    measuredRuns: 5,
+    scanPath: DEFAULT_SCAN_PATH,
+    reviewPath: DEFAULT_REVIEW_PATH,
+    trustPath: DEFAULT_TRUST_PATH,
+    baseRef: DEFAULT_BASE_REF,
+    warmupRuns: DEFAULT_WARMUP_RUNS,
+    measuredRuns: DEFAULT_MEASURED_RUNS,
+  }
+
+  const handlers: Record<string, (value: string) => void> = {
+    '--scan-path': (value) => { options.scanPath = value },
+    '--review-path': (value) => { options.reviewPath = value },
+    '--trust-path': (value) => { options.trustPath = value },
+    '--base': (value) => { options.baseRef = value },
+    '--warmup': (value) => { options.warmupRuns = parseNumberFlag(value, '--warmup') },
+    '--runs': (value) => { options.measuredRuns = parseNumberFlag(value, '--runs') },
+    '--json-out': (value) => { options.jsonOut = value },
   }
 
-  for (let i = 0; i < argv.length; i += 1) {
+  for (let i = 0; i < argv.length; i += 2) {
     const arg = argv[i]
     const next = argv[i + 1]
+    const handler = handlers[arg]
 
-    if (arg === '--scan-path' && next) {
-      options.scanPath = next
-      i += 1
-      continue
-    }
-    if (arg === '--review-path' && next) {
-      options.reviewPath = next
-      i += 1
-      continue
-    }
-    if (arg === '--trust-path' && next) {
-      options.trustPath = next
-      i += 1
-      continue
-    }
-    if (arg === '--base' && next) {
-      options.baseRef = next
-      i += 1
-      continue
-    }
-    if (arg === '--warmup' && next) {
-      options.warmupRuns = parseNumberFlag(next, '--warmup')
-      i += 1
-      continue
-    }
-    if (arg === '--runs' && next) {
-      options.measuredRuns = parseNumberFlag(next, '--runs')
-      i += 1
-      continue
-    }
-    if (arg === '--json-out' && next) {
-      options.jsonOut = next
-      i += 1
-      continue
-    }
-
-    throw new Error(`Unknown or incomplete argument: ${arg}`)
+    if (!handler || !next) throw new Error(`Unknown or incomplete argument: ${arg}`)
+    handler(next)
   }
 
   if (options.measuredRuns < 1) {
@@ -125,6 +133,10 @@ function formatMs(ms: number): string {
   return ms.toFixed(2)
 }
 
+function bytesToMb(bytes: number): number {
+  return bytes / (1024 * 1024)
+}
+
 async function runTask(
   name: TaskResult['name'],
   warmupRuns: number,
@@ -136,28 +148,37 @@ async function runTask(
   }
 
   const samplesMs: number[] = []
+  const samplesRssMb: number[] = []
   for (let i = 0; i < measuredRuns; i += 1) {
+    const rssBefore = process.memoryUsage().rss
     const started = performance.now()
     await task()
     samplesMs.push(performance.now() - started)
+    const rssAfter = process.memoryUsage().rss
+    samplesRssMb.push(bytesToMb(Math.max(rssBefore, rssAfter)))
   }
 
   const total = samplesMs.reduce((sum, sample) => sum + sample, 0)
+  const totalRss = samplesRssMb.reduce((sum, sample) => sum + sample, 0)
   return {
     name,
     warmupRuns,
     measuredRuns,
     samplesMs,
+    samplesRssMb,
     medianMs: median(samplesMs),
     meanMs: total / samplesMs.length,
     minMs: Math.min(...samplesMs),
     maxMs: Math.max(...samplesMs),
+    medianRssMb: median(samplesRssMb),
+    meanRssMb: totalRss / samplesRssMb.length,
+    maxRssMb: Math.max(...samplesRssMb),
   }
 }
 
 function printTable(results: TaskResult[]): void {
-  const headers = ['task', 'warmup', 'runs', 'median(ms)', 'mean(ms)', 'min(ms)', 'max(ms)']
-  const widths = [10, 8, 6, 13, 11, 10, 10]
+  const headers = TABLE_COLUMNS.map((column) => column.header)
+  const widths = TABLE_COLUMNS.map((column) => TABLE_WIDTHS[column.key])
 
   const row = (values: string[]): string => values
     .map((value, index) => value.padEnd(widths[index], ' '))
@@ -208,12 +229,16 @@ async function runTrust(trustPath: string, baseRef: string): Promise<void> {
   buildTrustReport(report, { diff })
 }
 
-async function main(): Promise<void> {
-  const options = parseOptions(process.argv.slice(2))
+async function runReview(reviewPath: string, baseRef: string): Promise<void> {
+  await generateReview(reviewPath, baseRef)
+}
+
+async function main(argv: string[]): Promise<void> {
+  const options = parseOptions(argv)
 
   const results = [
     await runTask('scan', options.warmupRuns, options.measuredRuns, () => runScan(options.scanPath)),
-    await runTask('review', options.warmupRuns, options.measuredRuns, () => generateReview(options.reviewPath, options.baseRef).then(() => undefined)),
+    await runTask('review', options.warmupRuns, options.measuredRuns, () => runReview(options.reviewPath, options.baseRef)),
     await runTask('trust', options.warmupRuns, options.measuredRuns, () => runTrust(options.trustPath, options.baseRef)),
   ]
 
@@ -238,7 +263,21 @@ async function main(): Promise<void> {
   }
 }
 
-main().catch((error) => {
-  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`)
-  process.exit(1)
-})
+function isExecutedAsEntryPoint(): boolean {
+  const entryArg = process.argv[1]
+  if (!entryArg) return false
+  return import.meta.url === pathToFileURL(path.resolve(entryArg)).href
+}
+
+export async function runBenchmarkCli(argv = process.argv.slice(2)): Promise<void> {
+  try {
+    await main(argv)
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`)
+    process.exit(1)
+  }
+}
+
+if (isExecutedAsEntryPoint()) {
+  void runBenchmarkCli()
+}