flanders 0.0.2 → 0.2.0

package/lib/ai/AiRunner.d.ts

@@ -0,0 +1,24 @@
+import type { TimeContext } from "../contexts";
+import type { ToolAdapter, ToolAdapterUsageCallback, ToolEventOutput } from "./ToolAdapter";
+export type RunCallbacks = Readonly<{
+    onOutput(event: ToolEventOutput): void;
+    onSessionId(id: string): void;
+    onUsage?: ToolAdapterUsageCallback;
+    onWaitStart?(kind: "rate-limit", endTimeMs: number): void;
+    onWaitEnd?(): void;
+}>;
+export type RunArgs = Readonly<{
+    adapter: ToolAdapter;
+    prompt: string;
+    model: string;
+    effort: string;
+    resumeSessionId?: string;
+    forkParentSessionId?: string;
+    abortSignal: AbortSignal;
+    callbacks: RunCallbacks;
+    time: TimeContext;
+}>;
+export type RunResult = Readonly<{
+    sessionId: string | null;
+}>;
+export declare function run(args: RunArgs): Promise<RunResult>;

package/lib/ai/AiRunner.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const wait_1 = require("../system/wait");
+const RATE_LIMIT_CHUNK_MS = 60 * 60 * 1000;
+const INITIAL_TRANSIENT_WAIT_MS = 1000;
+const TRANSIENT_WAIT_CAP_MS = 60000;
+async function run(args) {
+    var _a, _b;
+    const { adapter, prompt, model, effort, abortSignal, callbacks, time } = args;
+    if (abortSignal.aborted) {
+        throw abortError();
+    }
+    let capturedSessionId = null;
+    let transientAttempt = 0;
+    let firstInvocation = true;
+    for (;;) {
+        const base = { prompt, model, effort, abortSignal, onUsage: callbacks.onUsage };
+        let invokeArgs;
+        if (firstInvocation) {
+            if (args.forkParentSessionId) {
+                invokeArgs = { ...base, forkParentSessionId: args.forkParentSessionId };
+            }
+            else if (args.resumeSessionId) {
+                invokeArgs = { ...base, resumeSessionId: args.resumeSessionId };
+            }
+            else {
+                invokeArgs = base;
+            }
+            firstInvocation = false;
+        }
+        else {
+            const retrySessionId = capturedSessionId !== null && capturedSessionId !== void 0 ? capturedSessionId : args.resumeSessionId;
+            if (retrySessionId) {
+                invokeArgs = { ...base, resumeSessionId: retrySessionId };
+            }
+            else {
+                invokeArgs = base;
+            }
+        }
+        let terminal = null;
+        const iterable = adapter.invoke(invokeArgs);
+        for await (const event of iterable) {
+            switch (event.type) {
+                case "output":
+                    callbacks.onOutput(event);
+                    break;
+                case "session":
+                    capturedSessionId = event.id;
+                    callbacks.onSessionId(event.id);
+                    break;
+                case "error":
+                case "rate_limit":
+                case "done":
+                    terminal = event;
+                    break;
+            }
+            if (terminal)
+                break;
+        }
+        if (!terminal && abortSignal.aborted) {
+            throw abortError();
+        }
+        if (!terminal) {
+            throw new Error("adapter closed without terminal event");
+        }
+        if (terminal.type === "done") {
+            transientAttempt = 0;
+            return { sessionId: capturedSessionId };
+        }
+        if (terminal.type === "error" && !terminal.retryable) {
+            throw new Error(terminal.message);
+        }
+        if (terminal.type === "rate_limit") {
+            const waitMs = Math.max(0, terminal.waitUntilMs - time.now());
+            (_a = callbacks.onWaitStart) === null || _a === void 0 ? void 0 : _a.call(callbacks, "rate-limit", terminal.waitUntilMs);
+            try {
+                await (0, wait_1.wait)(waitMs, RATE_LIMIT_CHUNK_MS, time, abortSignal);
+            }
+            finally {
+                (_b = callbacks.onWaitEnd) === null || _b === void 0 ? void 0 : _b.call(callbacks);
+            }
+            if (abortSignal.aborted) {
+                throw abortError();
+            }
+            continue;
+        }
+        transientAttempt++;
+        const waitMs = Math.min(TRANSIENT_WAIT_CAP_MS, INITIAL_TRANSIENT_WAIT_MS * 2 ** (transientAttempt - 1));
+        await (0, wait_1.wait)(waitMs, waitMs, time, abortSignal);
+        if (abortSignal.aborted) {
+            throw abortError();
+        }
+    }
+}
+function abortError() {
+    const err = new Error("aborted");
+    err.name = "AbortError";
+    return err;
+}

