@sanity/ailf 0.1.0

package/dist/agent-observer/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * types.ts
+ *
+ * Data structures for capturing AI agent behavior during evaluation.
+ *
+ * When an AI agent runs a task (e.g., "implement a Sanity studio schema"),
+ * it may browse documentation, search for APIs, download code samples, etc.
+ * These types describe the observed network activity so we can answer:
+ *
+ *   - What URLs did the agent visit?
+ *   - What content did it actually download?
+ *   - Did it search sanity.io/docs? What queries?
+ *   - How long did it spend fetching vs generating?
+ *   - Did it find the *right* documentation pages?
+ */
+export interface AgentBehaviorLog {
+    /** Sanity API calls (non-docs) */
+    apiCalls: ApiCall[];
+    /** Sanity doc pages the agent visited */
+    docPageVisits: DocPageVisit[];
+    /** ISO 8601 timestamp when observation ended */
+    endedAt: string;
+    /** Requests to non-Sanity domains */
+    externalRequests: ExternalRequest[];
+    /** Time spent waiting on network requests, in ms */
+    networkDurationMs: number;
+    /** Provider that was observed (e.g., "openai:gpt-4o") */
+    provider: string;
+    /** Every HTTP request/response observed, in order */
+    requests: ObservedRequest[];
+    /** Search queries the agent performed */
+    searchQueries: SearchQuery[];
+    /** Unique identifier for this observation session */
+    sessionId: string;
+    /** ISO 8601 timestamp when observation started */
+    startedAt: string;
+    summary: AgentBehaviorSummary;
+    /** Task description from the test case */
+    taskDescription: string;
+    /** Total wall-clock time for the test, in ms */
+    totalDurationMs: number;
+}
+/** Roll-up stats for quick analysis */
+export interface AgentBehaviorSummary {
+    /** Number of Sanity API calls */
+    apiCallCount: number;
+    /** Number of sanity.io doc pages visited */
+    docPagesVisited: number;
+    /** List of unique sanity.io doc slugs visited */
+    docSlugsVisited: string[];
+    /** List of unique external domains contacted */
+    externalDomains: string[];
+    /** Number of external (non-Sanity) requests */
+    externalRequestCount: number;
+    /** Number of search queries performed */
+    searchesPerformed: number;
+    /** Total bytes downloaded */
+    totalBytesDownloaded: number;
+    /** Total network time in ms */
+    totalNetworkMs: number;
+    /** Total number of HTTP requests observed */
+    totalRequests: number;
+    /** List of unique search queries */
+    uniqueSearchQueries: string[];
+    /** Number of unique URLs visited */
+    uniqueUrls: number;
+    /** Whether the agent visited any sanity.io docs at all */
+    usedDocs: boolean;
+    /** Whether the agent performed any searches */
+    usedSearch: boolean;
+}
+/** An API call to Sanity's API (not docs) */
+export interface ApiCall {
+    /** API endpoint path */
+    endpoint: string;
+    /** HTTP method */
+    method: string;
+    /** Timestamp */
+    timestamp: string;
+    /** Full URL */
+    url: string;
+}
+/** A page the agent visited on sanity.io/docs */
+export interface DocPageVisit {
+    /** Response size in bytes */
+    contentSize: number;
+    /** Slug extracted from the URL, e.g., "groq-introduction" */
+    slug: string;
+    /** Timestamp of the visit */
+    timestamp: string;
+    /** Page title if extractable from response */
+    title?: string;
+    url: string;
+}
+/** A request to a non-Sanity URL */
+export interface ExternalRequest {
+    /** Domain extracted from URL */
+    domain: string;
+    method: string;
+    timestamp: string;
+    url: string;
+}
+export interface ObservedRequest {
+    /** Request body (for POST searches, etc.), truncated to maxBodyBytes */
+    body?: string;
+    /** Content-Type of the response */
+    contentType?: string;
+    /** Relevant request headers (e.g., Accept, User-Agent) */
+    headers: Record<string, string>;
+    /** Time from request start to response complete, in ms */
+    latencyMs: number;
+    /** HTTP method */
+    method: string;
+    /** Response body preview (first N chars), useful for seeing what the agent actually read */
+    responsePreview?: string;
+    /** Response body size in bytes */
+    responseSize: number;
+    /** Monotonic sequence number within the test run */
+    seq: number;
+    /** HTTP status code of the response */
+    statusCode: number;
+    /** ISO 8601 timestamp when the request was initiated */
+    timestamp: string;
+    /** Full URL requested */
+    url: string;
+}
+/** A search query the agent performed */
+export interface SearchQuery {
+    /** Extracted query string */
+    query: string;
+    /** Number of results returned (if detectable) */
+    resultCount?: number;
+    /** Timestamp */
+    timestamp: string;
+    /** The search endpoint URL */
+    url: string;
+}

