@eduardbar/drift 1.3.0 → 1.5.0

package/dist/benchmark.js

@@ -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';
@@ -7,6 +8,30 @@ import { generateReview } from './review.js';
 import { buildTrustReport } from './trust.js';
 import { cleanupTempDir, extractFilesAtRef } from './git.js';
 import { computeDiff } from './diff.js';
+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,
+};
+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)' },
+];
 function parseNumberFlag(value, flagName) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 0) {
@@ -16,52 +41,29 @@ function parseNumberFlag(value, flagName) {
 }
 function parseOptions(argv) {
     const options = {
-        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,
     };
-    for (let i = 0; i < argv.length; i += 1) {
+    const handlers = {
+        '--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 += 2) {
         const arg = argv[i];
         const next = argv[i + 1];
-        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}`);
+        const handler = handlers[arg];
+        if (!handler || !next)
+            throw new Error(`Unknown or incomplete argument: ${arg}`);
+        handler(next);
     }
     if (options.measuredRuns < 1) {
         throw new Error('--runs must be at least 1');
@@ -84,31 +86,43 @@ function median(values) {
 function formatMs(ms) {
     return ms.toFixed(2);
 }
+function bytesToMb(bytes) {
+    return bytes / (1024 * 1024);
+}
 async function runTask(name, warmupRuns, measuredRuns, task) {
     for (let i = 0; i < warmupRuns; i += 1) {
         await task();
     }
     const samplesMs = [];
+    const samplesRssMb = [];
     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) {
-    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) => values
         .map((value, index) => value.padEnd(widths[index], ' '))
         .join(' ');
@@ -153,11 +167,14 @@ async function runTrust(trustPath, baseRef) {
     }
     buildTrustReport(report, { diff });
 }
-async function main() {
-    const options = parseOptions(process.argv.slice(2));
+async function runReview(reviewPath, baseRef) {
+    await generateReview(reviewPath, baseRef);
+}
+async function main(argv) {
+    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)),
     ];
     const output = {
@@ -178,8 +195,22 @@ async function main() {
         process.stdout.write(`\nSaved benchmark JSON to ${options.jsonOut}\n`);
     }
 }
-main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exit(1);
-});
+function isExecutedAsEntryPoint() {
+    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)) {
+    try {
+        await main(argv);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    }
+}
+if (isExecutedAsEntryPoint()) {
+    void runBenchmarkCli();
+}
 //# sourceMappingURL=benchmark.js.map

package/dist/cli.js

@@ -14,6 +14,7 @@ import { printConsole, printDiff } from './printer.js';
 import { loadConfig } from './config.js';
 import { extractFilesAtRef, cleanupTempDir } from './git.js';
 import { computeDiff } from './diff.js';
+import { formatGuardJson, runGuard } from './guard.js';
 import { generateHtmlReport } from './report.js';
 import { generateBadge } from './badge.js';
 import { emitCIAnnotations, printCISummary } from './ci.js';
@@ -24,6 +25,11 @@ import { generateArchitectureMap } from './map.js';
 import { changeOrganizationPlan, generateSaasDashboardHtml, getOrganizationEffectiveLimits, getOrganizationUsageSnapshot, getSaasSummary, ingestSnapshotFromReport, listOrganizationPlanChanges, } from './saas.js';
 import { buildTrustReport, explainTrustGatePolicy, formatTrustGatePolicyExplanation, formatTrustJson, renderTrustOutput, shouldFailTrustGate, normalizeMergeRiskLevel, MERGE_RISK_ORDER, detectBranchName, } from './trust.js';
 import { computeTrustKpis, formatTrustKpiConsole, formatTrustKpiJson } from './trust-kpi.js';
+import { runBenchmarkCli } from './benchmark.js';
+import { runInit, INIT_PRESETS } from './init.js';
+import { runDoctor } from './doctor.js';
+import { resolveOutputFormat } from './format.js';
+import { toSarif, diffToSarif } from './sarif.js';
 const program = new Command();
 function parseOptionalPositiveInt(rawValue, flagName) {
     if (rawValue == null)
@@ -51,6 +57,77 @@ function addResourceOptions(command) {
         .option('--max-file-size-kb <n>', 'Skip files above this size and report diagnostics')
         .option('--with-semantic-duplication', 'Keep semantic-duplication rule enabled in low-memory mode');
 }
+function parseOptionalNumber(rawValue, flagName) {
+    if (rawValue == null)
+        return undefined;
+    const value = Number(rawValue);
+    if (!Number.isFinite(value)) {
+        throw new Error(`${flagName} must be a valid number`);
+    }
+    return value;
+}
+function parseBySeverity(rawValue) {
+    if (rawValue == null)
+        return undefined;
+    const spec = rawValue.trim();
+    if (!spec) {
+        throw new Error('--by-severity must not be empty. Expected format: error=0,warning=2,info=5');
+    }
+    const thresholds = {};
+    const seen = new Set();
+    for (const segment of spec.split(',')) {
+        const pair = segment.trim();
+        if (!pair)
+            continue;
+        const equalIndex = pair.indexOf('=');
+        if (equalIndex <= 0 || equalIndex === pair.length - 1) {
+            throw new Error(`Invalid --by-severity entry '${pair}'. Expected key=value (e.g. warning=2).`);
+        }
+        const key = pair.slice(0, equalIndex).trim().toLowerCase();
+        const rawThreshold = pair.slice(equalIndex + 1).trim();
+        if (key !== 'error' && key !== 'warning' && key !== 'info') {
+            throw new Error(`Invalid --by-severity key '${key}'. Allowed keys: error, warning, info.`);
+        }
+        if (seen.has(key)) {
+            throw new Error(`Duplicate --by-severity key '${key}'.`);
+        }
+        const threshold = Number(rawThreshold);
+        if (!Number.isFinite(threshold)) {
+            throw new Error(`Invalid --by-severity value for '${key}': '${rawThreshold}'. Must be a valid number.`);
+        }
+        const severityKey = key;
+        thresholds[severityKey] = threshold;
+        seen.add(severityKey);
+    }
+    if (seen.size === 0) {
+        throw new Error('--by-severity must include at least one threshold. Example: error=0,warning=2');
+    }
+    return thresholds;
+}
+function formatSigned(value) {
+    return value > 0 ? `+${value}` : `${value}`;
+}
+function printGuardSummary(result) {
+    const modeLabel = result.mode === 'diff' ? `diff (${result.baseRef ?? 'unknown base'})` : 'baseline';
+    const statusLabel = result.passed ? 'PASS' : 'FAIL';
+    process.stdout.write('\n');
+    process.stdout.write(`Guard mode: ${modeLabel}\n`);
+    process.stdout.write(`Result: ${statusLabel}\n`);
+    process.stdout.write(`Score delta: ${formatSigned(result.metrics.scoreDelta)}\n`);
+    process.stdout.write(`Total issues delta: ${formatSigned(result.metrics.totalIssuesDelta)}\n`);
+    process.stdout.write(`Severity delta: error=${formatSigned(result.metrics.severityDelta.error)}, warning=${formatSigned(result.metrics.severityDelta.warning)}, info=${formatSigned(result.metrics.severityDelta.info)}\n`);
+    if (result.mode === 'baseline' && result.baselinePath) {
+        process.stdout.write(`Baseline file: ${result.baselinePath}\n`);
+    }
+    if (result.checks.length === 0) {
+        process.stdout.write('Checks: none configured\n');
+        return;
+    }
+    process.stdout.write('Checks:\n');
+    for (const check of result.checks) {
+        process.stdout.write(`  - [${check.passed ? 'PASS' : 'FAIL'}] ${check.id}: ${check.message} (actual=${check.actual}, limit=${check.limit})\n`);
+    }
+}
 function parseTrustGateOverrides(options) {
     const cliMinTrust = options.minTrust ? Number(options.minTrust) : undefined;
     if (options.minTrust && Number.isNaN(cliMinTrust)) {
@@ -95,6 +172,7 @@ addResourceOptions(program
     .command('scan [path]', { isDefault: true })
     .description('Scan a directory for vibe coding drift')
     .option('-o, --output <file>', 'Write report to a Markdown file')
+    .option('--format <type>', 'Output format: console|json|markdown|ai|sarif')
     .option('--json', 'Output raw JSON report')
     .option('--ai', 'Output AI-optimized JSON for LLM consumption')
     .option('--fix', 'Show fix suggestions for each issue')
@@ -106,15 +184,33 @@ addResourceOptions(program
     const files = analyzeProject(resolvedPath, config, resolveAnalysisOptions(options));
     process.stderr.write(`  Found ${files.length} TypeScript file(s)\n\n`);
     const report = buildReport(resolvedPath, files);
-    if (options.ai) {
+    const format = resolveOutputFormat({
+        command: 'scan',
+        format: options.format,
+        supported: ['console', 'json', 'markdown', 'ai', 'sarif'],
+        legacyAliases: [
+            { flag: 'json', used: options.json, mapsTo: 'json' },
+            { flag: 'ai', used: options.ai, mapsTo: 'ai' },
+        ],
+        onWarning: (message) => process.stderr.write(`${message}\n`),
+    });
+    if (format === 'sarif') {
+        process.stdout.write(`${JSON.stringify(toSarif(report), null, 2)}\n`);
+        return;
+    }
+    if (format === 'ai') {
         const aiOutput = formatAIOutput(report);
         process.stdout.write(JSON.stringify(aiOutput, null, 2));
         return;
     }
-    if (options.json) {
+    if (format === 'json') {
         process.stdout.write(JSON.stringify(report, null, 2));
         return;
     }
+    if (format === 'markdown') {
+        process.stdout.write(`${formatMarkdown(report)}\n`);
+        return;
+    }
     printConsole(report, { showFix: options.fix });
     if (options.output) {
         const md = formatMarkdown(report);
@@ -128,9 +224,31 @@ addResourceOptions(program
         process.exit(1);
     }
 }));
+program
+    .command('init')
+    .description('Initialize drift configuration with presets and scaffolding')
+    .option('--preset <type>', `Scaffold config with preset: ${INIT_PRESETS.join(', ')}`)
+    .option('--ci', 'Generate GitHub Actions workflow for drift review')
+    .option('--baseline', 'Create drift-baseline.json with current project score')
+    .action(async (options) => {
+    const projectRoot = resolve('.');
+    try {
+        await runInit(projectRoot, {
+            preset: options.preset,
+            ci: options.ci,
+            baseline: options.baseline,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\n  Error: ${message}\n\n`);
+        process.exit(1);
+    }
+});
 addResourceOptions(program
     .command('diff [ref]')
     .description('Compare current state against a git ref (default: HEAD~1)')
+    .option('--format <type>', 'Output format: console|json|markdown|ai|sarif')
     .option('--json', 'Output raw JSON diff')
     .action(async (ref, options) => {
     const baseRef = ref ?? 'HEAD~1';
@@ -139,6 +257,13 @@ addResourceOptions(program
     let tempDir;
     try {
         process.stderr.write(`\nComputing diff: HEAD vs ${baseRef}...\n\n`);
+        const format = resolveOutputFormat({
+            command: 'diff',
+            format: options.format,
+            supported: ['console', 'json', 'sarif'],
+            legacyAliases: [{ flag: 'json', used: options.json, mapsTo: 'json' }],
+            onWarning: (message) => process.stderr.write(`${message}\n`),
+        });
         // Scan current state
         const config = await loadConfig(projectPath);
         const currentFiles = analyzeProject(projectPath, config, analysisOptions);
@@ -157,7 +282,10 @@ addResourceOptions(program
             })),
         };
         const diff = computeDiff(remappedBase, currentReport, baseRef);
-        if (options.json) {
+        if (format === 'sarif') {
+            process.stdout.write(`${JSON.stringify(diffToSarif(diff), null, 2)}\n`);
+        }
+        else if (format === 'json') {
             process.stdout.write(JSON.stringify(diff, null, 2) + '\n');
         }
         else {
@@ -174,21 +302,81 @@ addResourceOptions(program
             cleanupTempDir(tempDir);
     }
 }));
+addResourceOptions(program
+    .command('guard [path]')
+    .description('Evaluate drift guard thresholds against diff or baseline')
+    .option('--base <ref>', 'Git base ref for diff guard mode')
+    .option('--baseline <file>', 'Baseline file path (default: drift-baseline.json)')
+    .option('--budget <n>', 'Allowed score delta budget')
+    .option('--by-severity <spec>', 'Severity thresholds: error=0,warning=2,info=5')
+    .option('--json', 'Output raw JSON guard result')
+    .action(async (targetPath, options) => {
+    try {
+        const resolvedPath = resolve(targetPath ?? '.');
+        const budget = parseOptionalNumber(options.budget, '--budget');
+        const bySeverity = parseBySeverity(options.bySeverity);
+        const result = await runGuard(resolvedPath, {
+            baseRef: options.base,
+            baselinePath: options.baseline,
+            budget,
+            bySeverity,
+            analysis: resolveAnalysisOptions(options),
+        });
+        if (options.json) {
+            process.stdout.write(`${formatGuardJson(result)}\n`);
+        }
+        else {
+            printGuardSummary(result);
+        }
+        if (!result.passed) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\n  Error: ${message}\n\n`);
+        process.exit(1);
+    }
+}));
+program
+    .command('benchmark')
+    .description('Run benchmark harness for scan/review/trust commands')
+    .allowUnknownOption(true)
+    .action(async () => {
+    await runBenchmarkCli(process.argv.slice(3));
+});
 program
     .command('review')
     .description('Review drift against a base ref and output PR markdown')
     .option('--base <ref>', 'Git base ref to compare against', 'origin/main')
+    .option('--format <type>', 'Output format: console|json|markdown|ai|sarif')
     .option('--json', 'Output structured review JSON')
     .option('--comment', 'Output markdown comment body')
     .option('--fail-on <n>', 'Exit with code 1 if score delta is >= n')
     .action(async (options) => {
     try {
         const review = await generateReview(resolve('.'), options.base);
-        if (options.json) {
+        const format = resolveOutputFormat({
+            command: 'review',
+            format: options.format,
+            supported: ['console', 'json', 'markdown', 'sarif'],
+            legacyAliases: [
+                { flag: 'json', used: options.json, mapsTo: 'json' },
+                { flag: 'comment', used: options.comment, mapsTo: 'markdown' },
+            ],
+            onWarning: (message) => process.stderr.write(`${message}\n`),
+        });
+        if (format === 'sarif') {
+            process.stdout.write(`${JSON.stringify(diffToSarif(review.diff), null, 2)}\n`);
+        }
+        else if (format === 'json') {
             process.stdout.write(JSON.stringify(review, null, 2) + '\n');
         }
+        else if (format === 'markdown') {
+            process.stdout.write(`${review.markdown}\n`);
+        }
         else {
-            process.stdout.write((options.comment ? review.markdown : `${review.summary}\n\n${review.markdown}`) + '\n');
+            process.stdout.write(`${review.summary}\n\n${review.markdown}\n`);
         }
         const failOn = options.failOn ? Number(options.failOn) : undefined;
         if (typeof failOn === 'number' && !Number.isNaN(failOn) && review.totalDelta >= failOn) {
@@ -205,6 +393,7 @@ addResourceOptions(program
     .command('trust [path]')
     .description('Compute merge trust baseline from drift signals')
     .option('--base <ref>', 'Git base ref for diff-aware trust scoring')
+    .option('--format <type>', 'Output format: console|json|markdown|ai|sarif')
     .option('--json', 'Output structured trust JSON')
     .option('--markdown', 'Output trust report as markdown (PR comment ready)')
     .option('-o, --output <file>', 'Write trust output to file')
@@ -284,7 +473,22 @@ addResourceOptions(program
                 snapshots,
             },
         });
-        const rendered = `${renderTrustOutput(trust, options)}\n`;
+        const format = resolveOutputFormat({
+            command: 'trust',
+            format: options.format,
+            supported: ['console', 'json', 'markdown', 'sarif'],
+            legacyAliases: [
+                { flag: 'json', used: options.json, mapsTo: 'json' },
+                { flag: 'markdown', used: options.markdown, mapsTo: 'markdown' },
+            ],
+            onWarning: (message) => process.stderr.write(`${message}\n`),
+        });
+        const rendered = format === 'sarif'
+            ? `${JSON.stringify(toSarif(report), null, 2)}\n`
+            : `${renderTrustOutput(trust, {
+                json: format === 'json',
+                markdown: format === 'markdown',
+            })}\n`;
         process.stdout.write(rendered);
         if (options.output) {
             const outPath = resolve(options.output);
@@ -378,6 +582,20 @@ program
         process.exit(1);
     }
 });
+program
+    .command('doctor')
+    .description('Run project environment diagnostics')
+    .option('--json', 'Output structured doctor JSON')
+    .action(async (opts) => {
+    try {
+        await runDoctor(process.cwd(), { json: opts.json });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\n  Error: ${message}\n\n`);
+        process.exitCode = 1;
+    }
+});
 program
     .command('kpi <path>')
     .description('Aggregate trust KPIs from trust JSON artifacts')
@@ -442,14 +660,31 @@ addResourceOptions(program
 addResourceOptions(program
     .command('ci [path]')
     .description('Emit GitHub Actions annotations and step summary')
+    .option('--format <type>', 'Output format: console|json|markdown|ai|sarif')
+    .option('--json', 'Output raw JSON report (legacy alias for --format json)')
     .option('--min-score <n>', 'Exit with code 1 if overall score exceeds this threshold', '0')
     .action(async (targetPath, options) => {
     const resolvedPath = resolve(targetPath ?? '.');
     const config = await loadConfig(resolvedPath);
     const files = analyzeProject(resolvedPath, config, resolveAnalysisOptions(options));
     const report = buildReport(resolvedPath, files);
-    emitCIAnnotations(report);
-    printCISummary(report);
+    const format = resolveOutputFormat({
+        command: 'ci',
+        format: options.format,
+        supported: ['console', 'json', 'sarif'],
+        legacyAliases: [{ flag: 'json', used: options.json, mapsTo: 'json' }],
+        onWarning: (message) => process.stderr.write(`${message}\n`),
+    });
+    if (format === 'sarif') {
+        process.stdout.write(`${JSON.stringify(toSarif(report), null, 2)}\n`);
+    }
+    else if (format === 'json') {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    }
+    else {
+        emitCIAnnotations(report);
+        printCISummary(report);
+    }
     const minScore = Number(options.minScore);
     if (minScore > 0 && report.totalScore > minScore) {
         process.exit(1);

package/dist/config.js

@@ -1,6 +1,19 @@
 import { existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+function normalizeLegacyConfig(config) {
+    if (config.modules !== undefined) {
+        return config;
+    }
+    const legacyModules = config.moduleBoundaries ?? config.boundaries;
+    if (!legacyModules || legacyModules.length === 0) {
+        return config;
+    }
+    return {
+        ...config,
+        modules: legacyModules,
+    };
+}
 /**
  * Load drift.config.ts / .js / .json from the given project root.
  * Returns undefined if no config file is found.
@@ -23,13 +36,14 @@ export async function loadConfig(projectRoot) {
             const ext = candidate.split('.').pop();
             if (ext === 'json') {
                 const { readFileSync } = await import('node:fs');
-                return JSON.parse(readFileSync(candidate, 'utf-8'));
+                const rawConfig = JSON.parse(readFileSync(candidate, 'utf-8'));
+                return normalizeLegacyConfig(rawConfig);
             }
             // .ts / .js — dynamic import via file URL
             const fileUrl = pathToFileURL(resolve(candidate)).href;
             const mod = await import(fileUrl);
             const config = mod.default ?? mod;
-            return config;
+            return normalizeLegacyConfig(config);
         }
         catch { // drift-ignore
             // drift-ignore: catch-swallow — config is optional; load failure is non-fatal