@eduardbar/drift 1.2.0 → 1.4.0

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

@@ -1,7 +1,59 @@
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function normalizeIssueText(value) {
+    return value
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .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.
  *
- * Issues are matched by (rule + line + column) as a unique key within a file.
+ * Issues are matched in two passes:
+ * 1) strict location key (rule + line + column)
+ * 2) normalized content key (rule + severity + line + message + snippet)
+ *
+ * This keeps deterministic matching while preventing false churn caused by
+ * cross-platform line ending changes and small column offset noise.
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
@@ -11,11 +63,15 @@ function computeFileDiff(filePath, baseFile, currentFile) {
     const scoreDelta = scoreAfter - scoreBefore;
     const baseIssues = baseFile?.issues ?? [];
     const currentIssues = currentFile?.issues ?? [];
-    const issueKey = (i) => `${i.rule}:${i.line}:${i.column}`;
-    const baseKeys = new Set(baseIssues.map(issueKey));
-    const currentKeys = new Set(currentIssues.map(issueKey));
-    const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)));
-    const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)));
+    const matchedBaseIndexes = new Set();
+    const matchedCurrentIndexes = new Set();
+    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) {
         return {
             path: filePath,
@@ -30,11 +86,11 @@ function computeFileDiff(filePath, baseFile, currentFile) {
 }
 export function computeDiff(base, current, baseRef) {
     const fileDiffs = [];
-    const baseByPath = new Map(base.files.map(f => [f.path, f]));
-    const currentByPath = new Map(current.files.map(f => [f.path, f]));
+    const baseByPath = new Map(base.files.map(f => [normalizePath(f.path), f]));
+    const currentByPath = new Map(current.files.map(f => [normalizePath(f.path), f]));
     const allPaths = new Set([
-        ...base.files.map(f => f.path),
-        ...current.files.map(f => f.path),
+        ...base.files.map(f => normalizePath(f.path)),
+        ...current.files.map(f => normalizePath(f.path)),
     ]);
     for (const filePath of allPaths) {
         const baseFile = baseByPath.get(filePath);

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

package/dist/format.js

@@ -0,0 +1,45 @@
+const UNIFIED_FORMAT_VALUES = ['console', 'json', 'markdown', 'ai', 'sarif'];
+function assertSupportedFormatValue(command, format) {
+    if (UNIFIED_FORMAT_VALUES.includes(format))
+        return;
+    throw new Error(`Invalid --format '${format}' for '${command}'. Allowed values: ${UNIFIED_FORMAT_VALUES.join(', ')}.`);
+}
+function throwUnsupportedFormat(command, selected, supported) {
+    throw new Error(`Format '${selected}' is not supported for '${command}'. Supported formats: ${supported.join(', ')}.`);
+}
+function normalizeLegacyFormatSelection(command, selectedLegacyFormats) {
+    if (selectedLegacyFormats.length === 0)
+        return undefined;
+    const uniqueFormats = [...new Set(selectedLegacyFormats)];
+    if (uniqueFormats.length > 1) {
+        throw new Error(`Conflicting legacy format flags for '${command}': ${uniqueFormats.join(' vs ')}. Use a single format option.`);
+    }
+    return uniqueFormats[0];
+}
+export function resolveOutputFormat(options) {
+    const { command, format, supported, onWarning } = options;
+    const legacyAliases = options.legacyAliases ?? [];
+    for (const alias of legacyAliases) {
+        if (!alias.used)
+            continue;
+        onWarning?.(`Warning: --${alias.flag} is deprecated for '${command}'. Use --format ${alias.mapsTo} instead.`);
+    }
+    const selectedLegacyFormat = normalizeLegacyFormatSelection(command, legacyAliases.filter((alias) => alias.used).map((alias) => alias.mapsTo));
+    const selectedFormat = format?.trim();
+    if (selectedFormat) {
+        assertSupportedFormatValue(command, selectedFormat);
+        if (selectedLegacyFormat && selectedLegacyFormat !== selectedFormat) {
+            throw new Error(`Conflicting format flags for '${command}': --format ${selectedFormat} and legacy alias for ${selectedLegacyFormat}.`);
+        }
+        if (!supported.includes(selectedFormat)) {
+            throwUnsupportedFormat(command, selectedFormat, supported);
+        }
+        return selectedFormat;
+    }
+    const resolvedFromLegacy = selectedLegacyFormat ?? 'console';
+    if (!supported.includes(resolvedFromLegacy)) {
+        throwUnsupportedFormat(command, resolvedFromLegacy, supported);
+    }
+    return resolvedFromLegacy;
+}
+//# sourceMappingURL=format.js.map

package/dist/git.js

@@ -54,6 +54,15 @@ function extractFile(projectPath, ref, filePath, tempDir) {
     mkdirSync(destDir, { recursive: true });
     writeFileSync(destPath, content, 'utf-8');
 }
+function extractArchiveAtRef(projectPath, ref, tempDir) {
+    try {
+        execSync(`git archive --format=tar ${ref} | tar -x -C "${tempDir}"`, { cwd: projectPath, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function extractFilesAtRef(projectPath, ref) {
     verifyGitRepo(projectPath);
     verifyRefExists(projectPath, ref);
@@ -63,6 +72,9 @@ export function extractFilesAtRef(projectPath, ref) {
     }
     const tempDir = join(tmpdir(), `drift-diff-${randomUUID()}`);
     mkdirSync(tempDir, { recursive: true });
+    if (extractArchiveAtRef(projectPath, ref, tempDir)) {
+        return tempDir;
+    }
     for (const filePath of tsFiles) {
         extractFile(projectPath, ref, filePath, tempDir);
     }

package/dist/guard-types.d.ts

@@ -0,0 +1,57 @@
+import type { DriftAnalysisOptions, DriftDiff, DriftIssue, DriftReport } from './types.js';
+export type IssueSeverity = DriftIssue['severity'];
+export interface GuardBaseline {
+    score?: number;
+    totalIssues?: number;
+    errors?: number;
+    warnings?: number;
+    infos?: number;
+    bySeverity?: Partial<Record<IssueSeverity, number>>;
+    summary?: {
+        errors?: number;
+        warnings?: number;
+        infos?: number;
+    };
+}
+export interface GuardThresholds {
+    error?: number;
+    warning?: number;
+    info?: number;
+}
+export interface GuardOptions {
+    baseRef?: string;
+    baselinePath?: string;
+    baseline?: GuardBaseline;
+    budget?: number;
+    bySeverity?: GuardThresholds;
+    analysis?: DriftAnalysisOptions;
+}
+export interface GuardMetrics {
+    scoreDelta: number;
+    totalIssuesDelta: number;
+    severityDelta: Record<IssueSeverity, number>;
+}
+export interface GuardCheck {
+    id: string;
+    passed: boolean;
+    actual: number;
+    limit: number;
+    message: string;
+}
+export interface GuardEvaluation {
+    passed: boolean;
+    checks: GuardCheck[];
+}
+export interface GuardResult {
+    scannedAt: string;
+    projectPath: string;
+    mode: 'diff' | 'baseline';
+    passed: boolean;
+    baseRef?: string;
+    baselinePath?: string;
+    metrics: GuardMetrics;
+    checks: GuardCheck[];
+    current: DriftReport;
+    diff?: DriftDiff;
+}
+//# sourceMappingURL=guard-types.d.ts.map

package/dist/guard-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=guard-types.js.map

package/dist/guard.d.ts

@@ -0,0 +1,14 @@
+import type { GuardEvaluation, GuardMetrics, GuardOptions, GuardResult, GuardThresholds } from './guard-types.js';
+interface GuardEvalInput {
+    metrics: GuardMetrics;
+    budget?: number;
+    bySeverity?: GuardThresholds;
+    enforceNoRegression: {
+        score: boolean;
+        totalIssues: boolean;
+    };
+}
+export declare function evaluateGuard(input: GuardEvalInput): GuardEvaluation;
+export declare function runGuard(targetPath: string, options?: GuardOptions): Promise<GuardResult>;
+export {};
+//# sourceMappingURL=guard.d.ts.map

package/dist/guard.js

@@ -0,0 +1,239 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { analyzeProject } from './analyzer.js';
+import { loadConfig } from './config.js';
+import { computeDiff } from './diff.js';
+import { cleanupTempDir, extractFilesAtRef } from './git.js';
+import { buildReport } from './reporter.js';
+function parseNumber(value) {
+    return typeof value === 'number' && !Number.isNaN(value) ? value : undefined;
+}
+function normalizeBaseline(baseline) {
+    const bySeverityFromRoot = baseline.bySeverity;
+    const bySeverity = {
+        error: parseNumber(bySeverityFromRoot?.error) ?? parseNumber(baseline.errors) ?? parseNumber(baseline.summary?.errors),
+        warning: parseNumber(bySeverityFromRoot?.warning) ?? parseNumber(baseline.warnings) ?? parseNumber(baseline.summary?.warnings),
+        info: parseNumber(bySeverityFromRoot?.info) ?? parseNumber(baseline.infos) ?? parseNumber(baseline.summary?.infos),
+    };
+    const normalized = {
+        score: parseNumber(baseline.score),
+        totalIssues: parseNumber(baseline.totalIssues),
+        bySeverity,
+    };
+    const hasAnyAnchor = normalized.score !== undefined ||
+        normalized.totalIssues !== undefined ||
+        normalized.bySeverity.error !== undefined ||
+        normalized.bySeverity.warning !== undefined ||
+        normalized.bySeverity.info !== undefined;
+    if (!hasAnyAnchor) {
+        throw new Error('Invalid guard baseline: expected score, totalIssues, or severity counters (error/warning/info).');
+    }
+    return normalized;
+}
+function readBaselineFromFile(projectPath, baselinePath) {
+    const resolvedBaselinePath = resolve(projectPath, baselinePath ?? 'drift-baseline.json');
+    if (!existsSync(resolvedBaselinePath))
+        return undefined;
+    const raw = JSON.parse(readFileSync(resolvedBaselinePath, 'utf8'));
+    return {
+        baseline: normalizeBaseline(raw),
+        path: resolvedBaselinePath,
+    };
+}
+function remapBaseReportPaths(baseReport, tempDir, projectPath) {
+    return {
+        ...baseReport,
+        files: baseReport.files.map((file) => ({
+            ...file,
+            path: resolve(projectPath, relative(tempDir, file.path)),
+        })),
+    };
+}
+function countSeverityDeltaFromDiff(diff) {
+    const severityDelta = {
+        error: 0,
+        warning: 0,
+        info: 0,
+    };
+    for (const file of diff.files) {
+        for (const issue of file.newIssues) {
+            severityDelta[issue.severity] += 1;
+        }
+        for (const issue of file.resolvedIssues) {
+            severityDelta[issue.severity] -= 1;
+        }
+    }
+    return severityDelta;
+}
+function buildMetricsFromDiff(diff) {
+    return {
+        scoreDelta: diff.totalDelta,
+        totalIssuesDelta: diff.newIssuesCount - diff.resolvedIssuesCount,
+        severityDelta: countSeverityDeltaFromDiff(diff),
+    };
+}
+function buildMetricsFromBaseline(current, baseline) {
+    return {
+        scoreDelta: current.totalScore - (baseline.score ?? current.totalScore),
+        totalIssuesDelta: current.totalIssues - (baseline.totalIssues ?? current.totalIssues),
+        severityDelta: {
+            error: current.summary.errors - (baseline.bySeverity.error ?? current.summary.errors),
+            warning: current.summary.warnings - (baseline.bySeverity.warning ?? current.summary.warnings),
+            info: current.summary.infos - (baseline.bySeverity.info ?? current.summary.infos),
+        },
+    };
+}
+function addCheck(checks, input) {
+    checks.push({
+        id: input.id,
+        passed: input.actual <= input.limit,
+        actual: input.actual,
+        limit: input.limit,
+        message: input.message,
+    });
+}
+export function evaluateGuard(input) {
+    const checks = [];
+    if (input.enforceNoRegression.score) {
+        addCheck(checks, {
+            id: 'no-regression-score',
+            actual: input.metrics.scoreDelta,
+            limit: 0,
+            message: 'Score delta must be <= 0.',
+        });
+    }
+    if (input.enforceNoRegression.totalIssues) {
+        addCheck(checks, {
+            id: 'no-regression-total-issues',
+            actual: input.metrics.totalIssuesDelta,
+            limit: 0,
+            message: 'Total issues delta must be <= 0.',
+        });
+    }
+    if (typeof input.budget === 'number' && !Number.isNaN(input.budget)) {
+        addCheck(checks, {
+            id: 'budget-total-delta',
+            actual: input.metrics.scoreDelta,
+            limit: input.budget,
+            message: `Score delta must be <= budget (${input.budget}).`,
+        });
+    }
+    const severityThresholds = input.bySeverity;
+    if (severityThresholds) {
+        const severities = ['error', 'warning', 'info'];
+        for (const severity of severities) {
+            const threshold = severityThresholds[severity];
+            if (typeof threshold !== 'number' || Number.isNaN(threshold))
+                continue;
+            addCheck(checks, {
+                id: `severity-${severity}`,
+                actual: input.metrics.severityDelta[severity],
+                limit: threshold,
+                message: `${severity} delta must be <= ${threshold}.`,
+            });
+        }
+    }
+    return {
+        passed: checks.every((check) => check.passed),
+        checks,
+    };
+}
+export async function runGuard(targetPath, options = {}) {
+    const runtimeState = await initializeGuardRuntime(targetPath, options);
+    const { projectPath, config, currentReport } = runtimeState;
+    let tempDir;
+    try {
+        if (options.baseRef) {
+            tempDir = extractFilesAtRef(projectPath, options.baseRef);
+            return createDiffGuardResult({
+                projectPath,
+                currentReport,
+                options,
+                tempDir,
+                config,
+                baseRef: options.baseRef,
+            });
+        }
+        const inlineBaseline = options.baseline ? normalizeBaseline(options.baseline) : undefined;
+        const fileBaseline = inlineBaseline ? undefined : readBaselineFromFile(projectPath, options.baselinePath);
+        const baseline = inlineBaseline ?? fileBaseline?.baseline;
+        const baselinePath = fileBaseline?.path;
+        if (!baseline) {
+            throw new Error('Guard requires a comparison point: provide baseRef or a baseline (inline or file).');
+        }
+        return createBaselineGuardResult({
+            projectPath,
+            currentReport,
+            options,
+            baseline,
+            baselinePath,
+        });
+    }
+    finally {
+        if (tempDir)
+            cleanupTempDir(tempDir);
+    }
+}
+async function initializeGuardRuntime(targetPath, options) {
+    const projectPath = resolve(targetPath);
+    const config = await loadConfig(projectPath);
+    const currentFiles = analyzeProject(projectPath, config, options.analysis);
+    const currentReport = buildReport(projectPath, currentFiles);
+    return {
+        projectPath,
+        config,
+        currentReport,
+    };
+}
+function createDiffGuardResult(input) {
+    const { projectPath, currentReport, options, tempDir, config, baseRef } = input;
+    const baseFiles = analyzeProject(tempDir, config, options.analysis);
+    const baseReport = buildReport(tempDir, baseFiles);
+    const remappedBase = remapBaseReportPaths(baseReport, tempDir, projectPath);
+    const diff = computeDiff(remappedBase, currentReport, baseRef);
+    const metrics = buildMetricsFromDiff(diff);
+    const evaluation = evaluateGuard({
+        metrics,
+        budget: options.budget,
+        bySeverity: options.bySeverity,
+        enforceNoRegression: {
+            score: true,
+            totalIssues: true,
+        },
+    });
+    return {
+        scannedAt: new Date().toISOString(),
+        projectPath,
+        mode: 'diff',
+        passed: evaluation.passed,
+        baseRef,
+        metrics,
+        checks: evaluation.checks,
+        current: currentReport,
+        diff,
+    };
+}
+function createBaselineGuardResult(input) {
+    const { projectPath, currentReport, options, baseline, baselinePath } = input;
+    const metrics = buildMetricsFromBaseline(currentReport, baseline);
+    const evaluation = evaluateGuard({
+        metrics,
+        budget: options.budget,
+        bySeverity: options.bySeverity,
+        enforceNoRegression: {
+            score: baseline.score !== undefined,
+            totalIssues: baseline.totalIssues !== undefined,
+        },
+    });
+    return {
+        scannedAt: new Date().toISOString(),
+        projectPath,
+        mode: 'baseline',
+        passed: evaluation.passed,
+        baselinePath,
+        metrics,
+        checks: evaluation.checks,
+        current: currentReport,
+    };
+}
+//# sourceMappingURL=guard.js.map