package/lib/ai/AiSession.d.ts

@@ -0,0 +1,32 @@
+import type { OutputContext, TimeContext } from "../contexts";
+import type { ToolAdapter } from "./ToolAdapter";
+export type AiSessionResult = Readonly<{
+    text: string;
+    sessionId: string | null;
+    inputTokens: number;
+    outputTokens: number;
+}>;
+export type AiSessionOptions = Readonly<{
+    adapter: ToolAdapter;
+    prompt: string;
+    model: string;
+    effort: string;
+    resumeSessionId?: string | null;
+    forkParentSessionId?: string | null;
+    onLongWaitStart?(kind: "rate-limit", endTimeMs: number): void;
+    onLongWaitEnd?(): void;
+}>;
+export type AiSessionContexts = Readonly<{
+    time: TimeContext;
+    output: OutputContext;
+}>;
+export declare class AiSession {
+    private _options;
+    private _contexts;
+    private _disposed;
+    private _abortController;
+    private _runPromise;
+    constructor(_options: AiSessionOptions, _contexts: AiSessionContexts);
+    run(): Promise<AiSessionResult>;
+    dispose(): Promise<void>;
+}

package/lib/ai/AiSession.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiSession = void 0;
+const AiRunner_1 = require("./AiRunner");
+const formatters_1 = require("../ui/formatters");
+const TOOL_RESULT_MAX_LINES = 5;
+class AiSession {
+    constructor(_options, _contexts) {
+        this._options = _options;
+        this._contexts = _contexts;
+        this._disposed = false;
+        this._abortController = null;
+        this._runPromise = null;
+    }
+    async run() {
+        if (this._disposed) {
+            throw new Error("AiSession disposed");
+        }
+        const controller = new AbortController();
+        this._abortController = controller;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let capturedText = "";
+        let textOpen = false;
+        let inAssistantBlock = false;
+        const onUsage = (usage) => {
+            inputTokens += usage.inputTokens;
+            outputTokens += usage.outputTokens;
+        };
+        const closeOpenTextLine = () => {
+            if (textOpen) {
+                this._contexts.output.write("\n");
+                textOpen = false;
+            }
+        };
+        const emitText = (text) => {
+            this._contexts.output.write(text);
+            textOpen = !text.endsWith("\n");
+        };
+        const onOutput = (event) => {
+            if (event.title === "Assistant") {
+                if (!inAssistantBlock) {
+                    this._contexts.output.write((0, formatters_1.colorize)("Assistant", formatters_1.GREEN) + "\n");
+                    inAssistantBlock = true;
+                }
+                emitText(event.details);
+                capturedText += event.details;
+                return;
+            }
+            inAssistantBlock = false;
+            closeOpenTextLine();
+            if (event.title === "Result") {
+                const formatted = formatToolResultLines(event.details);
+                this._contexts.output.write(formatted);
+                return;
+            }
+            if (event.title === "stderr") {
+                this._contexts.output.writeError(event.details);
+                return;
+            }
+            if (event.title === "Thinking") {
+                this._contexts.output.write((0, formatters_1.colorize)("● Thinking(" + event.subtitle + ")", formatters_1.DIM) + "\n");
+                return;
+            }
+            this._contexts.output.write("● " + (0, formatters_1.colorize)(event.title, formatters_1.CYAN) + "(" + (0, formatters_1.colorize)(event.subtitle, formatters_1.YELLOW) + ")\n");
+        };
+        const promise = (async () => {
+            try {
+                const result = await (0, AiRunner_1.run)({
+                    adapter: this._options.adapter,
+                    prompt: this._options.prompt,
+                    model: this._options.model,
+                    effort: this._options.effort,
+                    ...(this._options.resumeSessionId != null ? { resumeSessionId: this._options.resumeSessionId } : null),
+                    ...(this._options.forkParentSessionId != null ? { forkParentSessionId: this._options.forkParentSessionId } : null),
+                    abortSignal: controller.signal,
+                    callbacks: {
+                        onOutput,
+                        onSessionId: () => { },
+                        onUsage,
+                        onWaitStart: this._options.onLongWaitStart,
+                        onWaitEnd: this._options.onLongWaitEnd
+                    },
+                    time: this._contexts.time
+                });
+                closeOpenTextLine();
+                return {
+                    text: capturedText,
+                    sessionId: result.sessionId,
+                    inputTokens,
+                    outputTokens
+                };
+            }
+            finally {
+                if (this._abortController === controller) {
+                    this._abortController = null;
+                }
+            }
+        })();
+        this._runPromise = promise;
+        try {
+            return await promise;
+        }
+        finally {
+            if (this._runPromise === promise) {
+                this._runPromise = null;
+            }
+        }
+    }
+    async dispose() {
+        var _a;
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        if (this._runPromise) {
+            try {
+                await this._runPromise;
+            }
+            catch {
+            }
+        }
+    }
+}
+exports.AiSession = AiSession;
+function formatToolResultLines(text) {
+    const prefix = (0, formatters_1.colorize)("  ⎿ ", formatters_1.MAGENTA);
+    const trimmed = text.replace(/\s+$/, "");
+    const lines = trimmed.split("\n");
+    if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+        return `${prefix}(empty)\n`;
+    }
+    const visible = lines.slice(0, TOOL_RESULT_MAX_LINES);
+    let out = "";
+    for (let i = 0; i < visible.length; i++) {
+        out += (i === 0 ? prefix : "    ") + visible[i] + "\n";
+    }
+    if (lines.length > TOOL_RESULT_MAX_LINES) {
+        out += `    … +${lines.length - TOOL_RESULT_MAX_LINES} more lines\n`;
+    }
+    return out;
+}