package/dist/agent-observer/types.js

@@ -0,0 +1,16 @@
+/**
+ * types.ts
+ *
+ * Data structures for capturing AI agent behavior during evaluation.
+ *
+ * When an AI agent runs a task (e.g., "implement a Sanity studio schema"),
+ * it may browse documentation, search for APIs, download code samples, etc.
+ * These types describe the observed network activity so we can answer:
+ *
+ *   - What URLs did the agent visit?
+ *   - What content did it actually download?
+ *   - Did it search sanity.io/docs? What queries?
+ *   - How long did it spend fetching vs generating?
+ *   - Did it find the *right* documentation pages?
+ */
+export {};

package/dist/assertions/source-isolation.d.ts

@@ -0,0 +1,72 @@
+/**
+ * source-isolation.ts
+ *
+ * Promptfoo custom assertion: verifies that the agentic provider only
+ * fetched documentation from the configured allowed origins.
+ *
+ * Compiled to dist/assertions/source-isolation.js and referenced via
+ * file:// in generated Promptfoo configs.
+ *
+ * The assertion has weight: 0 — it doesn't affect scores. It surfaces
+ * as an advisory pass/fail signal in results.
+ *
+ * @see docs/exec-plans/completed/source-aware-eval-isolation.md (Phase 3b)
+ */
+export interface SourceIsolationReport {
+    blocked: number;
+    isolationScore: number;
+    offOrigin: number;
+    offOriginUrls: string[];
+    onOrigin: number;
+    originBreakdown: Record<string, number>;
+    total: number;
+}
+interface AgentBehaviorData {
+    docPageVisits?: {
+        slug: string;
+        url: string;
+    }[];
+    requests?: {
+        statusCode: number;
+        url: string;
+    }[];
+}
+interface AssertionContext {
+    providerResponse?: {
+        metadata?: {
+            agentBehavior?: AgentBehaviorData;
+        };
+    };
+    vars?: Record<string, string>;
+}
+interface GradingResult {
+    pass: boolean;
+    reason: string;
+    score: number;
+}
+/**
+ * Analyze doc page visits and compute an isolation score.
+ *
+ * The isolation score is the fraction of doc-fetching requests that went
+ * to an allowed origin. A score of 1.0 means perfect isolation.
+ *
+ * @param docPageVisits - Classified doc page visit records
+ * @param allowedOrigins - Origin patterns (glob-capable)
+ * @returns Isolation report with score and breakdown
+ */
+export declare function analyzeSourceIsolation(docPageVisits: {
+    url: string;
+}[], allowedOrigins: string[]): SourceIsolationReport;
+/**
+ * Promptfoo custom assertion function.
+ *
+ * Called by Promptfoo for each test case when referenced as:
+ *   type: javascript
+ *   value: file://dist/assertions/source-isolation.js
+ *   weight: 0
+ *
+ * @param output - The model's text output (unused)
+ * @param context - Promptfoo assertion context with provider metadata
+ */
+export default function (_output: string, context: AssertionContext): GradingResult;
+export {};

package/dist/assertions/source-isolation.js

