@adecore/agents 0.0.1 → 0.17.0-beta.2

package/dist/chat/fake-cli.d.ts

@@ -0,0 +1,25 @@
+import type { SpawnChatProcess } from './chat-process.ts';
+export interface FakeIo {
+    readonly argv: string[];
+    readonly cwd: string;
+    out(frame: unknown): void;
+    err(text: string): void;
+    exit(code: number): void;
+    later(work: () => void): void;
+}
+export interface FakeProgram {
+    onLine(line: string): void;
+}
+export type FakeCli = (io: FakeIo) => FakeProgram;
+export interface StartedFake {
+    readonly argv: string[];
+    runLater(): void;
+    crash(code: number): void;
+    readonly exited: Promise<number | null>;
+}
+export interface InProcessCli {
+    spawn: SpawnChatProcess;
+    readonly started: StartedFake[];
+}
+export declare function inProcess(cli: FakeCli): InProcessCli;
+export declare function runOverStdio(cli: FakeCli): Promise<void>;

package/dist/chat/fake-cli.js

@@ -0,0 +1,157 @@
+/*
+ * A spawn that runs the fake in this process. A line written to stdin reaches the fake at once, and
+ * stdout is pulled: the exit is reported only after the backend has read every frame written before
+ * it, which is the order a real pipe delivers them in and leaves nothing to a clock.
+ */
+export function inProcess(cli) {
+    const started = [];
+    let nextPid = 900_000;
+    const spawn = (options) => {
+        const encoder = new TextEncoder();
+        const chunks = [];
+        let stderrController = null;
+        const stderr = new ReadableStream({
+            start: (controller) => {
+                stderrController = controller;
+            }
+        });
+        const deferred = [];
+        let ended = false;
+        let exitCode = null;
+        let inputClosed = false;
+        let pending = '';
+        let wake = null;
+        let settleExited = () => undefined;
+        const exited = new Promise((resolve) => {
+            settleExited = resolve;
+        });
+        const nudge = () => {
+            const waiting = wake;
+            wake = null;
+            waiting?.();
+        };
+        const exit = (code) => {
+            if (ended) {
+                return;
+            }
+            ended = true;
+            exitCode = code;
+            // A pipe closes with the process that held it.
+            stderrController?.close();
+            nudge();
+        };
+        const program = cli({
+            argv: options.command.slice(1),
+            cwd: options.cwd,
+            out: (frame) => {
+                if (ended) {
+                    return;
+                }
+                chunks.push(encoder.encode(`${JSON.stringify(frame)}\n`));
+                nudge();
+            },
+            err: (text) => {
+                if (!ended) {
+                    stderrController?.enqueue(encoder.encode(text));
+                }
+            },
+            exit: (code) => exit(code),
+            later: (work) => {
+                deferred.push(work);
+            }
+        });
+        const stdout = new ReadableStream({
+            pull: async (controller) => {
+                while (chunks.length === 0 && !ended) {
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                    });
+                }
+                const chunk = chunks.shift();
+                if (chunk) {
+                    controller.enqueue(chunk);
+                    return;
+                }
+                controller.close();
+                options.onExit(exitCode);
+                settleExited(exitCode);
+            }
+        }, { highWaterMark: 0 });
+        const stdin = {
+            write: (chunk) => {
+                if (ended || inputClosed) {
+                    return 0;
+                }
+                pending += chunk;
+                let newline = pending.indexOf('\n');
+                while (newline >= 0 && !ended) {
+                    const line = pending.slice(0, newline);
+                    pending = pending.slice(newline + 1);
+                    newline = pending.indexOf('\n');
+                    if (line.trim() !== '') {
+                        program.onLine(line);
+                    }
+                }
+                return chunk.length;
+            },
+            flush: () => 0,
+            // Both fakes leave the way the real CLIs do once their input is gone.
+            end: () => {
+                inputClosed = true;
+                exit(0);
+                return 0;
+            }
+        };
+        started.push({
+            argv: options.command.slice(1),
+            runLater: () => {
+                for (const work of deferred.splice(0)) {
+                    work();
+                }
+            },
+            crash: (code) => exit(code),
+            exited
+        });
+        return {
+            pid: nextPid++,
+            stdin,
+            stdout,
+            stderr,
+            // A signal ends a real process without an exit code of its own.
+            kill: () => exit(null)
+        };
+    };
+    return { spawn, started };
+}
+/* The same fake as a child process, for the one test that needs real pipes and a real exit code. */
+export async function runOverStdio(cli) {
+    const program = cli({
+        argv: process.argv.slice(2),
+        cwd: process.cwd(),
+        out: (frame) => {
+            process.stdout.write(`${JSON.stringify(frame)}\n`);
+        },
+        err: (text) => {
+            process.stderr.write(text);
+        },
+        exit: (code) => process.exit(code),
+        later: (work) => {
+            setImmediate(work);
+        }
+    });
+    const decoder = new TextDecoder();
+    let buffered = '';
+    for await (const chunk of process.stdin) {
+        buffered += decoder.decode(chunk, { stream: true });
+        let newline = buffered.indexOf('\n');
+        while (newline >= 0) {
+            const line = buffered.slice(0, newline);
+            buffered = buffered.slice(newline + 1);
+            newline = buffered.indexOf('\n');
+            if (line.trim() !== '') {
+                program.onLine(line);
+            }
+        }
+    }
+    process.exit(0);
+}

package/dist/chat/fake-codex.d.ts

@@ -0,0 +1,10 @@
+import { type FakeCli } from './fake-cli.ts';
+type Frame = Record<string, unknown>;
+export declare const FAKE_CHILD_STEPS = 250;
+export declare const fakeCodexForks: Frame[];
+export interface FakeCodexOptions {
+    resumeLead?: string;
+}
+export declare function fakeCodexWith(options: FakeCodexOptions): FakeCli;
+export declare const fakeCodex: FakeCli;
+export {};