poe-code 3.0.260 → 3.0.261

package/dist/sdk/gaslight.d.ts

@@ -1 +1 @@
-export { GASLIGHT_CONFIG_EXAMPLE, ingestGaslight, loadGaslightConfig, parseGaslightConfig, runGaslight, type GaslightConfig, type GaslightCollectHumanPrompts, type GaslightEvent, type GaslightFileSystem, type GaslightIngestEvent, type GaslightIngestOptions, type GaslightIngestResult, type GaslightOptions, type GaslightResult, type GaslightRound, type GaslightSpawn } from "../../packages/agent-gaslight/dist/index.js";
+export { GASLIGHT_CONFIG_EXAMPLE, ingestGaslight, loadGaslightConfig, parseGaslightConfig, runGaslight, type GaslightConfig, type GaslightCollectHumanPrompts, type GaslightEvent, type GaslightFileSystem, type GaslightIngestEvent, type GaslightIngestOptions, type GaslightIngestResult, type GaslightOptions, type GaslightPlanResult, type GaslightResult, type GaslightRound, type GaslightSpawn } from "../../packages/agent-gaslight/dist/index.js";

package/dist/sdk/gaslight.js.map

@@ -1 +1 @@
-{"version":3,"file":"gaslight.js","sourceRoot":"","sources":["../../src/sdk/gaslight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EAYZ,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"gaslight.js","sourceRoot":"","sources":["../../src/sdk/gaslight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EAaZ,MAAM,0BAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.260",
+  "version": "3.0.261",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,4 +1,4 @@
 export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig, parseGaslightConfig } from "./config.js";
 export { ingestGaslight } from "./ingest.js";
 export { runGaslight } from "./run.js";
-export type { GaslightConfig, GaslightCollectHumanPrompts, GaslightEvent, GaslightFileSystem, GaslightIngestEvent, GaslightIngestOptions, GaslightIngestResult, GaslightOptions, GaslightResult, GaslightRound, GaslightSpawn } from "./types.js";
+export type { GaslightConfig, GaslightCollectHumanPrompts, GaslightEvent, GaslightFileSystem, GaslightIngestEvent, GaslightIngestOptions, GaslightIngestResult, GaslightOptions, GaslightPlanResult, GaslightResult, GaslightRound, GaslightSpawn } from "./types.js";

package/packages/agent-gaslight/dist/run.js

@@ -45,46 +45,92 @@ function validateInlineConfig(prompt, followups) {
         throw new Error("followups must be a non-empty array of non-empty strings.");
     }
 }
