@sanity/ailf 0.1.34 → 0.3.0

package/dist/pipeline/grader-consistency-runner.js

@@ -16,6 +16,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
+import { ConsoleLogger } from "../adapters/loggers/index.js";
 import { gradeOnce } from "./grader-api.js";
 import { analyzeConsistency, } from "./grader-consistency.js";
 // ---------------------------------------------------------------------------
@@ -192,7 +193,8 @@ export function formatConsistencyReport(result, graderModel) {
  */
 export async function runGraderConsistency(options) {
     const { replications, resultsPath, rootDir } = options;
-    console.log("=== Grader Consistency Analysis ===\n");
+    const log = options.logger ?? new ConsoleLogger();
+    log.section("Grader Consistency Analysis");
     // Validate inputs
     if (!existsSync(resultsPath)) {
         throw new Error(`Results file not found: ${resultsPath}. Run 'pnpm eval' first to generate results.`);
@@ -201,8 +203,8 @@ export async function runGraderConsistency(options) {
         throw new Error("Need at least 2 replications for meaningful analysis.");
     }
     // Load eval results
-    console.log(`  Results:      ${resultsPath}`);
-    console.log(`  Replications: ${replications}`);
+    log.info(`Results:      ${resultsPath}`);
+    log.info(`Replications: ${replications}`);
     const file = JSON.parse(readFileSync(resultsPath, "utf-8"));
     // Extract grader model
     const graderModel = file.config?.defaultTest?.options?.rubricProvider ??
@@ -210,20 +212,20 @@ export async function runGraderConsistency(options) {
     if (!graderModel) {
         throw new Error("Could not determine grader model from eval results config.");
     }
-    console.log(`  Grader:       ${graderModel}`);
+    log.info(`Grader:       ${graderModel}`);
     // Extract judgments
     const judgments = extractGradingJudgments(file);
-    console.log(`  Judgments:    ${judgments.length} (gold tests × rubric dimensions)`);
+    log.info(`Judgments:    ${judgments.length} (gold tests × rubric dimensions)`);
     if (judgments.length === 0) {
         throw new Error("No gradable judgments found in results.");
     }
     const totalCalls = judgments.length * replications;
     const estimatedCost = totalCalls * 0.005;
-    console.log(`  API calls:    ${totalCalls} (${judgments.length} × ${replications})`);
-    console.log(`  Est. cost:    ~$${estimatedCost.toFixed(2)}`);
-    console.log();
+    log.info(`API calls:    ${totalCalls} (${judgments.length} × ${replications})`);
+    log.info(`Est. cost:    ~$${estimatedCost.toFixed(2)}`);
+    log.info("");
     // Re-grade each judgment N times
-    console.log(`  Running ${replications} replications per judgment...`);
+    log.info(`Running ${replications} replications per judgment...`);
     const gradings = [];
     let completed = 0;
     let failed = 0;
@@ -251,20 +253,20 @@ export async function runGraderConsistency(options) {
             taskId: judgment.description,
         });
     }
-    console.log(); // newline after progress
+    log.info(""); // newline after progress
     if (failed > 0) {
-        console.log(`  ⚠ ${failed} grading calls failed (excluded from analysis)`);
+        log.warn(`${failed} grading calls failed (excluded from analysis)`);
     }
-    console.log();
+    log.info("");
     // Analyze consistency
     const result = analyzeConsistency(gradings);
     // Print report
-    console.log(formatConsistencyReport(result, graderModel));
+    log.info(formatConsistencyReport(result, graderModel));
     // Write output
     const outDir = join(rootDir, "results", "latest");
     mkdirSync(outDir, { recursive: true });
     const outPath = join(outDir, "grader-consistency.json");
     writeFileSync(outPath, JSON.stringify(result, null, 2));
-    console.log(`\n  📄 Results written to ${outPath}`);
+    log.info(`\n📄 Results written to ${outPath}`);
     return result;
 }

package/dist/pipeline/grader-sensitivity-runner.d.ts

@@ -13,12 +13,15 @@
  *
  * @see docs/exec-plans/grader-reliability.md — Phase 4
  */
+import type { Logger } from "../_vendor/ailf-core/index.d.ts";
 import { type GraderSensitivityResult } from "./grader-sensitivity.js";
 export interface GraderSensitivityRunnerOptions {
     /** Filter to a specific feature area (e.g., "groq") */
     areaFilter?: string;
     /** Output format */
     format?: "json" | "table";
+    /** Logger instance (defaults to ConsoleLogger) */
+    logger?: Logger;
     /** Custom output path */
     outputPath?: string;
     /** Root directory of the eval package */

package/dist/pipeline/grader-sensitivity-runner.js

@@ -15,6 +15,7 @@
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "fs";
 import { basename, join } from "path";
+import { ConsoleLogger } from "../adapters/loggers/index.js";
 import { DEGRADATION_STRATEGIES } from "./degradations.js";
 import { gradeOnce, loadGraderModel } from "./grader-api.js";
 import { analyzeSensitivity, } from "./grader-sensitivity.js";
@@ -182,19 +183,20 @@ export function formatSensitivityReport(result) {
  */
 export async function runGraderSensitivity(options) {
     const { rootDir, areaFilter, format = "table" } = options;
-    console.log("=== Grader Sensitivity Analysis ===\n");
+    const log = options.logger ?? new ConsoleLogger();
+    log.info("=== Grader Sensitivity Analysis ===\n");
     // Resolve grader model
     const grader = loadGraderModel(rootDir);
-    console.log(`  Grader:       ${grader.label} (${grader.id})`);
+    log.info(`  Grader:       ${grader.label} (${grader.id})`);
     // Discover reference solutions
     const solutions = discoverReferenceSolutions(rootDir, areaFilter);
-    console.log(`  Solutions:    ${solutions.length} reference files`);
+    log.info(`  Solutions:    ${solutions.length} reference files`);
     if (areaFilter) {
-        console.log(`  Area filter:  ${areaFilter}`);
+        log.info(`  Area filter:  ${areaFilter}`);
     }
     // Generate degraded pairs
     const degradedPairs = generateDegradedPairs(solutions);
-    console.log(`  Pairs:        ${degradedPairs.length} (solutions × degradations)`);
+    log.info(`  Pairs:        ${degradedPairs.length} (solutions × degradations)`);
     if (degradedPairs.length === 0) {
         throw new Error("No degraded pairs generated. Check reference solutions.");
     }
@@ -206,11 +208,11 @@ export async function runGraderSensitivity(options) {
     ];
     const totalCalls = degradedPairs.length * dimensions.length * 2;
     const estimatedCost = totalCalls * 0.005;
-    console.log(`  API calls:    ${totalCalls}`);
-    console.log(`  Est. cost:    ~$${estimatedCost.toFixed(2)}`);
-    console.log();
+    log.info(`  API calls:    ${totalCalls}`);
+    log.info(`  Est. cost:    ~$${estimatedCost.toFixed(2)}`);
+    log.info("");
     // Grade each pair
-    console.log("  Grading original and degraded pairs...");
+    log.info("  Grading original and degraded pairs...");
     const rubricTemplate = (dim) => {
         const labels = {
             codeCorrectness: "Evaluate code correctness: Does the code follow best practices, use correct APIs, and avoid anti-patterns? Score 0–100.",
@@ -237,7 +239,7 @@ export async function runGraderSensitivity(options) {
                 completed === degradedPairs.length * dimensions.length) {
                 const total = degradedPairs.length * dimensions.length;
                 const pct = Math.round((completed / total) * 100);
-                process.stdout.write(`\r    Progress: ${completed}/${total} (${pct}%)`);
+                log.info(`    Progress: ${completed}/${total} (${pct}%)`);
             }
             if (originalScore === null || degradedScore === null) {
                 failed++;
@@ -254,11 +256,11 @@ export async function runGraderSensitivity(options) {
             });
         }
     }
-    console.log(); // newline after progress
+    log.info(""); // newline after progress
     if (failed > 0) {
-        console.log(`    ⚠ ${failed} grading pairs failed (excluded)`);
+        log.warn(`    ⚠ ${failed} grading pairs failed (excluded)`);
     }
-    console.log();
+    log.info("");
     if (sensitivityPairs.length === 0) {
         throw new Error("No sensitivity pairs to analyze. All grading calls failed.");
     }
@@ -266,10 +268,10 @@ export async function runGraderSensitivity(options) {
     const result = analyzeSensitivity(sensitivityPairs, grader.id);
     // Output
     if (format === "table") {
-        console.log(formatSensitivityReport(result));
+        log.info(formatSensitivityReport(result));
     }
     else {
-        console.log(JSON.stringify(result, null, 2));
+        log.info(JSON.stringify(result, null, 2));
     }
     // Write output
     const outPath = options.outputPath ??
@@ -277,6 +279,6 @@ export async function runGraderSensitivity(options) {
     const outDir = join(outPath, "..");
     mkdirSync(outDir, { recursive: true });
     writeFileSync(outPath, JSON.stringify(result, null, 2));
-    console.log(`\n  📄 Results written to ${outPath}`);
+    log.info(`\n  📄 Results written to ${outPath}`);
     return result;
 }

package/dist/pipeline/grader-validate-runner.d.ts

@@ -13,10 +13,13 @@
  *
  * @see docs/exec-plans/grader-reliability.md — Phase 2
  */
+import type { Logger } from "../_vendor/ailf-core/index.d.ts";
 import { type GraderValidation } from "./grader-validation.js";
 export interface GraderValidateRunnerOptions {
     /** Grader model to validate (defaults to loadGraderModel(rootDir).id) */
     graderModel?: string;
+    /** Logger instance (defaults to ConsoleLogger) */
+    logger?: Logger;
     /** MAE threshold for pass/fail (default: 10) */
     maeThreshold?: number;
     /** Root directory of the eval package */

package/dist/pipeline/grader-validate-runner.js

@@ -16,6 +16,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
 import { join } from "path";
 import { load } from "js-yaml";
+import { ConsoleLogger } from "../adapters/loggers/index.js";
 import { gradeOnce, loadGraderModel } from "./grader-api.js";
 import { classifyCorrelation, validateGrader, } from "./grader-validation.js";
 // ---------------------------------------------------------------------------
@@ -154,26 +155,27 @@ export function formatValidationReport(result) {
  */
 export async function runGraderValidate(options) {
     const { rootDir } = options;
+    const log = options.logger ?? new ConsoleLogger();
     const maeThreshold = options.maeThreshold ?? 10;
-    console.log("=== Grader Validation ===\n");
+    log.section("Grader Validation");
     // Resolve grader model
     const graderModel = options.graderModel ?? loadGraderModel(rootDir).id;
-    console.log(`  Grader:     ${graderModel}`);
-    console.log(`  Threshold:  MAE < ${maeThreshold}`);
+    log.info(`Grader:     ${graderModel}`);
+    log.info(`Threshold:  MAE < ${maeThreshold}`);
     // Load reference grades
     const rawGrades = loadReferenceGrades(rootDir);
-    console.log(`  Samples:    ${rawGrades.length} reference-graded responses`);
+    log.info(`Samples:    ${rawGrades.length} reference-graded responses`);
     // Count total rubric judgments
     let totalJudgments = 0;
     for (const rg of rawGrades) {
         totalJudgments += rg.rubrics.length;
     }
-    console.log(`  Judgments:  ${totalJudgments} (response × rubric pairs)`);
+    log.info(`Judgments:  ${totalJudgments} (response × rubric pairs)`);
     const estimatedCost = totalJudgments * 0.005;
-    console.log(`  Est. cost:  ~$${estimatedCost.toFixed(2)}`);
-    console.log();
+    log.info(`Est. cost:  ~$${estimatedCost.toFixed(2)}`);
+    log.info("");
     // Grade each reference sample
-    console.log("  Running grader on reference samples...");
+    log.info("Running grader on reference samples...");
     const grades = [];
     let completed = 0;
     let failed = 0;
@@ -181,7 +183,7 @@ export async function runGraderValidate(options) {
         for (const rubric of ref.rubrics) {
             const dimension = mapDimension(rubric.dimension);
             if (!dimension) {
-                console.error(`  ⚠ Unknown dimension '${rubric.dimension}' — skipping`);
+                log.error(`⚠ Unknown dimension '${rubric.dimension}' — skipping`);
                 continue;
             }
             const graderScore = await gradeOnce(graderModel, ref.response, rubric.rubricText);
@@ -203,24 +205,24 @@ export async function runGraderValidate(options) {
             });
         }
     }
-    console.log(); // newline after progress
+    log.info(""); // newline after progress
     if (failed > 0) {
-        console.log(`  ⚠ ${failed} grading calls failed (excluded from analysis)`);
+        log.warn(`${failed} grading calls failed (excluded from analysis)`);
     }
-    console.log();
+    log.info("");
     if (grades.length === 0) {
         throw new Error("No grades to analyze. All grading calls failed.");
     }
     // Validate
     const result = validateGrader(grades, graderModel, { maeThreshold });
     // Print report
-    console.log(formatValidationReport(result));
+    log.info(formatValidationReport(result));
     // Write output
     const outDir = join(rootDir, "results", "latest");
     mkdirSync(outDir, { recursive: true });
     const outPath = join(outDir, "grader-validation.json");
     writeFileSync(outPath, JSON.stringify(result, null, 2));
-    console.log(`\n  📄 Results written to ${outPath}`);
+    log.info(`\n📄 Results written to ${outPath}`);
     // Throw if threshold not met (instead of process.exit)
     if (!result.passesThreshold) {
         throw new Error(`VALIDATION FAILED: MAE ${result.overallMae} exceeds threshold ${maeThreshold}`);

package/dist/pipeline/mirror-repo-tasks.d.ts

@@ -13,7 +13,7 @@
  * @see docs/exec-plans/tasks-as-content/phase-5-content-lake-mirroring.md
  */
 import type { SanityClient } from "@sanity/client";
-import { type TaskDefinition } from "../_vendor/ailf-core/index.d.ts";
+import { type Logger, type TaskDefinition } from "../_vendor/ailf-core/index.d.ts";
 export interface MirrorOptions {
     /** Sanity client with write access */
     client: SanityClient;
@@ -23,6 +23,17 @@ export interface MirrorOptions {
     git: GitContext;
     /** If true, log what would be done without writing */
     dryRun?: boolean;
+    /** Logger instance (defaults to ConsoleLogger) */
+    logger?: Logger;
+}
+/** Authorship info extracted from git context or GitHub Actions environment. */
+export interface GitAuthor {
+    /** Git commit author name (e.g., "Jordan Smith") */
+    gitName?: string;
+    /** Git commit author email (e.g., "jordan@example.com") */
+    gitEmail?: string;
+    /** GitHub username (from GITHUB_ACTOR or event payload) */
+    githubUsername?: string;
 }
 export interface GitContext {
     /** Full repo identifier (e.g., "sanity-io/visual-editing") */
@@ -35,6 +46,8 @@ export interface GitContext {
     branch: string;
     /** HEAD commit SHA */
     commitSha: string;
+    /** Author of the current commit/trigger */
+    author: GitAuthor;
 }
 export interface MirrorResult {
     /** Total tasks processed */
@@ -84,3 +97,69 @@ export declare function mirrorDocId(owner: string, repo: string, taskId: string)
  * that's not mirrored.
  */
 export declare function computeTaskHash(task: TaskDefinition): string;
+/** @internal Exported for testing — not part of the public API. */
+export declare function buildMirrorDocument(task: TaskDefinition, opts: {
+    contentHash: string;
+    docId: string;
+    /** Existing author from the current mirror document (write-once preservation) */
+    existingAuthor?: GitAuthor;
+    git: GitContext;
+    slugToDocId: Map<string, string>;
+}): {
+    baseline?: {
+        rubric?: "full" | "abbreviated" | "none" | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
+    _id: string;
+    _type: string;
+    ownership: string;
+    status: "active" | "draft" | "paused" | "archived";
+    assert: Record<string, unknown>[];
+    canonicalDocs: ({
+        _key: string;
+        reason: string;
+    } | {
+        refType: string;
+        path: string;
+        _key: string;
+        reason: string;
+    } | {
+        doc?: {
+            _ref: string;
+            _type: string;
+        } | undefined;
+        docId?: string | undefined;
+        refType: string;
+        _key: string;
+        reason: string;
+    } | {
+        refType: string;
+        perspective: string;
+        _key: string;
+        reason: string;
+    })[];
+    description: string;
+    docCoverage: boolean;
+    featureArea: {
+        _ref: string;
+        _type: string;
+    };
+    id: {
+        _type: string;
+        current: string;
+    };
+    origin: {
+        branch: string;
+        commitSha: string;
+        contentHash: string;
+        lastSyncedAt: string;
+        path: string;
+        repo: string;
+        repoName: string;
+        repoOwner: string;
+        type: string;
+        author: GitAuthor;
+        lastEditor: GitAuthor;
+    };
+    taskPrompt: string;
+};