@sanity/ailf 1.0.0 → 2.0.1

package/dist/lib/baseline.d.ts

@@ -0,0 +1,19 @@
+/**
+ * lib/baseline.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/baseline.ts.
+ * This shim preserves backward compatibility for:
+ *   - Direct CLI invocation: `tsx src/lib/baseline.ts`
+ *   - Test imports that haven't been updated yet
+ *
+ * TODO: Update all importers to use pipeline/baseline.ts, then delete this file.
+ *
+ * @deprecated Import from ../pipeline/baseline.js instead.
+ */
+export type { BaselineMetadata, CompareResult, ScoreComparison, } from "../pipeline/baseline.js";
+export declare function saveBaseline(tag?: string): {
+    success: boolean;
+    message: string;
+};
+export declare function compareBaseline(baselineFile?: string): import("./baseline.js").CompareResult;
+export declare function listBaselines(): import("./baseline.js").BaselineMetadata[];

package/dist/lib/baseline.js

@@ -0,0 +1,153 @@
+/**
+ * lib/baseline.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/baseline.ts.
+ * This shim preserves backward compatibility for:
+ *   - Direct CLI invocation: `tsx src/lib/baseline.ts`
+ *   - Test imports that haven't been updated yet
+ *
+ * TODO: Update all importers to use pipeline/baseline.ts, then delete this file.
+ *
+ * @deprecated Import from ../pipeline/baseline.js instead.
+ */
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { saveBaseline as _saveBaseline, compareBaseline as _compareBaseline, listBaselines as _listBaselines, } from "../pipeline/baseline.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "../..");
+export function saveBaseline(tag) {
+    return _saveBaseline(ROOT, tag);
+}
+export function compareBaseline(baselineFile) {
+    return _compareBaseline(ROOT, baselineFile);
+}
+export function listBaselines() {
+    return _listBaselines(ROOT);
+}
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+if (process.argv[1]?.endsWith("baseline.ts") ||
+    process.argv[1]?.endsWith("baseline.js")) {
+    const args = process.argv.slice(2);
+    const command = args[0] || "save";
+    function getArg(name) {
+        const idx = args.indexOf(`--${name}`);
+        return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+    }
+    switch (command) {
+        case "compare": {
+            const file = getArg("file");
+            console.log("=== Baseline Comparison ===\n");
+            const result = compareBaseline(file);
+            if (!result.success) {
+                console.error(`  ❌ ${result.message}`);
+                process.exit(1);
+            }
+            console.log(`  ${result.message}\n`);
+            console.log("  " +
+                "Feature Area".padEnd(18) +
+                "Current".padEnd(10) +
+                "Baseline".padEnd(10) +
+                "Delta");
+            console.log("  " + "-".repeat(50));
+            for (const c of result.comparisons) {
+                const deltaStr = c.delta > 0 ? `+${c.delta}` : c.delta === 0 ? "=" : String(c.delta);
+                const icon = c.delta > 0 ? "📈" : c.delta < 0 ? "📉" : "➡️";
+                console.log("  " +
+                    c.feature.padEnd(18) +
+                    String(c.current).padEnd(10) +
+                    String(c.baseline).padEnd(10) +
+                    `${icon} ${deltaStr}`);
+            }
+            // Cost comparison (only if cost data exists)
+            const hasCostData = result.comparisons.some((c) => c.costCurrent !== undefined || c.costBaseline !== undefined);
+            if (hasCostData) {
+                console.log();
+                console.log("  Cost Comparison:");
+                console.log("  " +
+                    "Feature Area".padEnd(18) +
+                    "Current".padEnd(10) +
+                    "Baseline".padEnd(10) +
+                    "Delta");
+                console.log("  " + "-".repeat(50));
+                for (const c of result.comparisons) {
+                    if (c.costCurrent === undefined && c.costBaseline === undefined) {
+                        continue;
+                    }
+                    const cur = `$${(c.costCurrent ?? 0).toFixed(4)}`;
+                    const base = `$${(c.costBaseline ?? 0).toFixed(4)}`;
+                    const delta = c.costDelta ?? 0;
+                    const deltaStr = delta > 0
+                        ? `+$${delta.toFixed(4)}`
+                        : delta < 0
+                            ? `-$${Math.abs(delta).toFixed(4)}`
+                            : "=";
+                    const icon = delta > 0 ? "📈" : delta < 0 ? "📉" : "➡️";
+                    console.log("  " +
+                        c.feature.padEnd(18) +
+                        cur.padEnd(10) +
+                        base.padEnd(10) +
+                        `${icon} ${deltaStr}`);
+                }
+            }
+            console.log();
+            const overallIcon = result.overallDelta > 0 ? "📈" : result.overallDelta < 0 ? "📉" : "➡️";
+            const overallStr = result.overallDelta > 0
+                ? `+${result.overallDelta}`
+                : result.overallDelta === 0
+                    ? "="
+                    : String(result.overallDelta);
+            console.log(`  Overall: ${overallIcon} ${overallStr} points`);
+            break;
+        }
+        case "history": {
+            console.log("=== Baseline History ===\n");
+            const baselines = listBaselines();
+            if (baselines.length === 0) {
+                console.log("  No baselines saved yet.");
+            }
+            else {
+                const hasCosts = baselines.some((b) => b.totalCost !== undefined || b.graderCost !== undefined);
+                const costHeader = hasCosts ? "Cost".padEnd(10) : "";
+                console.log("  " +
+                    "Date".padEnd(22) +
+                    "Avg".padEnd(6) +
+                    "Areas".padEnd(7) +
+                    costHeader +
+                    "Tag");
+                console.log("  " + "-".repeat(hasCosts ? 60 : 50));
+                for (const b of baselines) {
+                    const date = new Date(b.timestamp).toLocaleString();
+                    const combinedCost = (b.totalCost ?? 0) + (b.graderCost ?? 0);
+                    const costStr = hasCosts
+                        ? (combinedCost > 0 ? `$${combinedCost.toFixed(2)}` : "-").padEnd(10)
+                        : "";
+                    console.log("  " +
+                        date.padEnd(22) +
+                        String(b.avgScore).padEnd(6) +
+                        String(b.areaCount).padEnd(7) +
+                        costStr +
+                        (b.tag ?? ""));
+                }
+            }
+            break;
+        }
+        case "save": {
+            const tag = getArg("tag");
+            console.log("=== Saving baseline snapshot ===\n");
+            const result = saveBaseline(tag);
+            if (result.success) {
+                console.log(`  ✅ ${result.message}`);
+            }
+            else {
+                console.error(`  ❌ ${result.message}`);
+                process.exit(1);
+            }
+            break;
+        }
+        default:
+            console.error(`Unknown command: "${command}". Use: save, history, compare`);
+            process.exit(1);
+    }
+}