package/lib/ai/ClaudeAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { ScriptContext, TimeContext } from "../contexts";
+import type { ToolAdapter, ToolAdapterInvokeArgs, ToolEvent } from "./ToolAdapter";
+export type ClaudeAdapterContexts = Readonly<{
+    claude: ScriptContext;
+    time: TimeContext;
+}>;
+export declare function formatToolInput(input: Readonly<Record<string, unknown>> | undefined): string;
+export declare class ClaudeAdapter implements ToolAdapter {
+    private _contexts;
+    constructor(_contexts: ClaudeAdapterContexts);
+    invoke(args: ToolAdapterInvokeArgs): AsyncIterable<ToolEvent>;
+}

package/lib/ai/ClaudeAdapter.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAdapter = void 0;
+exports.formatToolInput = formatToolInput;
+const TOOL_INPUT_INLINE_MAX = 120;
+function formatToolInput(input) {
+    if (!input || typeof input !== "object") {
+        return "";
+    }
+    const i = input;
+    if (typeof i["command"] === "string") {
+        return i["command"];
+    }
+    if (typeof i["file_path"] === "string") {
+        return i["file_path"];
+    }
+    if (typeof i["path"] === "string") {
+        return i["path"];
+    }
+    if (typeof i["pattern"] === "string") {
+        return i["pattern"];
+    }
+    if (typeof i["url"] === "string") {
+        return i["url"];
+    }
+    if (typeof i["query"] === "string") {
+        return i["query"];
+    }
+    const json = JSON.stringify(input);
+    if (json.length > TOOL_INPUT_INLINE_MAX) {
+        return json.slice(0, TOOL_INPUT_INLINE_MAX - 3) + "...";
+    }
+    return json;
+}
+function renderToolResultContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        let out = "";
+        for (const block of content) {
+            if (block && typeof block === "object") {
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string") {
+                    out += b.text;
+                }
+            }
+        }
+        return out;
+    }
+    return "";
+}
+function toolResultSummary(content) {
+    var _a;
+    const text = renderToolResultContent(content);
+    if (!text) {
+        return "";
+    }
+    const firstLine = (_a = text.split("\n")[0]) !== null && _a !== void 0 ? _a : "";
+    return firstLine;
+}
+class ClaudeAdapter {
+    constructor(_contexts) {
+        this._contexts = _contexts;
+    }
+    invoke(args) {
+        const iter = new ClaudeAdapterIterator(args, this._contexts);
+        return {
+            [Symbol.asyncIterator]() {
+                return iter;
+            }
+        };
+    }
+}
+exports.ClaudeAdapter = ClaudeAdapter;
+class ClaudeAdapterIterator {
+    constructor(_args, _contexts) {
+        this._args = _args;
+        this._contexts = _contexts;
+        this._proc = null;
+        this._capturedSessionId = null;
+        this._queue = [];
+        this._done = false;
+        this._error = null;
+        this._waitResolve = null;
+        this._abortListener = null;
+        this._pendingTerminal = null;
+        this._exitPromise = null;
+        this._start();
+    }
+    _start() {
+        var _a, _b, _c, _d;
+        const argv = this._buildArgv();
+        const spawnOptions = { stdio: "pipe" };
+        const proc = this._contexts.claude.spawn("claude", argv, spawnOptions);
+        this._proc = proc;
+        const initialMessage = {
+            type: "user",
+            message: { role: "user", content: this._args.prompt }
+        };
+        (_a = proc.stdin) === null || _a === void 0 ? void 0 : _a.write(JSON.stringify(initialMessage) + "\n");
+        (_b = proc.stdin) === null || _b === void 0 ? void 0 : _b.end();
+        let exitResolve = null;
+        this._exitPromise = new Promise(resolve => { exitResolve = resolve; });
+        let buffer = "";
+        (_c = proc.stdout) === null || _c === void 0 ? void 0 : _c.on("data", (chunk) => {
+            buffer += String(chunk);
+            for (;;) {
+                const nl = buffer.indexOf("\n");
+                if (nl < 0)
+                    break;
+                const line = buffer.slice(0, nl).replace(/\r$/, "");
+                buffer = buffer.slice(nl + 1);
+                if (line) {
+                    this._handleLine(line);
+                }
+            }
+        });
+        let stderrBuf = "";
+        (_d = proc.stderr) === null || _d === void 0 ? void 0 : _d.on("data", (chunk) => {
+            stderrBuf += String(chunk);
+        });
+        proc.on("error", (e) => {
+            if (!this._done) {
+                this._done = true;
+                this._error = e instanceof Error ? e : new Error(String(e));
+                this._wake();
+            }
+            exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+        });
+        proc.on("exit", () => {
+            if (stderrBuf) {
+                this._queue.push({
+                    type: "output",
+                    title: "stderr",
+                    subtitle: "",
+                    details: stderrBuf
+                });
+                stderrBuf = "";
+            }
+            if (this._pendingTerminal) {
+                this._queue.push(this._pendingTerminal);
+                this._pendingTerminal = null;
+            }
+            if (!this._done) {
+                this._done = true;
+            }
+            this._wake();
+            exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+        });
+        this._abortListener = () => {
+            if (this._proc) {
+                this._proc.kill("SIGINT");
+            }
+            this._done = true;
+            this._wake();
+        };
+        if (this._args.abortSignal.aborted) {
+            this._abortListener();
+        }
+        else {
+            this._args.abortSignal.addEventListener("abort", this._abortListener, { once: true });
+        }
+    }
+    _buildArgv() {
+        const argv = [];
+        if (this._args.resumeSessionId) {
+            argv.push("--resume", this._args.resumeSessionId);
+        }
+        else if (this._args.forkParentSessionId) {
+            argv.push("--resume", this._args.forkParentSessionId, "--fork-session");
+        }
+        if (this._args.model) {
+            argv.push("--model", this._args.model);
+        }
+        if (this._args.effort) {
+            argv.push("--effort", this._args.effort);
+        }
+        argv.push("--input-format", "stream-json", "--output-format", "stream-json", "--include-partial-messages", "--verbose", "--print");
+        return argv;
+    }
+    _handleLine(line) {
+        var _a, _b, _c, _d, _e, _f;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!parsed)
+            return;
+        if (parsed.session_id) {
+            if (this._capturedSessionId === null) {
+                this._capturedSessionId = parsed.session_id;
+                this._queue.push({ type: "session", id: parsed.session_id });
+            }
+            else if (this._capturedSessionId !== parsed.session_id) {
+                this._capturedSessionId = parsed.session_id;
+                this._queue.push({ type: "session", id: parsed.session_id });
+            }
+        }
+        if (parsed.type === "assistant" && ((_a = parsed.message) === null || _a === void 0 ? void 0 : _a.content)) {
+            for (const block of parsed.message.content) {
+                if (block.type === "tool_use" && typeof block.name === "string") {
+                    this._queue.push({
+                        type: "output",
+                        title: block.name,
+                        subtitle: formatToolInput(block.input),
+                        details: ""
+                    });
+                }
+                else if (block.type === "text" && typeof block.text === "string") {
+                    this._queue.push({
+                        type: "output",
+                        title: "Assistant",
+                        subtitle: "",
+                        details: block.text
+                    });
+                }
+                else if (block.type === "thinking" && typeof block.thinking === "string") {
+                    this._queue.push({
+                        type: "output",
+                        title: "Thinking",
+                        subtitle: "",
+                        details: block.thinking
+                    });
+                }
+            }
+        }
+        if (parsed.type === "user" && ((_b = parsed.message) === null || _b === void 0 ? void 0 : _b.content)) {
+            for (const block of parsed.message.content) {
+                if (block.type === "tool_result") {
+                    const text = renderToolResultContent(block.content);
+                    this._queue.push({
+                        type: "output",
+                        title: "Result",
+                        subtitle: toolResultSummary(block.content),
+                        details: text
+                    });
+                }
+            }
+        }
+        if (parsed.type === "result") {
+            const u = parsed.usage;
+            if (u && this._args.onUsage) {
+                const inputTokens = ((_c = u.input_tokens) !== null && _c !== void 0 ? _c : 0) + ((_d = u.cache_creation_input_tokens) !== null && _d !== void 0 ? _d : 0) + ((_e = u.cache_read_input_tokens) !== null && _e !== void 0 ? _e : 0);
+                const outputTokens = (_f = u.output_tokens) !== null && _f !== void 0 ? _f : 0;
+                this._args.onUsage({ inputTokens, outputTokens });
+            }
+            if (parsed.session_id && !this._capturedSessionId) {
+                this._capturedSessionId = parsed.session_id;
+                this._queue.push({ type: "session", id: parsed.session_id });
+            }
+            if (!parsed.is_error) {
+                this._pendingTerminal = { type: "done" };
+            }
+            else {
+                this._pendingTerminal = this._classifyError(parsed);
+            }
+        }
+        this._wake();
+    }
+    _classifyError(parsed) {
+        var _a, _b;
+        const status = parsed.api_error_status;
+        const subtype = parsed.subtype;
+        const message = (_b = (_a = parsed.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : "unknown error";
+        if (status === 429) {
+            const info = parsed.rate_limit_info;
+            if (info) {
+                const target = info.isUsingOverage && typeof info.overageResetsAt === "number"
+                    ? info.overageResetsAt
+                    : info.resetsAt;
+                if (typeof target === "number") {
+                    return { type: "rate_limit", waitUntilMs: target * 1000 };
+                }
+            }
+            return { type: "error", retryable: true, message };
+        }
+        if (typeof status === "number" && status >= 500) {
+            return { type: "error", retryable: true, message };
+        }
+        if (status === 408 || status === 425) {
+            return { type: "error", retryable: true, message };
+        }
+        if (status === null) {
+            return { type: "error", retryable: true, message };
+        }
+        if (subtype === "error_during_execution") {
+            return { type: "error", retryable: true, message };
+        }
+        if (subtype === "error_max_turns" || subtype === "error_max_budget_usd" || subtype === "error_max_structured_output_retries") {
+            return { type: "error", retryable: false, message };
+        }
+        return { type: "error", retryable: false, message };
+    }
+    _wake() {
+        if (this._waitResolve) {
+            const resolve = this._waitResolve;
+            this._waitResolve = null;
+            resolve();
+        }
+    }
+    _wait() {
+        return new Promise(resolve => {
+            this._waitResolve = resolve;
+        });
+    }
+    async next() {
+        for (;;) {
+            if (this._queue.length > 0) {
+                return { value: this._queue.shift(), done: false };
+            }
+            if (this._error) {
+                throw this._error;
+            }
+            if (this._done && this._queue.length === 0) {
+                this._cleanup();
+                if (this._exitPromise) {
+                    await this._exitPromise;
+                }
+                return { value: undefined, done: true };
+            }
+            await this._wait();
+        }
+    }
+    async return() {
+        this._done = true;
+        this._cleanup();
+        if (this._proc) {
+            this._proc.kill("SIGINT");
+            if (this._exitPromise) {
+                await this._exitPromise;
+            }
+        }
+        return { value: undefined, done: true };
+    }
+    _cleanup() {
+        if (this._abortListener) {
+            this._args.abortSignal.removeEventListener("abort", this._abortListener);
+            this._abortListener = null;
+        }
+    }
+}

package/lib/ai/CodexAdapter.d.ts

@@ -0,0 +1,13 @@
+import type { RandomContext, ScriptContext, TimeContext } from "../contexts";
+import type { ToolAdapter, ToolAdapterInvokeArgs, ToolEvent } from "./ToolAdapter";
+export type CodexAdapterContexts = Readonly<{
+    script: ScriptContext;
+    time: TimeContext;
+    random: RandomContext;
+}>;
+export declare function formatCodexCommand(command: string | undefined): string;
+export declare class CodexAdapter implements ToolAdapter {
+    private _contexts;
+    constructor(_contexts: CodexAdapterContexts);
+    invoke(args: ToolAdapterInvokeArgs): AsyncIterable<ToolEvent>;
+}