@justram/pie 0.1.0

package/dist/cli/image.js

@@ -0,0 +1,73 @@
+import * as photon from "@silvia-odwyer/photon-node";
+const DEFAULT_OPTIONS = {
+    maxWidth: 2000,
+    maxHeight: 2000,
+    jpegQuality: 85,
+};
+export function resizeImage(image, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const buffer = Buffer.from(image.data, "base64");
+    let decoded;
+    try {
+        decoded = photon.PhotonImage.new_from_byteslice(new Uint8Array(buffer));
+        const originalWidth = decoded.get_width();
+        const originalHeight = decoded.get_height();
+        if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight) {
+            return {
+                image,
+                originalWidth,
+                originalHeight,
+                width: originalWidth,
+                height: originalHeight,
+                wasResized: false,
+            };
+        }
+        const { width, height } = clampDimensions(originalWidth, originalHeight, opts.maxWidth, opts.maxHeight);
+        const resized = photon.resize(decoded, width, height, photon.SamplingFilter.Lanczos3);
+        try {
+            const mimeType = image.mimeType === "image/jpeg" ? "image/jpeg" : "image/png";
+            const bytes = mimeType === "image/jpeg" ? resized.get_bytes_jpeg(opts.jpegQuality) : resized.get_bytes();
+            const data = Buffer.from(bytes).toString("base64");
+            return {
+                image: { type: "image", mimeType, data },
+                originalWidth,
+                originalHeight,
+                width,
+                height,
+                wasResized: true,
+            };
+        }
+        finally {
+            resized.free();
+        }
+    }
+    finally {
+        decoded?.free();
+    }
+}
+export function isImagePath(path) {
+    return /\.(png|jpe?g|gif|webp)$/i.test(path);
+}
+export function mimeTypeForImage(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    return "image/png";
+}
+function clampDimensions(width, height, maxWidth, maxHeight) {
+    let nextWidth = width;
+    let nextHeight = height;
+    if (nextWidth > maxWidth) {
+        nextHeight = Math.round((nextHeight * maxWidth) / nextWidth);
+        nextWidth = maxWidth;
+    }
+    if (nextHeight > maxHeight) {
+        nextWidth = Math.round((nextWidth * maxHeight) / nextHeight);
+        nextHeight = maxHeight;
+    }
+    return { width: Math.max(1, nextWidth), height: Math.max(1, nextHeight) };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export type { CliDeps } from "../main.js";
+export { main as runCli } from "../main.js";

package/dist/cli/index.js

@@ -0,0 +1 @@
+export { main as runCli } from "../main.js";

package/dist/cli/oauth.d.ts

@@ -0,0 +1,14 @@
+import type { Writable } from "node:stream";
+import { type OAuthCredentials } from "@mariozechner/pi-ai";
+export type ApiKeyCredential = {
+    type: "api_key";
+    key: string;
+};
+export type OAuthCredential = {
+    type: "oauth";
+} & OAuthCredentials;
+export type AuthCredential = ApiKeyCredential | OAuthCredential;
+export type AuthMap = Record<string, AuthCredential | undefined>;
+export declare function resolveApiKeyForProvider(provider: string, stderr: Writable): Promise<string | undefined>;
+export declare function getSupportedOAuthProviders(): string[];
+export declare function loginWithOAuthProvider(provider: string, stderr: Writable): Promise<string>;

package/dist/cli/oauth.js

@@ -0,0 +1,178 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { getEnvApiKey, getOAuthApiKey, getOAuthProviders, loginAnthropic, loginAntigravity, loginGeminiCli, loginGitHubCopilot, loginOpenAICodex, } from "@mariozechner/pi-ai";
+const AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
+const OAUTH_PROVIDERS = new Set(getOAuthProviders().map((provider) => provider.id));
+export async function resolveApiKeyForProvider(provider, stderr) {
+    const auth = loadAuth();
+    const authKey = await getKeyFromAuth(provider, auth);
+    if (authKey) {
+        return authKey;
+    }
+    const envKey = getEnvApiKey(provider);
+    if (envKey) {
+        return envKey;
+    }
+    if (!isOAuthProvider(provider)) {
+        return undefined;
+    }
+    return await loginAndResolve(provider, auth, stderr);
+}
+export function getSupportedOAuthProviders() {
+    return getOAuthProviders()
+        .map((provider) => provider.id)
+        .sort();
+}
+export async function loginWithOAuthProvider(provider, stderr) {
+    if (!isOAuthProvider(provider)) {
+        const supported = getSupportedOAuthProviders().join(", ");
+        throw new Error(`Unsupported OAuth provider: ${provider}. Supported: ${supported}`);
+    }
+    const auth = loadAuth();
+    return await loginAndResolve(provider, auth, stderr);
+}
+function loadAuth() {
+    try {
+        const raw = readFileSync(AUTH_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveAuth(auth) {
+    const dir = dirname(AUTH_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(AUTH_PATH, JSON.stringify(auth, null, 2), "utf-8");
+    chmodSync(AUTH_PATH, 0o600);
+}
+async function getKeyFromAuth(provider, auth) {
+    const entry = auth[provider];
+    if (!entry) {
+        return undefined;
+    }
+    if (entry.type === "api_key") {
+        return entry.key;
+    }
+    if (!isOAuthProvider(provider)) {
+        return undefined;
+    }
+    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (!result) {
+        return undefined;
+    }
+    auth[provider] = { type: "oauth", ...result.newCredentials };
+    saveAuth(auth);
+    return result.apiKey;
+}
+async function loginAndResolve(provider, auth, stderr) {
+    const result = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (result) {
+        auth[provider] = { type: "oauth", ...result.newCredentials };
+        saveAuth(auth);
+        return result.apiKey;
+    }
+    writeLine(stderr, `[oauth:${provider}] No credentials found in ${AUTH_PATH}. Starting login...`);
+    const credentials = await login(provider, stderr);
+    auth[provider] = { type: "oauth", ...credentials };
+    saveAuth(auth);
+    const refreshed = await getOAuthApiKey(provider, oauthCredentials(auth));
+    if (!refreshed) {
+        throw new Error(`OAuth login completed, but no credentials were returned for ${provider}`);
+    }
+    auth[provider] = { type: "oauth", ...refreshed.newCredentials };
+    saveAuth(auth);
+    return refreshed.apiKey;
+}
+function oauthCredentials(auth) {
+    const result = {};
+    for (const [key, value] of Object.entries(auth)) {
+        if (value?.type === "oauth") {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function isOAuthProvider(provider) {
+    return OAUTH_PROVIDERS.has(provider);
+}
+async function login(provider, stderr) {
+    switch (provider) {
+        case "anthropic":
+            return await loginAnthropic((url) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+            }, async () => {
+                return await promptOnce("Paste the authorization code:", stderr);
+            });
+        case "github-copilot":
+            return await loginGitHubCopilot({
+                onAuth: (url, instructions) => {
+                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                    writeLine(stderr, url);
+                    if (instructions)
+                        writeLine(stderr, instructions);
+                },
+                onPrompt: async ({ message }) => {
+                    return await promptOnce(message, stderr);
+                },
+                onProgress: (message) => {
+                    writeLine(stderr, `[oauth:${provider}] ${message}`);
+                },
+            });
+        case "google-gemini-cli":
+            return await loginGeminiCli(({ url, instructions }) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+                if (instructions)
+                    writeLine(stderr, instructions);
+            }, (message) => {
+                writeLine(stderr, `[oauth:${provider}] ${message}`);
+            }, async () => {
+                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
+            });
+        case "google-antigravity":
+            return await loginAntigravity(({ url, instructions }) => {
+                writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                writeLine(stderr, url);
+                if (instructions)
+                    writeLine(stderr, instructions);
+            }, (message) => {
+                writeLine(stderr, `[oauth:${provider}] ${message}`);
+            }, async () => {
+                return await promptOnce("Paste the full redirect URL (or press Enter to wait for browser callback):", stderr);
+            });
+        case "openai-codex":
+            return await loginOpenAICodex({
+                onAuth: ({ url, instructions }) => {
+                    writeLine(stderr, `[oauth:${provider}] Open this URL to authenticate:`);
+                    writeLine(stderr, url);
+                    if (instructions)
+                        writeLine(stderr, instructions);
+                },
+                onPrompt: async ({ message }) => {
+                    return await promptOnce(message, stderr);
+                },
+                onProgress: (message) => {
+                    writeLine(stderr, `[oauth:${provider}] ${message}`);
+                },
+                onManualCodeInput: async () => {
+                    return await promptOnce("Paste the authorization code:", stderr);
+                },
+            });
+        default:
+            throw new Error(`OAuth login flow not implemented for provider: ${provider}.`);
+    }
+}
+async function promptOnce(prompt, stderr) {
+    const rl = createInterface({ input: process.stdin, output: stderr });
+    return rl.question(`${prompt} `).finally(() => rl.close());
+}
+function writeLine(stream, message) {
+    stream.write(`${message}\n`);
+}

package/dist/cli/stream.d.ts

@@ -0,0 +1,7 @@
+export interface JsonStreamer {
+    handleDelta(delta: string): void;
+    handleToolCall(args: unknown): void;
+    reset(): void;
+}
+export declare function createJsonStreamer(writeLine: (line: string) => void): JsonStreamer;
+export declare function parsePartialJson(text: string): unknown | null;

package/dist/cli/stream.js

@@ -0,0 +1,73 @@
+import { parseStreamingJson } from "@mariozechner/pi-ai";
+export function createJsonStreamer(writeLine) {
+    let buffer = "";
+    let lastSerialized = null;
+    const emit = (value) => {
+        const serialized = JSON.stringify(value);
+        if (serialized === lastSerialized) {
+            return;
+        }
+        lastSerialized = serialized;
+        writeLine(`${JSON.stringify({ partial: value })}\n`);
+    };
+    return {
+        handleDelta: (delta) => {
+            buffer += delta;
+            const parsed = parsePartialJson(buffer);
+            if (parsed !== null) {
+                emit(parsed);
+            }
+        },
+        handleToolCall: (args) => {
+            emit(args);
+        },
+        reset: () => {
+            buffer = "";
+            lastSerialized = null;
+        },
+    };
+}
+export function parsePartialJson(text) {
+    const start = findJsonStart(text);
+    if (start === -1) {
+        return null;
+    }
+    const slice = text.slice(start).trim();
+    if (!slice) {
+        return null;
+    }
+    const parsed = parseStreamingJson(slice);
+    return shouldEmitParsed(parsed, slice) ? parsed : null;
+}
+function shouldEmitParsed(parsed, source) {
+    if (parsed === null || parsed === undefined) {
+        return false;
+    }
+    const trimmed = source.trim();
+    if (trimmed === "{}" || trimmed === "[]") {
+        return true;
+    }
+    if (Array.isArray(parsed)) {
+        if (parsed.length > 0) {
+            return true;
+        }
+        return trimmed.endsWith("]");
+    }
+    if (typeof parsed === "object") {
+        const keys = Object.keys(parsed);
+        if (keys.length > 0) {
+            return true;
+        }
+        return trimmed.endsWith("}");
+    }
+    return true;
+}
+function findJsonStart(text) {
+    const objStart = text.indexOf("{");
+    const arrStart = text.indexOf("[");
+    if (objStart === -1)
+        return arrStart;
+    if (arrStart === -1)
+        return objStart;
+    return Math.min(objStart, arrStart);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { type CliDeps, runCli } from "./cli/index.js";

package/dist/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { main } from "./main.js";
+export { runCli } from "./cli/index.js";
+async function run() {
+    const exitCode = await main(process.argv.slice(2));
+    process.exitCode = exitCode;
+}
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void run().catch((error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        console.error(message);
+        process.exitCode = 1;
+    });
+}

package/dist/core/cache/file.d.ts

@@ -0,0 +1,4 @@
+import type { CacheStore } from "./types.js";
+export declare function createFileCache(options: {
+    directory: string;
+}): CacheStore;

package/dist/core/cache/file.js

@@ -0,0 +1,44 @@
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+function cachePath(directory, key) {
+    const prefix = key.slice(0, 2);
+    return `${directory}/${prefix}/${key}.json`;
+}
+function cacheDir(directory, key) {
+    return `${directory}/${key.slice(0, 2)}`;
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createFileCache(options) {
+    const directory = options.directory.replaceAll(/\/+$/g, "");
+    return {
+        get: async (key) => {
+            const path = cachePath(directory, key);
+            if (!(await exists(path))) {
+                return undefined;
+            }
+            const text = await readFile(path, { encoding: "utf8" });
+            return JSON.parse(text);
+        },
+        set: async (key, entry) => {
+            const dir = cacheDir(directory, key);
+            await mkdir(dir, { recursive: true });
+            const path = cachePath(directory, key);
+            await writeFile(path, JSON.stringify(entry), { encoding: "utf8" });
+        },
+        delete: async (key) => {
+            const path = cachePath(directory, key);
+            await rm(path, { force: true });
+        },
+        clear: async () => {
+            await rm(directory, { recursive: true, force: true });
+            await mkdir(directory, { recursive: true });
+        },
+    };
+}

package/dist/core/cache/key.d.ts

@@ -0,0 +1,2 @@
+import type { ExtractOptions } from "../types.js";
+export declare function computeCacheKey(input: string, options: ExtractOptions<unknown>): string;

package/dist/core/cache/key.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+export function computeCacheKey(input, options) {
+    const keyData = {
+        input,
+        schema: JSON.stringify(options.schema),
+        prompt: options.prompt,
+        model: options.model?.name ?? "unknown",
+        validateCommand: options.validateCommand ?? null,
+        validateUrl: options.validateUrl ?? null,
+    };
+    return createHash("sha256").update(JSON.stringify(keyData)).digest("hex");
+}

package/dist/core/cache/memory.d.ts

@@ -0,0 +1,4 @@
+import type { CacheStore } from "./types.js";
+export declare function createMemoryCache(options?: {
+    maxSize?: number;
+}): CacheStore;

package/dist/core/cache/memory.js

@@ -0,0 +1,33 @@
+export function createMemoryCache(options) {
+    const maxSize = options?.maxSize ?? 1000;
+    const map = new Map();
+    return {
+        get: async (key) => {
+            const entry = map.get(key);
+            if (!entry) {
+                return undefined;
+            }
+            // Refresh LRU
+            map.delete(key);
+            map.set(key, entry);
+            return entry;
+        },
+        set: async (key, entry) => {
+            map.delete(key);
+            map.set(key, entry);
+            while (map.size > maxSize) {
+                const oldest = map.keys().next().value;
+                if (!oldest) {
+                    break;
+                }
+                map.delete(oldest);
+            }
+        },
+        delete: async (key) => {
+            map.delete(key);
+        },
+        clear: async () => {
+            map.clear();
+        },
+    };
+}

package/dist/core/cache/types.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractOptions, Usage } from "../types.js";
+export interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    turns: number;
+    usage: Usage;
+}
+export interface CacheStore {
+    get<T>(key: string): Promise<CacheEntry<T> | undefined>;
+    set<T>(key: string, entry: CacheEntry<T>, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface CacheOptions {
+    ttl?: number;
+    key?: (input: string, options: ExtractOptions<unknown>) => string;
+    store?: CacheStore;
+    revalidate?: boolean;
+}

package/dist/core/cache/types.js

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

package/dist/core/errors.d.ts

@@ -0,0 +1,39 @@
+export declare class ExtractError extends Error {
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+export interface ValidationErrorDetail {
+    path: string;
+    message: string;
+}
+export declare class SchemaValidationError extends ExtractError {
+    readonly errors: ValidationErrorDetail[];
+    constructor(message: string, errors: ValidationErrorDetail[], options?: {
+        cause?: Error;
+    });
+}
+export declare class CommandValidationError extends ExtractError {
+    readonly command: string;
+    readonly exitCode: number;
+    constructor(message: string, command: string, exitCode: number, options?: {
+        cause?: Error;
+    });
+}
+export declare class HttpValidationError extends ExtractError {
+    readonly url: string;
+    readonly statusCode: number;
+    constructor(message: string, url: string, statusCode: number, options?: {
+        cause?: Error;
+    });
+}
+export declare class MaxTurnsError extends ExtractError {
+    readonly turns: number;
+    readonly lastError?: Error;
+    constructor(message: string, turns: number, lastError?: Error, options?: {
+        cause?: Error;
+    });
+}
+export declare class AbortError extends ExtractError {
+    constructor(message?: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,50 @@
+export class ExtractError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ExtractError";
+    }
+}
+export class SchemaValidationError extends ExtractError {
+    errors;
+    constructor(message, errors, options) {
+        super(message, options);
+        this.name = "SchemaValidationError";
+        this.errors = errors;
+    }
+}
+export class CommandValidationError extends ExtractError {
+    command;
+    exitCode;
+    constructor(message, command, exitCode, options) {
+        super(message, options);
+        this.name = "CommandValidationError";
+        this.command = command;
+        this.exitCode = exitCode;
+    }
+}
+export class HttpValidationError extends ExtractError {
+    url;
+    statusCode;
+    constructor(message, url, statusCode, options) {
+        super(message, options);
+        this.name = "HttpValidationError";
+        this.url = url;
+        this.statusCode = statusCode;
+    }
+}
+export class MaxTurnsError extends ExtractError {
+    turns;
+    lastError;
+    constructor(message, turns, lastError, options) {
+        super(message, options);
+        this.name = "MaxTurnsError";
+        this.turns = turns;
+        this.lastError = lastError;
+    }
+}
+export class AbortError extends ExtractError {
+    constructor(message = "Extraction aborted") {
+        super(message);
+        this.name = "AbortError";
+    }
+}

package/dist/core/events.d.ts

@@ -0,0 +1,87 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@mariozechner/pi-ai";
+import type { Usage } from "./types.js";
+export type ValidatorLayer = "schema" | "sync" | "async" | "command" | "http";
+export type ExtractEvent<T> = StartEvent | CompleteEvent<T> | ErrorEvent | WarningEvent | CacheHitEvent | CacheMissEvent | CacheSetEvent | TurnStartEvent | TurnEndEvent | LlmStartEvent | LlmSelectedEvent | LlmDeltaEvent | LlmEndEvent | ThinkingEvent | ToolCallEvent | JsonExtractedEvent | ValidationStartEvent | ValidationPassEvent | ValidationErrorEvent;
+export interface StartEvent {
+    type: "start";
+    maxTurns: number;
+}
+export interface CompleteEvent<T> {
+    type: "complete";
+    result: T;
+    turns: number;
+    usage: Usage;
+}
+export interface ErrorEvent {
+    type: "error";
+    error: Error;
+    turns: number;
+}
+export interface WarningEvent {
+    type: "warning";
+    code: "thinking_unsupported";
+    message: string;
+}
+export interface CacheHitEvent {
+    type: "cache_hit";
+    key: string;
+    age: number;
+}
+export interface CacheMissEvent {
+    type: "cache_miss";
+    key: string;
+}
+export interface CacheSetEvent {
+    type: "cache_set";
+    key: string;
+}
+export interface TurnStartEvent {
+    type: "turn_start";
+    turn: number;
+}
+export interface TurnEndEvent {
+    type: "turn_end";
+    turn: number;
+    hasResult: boolean;
+}
+export interface LlmStartEvent {
+    type: "llm_start";
+}
+export interface LlmSelectedEvent {
+    type: "llm_selected";
+    model: Model<Api>;
+}
+export interface LlmDeltaEvent {
+    type: "llm_delta";
+    delta: string;
+}
+export interface LlmEndEvent {
+    type: "llm_end";
+    message: AssistantMessage;
+    usage: Usage;
+}
+export interface ThinkingEvent {
+    type: "thinking";
+    text: string;
+}
+export interface ToolCallEvent {
+    type: "tool_call";
+    toolCall: ToolCall;
+}
+export interface JsonExtractedEvent {
+    type: "json_extracted";
+    source: "tool_call" | "text";
+}
+export interface ValidationStartEvent {
+    type: "validation_start";
+    layer: ValidatorLayer;
+}
+export interface ValidationPassEvent {
+    type: "validation_pass";
+    layer: ValidatorLayer;
+}
+export interface ValidationErrorEvent {
+    type: "validation_error";
+    layer: ValidatorLayer;
+    error: string;
+}