package/dist/lib/calculate-scores.d.ts

@@ -0,0 +1,23 @@
+/**
+ * lib/calculate-scores.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/calculate-scores.ts.
+ * This shim preserves backward compatibility for:
+ *   - Direct CLI invocation: `tsx src/lib/calculate-scores.ts`
+ *   - Test imports that haven't been updated yet
+ *
+ * TODO: Update all importers to use pipeline/calculate-scores.ts, then delete this file.
+ *
+ * @deprecated Import from ../pipeline/calculate-scores.js instead.
+ */
+export { calculateAndWriteScores, calculateScoresPerModel, extractGraderJudgments, scoreAgenticResults, type CalculateScoresOptions, type PromptfooResultsWrapper, type RawPromptfooFile, type RawTestResult, } from "../pipeline/calculate-scores.js";
+export { classifyRubric, detectFeatureArea, extractUrlMetadata, mergeScores, parseRubricScore, type ActualScoreEntry, type ComponentResult, type TestResult, type UrlMetadata, } from "../_vendor/ailf-core/index.d.ts";
+import type { CalculateScoresOptions } from "../pipeline/calculate-scores.js";
+/**
+ * Legacy main() entry point — wraps calculateAndWriteScores() with env var fallbacks.
+ *
+ * @deprecated Use calculateAndWriteScores() from pipeline/calculate-scores.ts instead.
+ */
+export declare function main(options?: Omit<CalculateScoresOptions, "rootDir"> & {
+    rootDir?: string;
+}): void;

