@eduardbar/drift 1.3.0 → 1.4.0

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/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

package/dist/index.d.ts

@@ -1,13 +1,20 @@
 export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js';
 export { buildReport, formatMarkdown } from './reporter.js';
 export { computeDiff } from './diff.js';
+export { runGuard, evaluateGuard } from './guard.js';
+export type { GuardBaseline, GuardThresholds, GuardOptions, GuardMetrics, GuardCheck, GuardEvaluation, GuardResult, } from './guard-types.js';
 export { generateReview, formatReviewMarkdown } from './review.js';
-export { buildTrustReport, formatTrustConsole, formatTrustMarkdown, formatTrustJson, shouldFailByMaxRisk, shouldFailTrustGate, normalizeMergeRiskLevel, MERGE_RISK_ORDER, } from './trust.js';
+export { runDoctor } from './doctor.js';
+export type { DoctorOptions } from './doctor.js';
+export { buildTrustReport, formatTrustConsole, formatTrustMarkdown, formatTrustJson, resolveTrustGatePolicy, evaluateTrustGate, shouldFailByMaxRisk, shouldFailTrustGate, normalizeMergeRiskLevel, MERGE_RISK_ORDER, } from './trust.js';
+export type { TrustGateOptions, TrustGatePolicyResolutionOptions, TrustGatePolicyResolutionStep, TrustGateEvaluation, } from './trust.js';
 export { computeTrustKpis, computeTrustKpisFromReports, formatTrustKpiConsole, formatTrustKpiJson, } from './trust-kpi.js';
+export { toSarif, diffToSarif } from './sarif.js';
+export type { SarifLevel, DriftSarifRule, DriftSarifResult, DriftSarifRun, DriftSarifLog, } from './sarif.js';
 export { generateArchitectureMap, generateArchitectureSvg } from './map.js';
-export type { DriftReport, FileReport, DriftIssue, DriftDiff, FileDiff, DriftConfig, RepoQualityScore, MaintenanceRiskMetrics, DriftTrustReport, TrustReason, TrustFixPriority, TrustDiffContext, TrustKpiReport, TrustKpiDiagnostic, TrustDiffTrendSummary, TrustScoreStats, MergeRiskLevel, DriftPlugin, DriftPluginRule, } from './types.js';
+export type { DriftReport, FileReport, DriftIssue, DriftDiff, FileDiff, DriftConfig, RepoQualityScore, MaintenanceRiskMetrics, DriftTrustReport, TrustReason, TrustFixPriority, TrustDiffContext, TrustKpiReport, TrustKpiDiagnostic, TrustDiffTrendSummary, TrustScoreStats, MergeRiskLevel, DriftPlugin, DriftPluginRule, TrustGatePolicyConfig, TrustAdvancedContext, } from './types.js';
 export { loadHistory, saveSnapshot } from './snapshot.js';
 export type { SnapshotEntry, SnapshotHistory } from './snapshot.js';
 export { DEFAULT_SAAS_POLICY, defaultSaasStorePath, resolveSaasPolicy, SaasActorRequiredError, SaasPermissionError, getRequiredRoleForOperation, assertSaasPermission, getSaasEffectiveLimits, getOrganizationEffectiveLimits, changeOrganizationPlan, listOrganizationPlanChanges, getOrganizationUsageSnapshot, ingestSnapshotFromReport, listSaasSnapshots, getSaasSummary, generateSaasDashboardHtml, } from './saas.js';
-export type { SaasRole, SaasPlan, SaasPolicy, SaasPolicyOverrides, SaasStore, SaasSummary, SaasSnapshot, SaasQueryOptions, IngestOptions, SaasPlanChange, SaasOperation, SaasPermissionContext, SaasPermissionResult, SaasEffectiveLimits, SaasOrganizationUsageSnapshot, ChangeOrganizationPlanOptions, SaasUsageQueryOptions, SaasPlanChangeQueryOptions, } from './saas.js';
+export type { SaasUser, SaasOrganization, SaasWorkspace, SaasRepo, SaasMembership, SaasRole, SaasPlan, SaasPolicy, SaasPolicyOverrides, SaasStore, SaasSummary, SaasSnapshot, SaasQueryOptions, IngestOptions, SaasPlanChange, SaasOperation, SaasPermissionContext, SaasPermissionResult, SaasEffectiveLimits, SaasOrganizationUsageSnapshot, ChangeOrganizationPlanOptions, SaasUsageQueryOptions, SaasPlanChangeQueryOptions, } from './saas.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,9 +1,12 @@
 export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js';
 export { buildReport, formatMarkdown } from './reporter.js';
 export { computeDiff } from './diff.js';
+export { runGuard, evaluateGuard } from './guard.js';
 export { generateReview, formatReviewMarkdown } from './review.js';
-export { buildTrustReport, formatTrustConsole, formatTrustMarkdown, formatTrustJson, shouldFailByMaxRisk, shouldFailTrustGate, normalizeMergeRiskLevel, MERGE_RISK_ORDER, } from './trust.js';
+export { runDoctor } from './doctor.js';
+export { buildTrustReport, formatTrustConsole, formatTrustMarkdown, formatTrustJson, resolveTrustGatePolicy, evaluateTrustGate, shouldFailByMaxRisk, shouldFailTrustGate, normalizeMergeRiskLevel, MERGE_RISK_ORDER, } from './trust.js';
 export { computeTrustKpis, computeTrustKpisFromReports, formatTrustKpiConsole, formatTrustKpiJson, } from './trust-kpi.js';
+export { toSarif, diffToSarif } from './sarif.js';
 export { generateArchitectureMap, generateArchitectureSvg } from './map.js';
 export { loadHistory, saveSnapshot } from './snapshot.js';
 export { DEFAULT_SAAS_POLICY, defaultSaasStorePath, resolveSaasPolicy, SaasActorRequiredError, SaasPermissionError, getRequiredRoleForOperation, assertSaasPermission, getSaasEffectiveLimits, getOrganizationEffectiveLimits, changeOrganizationPlan, listOrganizationPlanChanges, getOrganizationUsageSnapshot, ingestSnapshotFromReport, listSaasSnapshots, getSaasSummary, generateSaasDashboardHtml, } from './saas.js';

package/dist/init.d.ts

@@ -0,0 +1,15 @@
+interface InitOptions {
+    preset?: string;
+    ci?: boolean;
+    baseline?: boolean;
+}
+export declare const INIT_PRESETS: readonly ["node-backend", "react-app", "hexagonal", "monorepo"];
+/**
+ * Initialize drift configuration with optional presets and scaffolding.
+ *
+ * @param projectRoot - Absolute path to project root
+ * @param options - Init options from CLI
+ */
+export declare function runInit(projectRoot: string, options: InitOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init.d.ts.map