@justram/pie 0.1.0

package/dist/core/validators/shell.js

@@ -0,0 +1,24 @@
+import { spawn } from "node:child_process";
+export async function runShell(command, options) {
+    const child = spawn("sh", ["-c", command], {
+        stdio: ["pipe", "pipe", "pipe"],
+        signal: options?.signal,
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    if (options?.stdin !== undefined) {
+        child.stdin.write(options.stdin);
+    }
+    child.stdin.end();
+    const code = await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (value) => resolve(value ?? 0));
+    });
+    return {
+        code,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./core/errors.js";

package/dist/errors.js

@@ -0,0 +1 @@
+export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./core/errors.js";

package/dist/events.d.ts

@@ -0,0 +1 @@
+export type * from "./core/events.js";

package/dist/events.js

@@ -0,0 +1 @@
+export {};

package/dist/extract.d.ts

@@ -0,0 +1,4 @@
+import { type Message } from "@mariozechner/pi-ai";
+import type { ExtractOptions, ExtractStream } from "./types.js";
+export declare function extract<T>(input: string | Message[], options: ExtractOptions<T>): ExtractStream<T>;
+export declare function extractSync<T>(input: string | Message[], options: ExtractOptions<T>): Promise<T>;

package/dist/extract.js

@@ -0,0 +1,18 @@
+import { streamSimple } from "@mariozechner/pi-ai";
+import { extract as extractInternal, extractSync as extractSyncInternal } from "./core/extract.js";
+export function extract(input, options) {
+    const streamFn = options.streamFn ??
+        ((model, context, streamOptions) => {
+            streamOptions.onModelSelected?.(model);
+            return streamSimple(model, context, streamOptions);
+        });
+    return extractInternal(input, { ...options, streamFn });
+}
+export async function extractSync(input, options) {
+    const streamFn = options.streamFn ??
+        ((model, context, streamOptions) => {
+            streamOptions.onModelSelected?.(model);
+            return streamSimple(model, context, streamOptions);
+        });
+    return await extractSyncInternal(input, { ...options, streamFn });
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { type AssistantMessage, type ImageContent, type Message, type Model, StringEnum, type UserMessage, } from "@mariozechner/pi-ai";
+export { type Static, type TSchema, Type } from "@sinclair/typebox";
+export type { CacheEntry, CacheOptions, CacheStore } from "./cache/index.js";
+export { createFileCache, createMemoryCache, warmCache } from "./cache/index.js";
+export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./errors.js";
+export type { ExtractEvent, ValidatorLayer, } from "./events.js";
+export { extract, extractSync } from "./extract.js";
+export { getModel, getModels, getProviders } from "./models.js";
+export type { LoadRecipeSetupOptions, LoadRecipesOptions, LoadRecipesResult, Recipe, RecipeWarning, } from "./recipes/index.js";
+export { loadRecipeSetup, loadRecipes, resolveRecipe, } from "./recipes/index.js";
+export type { ExtractionSetup, LoadExtractionSetupOptions } from "./setup.js";
+export { loadExtractionSetup } from "./setup.js";
+export type { ExtractOptions, ExtractResult, ExtractStream, ThinkingBudgets, ThinkingLevel, Usage } from "./types.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { StringEnum, } from "@mariozechner/pi-ai";
+export { Type } from "@sinclair/typebox";
+export { createFileCache, createMemoryCache, warmCache } from "./cache/index.js";
+export { AbortError, CommandValidationError, ExtractError, HttpValidationError, MaxTurnsError, SchemaValidationError, } from "./errors.js";
+export { extract, extractSync } from "./extract.js";
+export { getModel, getModels, getProviders } from "./models.js";
+export { loadRecipeSetup, loadRecipes, resolveRecipe, } from "./recipes/index.js";
+export { loadExtractionSetup } from "./setup.js";

package/dist/main.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from "node:stream";
+import { extract } from "./extract.js";
+export interface CliDeps {
+    extractFn?: typeof extract;
+    stdin?: Readable;
+    stdout?: Writable;
+    stderr?: Writable;
+}
+export declare function main(argv: string[], deps?: CliDeps): Promise<number>;

package/dist/main.js

@@ -0,0 +1,571 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs, renderHelp } from "./cli/args.js";
+import { loadAttachments } from "./cli/attachments.js";
+import { loadCliConfig } from "./cli/config.js";
+import { loginWithOAuthProvider, resolveApiKeyForProvider } from "./cli/oauth.js";
+import { createJsonStreamer } from "./cli/stream.js";
+import { MaxTurnsError } from "./core/errors.js";
+import { normalizeToolSchema } from "./core/schema/normalize.js";
+import { loadExtractionSetupFromContent } from "./core/setup.js";
+import { extract } from "./extract.js";
+import { getModels, getProviders } from "./models.js";
+import { loadRecipeSetup, loadRecipes } from "./recipes/index.js";
+const MODEL_PROVIDER_PREFERENCE = ["anthropic", "openai", "google"];
+class CliExitError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CliExitError";
+    }
+}
+export async function main(argv, deps = {}) {
+    const stdout = deps.stdout ?? process.stdout;
+    const stderr = deps.stderr ?? process.stderr;
+    try {
+        return await runCliInternal(argv, deps, stdout, stderr);
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err instanceof CliExitError) {
+            writeLine(stderr, `Error: ${err.message}`);
+            return err.exitCode;
+        }
+        writeLine(stderr, `Error: ${err.message}`);
+        return mapExtractionExitCode(err);
+    }
+}
+async function runCliInternal(argv, deps, stdout, stderr) {
+    const { args, errors } = parseArgs(argv);
+    if (args.help) {
+        stdout.write(renderHelp());
+        return 0;
+    }
+    if (args.version) {
+        stdout.write(`${getVersion()}\n`);
+        return 0;
+    }
+    if (errors.length > 0) {
+        throw new CliExitError(errors.join("\n"), 2);
+    }
+    if (args.login) {
+        try {
+            await loginWithOAuthProvider(args.login, stderr);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(message, 3);
+        }
+        writeLine(stderr, `OAuth login completed for ${args.login}.`);
+        return 0;
+    }
+    if (args.prompt && args.promptFile) {
+        throw new CliExitError("Specify either --prompt or --prompt-file, not both.", 2);
+    }
+    const useRecipe = Boolean(args.recipe);
+    if (args.config && useRecipe) {
+        throw new CliExitError("Specify either --config or --recipe, not both.", 2);
+    }
+    if (useRecipe && (args.prompt || args.promptFile)) {
+        throw new CliExitError("Do not use --prompt or --prompt-file with --recipe.", 2);
+    }
+    if (!useRecipe && (args.recipeConfig || args.recipeVars)) {
+        throw new CliExitError("--recipe-config and --recipe-vars require --recipe.", 2);
+    }
+    if (args.listRecipes) {
+        const result = loadRecipes({ cwd: process.cwd() });
+        logRecipeWarnings(result.warnings, stderr);
+        const sorted = [...result.recipes].sort((left, right) => left.name.localeCompare(right.name));
+        for (const recipe of sorted) {
+            stdout.write(`${recipe.name}\t${recipe.description}\t${recipe.source}\n`);
+        }
+        return 0;
+    }
+    const promptInput = args.promptFile ? readTextFile(args.promptFile, "prompt") : args.prompt;
+    const promptPath = args.promptFile ? resolve(args.promptFile) : undefined;
+    const promptIsSetup = !args.config && !useRecipe && typeof promptInput === "string" && promptInput.startsWith("---");
+    let setupFromPrompt;
+    if (promptIsSetup) {
+        const setupPath = promptPath ?? resolve(process.cwd(), "inline-prompt.md");
+        try {
+            setupFromPrompt = loadExtractionSetupFromContent(promptInput, setupPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(message, 2);
+        }
+    }
+    if (!args.config && !useRecipe) {
+        if (!args.schema && !setupFromPrompt) {
+            throw new CliExitError("Missing required option: --schema", 2);
+        }
+        if (!args.jsonSchema && !promptInput) {
+            throw new CliExitError("Missing required option: --prompt or --prompt-file", 2);
+        }
+    }
+    const baseSchema = args.schema ? loadSchema(args.schema) : undefined;
+    const basePrompt = setupFromPrompt ? undefined : promptInput;
+    const modelOverride = args.model ? resolveModel(args.model) : undefined;
+    const baseModel = setupFromPrompt || useRecipe ? modelOverride : (modelOverride ?? resolveDefaultModel());
+    let recipe;
+    let recipeVars;
+    if (useRecipe) {
+        try {
+            recipeVars = args.recipeVars ? parseRecipeVars(args.recipeVars) : undefined;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(message, 2);
+        }
+        const result = loadRecipes({ cwd: process.cwd() });
+        logRecipeWarnings(result.warnings, stderr);
+        recipe = result.recipes.find((entry) => entry.name === args.recipe);
+        if (!recipe) {
+            throw new CliExitError(`Recipe not found: ${args.recipe}`, 2);
+        }
+    }
+    const attachments = (() => {
+        try {
+            return loadAttachments(args.attachments);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(`Failed to load attachments: ${message}`, 4);
+        }
+    })();
+    const input = args.jsonSchema ? "" : await loadInput(args.input, deps.stdin ?? process.stdin);
+    const inputText = [attachments.textPrefix, input].filter((part) => part.length > 0).join("\n\n");
+    const baseOptions = {
+        schema: baseSchema,
+        prompt: basePrompt,
+        model: baseModel,
+        attachments: attachments.images,
+        maxTurns: args.maxTurns,
+        validateCommand: args.validateCommand,
+        validateUrl: args.validateUrl,
+    };
+    const recipeOverrides = {
+        ...(baseSchema ? { schema: baseSchema } : {}),
+        ...(modelOverride ? { model: modelOverride } : {}),
+        ...(args.maxTurns ? { maxTurns: args.maxTurns } : {}),
+        ...(args.validateCommand ? { validateCommand: args.validateCommand } : {}),
+        ...(args.validateUrl ? { validateUrl: args.validateUrl } : {}),
+    };
+    let finalInput = inputText;
+    let outputPath = args.output;
+    let quiet = Boolean(args.quiet);
+    let verbose = Boolean(args.verbose);
+    let streamOutput = Boolean(args.stream);
+    let options;
+    if (useRecipe) {
+        if (!recipe) {
+            throw new CliExitError("Recipe not resolved.", 2);
+        }
+        let recipePath = args.recipeConfig ?? "setup.md";
+        let resolvedRecipePath = resolve(recipe.baseDir, recipePath);
+        let recipeUsesConfig = isConfigFile(resolvedRecipePath);
+        if (!args.recipeConfig && !existsSync(resolvedRecipePath)) {
+            const fallback = resolve(recipe.baseDir, "config.ts");
+            if (existsSync(fallback)) {
+                recipePath = "config.ts";
+                resolvedRecipePath = fallback;
+                recipeUsesConfig = true;
+            }
+        }
+        if (recipeUsesConfig) {
+            let configFn;
+            try {
+                configFn = await loadCliConfig(resolvedRecipePath);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new CliExitError(message, 4);
+            }
+            let configResult;
+            try {
+                configResult = await configFn({
+                    args,
+                    input,
+                    inputText,
+                    attachments,
+                    resolveModel,
+                    resolveApiKeyForProvider: async (provider) => await resolveApiKeyForProvider(provider, stderr),
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new CliExitError(`Config execution failed: ${message}`, 4);
+            }
+            if (!configResult || typeof configResult !== "object" || !("options" in configResult)) {
+                throw new CliExitError("Config must return an object with an options field.", 2);
+            }
+            const result = configResult;
+            if (!result.options || typeof result.options !== "object") {
+                throw new CliExitError("Config must return an options object.", 2);
+            }
+            options = {
+                ...result.options,
+                ...recipeOverrides,
+                attachments: attachments.images,
+            };
+            finalInput = result.input ?? finalInput;
+            outputPath = result.output ?? outputPath;
+            quiet = result.quiet ?? quiet;
+            verbose = result.verbose ?? verbose;
+            streamOutput = result.stream ?? streamOutput;
+        }
+        else {
+            let setup;
+            try {
+                setup = loadRecipeSetup(recipe, { setupFile: recipePath, vars: recipeVars });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new CliExitError(`Failed to load recipe setup: ${message}`, 4);
+            }
+            options = { ...setup.options, ...recipeOverrides, attachments: attachments.images };
+        }
+    }
+    else if (args.config) {
+        let configFn;
+        try {
+            configFn = await loadCliConfig(args.config);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(message, 4);
+        }
+        let configResult;
+        try {
+            configResult = await configFn({
+                args,
+                input,
+                inputText,
+                attachments,
+                resolveModel,
+                resolveApiKeyForProvider: async (provider) => await resolveApiKeyForProvider(provider, stderr),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(`Config execution failed: ${message}`, 4);
+        }
+        if (!configResult || typeof configResult !== "object" || !("options" in configResult)) {
+            throw new CliExitError("Config must return an object with an options field.", 2);
+        }
+        const result = configResult;
+        if (!result.options || typeof result.options !== "object") {
+            throw new CliExitError("Config must return an options object.", 2);
+        }
+        options = { ...baseOptions, ...result.options };
+        finalInput = result.input ?? finalInput;
+        outputPath = result.output ?? outputPath;
+        quiet = result.quiet ?? quiet;
+        verbose = result.verbose ?? verbose;
+        streamOutput = result.stream ?? streamOutput;
+    }
+    else if (setupFromPrompt) {
+        const setupOverrides = {
+            ...(baseSchema ? { schema: baseSchema } : {}),
+            ...(modelOverride ? { model: modelOverride } : {}),
+            ...(args.maxTurns ? { maxTurns: args.maxTurns } : {}),
+            ...(args.validateCommand ? { validateCommand: args.validateCommand } : {}),
+            ...(args.validateUrl ? { validateUrl: args.validateUrl } : {}),
+        };
+        options = {
+            ...setupFromPrompt.options,
+            ...setupOverrides,
+            attachments: attachments.images,
+        };
+    }
+    else {
+        options = baseOptions;
+    }
+    if (!options.schema) {
+        throw new CliExitError("Missing schema. Provide --schema, include schema in a setup, use --recipe with schema, or return schema from --config.", 2);
+    }
+    if (!options.model) {
+        throw new CliExitError("Missing model. Provide --model, include model in a setup, use --recipe with model, or return model from --config.", 2);
+    }
+    if (!args.jsonSchema && !options.prompt) {
+        throw new CliExitError("Missing prompt. Provide --prompt/--prompt-file, include prompt in a setup, use --recipe with prompt, or return prompt from --config.", 2);
+    }
+    if (args.jsonSchema) {
+        const normalized = normalizeToolSchema(options.model, options.schema).schema;
+        stdout.write(`${JSON.stringify(normalized, null, 2)}\n`);
+        return 0;
+    }
+    if (!options.apiKey) {
+        try {
+            options.apiKey = await resolveApiKeyForProvider(options.model.provider, stderr);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(`Authentication failed: ${message}`, 3);
+        }
+    }
+    const extractFn = deps.extractFn ?? extract;
+    const stream = extractFn(finalInput, options);
+    const effectiveQuiet = Boolean(quiet);
+    const effectiveVerbose = Boolean(verbose) && !effectiveQuiet;
+    const effectiveStreamOutput = Boolean(streamOutput) && !effectiveQuiet;
+    const jsonStreamer = effectiveStreamOutput
+        ? createJsonStreamer((line) => {
+            stderr.write(line);
+        })
+        : null;
+    let finalResult;
+    let extractionError;
+    for await (const event of stream) {
+        if (effectiveStreamOutput) {
+            if (event.type === "llm_delta") {
+                jsonStreamer?.handleDelta(event.delta);
+            }
+            if (event.type === "tool_call") {
+                jsonStreamer?.handleToolCall(event.toolCall.arguments);
+            }
+            if (event.type === "turn_start") {
+                jsonStreamer?.reset();
+            }
+        }
+        if (effectiveVerbose) {
+            logVerbose(event, stderr);
+        }
+        if (event.type === "complete") {
+            finalResult = { data: event.result, turns: event.turns, usage: event.usage };
+        }
+        if (event.type === "error") {
+            extractionError = event.error;
+        }
+    }
+    const result = finalResult ?? (await stream.result());
+    if (extractionError || !result) {
+        const err = extractionError ?? new Error("Extraction failed.");
+        writeLine(stderr, `Error: ${err.message}`);
+        return mapExtractionExitCode(err);
+    }
+    const json = `${JSON.stringify(result.data, null, 2)}\n`;
+    if (outputPath) {
+        try {
+            writeFileSync(resolve(outputPath), json, "utf8");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliExitError(`Failed to write output file: ${message}`, 4);
+        }
+        return 0;
+    }
+    stdout.write(json);
+    return 0;
+}
+function loadSchema(schemaArg) {
+    const trimmed = schemaArg.trim();
+    try {
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            return JSON.parse(trimmed);
+        }
+        const raw = readTextFile(trimmed, "schema");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error instanceof CliExitError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliExitError(`Invalid schema: ${message}`, 2);
+    }
+}
+function readTextFile(path, label) {
+    try {
+        return readFileSync(resolve(path), "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliExitError(`Failed to read ${label} file: ${message}`, 4);
+    }
+}
+function parseRecipeVars(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliExitError(`Invalid recipe vars JSON: ${message}`, 2);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new CliExitError("Recipe vars must be a JSON object.", 2);
+    }
+    return parsed;
+}
+function logRecipeWarnings(warnings, stderr) {
+    for (const warning of warnings) {
+        writeLine(stderr, `[recipe] ${warning.recipePath}: ${warning.message}`);
+    }
+}
+function isConfigFile(path) {
+    return path.endsWith(".ts") || path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs");
+}
+async function loadInput(inputPath, stdin) {
+    if (inputPath) {
+        return readTextFile(inputPath, "input");
+    }
+    const isTty = typeof stdin.isTTY === "boolean" && stdin.isTTY;
+    if (isTty) {
+        return "";
+    }
+    try {
+        return await readStream(stdin);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliExitError(`Failed to read stdin: ${message}`, 4);
+    }
+}
+function resolveModel(value) {
+    if (value.includes("/")) {
+        const [provider, pattern] = value.split("/");
+        if (!provider || !pattern) {
+            throw new CliExitError(`Invalid model spec: ${value}`, 2);
+        }
+        if (!isKnownProvider(provider)) {
+            throw new CliExitError(`Unknown provider: ${provider}`, 2);
+        }
+        const matches = findModelMatches(getModels(provider), pattern);
+        if (matches.length === 0) {
+            throw new CliExitError(`Model not found: ${value}`, 2);
+        }
+        return pickBestModelMatch(matches);
+    }
+    const allModels = getProviders().flatMap((provider) => getModels(provider));
+    const matches = findModelMatches(allModels, value);
+    if (matches.length === 0) {
+        throw new CliExitError(`Unknown model: ${value}`, 2);
+    }
+    return pickBestModelMatch(matches);
+}
+function resolveDefaultModel() {
+    const providers = getProviders();
+    const preferredProviders = MODEL_PROVIDER_PREFERENCE.filter((provider) => providers.includes(provider));
+    const orderedProviders = [
+        ...preferredProviders,
+        ...providers.filter((provider) => !preferredProviders.includes(provider)),
+    ];
+    for (const provider of orderedProviders) {
+        const models = getModels(provider);
+        if (models.length === 0) {
+            continue;
+        }
+        return pickBestModelMatch(models);
+    }
+    throw new CliExitError("No models available. Configure a provider API key or select a model explicitly.", 3);
+}
+function isAliasModelId(id) {
+    if (id.endsWith("-latest")) {
+        return true;
+    }
+    return !/-\d{8}$/.test(id);
+}
+function findModelMatches(models, pattern) {
+    const normalized = pattern.toLowerCase();
+    const exactMatches = models.filter((model) => model.id.toLowerCase() === normalized);
+    if (exactMatches.length > 0) {
+        return exactMatches;
+    }
+    const prefixMatches = models.filter((model) => model.id.toLowerCase().startsWith(normalized));
+    if (prefixMatches.length > 0) {
+        return prefixMatches;
+    }
+    return models.filter((model) => {
+        const id = model.id.toLowerCase();
+        const name = model.name?.toLowerCase() ?? "";
+        return id.includes(normalized) || name.includes(normalized);
+    });
+}
+function pickBestModelMatch(matches) {
+    const sorted = [...matches].sort((left, right) => {
+        const providerRank = providerPreferenceRank(left.provider) - providerPreferenceRank(right.provider);
+        if (providerRank !== 0) {
+            return providerRank;
+        }
+        const aliasRank = (isAliasModelId(left.id) ? 0 : 1) - (isAliasModelId(right.id) ? 0 : 1);
+        if (aliasRank !== 0) {
+            return aliasRank;
+        }
+        return right.id.localeCompare(left.id);
+    });
+    return sorted[0];
+}
+function providerPreferenceRank(provider) {
+    const index = MODEL_PROVIDER_PREFERENCE.indexOf(provider);
+    return index === -1 ? MODEL_PROVIDER_PREFERENCE.length : index;
+}
+function isKnownProvider(value) {
+    return getProviders().includes(value);
+}
+function logVerbose(event, stderr) {
+    switch (event.type) {
+        case "start":
+            writeLine(stderr, `[start] Max turns: ${event.maxTurns}`);
+            break;
+        case "turn_start":
+            writeLine(stderr, `[turn] Starting turn ${event.turn}`);
+            break;
+        case "llm_start":
+            writeLine(stderr, "[llm] Calling model");
+            break;
+        case "llm_selected":
+            writeLine(stderr, `[llm] Selected ${event.model.provider}:${event.model.id}`);
+            break;
+        case "llm_end":
+            writeLine(stderr, `[llm] Response received`);
+            break;
+        case "validation_start":
+            writeLine(stderr, `[validate] Running: ${event.layer}`);
+            break;
+        case "validation_pass":
+            writeLine(stderr, `[validate] Passed: ${event.layer}`);
+            break;
+        case "validation_error":
+            writeLine(stderr, `[validate] Failed: ${event.layer} - ${event.error}`);
+            break;
+        case "warning":
+            writeLine(stderr, `[warning] ${event.message}`);
+            break;
+        case "complete":
+            writeLine(stderr, `[complete] Success after ${event.turns} turn(s)`);
+            break;
+        case "error":
+            writeLine(stderr, `[error] ${event.error.message}`);
+            break;
+        default:
+            break;
+    }
+}
+function mapExtractionExitCode(error) {
+    if (error instanceof MaxTurnsError) {
+        return 1;
+    }
+    return 3;
+}
+function writeLine(stream, message) {
+    stream.write(`${message}\n`);
+}
+function getVersion() {
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const raw = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? "0.0.0";
+}
+async function readStream(stream) {
+    return await new Promise((resolveStream, reject) => {
+        let data = "";
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => {
+            data += chunk;
+        });
+        stream.on("error", (error) => reject(error));
+        stream.on("end", () => resolveStream(data));
+    });
+}