package/dist/lib/calculate-scores.js

@@ -0,0 +1,42 @@
+/**
+ * lib/calculate-scores.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/calculate-scores.ts.
+ * This shim preserves backward compatibility for:
+ *   - Direct CLI invocation: `tsx src/lib/calculate-scores.ts`
+ *   - Test imports that haven't been updated yet
+ *
+ * TODO: Update all importers to use pipeline/calculate-scores.ts, then delete this file.
+ *
+ * @deprecated Import from ../pipeline/calculate-scores.js instead.
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+// Re-export everything from the real implementation
+export { calculateAndWriteScores, calculateScoresPerModel, extractGraderJudgments, scoreAgenticResults, } from "../pipeline/calculate-scores.js";
+// Re-export core types/functions for backward compatibility
+export { classifyRubric, detectFeatureArea, extractUrlMetadata, mergeScores, parseRubricScore, } from "../_vendor/ailf-core/index.js";
+import { calculateAndWriteScores } from "../pipeline/calculate-scores.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, "..", "..");
+/**
+ * Legacy main() entry point — wraps calculateAndWriteScores() with env var fallbacks.
+ *
+ * @deprecated Use calculateAndWriteScores() from pipeline/calculate-scores.ts instead.
+ */
+export function main(options) {
+    calculateAndWriteScores({
+        rootDir: options?.rootDir ?? ROOT,
+        allowedOrigins: options?.allowedOrigins,
+        mode: options?.mode ?? process.env.EVAL_MODE ?? "baseline",
+        resolvedSource: options?.resolvedSource,
+        resultsPath: options?.resultsPath,
+        searchMode: options?.searchMode,
+        source: options?.source,
+    });
+}
+// Only run when invoked directly (not when imported for testing)
+if (process.argv[1]?.endsWith("calculate-scores.ts") ||
+    process.argv[1]?.endsWith("calculate-scores.js")) {
+    main();
+}

package/dist/lib/compare.d.ts

@@ -0,0 +1,18 @@
+/**
+ * compare.ts
+ *
+ * CLI for structured comparison between two evaluation runs.
+ *
+ * Usage:
+ *   pnpm compare                                # compare current vs latest baseline
+ *   pnpm compare --baseline <path>              # compare current vs specific file
+ *   pnpm compare --baseline <path> --experiment <path>  # compare two specific files
+ *   pnpm compare --threshold 5                  # custom noise threshold
+ *   pnpm compare --output /tmp/comparison.json  # write JSON report to file
+ *   pnpm compare --format json                  # output raw JSON (default: table)
+ *
+ * Reads: results/latest/score-summary.json (as experiment, unless --experiment)
+ * Reads: results/baselines/<latest>.json (as baseline, unless --baseline)
+ */
+export { formatComparisonMarkdown, formatComparisonTable, } from "../_vendor/ailf-core/index.d.ts";
+export declare function main(): void;

package/dist/lib/compare.js