+function resolvePlanPaths(options) {
+    if (options.planPaths.length === 0) {
+        throw new Error("Provide at least one plan path.");
+    }
+    for (const planPath of options.planPaths) {
+        if (planPath.trim().length === 0) {
+            throw new Error("plan paths must be non-empty strings.");
+        }
+    }
+    return options.planPaths.map((planPath) => planPath.trim());
+}
 export async function runGaslight(options) {
     const cwd = options.cwd ?? process.cwd();
     const homeDir = options.homeDir ?? os.homedir();
     const fs = options.fs ?? nodeFs;
     const spawn = options.spawn ?? defaultSpawn;
     validateInlineConfig(options.prompt, options.followups);
-    await requirePlan(fs, cwd, options.planPath);
+    const planPaths = resolvePlanPaths(options);
+    for (const planPath of planPaths) {
+        await requirePlan(fs, cwd, planPath);
+    }
     const config = options.prompt !== undefined && options.followups !== undefined
         ? { prompt: options.prompt.trim(), followups: options.followups.map((value) => value.trim()) }
         : await loadGaslightConfig(cwd, homeDir, fs, options.configPath);
-    const prompts = [`${config.prompt} ${options.planPath}`, ...config.followups];
     const rounds = [];
+    const plans = [];
     let usage;
-    let resumeThreadId;
-    for (const [index, prompt] of prompts.entries()) {
-        const round = index + 1;
-        options.onEvent?.({ type: "round.started", round, total: prompts.length, prompt });
-        const result = await spawn(options.agent, {
-            prompt,
-            cwd,
-            mode: options.mode ?? "edit",
-            ...(options.model ? { model: options.model } : {}),
-            ...(resumeThreadId ? { resumeThreadId } : {}),
-            ...(options.signal ? { signal: options.signal } : {})
-        });
-        if (result.exitCode !== 0) {
-            const completed = rounds.length;
-            const noun = completed === 1 ? "round" : "rounds";
-            throw new Error(`Gaslight round ${round} failed after ${completed} completed ${noun}: ${summarize(result.stderr, result.stdout) || `exit code ${result.exitCode}`}`);
-        }
-        const summary = summarize(result.stdout, result.stderr);
-        rounds.push({ prompt, summary, ...(result.threadId ? { threadId: result.threadId } : {}) });
-        usage = addUsage(usage, result.usage);
-        options.onEvent?.({ type: "round.finished", round, total: prompts.length, summary });
-        if (round < prompts.length) {
-            if (!result.threadId) {
-                throw new Error("agent returned no threadId; cannot resume the conversation");
+    for (const [planIndex, planPath] of planPaths.entries()) {
+        const prompts = [`${config.prompt} ${planPath}`, ...config.followups];
+        const planRounds = [];
+        let planUsage;
+        let resumeThreadId;
+        for (const [index, prompt] of prompts.entries()) {
+            const round = index + 1;
+            options.onEvent?.({
+                type: "round.started",
+                round,
+                total: prompts.length,
+                prompt,
+                planPath,
+                planIndex: planIndex + 1,
+                totalPlans: planPaths.length
+            });
+            const result = await spawn(options.agent, {
+                prompt,
+                cwd,
+                mode: options.mode ?? "edit",
+                ...(options.model ? { model: options.model } : {}),
+                ...(resumeThreadId ? { resumeThreadId } : {}),
+                ...(options.signal ? { signal: options.signal } : {})
+            });
+            if (result.exitCode !== 0) {
+                const completed = planRounds.length;
+                const noun = completed === 1 ? "round" : "rounds";
+                const prefix = planPaths.length === 1
+                    ? `Gaslight round ${round}`
+                    : `Gaslight plan ${planIndex + 1}/${planPaths.length} (${planPath}) round ${round}`;
+                throw new Error(`${prefix} failed after ${completed} completed ${noun}: ${summarize(result.stderr, result.stdout) || `exit code ${result.exitCode}`}`);
+            }
+            const summary = summarize(result.stdout, result.stderr);
+            const gaslightRound = {
+                prompt,
+                summary,
+                ...(result.threadId ? { threadId: result.threadId } : {})
+            };
+            planRounds.push(gaslightRound);
+            rounds.push(gaslightRound);
+            planUsage = addUsage(planUsage, result.usage);
+            usage = addUsage(usage, result.usage);
+            options.onEvent?.({
+                type: "round.finished",
+                round,
+                total: prompts.length,
+                summary,
+                planPath,
+                planIndex: planIndex + 1,
+                totalPlans: planPaths.length
+            });
+            if (round < prompts.length) {
+                if (!result.threadId) {
+                    throw new Error("agent returned no threadId; cannot resume the conversation");
+                }
+                resumeThreadId = result.threadId;
             }
-            resumeThreadId = result.threadId;
         }
+        plans.push({ planPath, rounds: planRounds, ...(planUsage ? { usage: planUsage } : {}) });
     }
-    return { rounds, ...(usage ? { usage } : {}) };
+    return { rounds, plans, ...(usage ? { usage } : {}) };
 }

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

@@ -7,11 +7,17 @@ export type GaslightEvent = {
     round: number;
     total: number;
     prompt: string;
+    planPath: string;
+    planIndex: number;
+    totalPlans: number;
 } | {
     type: "round.finished";
     round: number;
     total: number;
     summary: string;
+    planPath: string;
+    planIndex: number;
+    totalPlans: number;
 };
 export interface GaslightRound {
     prompt: string;
@@ -20,10 +26,16 @@ export interface GaslightRound {
 }
 export interface GaslightResult {
     rounds: GaslightRound[];
+    plans: GaslightPlanResult[];
     usage?: SpawnUsage;
 }
-export interface GaslightOptions {
+export interface GaslightPlanResult {
     planPath: string;
+    rounds: GaslightRound[];
+    usage?: SpawnUsage;
+}
+export interface GaslightOptions {
+    planPaths: string[];
     agent: string;
     model?: string;
     mode?: Exclude<SpawnMode, "auto">;

package/packages/toolcraft-openapi/dist/generate.js

@@ -43,6 +43,15 @@ const TRANSPORT_PARAMS = [
         definition: { kind: "boolean" }
     }
 ];
+const BINARY_OUTPUT_PARAM = {
+    paramName: "output",
+    sourceName: "output",
+    location: "transport",
+    description: "Write a binary response body to this local file path.",
+    scope: ["cli"],
+    optional: true,
+    definition: { kind: "string" }
+};
 const SCHEMA_OPTION_SOURCES = [
     {
         key: "description",
@@ -176,7 +185,7 @@ function createGeneratedCommand(document, entry) {
     const response = resolveSuccessResponse(document, operation, operationId);
     const noun = createSafeGeneratedNoun(deriveNoun(operation, entry.path, operationId));
     const verb = deriveVerb(entry.method, entry.path, operation, operationId, noun);
-    const collected = collectParams(document, entry, operation, operationId, auth);
+    const collected = collectParams(document, entry, operation, operationId, auth, response.mode);
     const methodDefaults = METHOD_DEFAULTS[entry.method];
     const exportName = `${toCamelCase(noun)}${toPascalCase(verb)}Command`;
     const filePath = `${noun}/${verb}.ts`;
@@ -220,11 +229,12 @@ function resolveOperationBaseUrl(operation, operationId) {
         throw new UserError(`Operation ${JSON.stringify(operationId)} defines invalid per-operation server URL ${JSON.stringify(server.url)}.`);
     }
 }
-function collectParams(document, entry, operation, operationId, auth) {
+function collectParams(document, entry, operation, operationId, auth, responseMode) {
+    const transportParams = responseMode === "binary" ? [...TRANSPORT_PARAMS, BINARY_OUTPUT_PARAM] : TRANSPORT_PARAMS;
     const operationParams = collectOperationParameters(document, entry.path, entry.pathItem.parameters ?? [], operation.parameters ?? [], operationId, auth);
     const requestBodyParams = collectRequestBodyParams(document, operation, operationId, entry.method);
-    const qualifiedRequestBodyParams = qualifyBodyParamCollisions(requestBodyParams, new Set([...operationParams.params, ...TRANSPORT_PARAMS].map((param) => param.paramName)));
-    const params = [...operationParams.params, ...qualifiedRequestBodyParams.params, ...TRANSPORT_PARAMS];
+    const qualifiedRequestBodyParams = qualifyBodyParamCollisions(requestBodyParams, new Set([...operationParams.params, ...transportParams].map((param) => param.paramName)));
+    const params = [...operationParams.params, ...qualifiedRequestBodyParams.params, ...transportParams];
     const deduped = new Map();
     for (const param of params) {
         const existing = deduped.get(param.paramName);
@@ -1284,13 +1294,24 @@ function applyDisambiguatedVerbs(candidates, existingPaths) {
 }
 function createCommandFile(options) {
     const requiresUserError = options.preflightBlocks.length > 0;
+    const usesMultipartFileInputs = options.bodyMode === "multipart" &&
+        options.multipartBinaryFields !== undefined &&
+        options.multipartBinaryFields.length > 0;
+    const usesBinaryOutput = options.responseMode === "binary";
+    const usesRequestShapeVariable = usesMultipartFileInputs || usesBinaryOutput;
+    const openApiImports = [
+        "requestJson",
+        "defineApiCommand",
+        ...(usesMultipartFileInputs ? ["prepareMultipartFileInputs"] : []),
+        ...(usesBinaryOutput ? ["writeBinaryResponseOutput"] : [])
+    ];
     const lines = createGeneratedTypeScriptFileLines([
         `spec-sha: ${options.specSha}`,
         `operation-id: ${options.operationId}`
     ]);
     lines.push(requiresUserError
         ? 'import { S, UserError } from "toolcraft";'
-        : 'import { S } from "toolcraft";', 'import { requestJson, defineApiCommand } from "toolcraft-openapi";', "", `export const ${options.exportName} = defineApiCommand({`, `  name: ${JSON.stringify(options.verb)},`);
+        : 'import { S } from "toolcraft";', `import { ${openApiImports.join(", ")} } from "toolcraft-openapi";`, "", `export const ${options.exportName} = defineApiCommand({`, `  name: ${JSON.stringify(options.verb)},`);
     if (options.description !== undefined) {
         lines.push(`  description: ${JSON.stringify(options.description)},`);
     }
@@ -1303,9 +1324,30 @@ function createCommandFile(options) {
     lines.push(options.paramsSchemaOptions?.additionalProperties === false
         ? "  }, { additionalProperties: false }),"
         : "  }),");
-    lines.push("  handler: async ({ params, baseUrl, tokenSource, fetch }) => {");
+    lines.push(usesRequestShapeVariable
+        ? "  handler: async ({ params, baseUrl, tokenSource, fetch, fs, env }) => {"
+        : "  handler: async ({ params, baseUrl, tokenSource, fetch }) => {");
     lines.push(...options.preflightBlocks.flatMap((block) => renderPreflightBlock(block)));
-    lines.push("    return requestJson({");
+    if (usesRequestShapeVariable) {
+        lines.push("    const requestShape = {");
+        lines.push(...renderRequestShape(options.requestFields, options.sectionRenders, options.optionalSections));
+        lines.push("    };");
+        if (usesMultipartFileInputs) {
+            lines.push("    const preparedRequestShape = await prepareMultipartFileInputs(requestShape, {");
+            lines.push('      bodyMode: "multipart",');
+            lines.push(`      multipartBinaryFields: ${JSON.stringify(options.multipartBinaryFields)},`);
+            lines.push("      fs,");
+            lines.push("      env,");
+            lines.push("    });");
+        }
+        else {
+            lines.push("    const preparedRequestShape = requestShape;");
+        }
+        lines.push("    const result = await requestJson({");
+    }
+    else {
+        lines.push("    return requestJson({");
+    }
     lines.push(options.baseUrl === undefined
         ? "      baseUrl,"
         : `      baseUrl: ${JSON.stringify(options.baseUrl)},`);
@@ -1340,8 +1382,16 @@ function createCommandFile(options) {
     lines.push("      fetch,");
     lines.push("      dryRun: params.dryRun,");
     lines.push("      verbose: params.verbose,");
-    lines.push(...renderRequestShape(options.requestFields, options.sectionRenders, options.optionalSections));
+    if (usesRequestShapeVariable) {
+        lines.push("      ...preparedRequestShape,");
+    }
+    else {
+        lines.push(...renderRequestShape(options.requestFields, options.sectionRenders, options.optionalSections));
+    }
     lines.push("    });");
+    if (usesBinaryOutput) {
+        lines.push("    return writeBinaryResponseOutput(result, params.output, { fs, env });");
+    }
     lines.push("  },");
     lines.push("});");
     lines.push("");

package/packages/toolcraft-openapi/dist/http.d.ts

@@ -1,3 +1,4 @@
+import { type HandlerEnv, type HandlerFs } from "../../toolcraft/dist/index.js";
 import type { TokenSource } from "./auth/types.js";
 type QueryScalar = string | number | boolean | null | undefined;
 type QueryObject = {
@@ -45,6 +46,9 @@ export interface BinaryHttpResponse {
     byteLength: number;
     data: string;
 }
+type RuntimeFileSystem = Pick<HandlerFs, "exists" | "readFile" | "writeFile">;
+type RuntimeEnvironment = Pick<HandlerEnv, "get">;
+type RequestShape = Partial<Pick<HttpRequestOptions, "pathParams" | "query" | "headers" | "body">>;
 export declare class HttpError extends Error {
     readonly status: number;
     readonly statusText: string;
@@ -58,4 +62,14 @@ export declare class HttpError extends Error {
     });
 }
 export declare function requestJson<TResult = unknown>(options: HttpRequestOptions): Promise<TResult | undefined>;
+export declare function prepareMultipartFileInputs(requestShape: RequestShape, options: {
+    bodyMode?: HttpRequestOptions["bodyMode"];
+    multipartBinaryFields?: readonly string[];
+    fs?: RuntimeFileSystem;
+    env?: RuntimeEnvironment;
+}): Promise<RequestShape>;
+export declare function writeBinaryResponseOutput(result: unknown, outputPath: unknown, runtime: {
+    fs?: RuntimeFileSystem;
+    env?: RuntimeEnvironment;
+}): Promise<unknown>;
 export {};

package/packages/toolcraft-openapi/dist/http.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { text as designText } from "toolcraft-design";
 import { UserError } from "toolcraft";
 import { classifyNetworkError } from "./network-error.js";
@@ -152,6 +153,58 @@ export async function requestJson(options) {
         }
     });
 }
+export async function prepareMultipartFileInputs(requestShape, options) {
+    if (options.bodyMode !== "multipart" ||
+        options.multipartBinaryFields === undefined ||
+        options.multipartBinaryFields.length === 0 ||
+        options.fs === undefined ||
+        options.env === undefined ||
+        requestShape.body === undefined) {
+        return requestShape;
+    }
+    if (requestShape.body === null ||
+        typeof requestShape.body !== "object" ||
+        Array.isArray(requestShape.body)) {
+        return requestShape;
+    }
+    const body = { ...requestShape.body };
+    for (const field of options.multipartBinaryFields) {
+        const value = body[field];
+        if (typeof value !== "string") {
+            continue;
+        }
+        const filePath = resolveUserPath(value, options.env);
+        if (!(await options.fs.exists(filePath))) {
+            continue;
+        }
+        body[field] = {
+            data: await options.fs.readFile(filePath, "base64"),
+            filename: path.basename(filePath) || field
+        };
+    }
+    return {
+        ...requestShape,
+        body
+    };
+}
+export async function writeBinaryResponseOutput(result, outputPath, runtime) {
+    if (outputPath === undefined) {
+        return result;
+    }
+    if (runtime.fs === undefined || runtime.env === undefined) {
+        throw new UserError("Cannot write binary output without a Toolcraft file runtime.");
+    }
+    if (!isBinaryHttpResponse(result)) {
+        throw new UserError("Cannot write an empty binary response to an output path.");
+    }
+    const resolvedOutputPath = resolveUserPath(String(outputPath), runtime.env);
+    await runtime.fs.writeFile(resolvedOutputPath, result.data, { encoding: "base64" });
+    return {
+        output: resolvedOutputPath,
+        byteLength: result.byteLength,
+        contentType: result.contentType
+    };
+}
 function buildRequestUrl(options) {
     const resolvedPath = substitutePathParams(options.path, options.pathParams);
     const baseUrl = new URL(options.baseUrl);
@@ -223,6 +276,22 @@ function decodeBase64Body(body) {
     }
     return Uint8Array.from(Buffer.from(body, "base64")).buffer;
 }
+function decodeMultipartBinaryValue(value, fallbackFilename) {
+    if (typeof value === "string") {
+        return {
+            data: value,
+            filename: fallbackFilename
+        };
+    }
+    if (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof value.data === "string" &&
+        typeof value.filename === "string") {
+        return value;
+    }
+    throw new UserError("Multipart binary request fields must be base64 strings or resolved file inputs.");
+}
 function serializeMultipartBody(body, binaryFields = []) {
     if (body === null || typeof body !== "object" || Array.isArray(body)) {
         throw new UserError("Multipart request bodies must be objects.");
@@ -233,7 +302,8 @@ function serializeMultipartBody(body, binaryFields = []) {
         if (value === undefined)
             continue;
         if (binary.has(key)) {
-            form.append(key, new Blob([decodeBase64Body(value)]), key);
+            const file = decodeMultipartBinaryValue(value, key);
+            form.append(key, new Blob([decodeBase64Body(file.data)]), file.filename);
         }
         else if (Array.isArray(value)) {
             for (const item of value)
@@ -245,6 +315,20 @@ function serializeMultipartBody(body, binaryFields = []) {
     }
     return form;
 }
+function resolveUserPath(userPath, env) {
+    if (path.isAbsolute(userPath)) {
+        return path.normalize(userPath);
+    }
+    return path.resolve(env.get("INIT_CWD") ?? process.cwd(), userPath);
+}
+function isBinaryHttpResponse(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.encoding === "base64" &&
+        typeof value.data === "string" &&
+        typeof value.byteLength === "number" &&
+        typeof value.contentType === "string");
+}
 function isQueryObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/packages/toolcraft-openapi/dist/index.d.ts

@@ -13,5 +13,5 @@ export type { DefineClientOptions, DefinedClient, OpenApiClientServices } from "
 export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export type { BearerTokenAuthOptions } from "./auth/bearer-token-auth.js";
-export { HttpError, requestJson } from "./http.js";
+export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
 export type { BinaryHttpResponse, HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";

package/packages/toolcraft-openapi/dist/index.js

@@ -6,4 +6,4 @@ export { inspectOpenApiSource } from "./inspect-source.js";
 export { renderOpenApiInspection } from "./render-inspection.js";
 export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
-export { HttpError, requestJson } from "./http.js";
+export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";

package/packages/toolcraft-openapi/dist/runtime.js

@@ -3,7 +3,7 @@ import { defineCommand, defineGroup, S } from "toolcraft";
 import { defineClient } from "./define-client.js";
 import { collectSchemaOptionEntries, collectGeneratedCommands } from "./generate.js";
 import { groupByNoun } from "./group-by-noun.js";
-import { requestJson } from "./http.js";
+import { prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
 import { buildRequestShape, executePreflightBlocks } from "./interpreter.js";
 import { parseOpenApiDocument, readOpenApiSourceText } from "./spec-source.js";
 const RUNTIME_COMMAND_SCOPE = ["cli", "mcp", "sdk"];
@@ -49,10 +49,16 @@ function createRuntimeCommand(command) {
     });
 }
 function createRuntimeHandler(command) {
-    return async ({ params, baseUrl, tokenSource, fetch }) => {
+    return async ({ params, baseUrl, tokenSource, fetch, fs, env }) => {
         const resolvedValues = executePreflightBlocks(command.preflightBlocks, params);
         const requestShape = buildRequestShape(command.requestFields, command.sectionRenders, command.optionalSections, params, resolvedValues);
-        return requestJson({
+        const preparedRequestShape = await prepareMultipartFileInputs(requestShape, {
+            bodyMode: command.bodyMode,
+            multipartBinaryFields: command.multipartBinaryFields,
+            fs,
+            env
+        });
+        const result = await requestJson({
             baseUrl: command.baseUrl ?? baseUrl,
             path: command.path,
             method: command.method,
@@ -66,8 +72,9 @@ function createRuntimeHandler(command) {
             fetch,
             dryRun: params.dryRun,
             verbose: params.verbose,
-            ...requestShape
+            ...preparedRequestShape
         });
+        return writeBinaryResponseOutput(result, command.responseMode === "binary" ? params.output : undefined, { fs, env });
     };
 }
 function createRuntimeParamSchema(param) {