@@ -0,0 +1,117 @@
+/**
+ * source-isolation.ts
+ *
+ * Promptfoo custom assertion: verifies that the agentic provider only
+ * fetched documentation from the configured allowed origins.
+ *
+ * Compiled to dist/assertions/source-isolation.js and referenced via
+ * file:// in generated Promptfoo configs.
+ *
+ * The assertion has weight: 0 — it doesn't affect scores. It surfaces
+ * as an advisory pass/fail signal in results.
+ *
+ * @see docs/exec-plans/completed/source-aware-eval-isolation.md (Phase 3b)
+ */
+import { isAllowedOrigin } from "../sources.js";
+/**
+ * Analyze doc page visits and compute an isolation score.
+ *
+ * The isolation score is the fraction of doc-fetching requests that went
+ * to an allowed origin. A score of 1.0 means perfect isolation.
+ *
+ * @param docPageVisits - Classified doc page visit records
+ * @param allowedOrigins - Origin patterns (glob-capable)
+ * @returns Isolation report with score and breakdown
+ */
+export function analyzeSourceIsolation(docPageVisits, allowedOrigins) {
+    if (allowedOrigins.length === 0 || docPageVisits.length === 0) {
+        return {
+            blocked: 0,
+            isolationScore: 1.0,
+            offOrigin: 0,
+            offOriginUrls: [],
+            onOrigin: docPageVisits.length,
+            originBreakdown: {},
+            total: docPageVisits.length,
+        };
+    }
+    let onOrigin = 0;
+    let offOrigin = 0;
+    const offOriginUrls = [];
+    const originBreakdown = {};
+    for (const visit of docPageVisits) {
+        try {
+            const hostname = new URL(visit.url).hostname.replace(/^www\./, "");
+            originBreakdown[hostname] = (originBreakdown[hostname] || 0) + 1;
+            if (isAllowedOrigin(visit.url, allowedOrigins)) {
+                onOrigin++;
+            }
+            else {
+                offOrigin++;
+                offOriginUrls.push(visit.url);
+            }
+        }
+        catch {
+            offOrigin++;
+            offOriginUrls.push(visit.url);
+        }
+    }
+    const total = onOrigin + offOrigin;
+    const isolationScore = total > 0 ? onOrigin / total : 1.0;
+    return {
+        blocked: 0, // Blocked requests aren't in docPageVisits — they're caught earlier
+        isolationScore,
+        offOrigin,
+        offOriginUrls,
+        onOrigin,
+        originBreakdown,
+        total,
+    };
+}
+// ---------------------------------------------------------------------------
+// Promptfoo assertion entry point
+// ---------------------------------------------------------------------------
+/**
+ * Promptfoo custom assertion function.
+ *
+ * Called by Promptfoo for each test case when referenced as:
+ *   type: javascript
+ *   value: file://dist/assertions/source-isolation.js
+ *   weight: 0
+ *
+ * @param output - The model's text output (unused)
+ * @param context - Promptfoo assertion context with provider metadata
+ */
+export default function (_output, context) {
+    const behavior = context.providerResponse?.metadata?.agentBehavior;
+    if (!behavior) {
+        return { pass: true, reason: "No agent behavior recorded", score: 1 };
+    }
+    const docVisits = behavior.docPageVisits ?? [];
+    if (docVisits.length === 0) {
+        return { pass: true, reason: "No doc page visits recorded", score: 1 };
+    }
+    // Read allowed origins from env (set by pipeline.ts)
+    const originsEnv = process.env.DOC_ALLOWED_ORIGINS;
+    const allowedOrigins = originsEnv
+        ? originsEnv
+            .split(",")
+            .map((o) => o.trim())
+            .filter(Boolean)
+        : [];
+    if (allowedOrigins.length === 0) {
+        return {
+            pass: true,
+            reason: `No origin sandboxing configured (${docVisits.length} doc visits)`,
+            score: 1,
+        };
+    }
+    const report = analyzeSourceIsolation(docVisits, allowedOrigins);
+    return {
+        pass: report.offOrigin === 0,
+        reason: report.offOrigin === 0
+            ? `All doc fetches on-origin (${report.onOrigin} visits, origins: ${allowedOrigins.join(", ")})`
+            : `${report.offOrigin} off-origin doc fetch(es): ${report.offOriginUrls.join(", ")}`,
+        score: report.isolationScore,
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * cli.ts — AILF CLI entry point.
+ *
+ * Unified command-line interface for the AI Literacy Framework.
+ * All evaluation commands are exposed as subcommands under `ailf`.
+ *
+ * Usage:
+ *   ailf pipeline [flags]       # full evaluation pipeline
+ *   ailf compare [flags]        # compare evaluation runs
+ *   ailf baseline <cmd> [flags] # baseline management
+ *   ailf validate [flags]       # config validation
+ *   ailf completion bash        # generate shell completions
+ *   ailf --help                 # list all commands
+ *
+ * Global options:
+ *   --verbose / -v              # increase log output
+ *   --quiet / -q                # suppress non-error output
+ *   --dotenv <path>             # override default .env path
+ *
+ * Dev mode (without building):
+ *   tsx src/cli.ts pipeline --debug
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/* oxlint-disable import/first -- imports are intentionally interleaved with
+   command registration for readability and lazy loading */
+/**
+ * cli.ts — AILF CLI entry point.
+ *
+ * Unified command-line interface for the AI Literacy Framework.
+ * All evaluation commands are exposed as subcommands under `ailf`.
+ *
+ * Usage:
+ *   ailf pipeline [flags]       # full evaluation pipeline
+ *   ailf compare [flags]        # compare evaluation runs
+ *   ailf baseline <cmd> [flags] # baseline management
+ *   ailf validate [flags]       # config validation
+ *   ailf completion bash        # generate shell completions
+ *   ailf --help                 # list all commands
+ *
+ * Global options:
+ *   --verbose / -v              # increase log output
+ *   --quiet / -q                # suppress non-error output
+ *   --dotenv <path>             # override default .env path
+ *
+ * Dev mode (without building):
+ *   tsx src/cli.ts pipeline --debug
+ */
+import { config as dotenvConfig } from "dotenv";
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..");
+/** Path to the eval package root (packages/eval). Used by --explain. */
+const EVAL_ROOT = ROOT;
+// ---------------------------------------------------------------------------
+// Load .env — must happen before Commander parses so that .env()
+// fallbacks resolve correctly.
+//
+// Resolution order:
+//   1. Explicit --dotenv <path> flag
+//   2. Monorepo root .env (../../.env relative to packages/eval/)
+//   3. Caller's working directory .env
+//
+// This allows the CLI to work both in the monorepo (dev) and when
+// installed globally via npm (production).
+// ---------------------------------------------------------------------------
+function resolveEnvPath() {
+    const idx = process.argv.indexOf("--dotenv");
+    if (idx !== -1 && process.argv[idx + 1]) {
+        return resolve(process.argv[idx + 1]);
+    }
+    // Monorepo root .env (dev mode)
+    const monorepoEnv = resolve(ROOT, "..", "..", ".env");
+    if (existsSync(monorepoEnv))
+        return monorepoEnv;
+    // Caller's working directory .env (npm install mode)
+    const callerCwd = process.env.AILF_CALLER_CWD ?? process.cwd();
+    return resolve(callerCwd, ".env");
+}
+const envPath = resolveEnvPath();
+if (existsSync(envPath)) {
+    dotenvConfig({ override: true, path: envPath });
+}
+// ---------------------------------------------------------------------------
+// Pre-scan for --verbose / --quiet to make them available globally before
+// Commander parses. Commands can check process.env.AILF_LOG_LEVEL.
+// ---------------------------------------------------------------------------
+if (process.argv.includes("--verbose") || process.argv.includes("-v")) {
+    process.env.AILF_LOG_LEVEL = "verbose";
+}
+else if (process.argv.includes("--quiet") || process.argv.includes("-q")) {
+    process.env.AILF_LOG_LEVEL = "quiet";
+}
+// ---------------------------------------------------------------------------
+// Build CLI program
+// ---------------------------------------------------------------------------
+import { Command } from "commander";
+// Read version from package.json
+const pkgPath = resolve(ROOT, "package.json");
+const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+const program = new Command()
+    .name("ailf")
+    .description("AI Literacy Framework — evaluate how well docs enable AI coding tools")
+    .version(pkg.version)
+    .option("-v, --verbose", "Increase log output")
+    .option("-q, --quiet", "Suppress non-error output")
+    .option("--dotenv <path>", "Override default .env file path")
+    .option("--explain", "Show execution plan without running")
+    .option("--format <fmt>", "Output format for --explain (console, json)", "console")
+    .option("-y, --yes", "With --explain: show plan then prompt to confirm execution");
+// ---------------------------------------------------------------------------
+// Global --explain hook — intercepts any command before execution
+// ---------------------------------------------------------------------------
+program.hook("preAction", async (thisCommand, actionCommand) => {
+    const globalOpts = thisCommand.opts();
+    if (!globalOpts.explain)
+        return;
+    const { handleExplain } = await import("./commands/explain-handler.js");
+    try {
+        await handleExplain(actionCommand, globalOpts.yes ?? false, EVAL_ROOT);
+        process.exit(0);
+    }
+    catch (err) {
+        // Sentinel from --yes confirmation: user wants to proceed
+        if (err !== null &&
+            typeof err === "object" &&
+            "__proceedArgv" in err) {
+            const filteredArgv = err.__proceedArgv;
+            console.log("\n  ▸ Proceeding with execution…\n");
+            await program.parseAsync(filteredArgv);
+            return;
+        }
+        throw err;
+    }
+});
+// ---------------------------------------------------------------------------
+// Register commands
+// ---------------------------------------------------------------------------
+// Pipeline — the main orchestrator
+import { createPipelineCommand } from "./commands/pipeline.js";
+program.addCommand(createPipelineCommand());
+// Compare — structured score comparison
+import { createCompareCommand } from "./commands/compare.js";
+program.addCommand(createCompareCommand());
+// Baseline — save/compare/history
+import { createBaselineCommand } from "./commands/baseline.js";
+program.addCommand(createBaselineCommand());
+// Validate — config validation
+import { createValidateCommand } from "./commands/validate.js";
+program.addCommand(createValidateCommand());
+// Coverage audit — feature coverage analysis
+import { createCoverageAuditCommand } from "./commands/coverage-audit.js";
+program.addCommand(createCoverageAuditCommand());
+// Weekly digest — trend digest delivery
+import { createWeeklyDigestCommand } from "./commands/weekly-digest.js";
+program.addCommand(createWeeklyDigestCommand());
+// Readiness report — launch readiness checklist
+import { createReadinessReportCommand } from "./commands/readiness-report.js";
+program.addCommand(createReadinessReportCommand());
+// Discovery report — agent discoverability analysis
+import { createDiscoveryReportCommand } from "./commands/discovery-report.js";
+program.addCommand(createDiscoveryReportCommand());
+// Grader — reliability tools (consistency, compare, sensitivity, validate)
+import { createGraderCommand } from "./commands/grader/index.js";
+program.addCommand(createGraderCommand());
+// Fetch docs — pull documentation from Sanity CMS
+import { createFetchDocsCommand } from "./commands/fetch-docs.js";
+program.addCommand(createFetchDocsCommand());
+// Generate configs — generate promptfoo config files
+import { createGenerateConfigsCommand } from "./commands/generate-configs.js";
+program.addCommand(createGenerateConfigsCommand());
+// Calculate scores — compute AI Literacy Scores from eval results
+import { createCalculateScoresCommand } from "./commands/calculate-scores.js";
+program.addCommand(createCalculateScoresCommand());
+// Eval — direct promptfoo eval passthrough
+import { createEvalCommand } from "./commands/eval.js";
+program.addCommand(createEvalCommand());
+// PR comment — generate markdown PR comment
+import { createPrCommentCommand } from "./commands/pr-comment.js";
+program.addCommand(createPrCommentCommand());
+// Publish — standalone report publishing to Sanity Content Lake
+import { createPublishCommand } from "./commands/publish.js";
+program.addCommand(createPublishCommand());
+// Agent report — agent behavior observation report
+import { createAgentReportCommand } from "./commands/agent-report.js";
+program.addCommand(createAgentReportCommand());
+// Cache — local pipeline cache management
+import { createCacheCommand } from "./commands/cache.js";
+program.addCommand(createCacheCommand());
+// Webhook server — local development server
+import { createWebhookServerCommand } from "./commands/webhook-server.js";
+program.addCommand(createWebhookServerCommand());
+// Lookup doc — search Sanity for documentation articles
+import { createLookupDocCommand } from "./commands/lookup-doc.js";
+program.addCommand(createLookupDocCommand());
+// Measure retrieval — retrieval quality measurement
+import { createMeasureRetrievalCommand } from "./commands/measure-retrieval.js";
+program.addCommand(createMeasureRetrievalCommand());
+// Init — initialize a directory for AILF
+import { createInitCommand } from "./commands/init.js";
+program.addCommand(createInitCommand());
+// Validate tasks — standalone repo task validation
+import { createValidateTasksCommand } from "./commands/validate-tasks.js";
+program.addCommand(createValidateTasksCommand());
+// Interactive — guided wizard
+import { createInteractiveCommand } from "./commands/interactive.js";
+program.addCommand(createInteractiveCommand());
+// Shell completion — must be registered last (needs full program tree)
+import { createCompletionCommand } from "./commands/completion.js";
+program.addCommand(createCompletionCommand(program));
+// ---------------------------------------------------------------------------
+// Parse and run — default to interactive mode when no arguments given
+// ---------------------------------------------------------------------------
+// If no command is specified (just `ailf`), launch interactive mode
+if (process.argv.length <= 2) {
+    await program.parseAsync([...process.argv, "interactive"]);
+}
+else {
+    await program.parseAsync();
+}

package/dist/commands/agent-report.d.ts

@@ -0,0 +1,5 @@
+/**
+ * agent-report command — generate an agent behavior observation report.
+ */
+import { Command } from "commander";
+export declare function createAgentReportCommand(): Command;

package/dist/commands/agent-report.js

@@ -0,0 +1,69 @@
+/**
+ * agent-report command — generate an agent behavior observation report.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { Command } from "commander";
+import { analyzeResults } from "../pipeline/agent-behavior-report.js";
+export function createAgentReportCommand() {
+    return new Command("agent-report")
+        .description("Generate an agent behavior observation report from eval results")
+        .argument("[results-path]", "Path to eval-results.json (default: results/latest/eval-results.json)")
+        .action(async (resultsPath) => {
+        try {
+            const ROOT = join(dirname(new URL(import.meta.url).pathname), "..", "..");
+            const resolvedPath = resultsPath ?? join(ROOT, "results", "latest", "eval-results.json");
+            if (!existsSync(resolvedPath)) {
+                console.error(`Results file not found: ${resolvedPath}`);
+                console.error("Run an evaluation first: pnpm eval:observed");
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`Reading results from: ${resolvedPath}`);
+            console.log();
+            const json = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+            const rawResults = Array.isArray(json.results)
+                ? json.results
+                : json.results.results;
+            const analysis = analyzeResults(rawResults);
+            if (!analysis.hasData) {
+                console.log("No agent behavior data found in the results.");
+                console.log("Make sure you ran the evaluation with the observed config:");
+                console.log("  pnpm eval:observed");
+                return;
+            }
+            // Write JSON report
+            const outDir = join(ROOT, "results", "latest");
+            mkdirSync(outDir, { recursive: true });
+            const reportData = {
+                features: analysis.features.map((f) => ({
+                    avgDocPages: f.avgDocPages,
+                    avgNetworkMs: f.avgNetworkMs,
+                    avgSearches: f.avgSearches,
+                    canonicalCoverage: f.canonicalCoverage,
+                    canonicalSlugs: f.canonicalSlugs,
+                    docSlugsVisited: f.allDocSlugs,
+                    externalDomains: f.allExternalDomains,
+                    feature: f.feature,
+                    searchQueries: f.allSearchQueries,
+                    taskCount: f.tasks.length,
+                })),
+                tasks: analysis.tasks.map((t) => ({
+                    behavior: t.behavior,
+                    description: t.description,
+                    feature: t.feature,
+                    hasDocs: t.hasDocs,
+                })),
+                timestamp: new Date().toISOString(),
+                totalTasks: analysis.tasks.length,
+            };
+            writeFileSync(join(outDir, "agent-behavior-report.json"), JSON.stringify(reportData, null, 2));
+            console.log("Agent behavior report written to results/latest/agent-behavior-report.json");
+        }
+        catch (err) {
+            process.exitCode = 1;
+            if (err instanceof Error)
+                console.error(err.message);
+        }
+    });
+}

package/dist/commands/baseline.d.ts

@@ -0,0 +1,9 @@
+/**
+ * baseline command — manage historical baseline snapshots of evaluation scores.
+ *
+ * Wraps the core baseline functions from pipeline/baseline.ts behind a
+ * Commander subcommand interface: `baseline save`, `baseline compare`,
+ * `baseline history`.
+ */
+import { Command } from "commander";
+export declare function createBaselineCommand(): Command;