poe-code 3.0.258 → 3.0.259-beta.1

package/packages/agent-gaslight/dist/types.d.ts

@@ -1,10 +1,6 @@
 import type { SpawnMode, SpawnOptions, SpawnResult, SpawnUsage } from "../../agent-spawn/dist/index.js";
-export interface GaslightFileSystem {
-    readFile(path: string, encoding: BufferEncoding): Promise<string>;
-    stat(path: string): Promise<{
-        isFile(): boolean;
-    }>;
-}
+import type { AgentTraceFileSystem, AgentTraceSource, CollectHumanPromptsOptions, CollectHumanPromptsResult } from "../../agent-traces/dist/index.js";
+export type GaslightFileSystem = AgentTraceFileSystem;
 export type GaslightSpawn = (agent: string, options: SpawnOptions) => Promise<SpawnResult>;
 export type GaslightEvent = {
     type: "round.started";
@@ -33,6 +29,7 @@ export interface GaslightOptions {
     mode?: Exclude<SpawnMode, "auto">;
     cwd?: string;
     homeDir?: string;
+    configPath?: string;
     prompt?: string;
     followups?: string[];
     onEvent?: (event: GaslightEvent) => void;
@@ -45,3 +42,41 @@ export interface GaslightConfig {
     followups: string[];
     path: string;
 }
+export type GaslightCollectHumanPrompts = (options: CollectHumanPromptsOptions) => Promise<CollectHumanPromptsResult>;
+export type GaslightIngestEvent = {
+    type: "traces.discovered";
+    count: number;
+} | {
+    type: "prompts.extracted";
+    traces: number;
+    prompts: number;
+} | {
+    type: "analysis.started";
+    agent: string;
+    dataPath: string;
+} | {
+    type: "config.written";
+    path: string;
+};
+export interface GaslightIngestOptions {
+    sources?: AgentTraceSource[];
+    analysisAgent: string;
+    model?: string;
+    cwd?: string;
+    homeDir?: string;
+    since?: string | Date;
+    limit?: number;
+    allWorkspaces?: boolean;
+    outputPath?: string;
+    keepDataPath?: string;
+    onEvent?: (event: GaslightIngestEvent) => void;
+    fs?: GaslightFileSystem;
+    spawn?: GaslightSpawn;
+    collectHumanPrompts?: GaslightCollectHumanPrompts;
+}
+export interface GaslightIngestResult {
+    outputPath: string;
+    dataPath: string;
+    promptCount: number;
+    traceCount: number;
+}

package/packages/agent-harness/dist/loader/run.js

@@ -3,7 +3,7 @@ import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promi
 import os from "node:os";
 import { dirname, join, parse, resolve, sep } from "node:path";
 import { resolveRunLogDir } from "@poe-code/agent-harness-tools";
-import { lint, FileSnapshotBackend, createSpawnUsageAccumulator, makeTimeModule, parseModule, run, splitFrontmatter, runWithSpawnUsageAccumulator } from "@poe-code/agent-script";
+import { lint, FileSnapshotBackend, createSpawnUsageAccumulator, makeTimeModule, run, splitFrontmatter, runWithSpawnUsageAccumulator } from "@poe-code/agent-script";
 import { hasOwnErrorCode } from "../error-codes.js";
 import { makeSchemaModule } from "../modules/schema.js";
 import { extractSchema } from "./extract-schema.js";
@@ -82,6 +82,10 @@ export async function runHarnessPair(mdPath, options) {
         const lintOptions = {
             allowedExportNames: ["schema"],
             allowedGlobals: options.allowedGlobals,
+            defaultExport: {
+                parameters: ["frontmatter"],
+                required: true
+            },
             filename: pair.ajsPath,
             frontmatterFields: readSchemaTopLevelFields(schema),
             modules: createLintModules(modules)
@@ -96,8 +100,7 @@ export async function runHarnessPair(mdPath, options) {
             }
         }
         const diagnostics = [
-            ...(Array.isArray(lintDiagnostics) ? lintDiagnostics : lintDiagnostics.diagnostics),
-            ...missingDefaultExportDiagnostics(executableSource, pair.ajsPath)
+            ...(Array.isArray(lintDiagnostics) ? lintDiagnostics : lintDiagnostics.diagnostics)
         ];
         options.onDiagnostics?.(diagnostics);
         throwOnLintErrors(diagnostics);
@@ -144,24 +147,6 @@ function throwOnLintErrors(diagnostics) {
         throw new LintError(errors);
     }
 }
-function missingDefaultExportDiagnostics(source, filename) {
-    const module = parseModule(source, filename);
-    const hasDefaultExport = module.body.some((statement) => statement.type === "ExportDefaultDeclaration");
-    if (hasDefaultExport) {
-        return [];
-    }
-    return [
-        {
-            code: "AS-EXPORT-DEFAULT-MISSING",
-            severity: "error",
-            message: "Module must export a default entry point.",
-            filename,
-            line: module.span.start.line,
-            column: module.span.start.column,
-            span: module.span
-        }
-    ];
-}
 function readSchemaTopLevelFields(schema) {
     if (schema?.kind !== "object") {
         return undefined;

package/packages/agent-script/dist/cli.d.ts

@@ -1,7 +1,6 @@
+import { type OutputStream } from "./output-stream.js";
 import type { ModuleRegistry } from "./modules/registry.js";
-type CliStream = {
-    write(chunk: string): void;
-};
+type CliStream = OutputStream;
 type CliProcess = Pick<NodeJS.Process, "off" | "on">;
 type FileStats = {
     isFile(): boolean;

package/packages/agent-script/dist/cli.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path, { dirname, extname } from "node:path";
-import { inspect } from "node:util";
+import { formatWithOptions } from "node:util";
 import { pathToFileURL } from "node:url";
 import { hasOwnErrorCode } from "./error-codes.js";
 import { formatInterpreterError } from "./error/format.js";
@@ -15,6 +15,7 @@ import { makeFailModule } from "./modules/fail.js";
 import { makeHarnessModule } from "./modules/harness.js";
 import { makeLogModule } from "./modules/log.js";
 import { makeMetricModule } from "./modules/metric.js";
+import { createBrokenPipeState, createSafeOutputStream, withBrokenPipeGuard } from "./output-stream.js";
 import { parseModule } from "./parse/parser.js";
 import { restore } from "./restore.js";
 import { run } from "./run.js";
@@ -24,38 +25,57 @@ const EXIT_PARSE = 2;
 const EXIT_BUDGET = 3;
 const EXIT_SIGINT = 130;
 export async function runCli(argv, options = {}) {
-    const stdout = options.stdout ?? process.stdout;
-    const stderr = options.stderr ?? process.stderr;
-    const cwd = options.cwd ?? process.cwd();
-    try {
-        if (argv.includes("--help") || argv.includes("-h")) {
-            stdout.write(`${createUsage()}\n`);
-            return 0;
+    const brokenPipe = createBrokenPipeState();
+    const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
+    const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
+    return withBrokenPipeGuard([options.stdout ?? process.stdout, options.stderr ?? process.stderr], brokenPipe, async () => {
+        try {
+            if (argv.includes("--help") || argv.includes("-h")) {
+                stdout.write(`${createUsage()}\n`);
+                return 0;
+            }
+            const parsed = parseArgs(argv);
+            if (parsed.filepath === undefined) {
+                stderr.write(`${createUsage()}\n`);
+                return brokenPipe.closed ? 0 : EXIT_RUNTIME;
+            }
+            const cwd = options.cwd ?? readCurrentWorkingDirectory();
+            const filepath = path.resolve(cwd, parsed.filepath);
+            await assertHarnessFile({
+                displayPath: parsed.filepath,
+                filepath,
+                statFile: options.stat ?? stat
+            });
+            return await runScriptFile(filepath, parsed, {
+                cwd,
+                modulesFor: options.modulesFor,
+                process: options.process ?? process,
+                readFile: options.readFile ?? readFile,
+                brokenPipe,
+                stderr,
+                stdout,
+                writeFile: options.writeFile ?? writeFile
+            });
         }
-        const parsed = parseArgs(argv);
-        if (parsed.filepath === undefined) {
-            stderr.write(`${createUsage()}\n`);
-            return EXIT_RUNTIME;
+        catch (error) {
+            if (brokenPipe.closed) {
+                return 0;
+            }
+            stderr.write(`${readErrorMessage(error)}\n`);
+            return brokenPipe.closed
+                ? 0
+                : error instanceof CliExitError
+                    ? error.exitCode
+                    : exitCodeForError(error);
         }
-        const filepath = path.resolve(cwd, parsed.filepath);
-        await assertHarnessFile({
-            displayPath: parsed.filepath,
-            filepath,
-            statFile: options.stat ?? stat
-        });
-        return await runScriptFile(filepath, parsed, {
-            cwd,
-            modulesFor: options.modulesFor,
-            process: options.process ?? process,
-            readFile: options.readFile ?? readFile,
-            stderr,
-            stdout,
-            writeFile: options.writeFile ?? writeFile
-        });
+    });
+}
+function readCurrentWorkingDirectory() {
+    try {
+        return process.cwd();
     }
     catch (error) {
-        stderr.write(`${readErrorMessage(error)}\n`);
-        return error instanceof CliExitError ? error.exitCode : exitCodeForError(error);
+        throw new Error(`Unable to resolve current working directory: ${readErrorMessage(error)}`);
     }
 }
 function parseArgs(argv) {
@@ -167,11 +187,19 @@ async function runScriptFile(filepath, parsed, options) {
     const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
     if (lintErrors.length > 0) {
         options.stderr.write(`Lint failed:\n${formatDiagnostics(lintErrors)}\n`);
-        return lintErrors.some((diagnostic) => diagnostic.code === "AS001") ? EXIT_PARSE : EXIT_RUNTIME;
+        if (options.brokenPipe.closed) {
+            return 0;
+        }
+        return lintErrors.some((diagnostic) => diagnostic.code === "AS001")
+            ? EXIT_PARSE
+            : EXIT_RUNTIME;
     }
     const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
     if (lintWarnings.length > 0) {
         options.stderr.write(`Lint warnings:\n${formatDiagnostics(lintWarnings)}\n`);
+        if (options.brokenPipe.closed) {
+            return 0;
+        }
     }
     const snapshot = await readRestoreSnapshot(parsed.restorePath, options);
     if (snapshot !== undefined) {
@@ -204,6 +232,9 @@ async function runScriptFile(filepath, parsed, options) {
         });
         const result = await runPromise;
         await signalSnapshotWrite;
+        if (options.brokenPipe.closed) {
+            return 0;
+        }
         if (parsed.snapshotPath !== undefined) {
             await writeSnapshot(parsed.snapshotPath, await dump(result), options);
         }
@@ -212,18 +243,24 @@ async function runScriptFile(filepath, parsed, options) {
                 filename: filepath,
                 source: executableSource
             })}\n`);
+            if (options.brokenPipe.closed) {
+                return 0;
+            }
             return interrupted ? EXIT_SIGINT : exitCodeForError(result.error);
         }
         options.stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}\n`);
-        return interrupted ? EXIT_SIGINT : 0;
+        return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : 0;
     }
     catch (error) {
         await signalSnapshotWrite;
+        if (options.brokenPipe.closed) {
+            return 0;
+        }
         options.stderr.write(`${formatInterpreterError(error, {
             filename: filepath,
             source: executableSource
         })}\n`);
-        return interrupted ? EXIT_SIGINT : exitCodeForError(error);
+        return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : exitCodeForError(error);
     }
     finally {
         options.process.off("SIGINT", onSigint);
@@ -367,10 +404,7 @@ function createConsoleSink(stdout, stderr) {
     };
 }
 function formatConsoleArgs(args) {
-    return args.map(formatConsoleArg).join(" ");
-}
-function formatConsoleArg(value) {
-    return typeof value === "string" ? value : inspect(value, { colors: false, depth: 4 });
+    return formatWithOptions({ colors: false, depth: 4 }, ...args);
 }
 function createUsage() {
     return [

package/packages/agent-script/dist/example-runner.d.ts

@@ -1,6 +1,5 @@
-type CliStream = {
-    write(chunk: string): void;
-};
+import { type OutputStream } from "./output-stream.js";
+type CliStream = OutputStream;
 export type ReadMarkdownFile = (filepath: string, encoding: "utf8") => Promise<string>;
 export type WriteMarkdownFile = (filepath: string, source: string, options: {
     encoding: "utf8";

package/packages/agent-script/dist/example-runner.js

@@ -9,6 +9,7 @@ import { makeFailModule } from "./modules/fail.js";
 import { makeHarnessModule } from "./modules/harness.js";
 import { makeLogModule } from "./modules/log.js";
 import { makeMetricModule } from "./modules/metric.js";
+import { createBrokenPipeState, createSafeOutputStream, withBrokenPipeGuard } from "./output-stream.js";
 import { parseModule } from "./parse/parser.js";
 import { run } from "./run.js";
 async function main(argv) {
@@ -20,68 +21,80 @@ async function main(argv) {
     return await runExampleFile(filepath, { fix });
 }
 export async function runExampleFile(filepath, options = {}) {
-    const stdout = options.stdout ?? process.stdout;
-    const stderr = options.stderr ?? process.stderr;
+    const brokenPipe = createBrokenPipeState();
+    const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
+    const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
     const readMarkdownFile = options.readFile ?? readFile;
     const writeMarkdownFile = options.writeFile ?? writeFile;
-    try {
-        const rawSource = await readMarkdownFile(filepath, "utf8");
-        const loaded = loadExecutableSource(rawSource);
-        const { frontmatter, hasScriptBlock } = loaded;
-        let executableSource = loaded.executableSource;
-        const meta = {
-            filepath,
-            kind: frontmatter.kind,
-            version: frontmatter.version
-        };
-        const runtime = createExampleRuntime(frontmatter, meta, stdout);
-        if (!hasScriptBlock) {
-            const returnValue = await runDemoFallback(frontmatter, runtime);
-            stdout.write(`${JSON.stringify({ ok: true, returnValue })}\n`);
+    return withBrokenPipeGuard([options.stdout ?? process.stdout, options.stderr ?? process.stderr], brokenPipe, async () => {
+        try {
+            const rawSource = await readMarkdownFile(filepath, "utf8");
+            const loaded = loadExecutableSource(rawSource);
+            const { frontmatter, hasScriptBlock } = loaded;
+            let executableSource = loaded.executableSource;
+            const meta = {
+                filepath,
+                kind: frontmatter.kind,
+                version: frontmatter.version
+            };
+            const runtime = createExampleRuntime(frontmatter, meta, stdout);
+            if (!hasScriptBlock) {
+                const returnValue = await runDemoFallback(frontmatter, runtime);
+                stdout.write(`${JSON.stringify({ ok: true, returnValue })}\n`);
+                return 0;
+            }
+            const lintOptions = {
+                allowedExportNames: ["schema"],
+                filename: filepath,
+                modules: createLintModulesFromRuntimeRegistry(runtime.registry)
+            };
+            const lintResult = options.fix
+                ? lint(executableSource, { ...lintOptions, fix: true })
+                : lint(executableSource, lintOptions);
+            const diagnostics = Array.isArray(lintResult) ? lintResult : lintResult.diagnostics;
+            if (!Array.isArray(lintResult)) {
+                executableSource = lintResult.fixed;
+                if (lintResult.fixed !== loaded.executableSource) {
+                    await writeMarkdownFile(filepath, replaceExecutableSource(rawSource, loaded, lintResult.fixed), {
+                        encoding: "utf8"
+                    });
+                }
+            }
+            const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+            if (lintErrors.length > 0) {
+                stderr.write(`Lint failed:\n${formatDiagnostics(lintErrors)}\n`);
+                return brokenPipe.closed ? 0 : 1;
+            }
+            const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+            if (lintWarnings.length > 0) {
+                stderr.write(`Lint warnings:\n${formatDiagnostics(lintWarnings)}\n`);
+                if (brokenPipe.closed) {
+                    return 0;
+                }
+            }
+            const result = await run(executableSource, {
+                entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : undefined,
+                filename: filepath,
+                modules: runtime.registry
+            });
+            if (brokenPipe.closed) {
+                return 0;
+            }
+            if (!result.ok) {
+                stderr.write(`${readErrorMessage(result.error)}\n`);
+                return brokenPipe.closed ? 0 : 1;
+            }
+            stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}\n`);
             return 0;
         }
-        const lintOptions = {
-            allowedExportNames: ["schema"],
-            filename: filepath,
-            modules: createLintModulesFromRuntimeRegistry(runtime.registry)
-        };
-        const lintResult = options.fix
-            ? lint(executableSource, { ...lintOptions, fix: true })
-            : lint(executableSource, lintOptions);
-        const diagnostics = Array.isArray(lintResult) ? lintResult : lintResult.diagnostics;
-        if (!Array.isArray(lintResult)) {
-            executableSource = lintResult.fixed;
-            if (lintResult.fixed !== loaded.executableSource) {
-                await writeMarkdownFile(filepath, replaceExecutableSource(rawSource, loaded, lintResult.fixed), {
-                    encoding: "utf8"
-                });
+        catch (error) {
+            if (brokenPipe.closed) {
+                return 0;
             }
+            stderr.write(`${readErrorMessage(error)}\n`);
+            return brokenPipe.closed ? 0 : 1;
         }
-        const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
-        if (lintErrors.length > 0) {
-            stderr.write(`Lint failed:\n${formatDiagnostics(lintErrors)}\n`);
-            return 1;
-        }
-        const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
-        if (lintWarnings.length > 0) {
-            stderr.write(`Lint warnings:\n${formatDiagnostics(lintWarnings)}\n`);
-        }
-        const result = await run(executableSource, {
-            entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : undefined,
-            filename: filepath,
-            modules: runtime.registry
-        });
-        if (!result.ok) {
-            stderr.write(`${readErrorMessage(result.error)}\n`);
-            return 1;
-        }
-        stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}\n`);
-        return 0;
-    }
-    catch (error) {
-        stderr.write(`${readErrorMessage(error)}\n`);
-        return 1;
-    }
+    });
 }
 function loadExecutableSource(source) {
     const { frontmatter, body } = splitFrontmatter(source);

package/packages/agent-script/dist/interp/exceptions.js

@@ -315,7 +315,7 @@ function getPatternBindingNames(pattern) {
 async function bindPattern(pattern, value, context, evaluateNode) {
     switch (pattern.type) {
         case "Identifier":
-            context.scope.declare(pattern.name, "const", value);
+            context.scope.declare(pattern.name, "let", value);
             return { ok: true };
         case "MemberExpression":
             throw new TypeError("Catch bindings do not support member expressions.");

package/packages/agent-script/dist/interp/globals/object-array.d.ts

@@ -2,7 +2,7 @@ import type { Budget } from "../budget.js";
 import { type SandboxClosure, type SandboxObject } from "../values.js";
 export type ObjectArrayGlobals = {
     Object: SandboxObject;
-    Array: SandboxObject;
+    Array: SandboxClosure;
     String: SandboxClosure;
     Number: SandboxClosure;
     Boolean: SandboxClosure;

package/packages/agent-script/dist/interp/globals/object-array.js

@@ -45,20 +45,25 @@ export function createObjectArrayGlobals(options) {
                 name: "assign"
             })
         },
-        Array: {
-            isArray: createSandboxClosure({
-                call: ([value]) => Array.isArray(value),
-                name: "isArray"
-            }),
-            from: createSandboxClosure({
-                call: (args) => arrayFromSandboxValues(args, options.budget),
-                name: "from"
-            }),
-            of: createSandboxClosure({
-                call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), options.budget),
-                name: "of"
-            })
-        },
+        Array: createSandboxClosure({
+            call: (args) => createArrayFromConstructorArgs(args, options.budget),
+            construct: (args) => createArrayFromConstructorArgs(args, options.budget),
+            name: "Array",
+            properties: {
+                isArray: createSandboxClosure({
+                    call: ([value]) => Array.isArray(value),
+                    name: "isArray"
+                }),
+                from: createSandboxClosure({
+                    call: (args) => arrayFromSandboxValues(args, options.budget),
+                    name: "from"
+                }),
+                of: createSandboxClosure({
+                    call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), options.budget),
+                    name: "of"
+                })
+            }
+        }),
         String: createSandboxClosure({
             call: ([value]) => options.budget.allocateString(String(value)),
             name: "String",
@@ -152,13 +157,13 @@ function isAssignableSandboxTarget(value) {
 async function arrayFromSandboxValues(args, budget) {
     const [items, mapFn] = args;
     const iterator = getSandboxIterator(items);
-    if (iterator?.generator !== true && (mapFn === undefined || !isSandboxClosure(mapFn))) {
-        return budgetSandboxValue(Reflect.apply(Array.from, Array, [...args]), budget);
-    }
-    const values = iterator?.generator === true
-        ? await collectIteratorValues(iterator)
-        : Reflect.apply(Array.from, Array, [items]);
+    const values = iterator === undefined
+        ? Reflect.apply(Array.from, Array, [items])
+        : await collectIteratorValues(iterator);
     if (mapFn === undefined || !isSandboxClosure(mapFn)) {
+        if (mapFn !== undefined) {
+            throw new TypeError("Array.from mapping callback must be a function.");
+        }
         return budgetSandboxValue(values, budget);
     }
     const mappedValues = [];
@@ -168,6 +173,20 @@ async function arrayFromSandboxValues(args, budget) {
     }
     return budgetSandboxValue(mappedValues, budget);
 }
+function createArrayFromConstructorArgs(args, budget) {
+    if (args.length !== 1) {
+        return budgetSandboxValue(Reflect.apply(Array, Array, [...args]), budget);
+    }
+    const [lengthOrValue] = args;
+    if (typeof lengthOrValue !== "number") {
+        return budgetSandboxValue([lengthOrValue], budget);
+    }
+    if (!Number.isInteger(lengthOrValue) || lengthOrValue < 0 || lengthOrValue > 0xffffffff) {
+        throw new RangeError("Invalid array length.");
+    }
+    budget.allocateArrayLength(lengthOrValue);
+    return new Array(lengthOrValue);
+}
 async function collectIteratorValues(iterator) {
     const values = [];
     while (true) {

package/packages/agent-script/dist/interp/host-bridge.js

@@ -475,7 +475,7 @@ function readStringProperty(value, key) {
 }
 function copyFunctionProperties(callable, stackFrames, options, state, path) {
     const properties = {};
-    for (const key of Object.keys(callable)) {
+    for (const key of Object.getOwnPropertyNames(callable)) {
         const descriptor = Object.getOwnPropertyDescriptor(callable, key);
         if (descriptor === undefined) {
             continue;