@@ -0,0 +1,170 @@
+/**
+ * compare.ts
+ *
+ * CLI for structured comparison between two evaluation runs.
+ *
+ * Usage:
+ *   pnpm compare                                # compare current vs latest baseline
+ *   pnpm compare --baseline <path>              # compare current vs specific file
+ *   pnpm compare --baseline <path> --experiment <path>  # compare two specific files
+ *   pnpm compare --threshold 5                  # custom noise threshold
+ *   pnpm compare --output /tmp/comparison.json  # write JSON report to file
+ *   pnpm compare --format json                  # output raw JSON (default: table)
+ *
+ * Reads: results/latest/score-summary.json (as experiment, unless --experiment)
+ * Reads: results/baselines/<latest>.json (as baseline, unless --baseline)
+ */
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { formatComparisonTable, } from "../_vendor/ailf-core/index.js";
+import { compare } from "../pipeline/compare.js";
+import { DEFAULT_NOISE_THRESHOLD, } from "../pipeline/types.js";
+// Re-export pure formatters from core for backward compatibility.
+export { formatComparisonMarkdown, formatComparisonTable, } from "../_vendor/ailf-core/index.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+const BASELINES_DIR = join(ROOT, "results", "baselines");
+const SCORE_SUMMARY_PATH = join(ROOT, "results", "latest", "score-summary.json");
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+const args = process.argv.slice(2);
+function getFlag(name) {
+    return args.includes(`--${name}`);
+}
+function getOption(name) {
+    const idx = args.indexOf(`--${name}`);
+    return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+const baselinePath = getOption("baseline");
+const experimentPath = getOption("experiment");
+const thresholdStr = getOption("threshold");
+const threshold = thresholdStr
+    ? parseFloat(thresholdStr)
+    : DEFAULT_NOISE_THRESHOLD;
+const outputPath = getOption("output");
+const format = getOption("format") ?? "table";
+const showHelp = getFlag("help") || getFlag("h");
+if (showHelp) {
+    console.log(`
+Usage: pnpm compare [options]
+
+Compare two evaluation score summaries and produce structured deltas.
+
+Options:
+  --baseline <path>     Baseline score-summary.json (default: latest baseline)
+  --experiment <path>   Experiment score-summary.json (default: results/latest/score-summary.json)
+  --threshold <n>       Noise threshold for unchanged classification (default: ${DEFAULT_NOISE_THRESHOLD})
+  --output <path>       Write JSON report to file
+  --format <fmt>        Output format: table (default) or json
+  --help, -h            Show this help
+
+Examples:
+  pnpm compare                           # current scores vs latest baseline
+  pnpm compare --threshold 5             # wider noise band
+  pnpm compare --format json             # machine-readable output
+  pnpm compare --baseline results/baselines/20260310_02_43_44.json
+  pnpm compare --baseline before.json --experiment after.json
+`);
+    process.exit(0);
+}
+// ---------------------------------------------------------------------------
+// File loading helpers
+// ---------------------------------------------------------------------------
+/**
+ * formatComparisonMarkdown — re-exported from @sanity/ailf-core above.
+ * formatComparisonTable — re-exported from @sanity/ailf-core above.
+ */
+function findLatestBaseline() {
+    if (!existsSync(BASELINES_DIR))
+        return null;
+    const files = readdirSync(BASELINES_DIR)
+        .filter((f) => f.endsWith(".json"))
+        .sort()
+        .reverse();
+    return files.length > 0 ? join(BASELINES_DIR, files[0]) : null;
+}
+function loadSummary(path) {
+    if (!existsSync(path)) {
+        console.error(`❌ File not found: ${path}`);
+        process.exit(1);
+    }
+    const raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw);
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export function main() {
+    // Resolve experiment path
+    const expPath = experimentPath ?? SCORE_SUMMARY_PATH;
+    const experiment = loadSummary(expPath);
+    // Resolve baseline path
+    let basePath;
+    if (baselinePath) {
+        basePath = resolve(baselinePath);
+    }
+    else {
+        const latest = findLatestBaseline();
+        if (!latest) {
+            console.error("❌ No baselines found. Run 'pnpm baseline:save' first, or use --baseline <path>.");
+            process.exit(1);
+        }
+        basePath = latest;
+    }
+    const baseline = loadSummary(basePath);
+    // Try to load grader consistency data for empirical thresholds
+    const consistencyPath = join(ROOT, "results", "latest", "grader-consistency.json");
+    let graderConsistency;
+    if (existsSync(consistencyPath) && !thresholdStr) {
+        try {
+            const consistencyRaw = JSON.parse(readFileSync(consistencyPath, "utf-8"));
+            if (consistencyRaw.recommendedThreshold && consistencyRaw.perDimension) {
+                graderConsistency =
+                    consistencyRaw;
+                console.log(`  📊 Using empirical noise threshold: ±${graderConsistency.recommendedThreshold.toFixed(1)} (from grader consistency data)`);
+            }
+        }
+        catch {
+            // Non-fatal — fall back to default threshold
+        }
+    }
+    console.log(`  Baseline:   ${basePath}`);
+    console.log(`  Experiment: ${expPath}`);
+    if (!graderConsistency) {
+        console.log(`  Threshold:  ±${threshold} (default — run --grader-replications for empirical threshold)`);
+    }
+    console.log("");
+    const report = compare(baseline, experiment, {
+        graderConsistency,
+        noiseThreshold: threshold,
+    });
+    if (format === "json") {
+        const json = JSON.stringify(report, null, 2);
+        if (outputPath) {
+            writeFileSync(outputPath, json);
+            console.log(`  ✅ Comparison report written to ${outputPath}`);
+        }
+        else {
+            console.log(json);
+        }
+    }
+    else {
+        const table = formatComparisonTable(report);
+        console.log(table);
+        if (outputPath) {
+            const json = JSON.stringify(report, null, 2);
+            writeFileSync(outputPath, json);
+            console.log(`  ✅ Comparison report also written to ${outputPath}`);
+        }
+    }
+    // Write comparison report to results/latest for other steps to consume
+    const latestComparisonPath = join(ROOT, "results", "latest", "comparison-report.json");
+    writeFileSync(latestComparisonPath, JSON.stringify(report, null, 2));
+}
+// Only run when invoked directly
+if (process.argv[1]?.endsWith("compare.ts") ||
+    process.argv[1]?.endsWith("compare.js")) {
+    main();
+}

package/dist/lib/coverage-audit.d.ts

@@ -0,0 +1,4 @@
+export { countReferencedDocs, countTasksByArea, formatCoverageConsole, formatCoverageMarkdown, loadFeatureRegistry, runCoverageAudit, } from "../pipeline/coverage-audit.js";
+export type { CoverageAuditReport, ProductFeature } from "../pipeline/types.js";
+/** @deprecated Use pipeline functions directly with explicit rootDir */
+export declare function main(): void;

package/dist/lib/coverage-audit.js

@@ -0,0 +1,42 @@
+/**
+ * lib/coverage-audit.ts — DEPRECATED re-export shim.
+ * @deprecated Import from ../pipeline/coverage-audit.js instead.
+ */
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+export { countReferencedDocs, countTasksByArea, formatCoverageConsole, formatCoverageMarkdown, loadFeatureRegistry, runCoverageAudit, } from "../pipeline/coverage-audit.js";
+import { countReferencedDocs, formatCoverageConsole, formatCoverageMarkdown, runCoverageAudit, } from "../pipeline/coverage-audit.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "../..");
+/** @deprecated Use pipeline functions directly with explicit rootDir */
+export function main() {
+    const args = process.argv.slice(2);
+    const formatArg = args.includes("--format")
+        ? args[args.indexOf("--format") + 1]
+        : undefined;
+    const jsonOutput = args.includes("--json");
+    const report = runCoverageAudit(ROOT);
+    if (!report) {
+        console.error("❌ Coverage audit failed.");
+        process.exit(1);
+    }
+    if (jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else if (formatArg === "md" || formatArg === "markdown") {
+        console.log(formatCoverageMarkdown(report));
+    }
+    else {
+        console.log(formatCoverageConsole(report));
+    }
+    if (!jsonOutput && formatArg !== "md") {
+        const docStats = countReferencedDocs(ROOT);
+        console.log("DOCUMENT UTILIZATION:");
+        console.log(`  ${docStats.total} unique document slugs referenced across evaluation tasks`);
+        console.log("");
+    }
+}
+if (process.argv[1]?.endsWith("coverage-audit.ts") ||
+    process.argv[1]?.endsWith("coverage-audit.js")) {
+    main();
+}

package/dist/lib/discovery-report.d.ts

@@ -0,0 +1,13 @@
+/**
+ * lib/discovery-report.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/discovery-report.ts.
+ *
+ * @deprecated Import from ../pipeline/discovery-report.js instead.
+ */
+export { formatDiscoveryMarkdown, generateDiscoveryReport, type DiscoveryReport, type InvisibleDoc, } from "../pipeline/discovery-report.js";
+/**
+ * Legacy main() entry point.
+ * @deprecated Use generateDiscoveryReport() + formatDiscoveryMarkdown() directly.
+ */
+export declare function main(): void;

package/dist/lib/discovery-report.js

@@ -0,0 +1,57 @@
+/**
+ * lib/discovery-report.ts — DEPRECATED re-export shim.
+ *
+ * The real implementation has moved to pipeline/discovery-report.ts.
+ *
+ * @deprecated Import from ../pipeline/discovery-report.js instead.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export { formatDiscoveryMarkdown, generateDiscoveryReport, } from "../pipeline/discovery-report.js";
+import { formatDiscoveryMarkdown, generateDiscoveryReport, } from "../pipeline/discovery-report.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+/**
+ * Legacy main() entry point.
+ * @deprecated Use generateDiscoveryReport() + formatDiscoveryMarkdown() directly.
+ */
+export function main() {
+    const args = process.argv.slice(2);
+    let output;
+    const areaFilter = [];
+    let summaryPath = join(ROOT, "results", "latest", "score-summary.json");
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--output" && args[i + 1]) {
+            output = args[++i];
+        }
+        else if (args[i] === "--area" && args[i + 1]) {
+            areaFilter.push(...args[++i].split(","));
+        }
+        else if (args[i] === "--input" && args[i + 1]) {
+            summaryPath = args[++i];
+        }
+        else if (!args[i].startsWith("-")) {
+            summaryPath = args[i];
+        }
+    }
+    if (!existsSync(summaryPath)) {
+        console.error(`❌ Score summary not found: ${summaryPath}`);
+        console.error("Run an agentic evaluation first: pnpm pipeline -- --mode agentic");
+        process.exit(1);
+    }
+    const summary = JSON.parse(readFileSync(summaryPath, "utf-8"));
+    const report = generateDiscoveryReport(summary, areaFilter.length > 0 ? areaFilter : undefined);
+    const markdown = formatDiscoveryMarkdown(report);
+    if (output) {
+        writeFileSync(output, markdown, "utf-8");
+        console.log(`✅ Discovery report written to ${output}`);
+    }
+    else {
+        console.log(markdown);
+    }
+}
+if (process.argv[1]?.endsWith("discovery-report.ts") ||
+    process.argv[1]?.endsWith("discovery-report.js")) {
+    main();
+}

