feat: add affected test runner for faster test execution

Implements intelligent test selection based on git changes to speed up
local development and precommit hooks. Maps source files to their
corresponding test files, running only affected tests when possible.

Key features:
- Detects changed/staged files using git utilities
- Maps commands to co-located test files
- Maps utils to test files in src/utils/ and test/unit/utils/
- Core files (cli, constants, types) trigger all tests
- Supports --staged, --all, --force, and --coverage flags
- Builds project automatically if needed

Author: jdalton

scripts/test-affected.mjs

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Affected test runner that runs only tests affected by changes.
+ * Uses git utilities to detect changes and maps them to relevant test files.
+ */
+
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+
+import WIN32 from '@socketsecurity/registry/lib/constants/WIN32'
+import { logger } from '@socketsecurity/registry/lib/logger'
+
+import { getTestsToRun } from './utils/affected-test-mapper.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const rootPath = path.join(__dirname, '..')
+const nodeModulesBinPath = path.join(rootPath, 'node_modules', '.bin')
+
+async function main() {
+  try {
+    // Parse arguments
+    const { positionals, values } = parseArgs({
+      options: {
+        staged: {
+          type: 'boolean',
+          default: false,
+        },
+        all: {
+          type: 'boolean',
+          default: false,
+        },
+        force: {
+          type: 'boolean',
+          default: false,
+        },
+        coverage: {
+          type: 'boolean',
+          default: false,
+        },
+      },
+      allowPositionals: true,
+      strict: false,
+    })
+
+    const { all, coverage, force, staged } = values
+    // Support --force as alias for --all for backwards compatibility
+    const runAll = all || force
+
+    // Build first if dist doesn't exist
+    const distIndexPath = path.join(rootPath, 'dist', 'cli.js')
+    if (!existsSync(distIndexPath)) {
+      logger.info('Building project before tests...')
+      const { execSync } = await import('node:child_process')
+      execSync('pnpm run build:dist:src', {
+        cwd: rootPath,
+        stdio: 'inherit',
+      })
+    }
+
+    // Get tests to run
+    const testsToRun = getTestsToRun({ staged, all: runAll })
+
+    // No tests needed
+    if (testsToRun === null) {
+      logger.info('No relevant changes detected, skipping tests')
+      return
+    }
+
+    // Prepare vitest command
+    const vitestCmd = WIN32 ? 'vitest.cmd' : 'vitest'
+    const vitestPath = path.join(nodeModulesBinPath, vitestCmd)
+
+    const vitestArgs = ['--config', '.config/vitest.config.mts', 'run']
+
+    // Add coverage if requested
+    if (coverage) {
+      vitestArgs.push('--coverage')
+    }
+
+    // Add test patterns if not running all
+    if (testsToRun === 'all') {
+      logger.info('Running all tests')
+    } else {
+      logger.info(`Running affected tests: ${testsToRun.join(', ')}`)
+      vitestArgs.push(...testsToRun)
+    }
+
+    // Add any additional arguments
+    if (positionals.length > 0) {
+      vitestArgs.push(...positionals)
+    }
+
+    const spawnOptions = {
+      cwd: rootPath,
+      env: {
+        ...process.env,
+        NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=${process.env.CI ? 8192 : 4096}`.trim(),
+      },
+      stdio: 'inherit',
+    }
+
+    const child = spawn(vitestPath, vitestArgs, spawnOptions)
+
+    child.on('exit', code => {
+      process.exitCode = code || 0
+    })
+  } catch (e) {
+    logger.error('Error running tests:', e.message)
+    process.exitCode = 1
+  }
+}
+
+main().catch(console.error)

scripts/utils/affected-test-mapper.mjs

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Maps changed source files to test files for affected test running.
+ * Uses git utilities from socket-registry to detect changes.
+ */
+
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+
+import {
+  getChangedFilesSync,
+  getStagedFilesSync,
+} from '@socketsecurity/registry/lib/git'
+import { normalizePath } from '@socketsecurity/registry/lib/path'
+
+const rootPath = path.resolve(process.cwd())
+
+/**
+ * Core files that require running all tests when changed.
+ */
+const CORE_FILES = [
+  'src/cli.mts',
+  'src/constants.mts',
+  'src/types.mts',
+  'src/utils/debug.mts',
+  'src/utils/errors.mts',
+  'src/utils/logger.mts',
+  'src/utils/config.mts',
+  'src/utils/api-helpers.mts',
+]
+
+/**
+ * Patterns that trigger running all tests.
+ */
+const RUN_ALL_PATTERNS = [
+  '.config/',
+  'vitest.config.',
+  'tsconfig',
+  'package.json',
+  'pnpm-lock.yaml',
+  '.env.test',
+]
+
+/**
+ * Map source files to their corresponding test files.
+ * @param {string} filepath - Path to source file
+ * @returns {string[]} Array of test file paths or ['all'] to run all tests
+ */
+function mapSourceToTests(filepath) {
+  const normalized = normalizePath(filepath)
+
+  // Core utilities affect all tests
+  if (CORE_FILES.some(f => normalized.includes(f))) {
+    return ['all']
+  }
+
+  // Config changes run all tests
+  if (RUN_ALL_PATTERNS.some(pattern => normalized.includes(pattern))) {
+    return ['all']
+  }
+
+  // Test files always run themselves
+  if (normalized.includes('.test.')) {
+    return [filepath]
+  }
+
+  // Map command files to their co-located tests
+  if (normalized.startsWith('src/commands/')) {
+    const tests = []
+    // Direct co-located test
+    const dirname = path.dirname(normalized)
+    const basename = path.basename(normalized, path.extname(normalized))
+    const colocatedTest = path.join(dirname, `${basename}.test.mts`)
+    if (existsSync(path.join(rootPath, colocatedTest))) {
+      tests.push(colocatedTest)
+    }
+    // If it's a cmd-* file, also check for cmd-*.test.mts in same directory
+    if (basename.startsWith('cmd-')) {
+      const pattern = path.join(dirname, `${basename}.test.mts`)
+      if (existsSync(path.join(rootPath, pattern))) {
+        tests.push(pattern)
+      }
+    }
+    return tests.length > 0 ? tests : ['all']
+  }
+
+  // Map utils files to their tests
+  if (normalized.startsWith('src/utils/')) {
+    const tests = []
+    const basename = path.basename(normalized, path.extname(normalized))
+
+    // Check for co-located test in src/utils/
+    const colocatedTest = `src/utils/${basename}.test.mts`
+    if (existsSync(path.join(rootPath, colocatedTest))) {
+      tests.push(colocatedTest)
+    }
+
+    // Check for test in test/unit/utils/
+    const testUnitTest = `test/unit/utils/${basename}.test.mts`
+    if (existsSync(path.join(rootPath, testUnitTest))) {
+      tests.push(testUnitTest)
+    }
+
+    return tests.length > 0 ? tests : ['all']
+  }
+
+  // If no specific mapping, run all tests to be safe
+  return ['all']
+}
+
+/**
+ * Get affected test files to run based on changed files.
+ * @param {Object} options
+ * @param {boolean} options.staged - Use staged files instead of all changes
+ * @param {boolean} options.all - Run all tests
+ * @returns {string[] | null} Array of test patterns, 'all', or null if no tests needed
+ */
+export function getTestsToRun(options = {}) {
+  const { all = false, staged = false } = options
+
+  // All mode runs all tests
+  if (all || process.env.FORCE_TEST === '1') {
+    return 'all'
+  }
+
+  // CI always runs all tests
+  if (process.env.CI === 'true') {
+    return 'all'
+  }
+
+  // Get changed files
+  const changedFiles = staged ? getStagedFilesSync() : getChangedFilesSync()
+
+  if (changedFiles.length === 0) {
+    // No changes, skip tests
+    return null
+  }
+
+  const testFiles = new Set()
+  let runAllTests = false
+
+  for (const file of changedFiles) {
+    const normalized = normalizePath(file)
+    const tests = mapSourceToTests(normalized)
+
+    if (tests.includes('all')) {
+      runAllTests = true
+      break
+    }
+
+    for (const test of tests) {
+      testFiles.add(test)
+    }
+  }
+
+  if (runAllTests) {
+    return 'all'
+  }
+
+  if (testFiles.size === 0) {
+    return null
+  }
+
+  return Array.from(testFiles)
+}