@qulib/core 0.7.0 → 0.9.0

package/dist/baseline/baseline.js

@@ -0,0 +1,252 @@
+import { readFile, writeFile, mkdir, readdir, unlink } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, extname } from 'node:path';
+import { BaselineSnapshotSchema, BaselineDeltaSchema, } from './baseline.schema.js';
+const BASELINE_DIR_NAME = '.qulib-baselines';
+/**
+ * Resolve the directory where baselines for the given URL are stored.
+ * Each URL gets its own subdirectory under baseDir, keyed by a stable slug.
+ */
+function resolveBaselineDir(baseDir, urlSlug) {
+    return join(baseDir, urlSlug);
+}
+/**
+ * Produce a filesystem-safe slug from a URL.
+ * e.g. "https://my-app.vercel.app/admin" → "my-app_vercel_app__admin"
+ */
+export function slugifyUrl(url) {
+    return url
+        .replace(/^https?:\/\//, '')
+        .replace(/[^a-zA-Z0-9._-]/g, '_')
+        .replace(/__+/g, '_')
+        .replace(/^_|_$/g, '')
+        .slice(0, 80);
+}
+/**
+ * Return the default root for baseline storage: `<cwd>/.qulib-baselines`.
+ * Callers may supply an explicit `baseDir` to override.
+ */
+export function defaultBaselineRoot() {
+    return join(process.cwd(), BASELINE_DIR_NAME);
+}
+/**
+ * Convert a `GapAnalysis` result into the compact `BaselineGap[]` shape.
+ * Drops fields not needed for delta comparison (id, description, recommendation).
+ */
+function toBaselineGaps(gaps) {
+    return gaps.map((g) => ({
+        path: g.path,
+        severity: g.severity,
+        category: g.category,
+        reason: g.reason,
+    }));
+}
+/**
+ * Save a baseline snapshot derived from the given `GapAnalysis` result.
+ *
+ * @returns The saved snapshot.
+ */
+export async function saveBaseline(analysis, url, options = {}) {
+    const baseDir = options.baseDir ?? defaultBaselineRoot();
+    const urlSlug = slugifyUrl(url);
+    const dir = resolveBaselineDir(baseDir, urlSlug);
+    await mkdir(dir, { recursive: true });
+    const now = new Date();
+    // Include milliseconds (23 chars: "2024-01-01T00-00-00-000") so rapid successive saves
+    // do not collide on the same filename within the same second.
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 23);
+    const id = `${urlSlug}__${timestamp}`;
+    const filename = `${id}.json`;
+    const snapshot = {
+        id,
+        url,
+        savedAt: now.toISOString(),
+        releaseConfidence: analysis.releaseConfidence ?? 0,
+        gapCount: analysis.gaps.length,
+        gaps: toBaselineGaps(analysis.gaps),
+        ...(options.label !== undefined ? { label: options.label } : {}),
+    };
+    const validated = BaselineSnapshotSchema.parse(snapshot);
+    await writeFile(join(dir, filename), JSON.stringify(validated, null, 2), 'utf8');
+    return validated;
+}
+/**
+ * Load a specific baseline snapshot by its `id`.
+ *
+ * @throws If the file does not exist or fails schema validation.
+ */
+export async function loadBaseline(id, options = {}) {
+    const baseDir = options.baseDir ?? defaultBaselineRoot();
+    // id encodes the urlSlug: <urlSlug>__<timestamp>
+    const doubleUnderIndex = id.lastIndexOf('__');
+    if (doubleUnderIndex < 0) {
+        throw new Error(`Invalid baseline id (no __ separator): ${id}`);
+    }
+    const urlSlug = id.slice(0, doubleUnderIndex);
+    const dir = resolveBaselineDir(baseDir, urlSlug);
+    const filepath = join(dir, `${id}.json`);
+    if (!existsSync(filepath)) {
+        throw new Error(`Baseline not found: ${id} (${filepath})`);
+    }
+    const raw = await readFile(filepath, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Baseline file is not valid JSON: ${filepath}`);
+    }
+    return BaselineSnapshotSchema.parse(parsed);
+}
+/**
+ * List all saved baselines for the given URL, sorted newest-first.
+ *
+ * Returns an empty array if no baselines exist yet.
+ */
+export async function listBaselines(url, options = {}) {
+    const baseDir = options.baseDir ?? defaultBaselineRoot();
+    const urlSlug = slugifyUrl(url);
+    const dir = resolveBaselineDir(baseDir, urlSlug);
+    if (!existsSync(dir)) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const snapshots = [];
+    for (const entry of entries) {
+        if (extname(entry) !== '.json')
+            continue;
+        const filepath = join(dir, entry);
+        const raw = await readFile(filepath, 'utf8');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const result = BaselineSnapshotSchema.safeParse(parsed);
+        if (result.success) {
+            snapshots.push(result.data);
+        }
+    }
+    // Newest first
+    snapshots.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+    return snapshots;
+}
+/**
+ * Delete a specific baseline snapshot by its `id`.
+ *
+ * @throws If the file does not exist.
+ */
+export async function deleteBaseline(id, options = {}) {
+    const baseDir = options.baseDir ?? defaultBaselineRoot();
+    const doubleUnderIndex = id.lastIndexOf('__');
+    if (doubleUnderIndex < 0) {
+        throw new Error(`Invalid baseline id (no __ separator): ${id}`);
+    }
+    const urlSlug = id.slice(0, doubleUnderIndex);
+    const dir = resolveBaselineDir(baseDir, urlSlug);
+    const filepath = join(dir, `${id}.json`);
+    if (!existsSync(filepath)) {
+        throw new Error(`Baseline not found: ${id}`);
+    }
+    await unlink(filepath);
+}
+// ---------------------------------------------------------------------------
+// Delta detection
+// ---------------------------------------------------------------------------
+/**
+ * Stable key used to match gaps across snapshots for delta detection.
+ * Two gaps are "the same problem" when they share path + category.
+ */
+function gapKey(g) {
+    return `${g.path}|||${g.category}`;
+}
+/**
+ * Compare two baseline snapshots and return a structured delta report.
+ *
+ * - `newGaps`: problems present in `current` but not in `prior`.
+ * - `resolvedGaps`: problems present in `prior` but no longer in `current`.
+ * - `severityChanges`: same problem (matching key) with a different severity.
+ */
+export function compareBaselines(prior, current) {
+    const priorMap = new Map();
+    for (const g of prior.gaps) {
+        priorMap.set(gapKey(g), g);
+    }
+    const currentMap = new Map();
+    for (const g of current.gaps) {
+        currentMap.set(gapKey(g), g);
+    }
+    const severityOrder = {
+        critical: 4,
+        high: 3,
+        medium: 2,
+        low: 1,
+    };
+    const newGaps = [];
+    const resolvedGaps = [];
+    const severityChanges = [];
+    // Gaps in current that were not in prior → new
+    for (const [key, g] of currentMap) {
+        if (!priorMap.has(key)) {
+            newGaps.push({ path: g.path, category: g.category, severity: g.severity, reason: g.reason, status: 'new' });
+        }
+        else {
+            const prev = priorMap.get(key);
+            if (prev.severity !== g.severity) {
+                const prevOrd = severityOrder[prev.severity];
+                const currOrd = severityOrder[g.severity];
+                severityChanges.push({
+                    path: g.path,
+                    category: g.category,
+                    severity: g.severity,
+                    reason: g.reason,
+                    status: currOrd > prevOrd ? 'severity-increased' : 'severity-decreased',
+                });
+            }
+        }
+    }
+    // Gaps in prior that are no longer in current → resolved
+    for (const [key, g] of priorMap) {
+        if (!currentMap.has(key)) {
+            resolvedGaps.push({
+                path: g.path,
+                category: g.category,
+                severity: g.severity,
+                reason: g.reason,
+                status: 'resolved',
+            });
+        }
+    }
+    const confidenceDelta = current.releaseConfidence - prior.releaseConfidence;
+    const direction = confidenceDelta > 0 ? 'improved' : confidenceDelta < 0 ? 'regressed' : 'unchanged';
+    const summary = [
+        `Confidence ${direction} (${prior.releaseConfidence} → ${current.releaseConfidence})`,
+        newGaps.length > 0 ? `${newGaps.length} new gap(s)` : '',
+        resolvedGaps.length > 0 ? `${resolvedGaps.length} resolved gap(s)` : '',
+        severityChanges.length > 0 ? `${severityChanges.length} severity change(s)` : '',
+    ]
+        .filter(Boolean)
+        .join(', ');
+    const delta = {
+        fromId: prior.id,
+        toId: current.id,
+        fromSavedAt: prior.savedAt,
+        toSavedAt: current.savedAt,
+        fromReleaseConfidence: prior.releaseConfidence,
+        toReleaseConfidence: current.releaseConfidence,
+        confidenceDelta,
+        newGaps,
+        resolvedGaps,
+        severityChanges,
+        summary,
+    };
+    return BaselineDeltaSchema.parse(delta);
+}

package/dist/baseline/baseline.schema.d.ts

@@ -0,0 +1,233 @@
+import { z } from 'zod';
+/**
+ * A snapshot of a single gap found during a scan, stored in a baseline.
+ * Intentionally lighter than the full GapSchema: only the fields needed to
+ * detect meaningful drift between scans are captured.
+ */
+export declare const BaselineGapSchema: z.ZodObject<{
+    path: z.ZodString;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+}, {
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+}>;
+export type BaselineGap = z.infer<typeof BaselineGapSchema>;
+/**
+ * A persisted baseline snapshot for a given URL, saved by `qulib baseline save`.
+ */
+export declare const BaselineSnapshotSchema: z.ZodObject<{
+    /** Monotonic slug used as the on-disk filename stem: <url-slug>__<timestamp> */
+    id: z.ZodString;
+    url: z.ZodString;
+    savedAt: z.ZodString;
+    releaseConfidence: z.ZodNumber;
+    gapCount: z.ZodNumber;
+    gaps: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }, {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }>, "many">;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    url: string;
+    releaseConfidence: number;
+    gaps: {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    gapCount: number;
+    savedAt: string;
+    label?: string | undefined;
+}, {
+    id: string;
+    url: string;
+    releaseConfidence: number;
+    gaps: {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    gapCount: number;
+    savedAt: string;
+    label?: string | undefined;
+}>;
+export type BaselineSnapshot = z.infer<typeof BaselineSnapshotSchema>;
+/**
+ * A single change in gap status between two baselines.
+ */
+export declare const BaselineDeltaItemSchema: z.ZodObject<{
+    path: z.ZodString;
+    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    reason: z.ZodString;
+    status: z.ZodEnum<["new", "resolved", "severity-increased", "severity-decreased"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+}, {
+    status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+}>;
+export type BaselineDeltaItem = z.infer<typeof BaselineDeltaItemSchema>;
+/**
+ * The result of comparing two snapshots.
+ */
+export declare const BaselineDeltaSchema: z.ZodObject<{
+    fromId: z.ZodString;
+    toId: z.ZodString;
+    fromSavedAt: z.ZodString;
+    toSavedAt: z.ZodString;
+    fromReleaseConfidence: z.ZodNumber;
+    toReleaseConfidence: z.ZodNumber;
+    confidenceDelta: z.ZodNumber;
+    newGaps: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        reason: z.ZodString;
+        status: z.ZodEnum<["new", "resolved", "severity-increased", "severity-decreased"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }>, "many">;
+    resolvedGaps: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        reason: z.ZodString;
+        status: z.ZodEnum<["new", "resolved", "severity-increased", "severity-decreased"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }>, "many">;
+    severityChanges: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        reason: z.ZodString;
+        status: z.ZodEnum<["new", "resolved", "severity-increased", "severity-decreased"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }, {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }>, "many">;
+    summary: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    fromId: string;
+    toId: string;
+    fromSavedAt: string;
+    toSavedAt: string;
+    fromReleaseConfidence: number;
+    toReleaseConfidence: number;
+    confidenceDelta: number;
+    newGaps: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    resolvedGaps: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    severityChanges: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+}, {
+    summary: string;
+    fromId: string;
+    toId: string;
+    fromSavedAt: string;
+    toSavedAt: string;
+    fromReleaseConfidence: number;
+    toReleaseConfidence: number;
+    confidenceDelta: number;
+    newGaps: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    resolvedGaps: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+    severityChanges: {
+        status: "new" | "resolved" | "severity-increased" | "severity-decreased";
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    }[];
+}>;
+export type BaselineDelta = z.infer<typeof BaselineDeltaSchema>;
+//# sourceMappingURL=baseline.schema.d.ts.map

package/dist/baseline/baseline.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.schema.d.ts","sourceRoot":"","sources":["../../src/baseline/baseline.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAa5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,sBAAsB;IACjC,gFAAgF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhF,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;EAMlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/baseline/baseline.schema.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * A snapshot of a single gap found during a scan, stored in a baseline.
+ * Intentionally lighter than the full GapSchema: only the fields needed to
+ * detect meaningful drift between scans are captured.
+ */
+export const BaselineGapSchema = z.object({
+    path: z.string(),
+    severity: z.enum(['critical', 'high', 'medium', 'low']),
+    category: z.enum([
+        'untested-route',
+        'a11y',
+        'console-error',
+        'broken-link',
+        'auth-surface',
+        'coverage',
+        'untested-api-endpoint',
+    ]),
+    reason: z.string(),
+});
+/**
+ * A persisted baseline snapshot for a given URL, saved by `qulib baseline save`.
+ */
+export const BaselineSnapshotSchema = z.object({
+    /** Monotonic slug used as the on-disk filename stem: <url-slug>__<timestamp> */
+    id: z.string(),
+    url: z.string(),
+    savedAt: z.string().datetime(),
+    releaseConfidence: z.number().min(0).max(100),
+    gapCount: z.number().int().min(0),
+    gaps: z.array(BaselineGapSchema),
+    label: z.string().optional(),
+});
+/**
+ * A single change in gap status between two baselines.
+ */
+export const BaselineDeltaItemSchema = z.object({
+    path: z.string(),
+    category: BaselineGapSchema.shape.category,
+    severity: BaselineGapSchema.shape.severity,
+    reason: z.string(),
+    status: z.enum(['new', 'resolved', 'severity-increased', 'severity-decreased']),
+});
+/**
+ * The result of comparing two snapshots.
+ */
+export const BaselineDeltaSchema = z.object({
+    fromId: z.string(),
+    toId: z.string(),
+    fromSavedAt: z.string().datetime(),
+    toSavedAt: z.string().datetime(),
+    fromReleaseConfidence: z.number().min(0).max(100),
+    toReleaseConfidence: z.number().min(0).max(100),
+    confidenceDelta: z.number(),
+    newGaps: z.array(BaselineDeltaItemSchema),
+    resolvedGaps: z.array(BaselineDeltaItemSchema),
+    severityChanges: z.array(BaselineDeltaItemSchema),
+    summary: z.string(),
+});

package/dist/cli/confidence-run.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from 'commander';
+import type { ReleaseConfidence } from '../schemas/confidence.schema.js';
+export interface ConfidenceOptions {
+    url?: string;
+    repo?: string;
+    json?: boolean;
+}
+/** Render the human-friendly report for a ReleaseConfidence result. */
+export declare function formatConfidenceReport(rc: ReleaseConfidence, subjectRef: string): string;
+/**
+ * Core of the command, factored out of the action handler so node:test can drive it
+ * without spawning a subprocess.
+ */
+export declare function runConfidence(options: ConfidenceOptions, out?: (line: string) => void): Promise<ReleaseConfidence>;
+export declare function registerConfidenceCommand(program: Command): void;
+//# sourceMappingURL=confidence-run.d.ts.map

package/dist/cli/confidence-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-run.d.ts","sourceRoot":"","sources":["../../src/cli/confidence-run.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGzE,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAiBD,uEAAuE;AACvE,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAuCxF;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,iBAAiB,EAC1B,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkC,GACxD,OAAO,CAAC,iBAAiB,CAAC,CAmE5B;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmBhE"}