@sanity/ailf 0.1.0

package/dist/adapters/eval-runners/promptfoo-eval-adapter.js

@@ -0,0 +1,63 @@
+/**
+ * Adapter: Run evaluation via Promptfoo CLI subprocess.
+ *
+ * This wraps the current execSync-based eval execution behind the
+ * EvalRunner port interface, enabling mock-based testing of the
+ * pipeline orchestrator.
+ */
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+export class PromptfooEvalAdapter {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    async run(config) {
+        const start = Date.now();
+        // Resolve .env path — monorepo root (../../.env) or caller's cwd (.env)
+        const monorepoEnv = resolve(this.rootDir, "..", "..", ".env");
+        const callerEnv = resolve(process.env.AILF_CALLER_CWD ?? process.cwd(), ".env");
+        const envFile = existsSync(monorepoEnv) ? monorepoEnv : callerEnv;
+        const dotenvPrefix = existsSync(envFile) ? `dotenv -e ${envFile} -o --` : "";
+        const parts = [
+            dotenvPrefix,
+            "npx promptfoo eval",
+            `-c ${config.configPath}`,
+            config.filterFlags ?? "",
+            config.concurrency ? `--max-concurrency ${config.concurrency}` : "",
+        ].filter(Boolean);
+        const cmd = parts.join(" ");
+        try {
+            execSync(cmd, {
+                cwd: this.rootDir,
+                env: { ...process.env, ...config.env },
+                stdio: "inherit",
+            });
+            return {
+                durationMs: Date.now() - start,
+                status: "success",
+                summary: `Evaluation complete (${config.configPath})`,
+            };
+        }
+        catch {
+            return {
+                durationMs: Date.now() - start,
+                error: `Promptfoo evaluation failed: ${config.configPath}`,
+                status: "failed",
+            };
+        }
+    }
+    extractShareUrl(outputPath) {
+        if (!existsSync(outputPath))
+            return undefined;
+        try {
+            const raw = readFileSync(outputPath, "utf-8");
+            const data = JSON.parse(raw);
+            return data.shareableUrl ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Adapters barrel export.
+ *
+ * Adapters implement port interfaces from @sanity/ailf-core.
+ * This is the "outside" of the hexagonal architecture.
+ */
+export { ContentLakeCacheAdapter, FilesystemCache } from "./cache/index.js";
+export { SanityDocFetcher } from "./doc-fetchers/index.js";
+export { PromptfooEvalAdapter } from "./eval-runners/index.js";
+export { ConsoleLogger, type ConsoleLoggerOptions, JsonLogger, QuietLogger, } from "./loggers/index.js";
+export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
+export { YamlTaskSource } from "./task-sources/index.js";

package/dist/adapters/index.js

@@ -0,0 +1,12 @@
+/**
+ * Adapters barrel export.
+ *
+ * Adapters implement port interfaces from @sanity/ailf-core.
+ * This is the "outside" of the hexagonal architecture.
+ */
+export { ContentLakeCacheAdapter, FilesystemCache } from "./cache/index.js";
+export { SanityDocFetcher } from "./doc-fetchers/index.js";
+export { PromptfooEvalAdapter } from "./eval-runners/index.js";
+export { ConsoleLogger, JsonLogger, QuietLogger, } from "./loggers/index.js";
+export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
+export { YamlTaskSource } from "./task-sources/index.js";

package/dist/adapters/loggers/console-logger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ConsoleLogger — the default human-readable logger adapter.
+ *
+ * Matches the existing emoji-prefix console output style used throughout
+ * the pipeline. This is a drop-in replacement for the scattered
+ * console.log calls — same visual output, structured interface.
+ */
+import type { Logger, StepResult } from "../../_vendor/ailf-core/index.d.ts";
+export interface ConsoleLoggerOptions {
+    verbose?: boolean;
+}
+export declare class ConsoleLogger implements Logger {
+    private readonly verbose;
+    constructor(options?: ConsoleLoggerOptions);
+    debug(msg: string, ctx?: Record<string, unknown>): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    step(name: string, result: StepResult): void;
+    section(title: string): void;
+    table(headers: string[], rows: string[][]): void;
+}

package/dist/adapters/loggers/console-logger.js

@@ -0,0 +1,54 @@
+/**
+ * ConsoleLogger — the default human-readable logger adapter.
+ *
+ * Matches the existing emoji-prefix console output style used throughout
+ * the pipeline. This is a drop-in replacement for the scattered
+ * console.log calls — same visual output, structured interface.
+ */
+export class ConsoleLogger {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose ?? false;
+    }
+    debug(msg, ctx) {
+        if (!this.verbose)
+            return;
+        console.log(`  🔍 ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ""}`);
+    }
+    info(msg) {
+        console.log(`  ${msg}`);
+    }
+    warn(msg) {
+        console.warn(`  ⚠️  ${msg}`);
+    }
+    error(msg) {
+        console.error(`  ❌ ${msg}`);
+    }
+    step(name, result) {
+        const icon = result.status === "success"
+            ? "✅"
+            : result.status === "skipped"
+                ? "⏭️"
+                : "❌";
+        const detail = result.status === "success"
+            ? `(${result.durationMs}ms) ${result.summary}`
+            : result.status === "skipped"
+                ? result.reason
+                : result.error;
+        console.log(`  ${icon} ${name}: ${detail}`);
+    }
+    section(title) {
+        const line = "═".repeat(65);
+        console.log(`\n${line}\n ${title}\n${line}\n`);
+    }
+    table(headers, rows) {
+        const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+        const pad = (s, w) => s.padEnd(w);
+        const sep = widths.map((w) => "─".repeat(w)).join("─┼─");
+        console.log(headers.map((h, i) => pad(h, widths[i])).join(" │ "));
+        console.log(sep);
+        for (const row of rows) {
+            console.log(row.map((c, i) => pad(c ?? "", widths[i])).join(" │ "));
+        }
+    }
+}

package/dist/adapters/loggers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Logger adapters barrel export.
+ *
+ * Each adapter implements the Logger port from @sanity/ailf-core
+ * with different output strategies.
+ */
+export { ConsoleLogger, type ConsoleLoggerOptions } from "./console-logger.js";
+export { QuietLogger } from "./quiet-logger.js";
+export { JsonLogger } from "./json-logger.js";

package/dist/adapters/loggers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Logger adapters barrel export.
+ *
+ * Each adapter implements the Logger port from @sanity/ailf-core
+ * with different output strategies.
+ */
+export { ConsoleLogger } from "./console-logger.js";
+export { QuietLogger } from "./quiet-logger.js";
+export { JsonLogger } from "./json-logger.js";

package/dist/adapters/loggers/json-logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JsonLogger — machine-readable NDJSON output.
+ *
+ * Used with --format json flag. Every log call emits a single JSON
+ * line to stdout, suitable for piping to jq, structured log collectors,
+ * or programmatic consumption.
+ */
+import type { Logger, StepResult } from "../../_vendor/ailf-core/index.d.ts";
+export declare class JsonLogger implements Logger {
+    private emit;
+    debug(msg: string, ctx?: Record<string, unknown>): void;
+    info(msg: string, ctx?: Record<string, unknown>): void;
+    warn(msg: string, ctx?: Record<string, unknown>): void;
+    error(msg: string, ctx?: Record<string, unknown>): void;
+    step(name: string, result: StepResult): void;
+    section(title: string): void;
+    table(headers: string[], rows: string[][]): void;
+}

package/dist/adapters/loggers/json-logger.js

@@ -0,0 +1,33 @@
+/**
+ * JsonLogger — machine-readable NDJSON output.
+ *
+ * Used with --format json flag. Every log call emits a single JSON
+ * line to stdout, suitable for piping to jq, structured log collectors,
+ * or programmatic consumption.
+ */
+export class JsonLogger {
+    emit(level, msg, ctx) {
+        console.log(JSON.stringify({ level, msg, ts: Date.now(), ...ctx }));
+    }
+    debug(msg, ctx) {
+        this.emit("debug", msg, ctx);
+    }
+    info(msg, ctx) {
+        this.emit("info", msg, ctx);
+    }
+    warn(msg, ctx) {
+        this.emit("warn", msg, ctx);
+    }
+    error(msg, ctx) {
+        this.emit("error", msg, ctx);
+    }
+    step(name, result) {
+        this.emit("step", name, { result });
+    }
+    section(title) {
+        this.emit("section", title);
+    }
+    table(headers, rows) {
+        this.emit("table", "data", { headers, rows });
+    }
+}

package/dist/adapters/loggers/quiet-logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * QuietLogger — only errors and step failures.
+ *
+ * Used with --quiet flag. Suppresses all informational output,
+ * showing only errors and failed pipeline steps.
+ */
+import type { Logger, StepResult } from "../../_vendor/ailf-core/index.d.ts";
+export declare class QuietLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(msg: string): void;
+    step(name: string, result: StepResult): void;
+    section(): void;
+    table(): void;
+}

package/dist/adapters/loggers/quiet-logger.js

@@ -0,0 +1,30 @@
+/**
+ * QuietLogger — only errors and step failures.
+ *
+ * Used with --quiet flag. Suppresses all informational output,
+ * showing only errors and failed pipeline steps.
+ */
+export class QuietLogger {
+    debug() {
+        /* noop */
+    }
+    info() {
+        /* noop */
+    }
+    warn() {
+        /* noop */
+    }
+    error(msg) {
+        console.error(msg);
+    }
+    step(name, result) {
+        if (result.status === "failed")
+            console.error(`❌ ${name}: ${result.error}`);
+    }
+    section() {
+        /* noop */
+    }
+    table() {
+        /* noop */
+    }
+}

package/dist/adapters/task-sources/composite-task-source.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapter: Merge tasks from multiple TaskSource implementations.
+ *
+ * CompositeTaskSource wraps N TaskSource adapters and returns the union
+ * of their tasks. When two sources produce a task with the same ID,
+ * the later source wins (repo overrides Content Lake). A warning is
+ * logged on ID collision.
+ *
+ * This is how the pipeline sees both Content Lake tasks and repo-based
+ * tasks in a single TaskDefinition[].
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+import type { FilterOptions, TaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+export declare class CompositeTaskSource implements TaskSource {
+    private readonly sources;
+    constructor(sources: TaskSource[]);
+    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+}

package/dist/adapters/task-sources/composite-task-source.js

@@ -0,0 +1,59 @@
+/**
+ * Adapter: Merge tasks from multiple TaskSource implementations.
+ *
+ * CompositeTaskSource wraps N TaskSource adapters and returns the union
+ * of their tasks. When two sources produce a task with the same ID,
+ * the later source wins (repo overrides Content Lake). A warning is
+ * logged on ID collision.
+ *
+ * This is how the pipeline sees both Content Lake tasks and repo-based
+ * tasks in a single TaskDefinition[].
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/tasks-as-content/phase-4-repo-based-tasks.md
+ */
+export class CompositeTaskSource {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+        if (sources.length === 0) {
+            throw new Error("CompositeTaskSource requires at least one source");
+        }
+    }
+    async loadTasks(filter) {
+        const results = await Promise.all(this.sources.map((s) => s.loadTasks(filter)));
+        return deduplicateById(results);
+    }
+}
+// ---------------------------------------------------------------------------
+// Deduplication — later sources override earlier ones
+// ---------------------------------------------------------------------------
+/**
+ * Merge task arrays with later-wins deduplication.
+ *
+ * Sources are ordered [Content Lake, Repo, ...]. When a repo defines a
+ * task with the same ID as a Content Lake task, the repo version wins
+ * because it's fresher (the developer just edited it locally).
+ *
+ * Logs a warning on ID collision so it's visible but not blocking.
+ */
+function deduplicateById(taskArrays) {
+    const seen = new Map();
+    const merged = [];
+    for (let sourceIdx = 0; sourceIdx < taskArrays.length; sourceIdx++) {
+        for (const task of taskArrays[sourceIdx]) {
+            const existing = seen.get(task.id);
+            if (existing !== undefined) {
+                // Later source wins — replace the earlier task
+                console.warn(`  ⚠️  Task "${task.id}" from source ${sourceIdx} overrides source ${existing.sourceIdx}`);
+                merged[existing.index] = task;
+                seen.set(task.id, { index: existing.index, sourceIdx });
+            }
+            else {
+                seen.set(task.id, { index: merged.length, sourceIdx });
+                merged.push(task);
+            }
+        }
+    }
+    return merged;
+}

package/dist/adapters/task-sources/content-lake-task-source.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapter: Load task definitions from the Sanity Content Lake.
+ *
+ * Fetches ailf.task documents via GROQ and maps them to the canonical
+ * TaskDefinition type. This adapter is the Content Lake counterpart of
+ * YamlTaskSource — both produce identical TaskDefinition[] for the same
+ * logical tasks. The pipeline never knows which adapter loaded the tasks.
+ *
+ * Wired in the composition root when --task-source content-lake is set.
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/tasks-as-content/phase-2-pipeline-integration.md
+ */
+import type { SanityClient } from "@sanity/client";
+import type { FilterOptions, TaskDefinition, TaskSource } from "../../_vendor/ailf-core/index.d.ts";
+export declare class ContentLakeTaskSource implements TaskSource {
+    private readonly client;
+    constructor(client: SanityClient);
+    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+}

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -0,0 +1,219 @@
+/**
+ * Adapter: Load task definitions from the Sanity Content Lake.
+ *
+ * Fetches ailf.task documents via GROQ and maps them to the canonical
+ * TaskDefinition type. This adapter is the Content Lake counterpart of
+ * YamlTaskSource — both produce identical TaskDefinition[] for the same
+ * logical tasks. The pipeline never knows which adapter loaded the tasks.
+ *
+ * Wired in the composition root when --task-source content-lake is set.
+ *
+ * @see packages/core/src/ports/task-source.ts — TaskSource port
+ * @see docs/exec-plans/completed/tasks-as-content/phase-2-pipeline-integration.md
+ */
+// ---------------------------------------------------------------------------
+// GROQ query — fetches ailf.task documents with resolved references
+// ---------------------------------------------------------------------------
+/**
+ * GROQ query that projects ailf.task documents into a shape suitable for
+ * mapping to TaskDefinition.
+ *
+ * Key projections:
+ * - featureArea reference → dereferenced areaId string
+ * - canonicalDocs[] → dereferenced article slugs with reason
+ * - referenceSolution → title (for identification, not full content)
+ *
+ * Filter parameters:
+ * - $areas: string[] | null — when non-null, only tasks in these areas
+ * - $taskIds: string[] | null — when non-null, only these task IDs
+ */
+const TASKS_QUERY = /* groq */ `
+*[_type == "ailf.task"
+  && (!defined($areas) || featureArea->areaId.current in $areas)
+  && (!defined($taskIds) || id.current in $taskIds)
+  && (execution.enabled != false)
+] | order(featureArea->areaId.current asc, id.current asc) {
+  "taskId": id.current,
+  description,
+  "featureAreaId": featureArea->areaId.current,
+  taskPrompt,
+  docCoverage,
+  "canonicalDocs": canonicalDocs[] {
+    refType,
+    "slug": doc->slug.current,
+    "docRefId": doc->_id,
+    "sectionSlug": doc->primarySection->slug.current,
+    path,
+    "docId": docId,
+    perspective,
+    reason
+  },
+  assert,
+  rawAssert,
+  baseline,
+  "referenceSolutionTitle": referenceSolution->title
+}
+`;
+// ---------------------------------------------------------------------------
+// ContentLakeTaskSource adapter
+// ---------------------------------------------------------------------------
+export class ContentLakeTaskSource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async loadTasks(filter) {
+        const params = buildGroqParams(filter);
+        const raw = await this.client.fetch(TASKS_QUERY, params);
+        if (!Array.isArray(raw)) {
+            throw new Error("ContentLakeTaskSource: GROQ query did not return an array");
+        }
+        const definitions = [];
+        for (const entry of raw) {
+            const mapped = mapToTaskDefinition(entry);
+            if (!mapped)
+                continue;
+            definitions.push(mapped);
+        }
+        if (definitions.length === 0 && !filter) {
+            console.warn("  ⚠️  ContentLakeTaskSource: no ailf.task documents found in the Content Lake. " +
+                "Have you run the migration (Phase 3) or created tasks in Studio?");
+        }
+        return definitions;
+    }
+}
+// ---------------------------------------------------------------------------
+// GROQ parameter builder
+// ---------------------------------------------------------------------------
+function buildGroqParams(filter) {
+    return {
+        areas: filter?.areas && filter.areas.length > 0
+            ? filter.areas.map((a) => a.toLowerCase())
+            : null,
+        taskIds: filter?.taskIds && filter.taskIds.length > 0 ? filter.taskIds : null,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mapping: Content Lake → TaskDefinition
+// ---------------------------------------------------------------------------
+/**
+ * Map a Content Lake ailf.task document to the canonical TaskDefinition.
+ *
+ * Returns null if the document is missing required fields (taskId,
+ * description, featureAreaId, taskPrompt). These are required by the
+ * Studio schema, but defensive coding handles edge cases (drafts,
+ * partially-created documents, etc.).
+ */
+function mapToTaskDefinition(raw) {
+    // Required fields — skip malformed documents
+    if (!raw.taskId ||
+        !raw.description ||
+        !raw.featureAreaId ||
+        !raw.taskPrompt) {
+        return null;
+    }
+    const canonicalDocs = (raw.canonicalDocs ?? [])
+        .map(mapCanonicalDocRef)
+        .filter((d) => d !== null);
+    const assertions = mapAssertions(raw.assert ?? []);
+    const baseline = raw.baseline
+        ? {
+            ...(raw.baseline.enabled !== undefined
+                ? { enabled: raw.baseline.enabled }
+                : {}),
+            ...(raw.baseline.rubric
+                ? {
+                    rubric: raw.baseline.rubric,
+                }
+                : {}),
+        }
+        : undefined;
+    return {
+        assertions,
+        canonicalDocs,
+        description: raw.description,
+        docCoverage: raw.docCoverage ?? false,
+        featureArea: raw.featureAreaId,
+        id: raw.taskId,
+        // Reference solution path is not meaningful for CL tasks — the solution
+        // content lives in the Content Lake document, not on the filesystem.
+        // Downstream consumers that need the solution content will need to fetch
+        // it via the referenceSolution reference. For now, use empty string
+        // (same as tasks without a reference solution).
+        referenceSolution: "",
+        taskPrompt: raw.taskPrompt,
+        ...(baseline ? { baseline } : {}),
+    };
+}
+/**
+ * Map a Content Lake canonical doc entry to the polymorphic CanonicalDocRef.
+ *
+ * Uses `refType` to determine which value field to read. Falls back to
+ * slug-based resolution for backward compatibility (documents created
+ * before the polymorphic schema migration).
+ */
+function mapCanonicalDocRef(raw) {
+    const reason = raw.reason ?? "";
+    const refType = raw.refType ?? "slug"; // default for legacy documents (pre-id-default)
+    switch (refType) {
+        case "slug":
+            return raw.slug ? { slug: raw.slug, reason } : null;
+        case "path": {
+            // Prefer explicit path field; fall back to deriving from doc reference
+            const path = raw.path ||
+                (raw.sectionSlug && raw.slug ? `${raw.sectionSlug}/${raw.slug}` : null);
+            return path ? { path, reason } : null;
+        }
+        case "id": {
+            // Prefer explicit docId field; fall back to doc reference _id
+            const id = raw.docId || raw.docRefId || null;
+            if (!id)
+                return null;
+            // Carry slug and derived path as optional DX annotations
+            const derivedPath = raw.sectionSlug && raw.slug
+                ? `${raw.sectionSlug}/${raw.slug}`
+                : undefined;
+            return {
+                id,
+                reason,
+                ...(raw.slug ? { slug: raw.slug } : {}),
+                ...(derivedPath ? { path: derivedPath } : {}),
+            };
+        }
+        case "perspective":
+            return raw.perspective ? { perspective: raw.perspective, reason } : null;
+        default:
+            // Unknown refType — try slug as fallback
+            return raw.slug ? { slug: raw.slug, reason } : null;
+    }
+}
+/**
+ * Map Content Lake assertion objects to domain AssertionDefinition[].
+ *
+ * Content Lake assertions use the same field names as the domain type
+ * (type, template, criteria, value, threshold, weight) but all fields
+ * are optional in the raw response. This function normalizes them.
+ */
+function mapAssertions(raw) {
+    return raw
+        .filter((a) => !!a.type)
+        .map((a) => {
+        if (a.type === "llm-rubric" && a.template && a.criteria) {
+            return {
+                criteria: a.criteria,
+                template: a.template,
+                type: "llm-rubric",
+                ...(a.weight !== undefined ? { weight: a.weight } : {}),
+            };
+        }
+        // Value-based assertion
+        const result = { type: a.type };
+        if (a.value !== undefined)
+            result.value = a.value;
+        if (a.threshold !== undefined)
+            result.threshold = a.threshold;
+        if (a.weight !== undefined)
+            result.weight = a.weight;
+        return result;
+    });
+}

package/dist/adapters/task-sources/index.d.ts

@@ -0,0 +1,7 @@
+export { CompositeTaskSource } from "./composite-task-source.js";
+export { ContentLakeTaskSource } from "./content-lake-task-source.js";
+export { parseRepoConfig, parseRepoTaskFile, RepoConfigSchema, RepoTaskSchema, CURATED_ASSERTION_TYPES, RUBRIC_TEMPLATE_NAMES, type RepoConfig, type RepoTask, } from "./repo-schemas.js";
+export { RepoTaskSource } from "./repo-task-source.js";
+export { detectTriggerContext, resolveTrigger, type ResolvedTrigger, type TriggerContext, } from "./repo-trigger.js";
+export { formatValidationResult, validateRepoTasks, type ValidationMessage, type ValidationResult, } from "./repo-validation.js";
+export { YamlTaskSource } from "./yaml-task-source.js";

package/dist/adapters/task-sources/index.js

@@ -0,0 +1,7 @@
+export { CompositeTaskSource } from "./composite-task-source.js";
+export { ContentLakeTaskSource } from "./content-lake-task-source.js";
+export { parseRepoConfig, parseRepoTaskFile, RepoConfigSchema, RepoTaskSchema, CURATED_ASSERTION_TYPES, RUBRIC_TEMPLATE_NAMES, } from "./repo-schemas.js";
+export { RepoTaskSource } from "./repo-task-source.js";
+export { detectTriggerContext, resolveTrigger, } from "./repo-trigger.js";
+export { formatValidationResult, validateRepoTasks, } from "./repo-validation.js";
+export { YamlTaskSource } from "./yaml-task-source.js";