package/dist/lib/fetch-docs.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Fetch-docs.ts — CLI entry point for documentation fetching.
+ *
+ * This is a standalone script for direct CLI invocation:
+ *   npx tsx src/lib/fetch-docs.ts [--source name] [--include-feature-areas] [--include-corpus]
+ *
+ * The pipeline uses ctx.docFetcher (SanityDocFetcher adapter) directly via
+ * FetchDocsStep — this file is NOT called by the pipeline.
+ *
+ * Capabilities:
+ *   1. Canonical contexts     — delegates to SanityDocFetcher adapter (always)
+ *   2. Feature-area contexts  — one file per GROQ feature area query
+ *      (opt-in via --include-feature-areas)
+ *   3. Full corpus            — all articles in one file
+ *      (opt-in via --include-corpus)
+ */
+import "dotenv/config";
+import { type ResolvedSourceConfig } from "../sources.js";
+/** Options for the fetch-docs main() function. */
+export interface FetchDocsOptions {
+    /** Fetch full corpus (for retrieval experiments) */
+    includeCorpus?: boolean;
+    /** Fetch feature-area contexts in addition to canonical contexts */
+    includeFeatureAreas?: boolean;
+    /** Pre-resolved source config (skips loadSource() call) */
+    resolvedSource?: ResolvedSourceConfig;
+    /** Documentation source name (e.g., "branch", "local") */
+    source?: string;
+}
+export declare function main(options?: FetchDocsOptions): Promise<void>;