@eduardbar/drift 1.3.0 → 1.4.0

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 { 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(JSON.stringify(result, null, 2) + '\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

package/dist/diff.js

@@ -8,6 +8,43 @@ function normalizeIssueText(value) {
         .replace(/\s+/g, ' ')
         .trim();
 }
+const SNIPPET_PREFIX_LENGTH = 80;
+function strictIssueKey(i) {
+    return `${i.rule}:${i.line}:${i.column}`;
+}
+function normalizedIssueKey(i) {
+    const normalizedMessage = normalizeIssueText(i.message);
+    const normalizedSnippetPrefix = normalizeIssueText(i.snippet).slice(0, SNIPPET_PREFIX_LENGTH);
+    return `${i.rule}:${i.severity}:${i.line}:${normalizedMessage}:${normalizedSnippetPrefix}`;
+}
+function buildIssueIndex(issues, getKey, skip) {
+    const index = new Map();
+    for (const [idx, issue] of issues.entries()) {
+        if (skip?.has(idx))
+            continue;
+        const key = getKey(issue);
+        const bucket = index.get(key);
+        if (bucket)
+            bucket.push(idx);
+        else
+            index.set(key, [idx]);
+    }
+    return index;
+}
+function matchIssues(currentIssues, index, state, getKey) {
+    for (const [currentIndex, issue] of currentIssues.entries()) {
+        if (state.matchedCurrentIndexes.has(currentIndex))
+            continue;
+        const bucket = index.get(getKey(issue));
+        if (!bucket || bucket.length === 0)
+            continue;
+        const matchedIndex = bucket.shift();
+        if (matchedIndex === undefined)
+            continue;
+        state.matchedBaseIndexes.add(matchedIndex);
+        state.matchedCurrentIndexes.add(currentIndex);
+    }
+}
 /**
  * Compute the diff between two DriftReports.
  *
@@ -26,58 +63,13 @@ function computeFileDiff(filePath, baseFile, currentFile) {
     const scoreDelta = scoreAfter - scoreBefore;
     const baseIssues = baseFile?.issues ?? [];
     const currentIssues = currentFile?.issues ?? [];
-    const strictIssueKey = (i) => `${i.rule}:${i.line}:${i.column}`;
-    const normalizedIssueKey = (i) => {
-        const normalizedMessage = normalizeIssueText(i.message);
-        const normalizedSnippetPrefix = normalizeIssueText(i.snippet).slice(0, 80);
-        return `${i.rule}:${i.severity}:${i.line}:${normalizedMessage}:${normalizedSnippetPrefix}`;
-    };
     const matchedBaseIndexes = new Set();
     const matchedCurrentIndexes = new Set();
-    const baseStrictIndex = new Map();
-    for (const [index, issue] of baseIssues.entries()) {
-        const key = strictIssueKey(issue);
-        const bucket = baseStrictIndex.get(key);
-        if (bucket)
-            bucket.push(index);
-        else
-            baseStrictIndex.set(key, [index]);
-    }
-    for (const [currentIndex, issue] of currentIssues.entries()) {
-        const key = strictIssueKey(issue);
-        const bucket = baseStrictIndex.get(key);
-        if (!bucket || bucket.length === 0)
-            continue;
-        const matchedIndex = bucket.shift();
-        if (matchedIndex === undefined)
-            continue;
-        matchedBaseIndexes.add(matchedIndex);
-        matchedCurrentIndexes.add(currentIndex);
-    }
-    const baseNormalizedIndex = new Map();
-    for (const [index, issue] of baseIssues.entries()) {
-        if (matchedBaseIndexes.has(index))
-            continue;
-        const key = normalizedIssueKey(issue);
-        const bucket = baseNormalizedIndex.get(key);
-        if (bucket)
-            bucket.push(index);
-        else
-            baseNormalizedIndex.set(key, [index]);
-    }
-    for (const [currentIndex, issue] of currentIssues.entries()) {
-        if (matchedCurrentIndexes.has(currentIndex))
-            continue;
-        const key = normalizedIssueKey(issue);
-        const bucket = baseNormalizedIndex.get(key);
-        if (!bucket || bucket.length === 0)
-            continue;
-        const matchedIndex = bucket.shift();
-        if (matchedIndex === undefined)
-            continue;
-        matchedBaseIndexes.add(matchedIndex);
-        matchedCurrentIndexes.add(currentIndex);
-    }
+    const matchState = { matchedBaseIndexes, matchedCurrentIndexes };
+    const baseStrictIndex = buildIssueIndex(baseIssues, strictIssueKey);
+    matchIssues(currentIssues, baseStrictIndex, matchState, strictIssueKey);
+    const baseNormalizedIndex = buildIssueIndex(baseIssues, normalizedIssueKey, matchedBaseIndexes);
+    matchIssues(currentIssues, baseNormalizedIndex, matchState, normalizedIssueKey);
     const newIssues = currentIssues.filter((_, index) => !matchedCurrentIndexes.has(index));
     const resolvedIssues = baseIssues.filter((_, index) => !matchedBaseIndexes.has(index));
     if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {

package/dist/doctor.d.ts

@@ -0,0 +1,5 @@
+export interface DoctorOptions {
+    json?: boolean;
+}
+export declare function runDoctor(projectPath: string, options?: DoctorOptions): Promise<number>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.js

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import kleur from 'kleur';
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', '.next', 'coverage']);
+const DECIMAL_RADIX = 10;
+const MIN_SUPPORTED_NODE_MAJOR = 18;
+const LOW_MEMORY_SOURCE_FILE_THRESHOLD = 500;
+const DRIFT_CONFIG_CANDIDATES = [
+    'drift.config.ts',
+    'drift.config.js',
+    'drift.config.mjs',
+    'drift.config.cjs',
+    'drift.config.json',
+];
+function parseNodeMajor(version) {
+    const parsed = Number.parseInt(version.replace(/^v/, '').split('.')[0] ?? '0', DECIMAL_RADIX);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function detectDriftConfig(projectPath) {
+    for (const candidate of DRIFT_CONFIG_CANDIDATES) {
+        if (existsSync(join(projectPath, candidate))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function countSourceFiles(projectPath) {
+    let total = 0;
+    const stack = [projectPath];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir)
+            continue;
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)) {
+                stack.push(join(currentDir, entry.name));
+                continue;
+            }
+            if (entry.isDirectory()) {
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const lastDot = entry.name.lastIndexOf('.');
+            if (lastDot === -1)
+                continue;
+            const extension = entry.name.slice(lastDot);
+            if (SOURCE_EXTENSIONS.has(extension)) {
+                total += 1;
+            }
+        }
+    }
+    return total;
+}
+function buildDoctorReport(projectPath) {
+    const nodeMajor = parseNodeMajor(process.version);
+    const packageJsonPath = join(projectPath, 'package.json');
+    const packageJsonFound = existsSync(packageJsonPath);
+    let esm = false;
+    if (packageJsonFound) {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        esm = parsed.type === 'module';
+    }
+    const sourceFilesCount = countSourceFiles(projectPath);
+    return {
+        targetPath: projectPath,
+        node: {
+            version: process.version,
+            major: nodeMajor,
+            supported: nodeMajor >= MIN_SUPPORTED_NODE_MAJOR,
+        },
+        project: {
+            packageJsonFound,
+            esm,
+            tsconfigFound: existsSync(join(projectPath, 'tsconfig.json')),
+            sourceFilesCount,
+            lowMemorySuggested: sourceFilesCount > LOW_MEMORY_SOURCE_FILE_THRESHOLD,
+            driftConfigFile: detectDriftConfig(projectPath),
+        },
+    };
+}
+function printConsoleReport(report) {
+    const icons = {
+        check: kleur.green('✓'),
+        warn: kleur.yellow('⚠'),
+        error: kleur.red('✗'),
+        info: kleur.cyan('ℹ'),
+    };
+    process.stdout.write('\n');
+    process.stdout.write(`${kleur.bold().white('drift doctor')} ${kleur.gray('- environment diagnostics')}\n\n`);
+    const nodeStatus = report.node.supported
+        ? `${icons.check} ${kleur.green('Node runtime supported')}`
+        : `${icons.warn} ${kleur.yellow('Node runtime below recommended minimum (>=18)')}`;
+    process.stdout.write(`${nodeStatus} ${kleur.gray(`(${report.node.version})`)}\n`);
+    if (report.project.packageJsonFound) {
+        process.stdout.write(`${icons.check} package.json found\n`);
+        process.stdout.write(`${icons.info} ESM mode: ${report.project.esm ? kleur.green('yes') : kleur.yellow('no')}\n`);
+    }
+    else {
+        process.stdout.write(`${icons.warn} package.json not found\n`);
+        process.stdout.write(`${icons.info} ESM mode: ${kleur.gray('unknown')}\n`);
+    }
+    if (report.project.tsconfigFound) {
+        process.stdout.write(`${icons.check} tsconfig.json found\n`);
+    }
+    else {
+        process.stdout.write(`${icons.warn} tsconfig.json not found\n`);
+    }
+    process.stdout.write(`${icons.info} Source files (.ts/.tsx/.js/.jsx): ${report.project.sourceFilesCount}\n`);
+    if (report.project.lowMemorySuggested) {
+        process.stdout.write(`${icons.warn} Large codebase detected, consider ${kleur.bold('--low-memory')}\n`);
+    }
+    if (report.project.driftConfigFile) {
+        process.stdout.write(`${icons.check} Drift config: ${report.project.driftConfigFile}\n`);
+    }
+    else {
+        process.stdout.write(`${icons.warn} Drift config not found (drift.config.*)\n`);
+    }
+    process.stdout.write('\n');
+}
+export async function runDoctor(projectPath, options) {
+    const report = buildDoctorReport(projectPath);
+    if (options?.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    }
+    else {
+        printConsoleReport(report);
+    }
+    return 0;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/format.d.ts

@@ -0,0 +1,17 @@
+declare const UNIFIED_FORMAT_VALUES: readonly ["console", "json", "markdown", "ai", "sarif"];
+type UnifiedOutputFormat = (typeof UNIFIED_FORMAT_VALUES)[number];
+type LegacyAlias = {
+    flag: string;
+    used?: boolean;
+    mapsTo: UnifiedOutputFormat;
+};
+interface ResolveOutputFormatOptions {
+    command: string;
+    format?: string;
+    supported: readonly UnifiedOutputFormat[];
+    legacyAliases?: LegacyAlias[];
+    onWarning?: (message: string) => void;
+}
+export declare function resolveOutputFormat(options: ResolveOutputFormatOptions): UnifiedOutputFormat;
+export {};
+//# sourceMappingURL=format.d.ts.map