@psnext/slingcli 2.4.20260520-2 → 2.4.20260520-4

package/node_modules/@earendil-works/pi-agent-core/dist/harness/compaction/utils.js

@@ -1,6 +1,4 @@
-/**
- * Shared utilities for compaction and branch summarization.
- */
+/** Create an empty file-operation accumulator. */
 export function createFileOps() {
     return {
         read: new Set(),
@@ -8,9 +6,7 @@ export function createFileOps() {
         edited: new Set(),
     };
 }
-/**
- * Extract file operations from tool calls in an assistant message.
- */
+/** Add file operations from assistant tool calls to an accumulator. */
 export function extractFileOpsFromMessage(message, fileOps) {
     if (message.role !== "assistant")
         return;
@@ -42,19 +38,14 @@ export function extractFileOpsFromMessage(message, fileOps) {
         }
     }
 }
-/**
- * Compute final file lists from file operations.
- * Returns readFiles (files only read, not modified) and modifiedFiles.
- */
+/** Compute sorted read-only and modified file lists from accumulated operations. */
 export function computeFileLists(fileOps) {
     const modified = new Set([...fileOps.edited, ...fileOps.written]);
     const readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort();
     const modifiedFiles = [...modified].sort();
     return { readFiles: readOnly, modifiedFiles };
 }
-/**
- * Format file operations as XML tags for summary.
- */
+/** Format file lists as summary metadata tags. */
 export function formatFileOperations(readFiles, modifiedFiles) {
     const sections = [];
     if (readFiles.length > 0) {
@@ -67,29 +58,22 @@ export function formatFileOperations(readFiles, modifiedFiles) {
         return "";
     return `\n\n${sections.join("\n\n")}`;
 }
-// ============================================================================
-// Message Serialization
-// ============================================================================
-/** Maximum characters for a tool result in serialized summaries. */
 const TOOL_RESULT_MAX_CHARS = 2000;
-/**
- * Truncate text to a maximum character length for summarization.
- * Keeps the beginning and appends a truncation marker.
- */
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
 function truncateForSummary(text, maxChars) {
     if (text.length <= maxChars)
         return text;
     const truncatedChars = text.length - maxChars;
     return `${text.slice(0, maxChars)}\n\n[... ${truncatedChars} more characters truncated]`;
 }
-/**
- * Serialize LLM messages to text for summarization.
- * This prevents the model from treating it as a conversation to continue.
- * Call convertToLlm() first to handle custom message types.
- *
- * Tool results are truncated to keep the summarization request within
- * reasonable token budgets. Full content is not needed for summarization.
- */
+/** Serialize LLM messages to plain text for summarization prompts. */
 export function serializeConversation(messages) {
     const parts = [];
     for (const msg of messages) {
@@ -117,7 +101,7 @@ export function serializeConversation(messages) {
                 else if (block.type === "toolCall") {
                     const args = block.arguments;
                     const argsStr = Object.entries(args)
-                        .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+                        .map(([k, v]) => `${k}=${safeJsonStringify(v)}`)
                         .join(", ");
                     toolCalls.push(`${block.name}(${argsStr})`);
                 }
@@ -144,10 +128,4 @@ export function serializeConversation(messages) {
     }
     return parts.join("\n\n");
 }
-// ============================================================================
-// Summarization System Prompt
-// ============================================================================
-export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
-
-Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
 //# sourceMappingURL=utils.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/env/nodejs.js

@@ -1,10 +1,11 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { access, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { constants, createReadStream } from "node:fs";
+import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { FileError } from "../types.js";
+import { createInterface } from "node:readline";
+import { ExecutionError, err, FileError, ok, toError, } from "../types.js";
 function resolvePath(cwd, path) {
     return isAbsolute(path) ? path : resolve(cwd, path);
 }
@@ -15,16 +16,19 @@ function fileKindFromStats(stats) {
         return "directory";
     if (stats.isSymbolicLink())
         return "symlink";
-    throw new FileError("invalid", "Unsupported file type");
+    return undefined;
 }
 function fileInfoFromStats(path, stats) {
-    return {
+    const kind = fileKindFromStats(stats);
+    if (!kind)
+        return err(new FileError("invalid", "Unsupported file type", path));
+    return ok({
         name: path.replace(/\/+$/, "").split("/").pop() ?? path,
         path,
-        kind: fileKindFromStats(stats),
+        kind,
         size: stats.size,
         mtimeMs: stats.mtimeMs,
-    };
+    });
 }
 function isNodeError(error) {
     return error instanceof Error && "code" in error;
@@ -32,23 +36,29 @@ function isNodeError(error) {
 function toFileError(error, path) {
     if (error instanceof FileError)
         return error;
+    const cause = toError(error);
     if (isNodeError(error)) {
         const message = error.message;
         switch (error.code) {
+            case "ABORT_ERR":
+                return new FileError("aborted", message, path, cause);
             case "ENOENT":
-                return new FileError("not_found", message, path, { cause: error });
+                return new FileError("not_found", message, path, cause);
             case "EACCES":
             case "EPERM":
-                return new FileError("permission_denied", message, path, { cause: error });
+                return new FileError("permission_denied", message, path, cause);
             case "ENOTDIR":
-                return new FileError("not_directory", message, path, { cause: error });
+                return new FileError("not_directory", message, path, cause);
             case "EISDIR":
-                return new FileError("is_directory", message, path, { cause: error });
+                return new FileError("is_directory", message, path, cause);
             case "EINVAL":
-                return new FileError("invalid", message, path, { cause: error });
+                return new FileError("invalid", message, path, cause);
         }
     }
-    return new FileError("unknown", error instanceof Error ? error.message : String(error), path, { cause: error });
+    return new FileError("unknown", cause.message, path, cause);
+}
+function abortResult(signal, path) {
+    return signal?.aborted ? err(new FileError("aborted", "aborted", path)) : undefined;
 }
 async function pathExists(path) {
     try {
@@ -62,7 +72,17 @@ async function pathExists(path) {
 async function runCommand(command, args, timeoutMs) {
     return await new Promise((resolve) => {
         let stdout = "";
-        const child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+        let child;
+        try {
+            child = spawn(command, args, {
+                stdio: ["ignore", "pipe", "ignore"],
+                windowsHide: true,
+            });
+        }
+        catch {
+            resolve({ stdout: "", status: null });
+            return;
+        }
         const timeout = setTimeout(() => {
             if (child.pid)
                 killProcessTree(child.pid);
@@ -93,9 +113,9 @@ async function findBashOnPath() {
 async function getShellConfig(customShellPath) {
     if (customShellPath) {
         if (await pathExists(customShellPath)) {
-            return { shell: customShellPath, args: ["-c"] };
+            return ok({ shell: customShellPath, args: ["-c"] });
         }
-        throw new Error(`Custom shell path not found: ${customShellPath}`);
+        return err(new ExecutionError("shell_unavailable", `Custom shell path not found: ${customShellPath}`));
     }
     if (process.platform === "win32") {
         const candidates = [];
@@ -107,23 +127,23 @@ async function getShellConfig(customShellPath) {
             candidates.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
         for (const candidate of candidates) {
             if (await pathExists(candidate)) {
-                return { shell: candidate, args: ["-c"] };
+                return ok({ shell: candidate, args: ["-c"] });
             }
         }
         const bashOnPath = await findBashOnPath();
         if (bashOnPath) {
-            return { shell: bashOnPath, args: ["-c"] };
+            return ok({ shell: bashOnPath, args: ["-c"] });
         }
-        throw new Error("No bash shell found");
+        return err(new ExecutionError("shell_unavailable", "No bash shell found"));
     }
     if (await pathExists("/bin/bash")) {
-        return { shell: "/bin/bash", args: ["-c"] };
+        return ok({ shell: "/bin/bash", args: ["-c"] });
     }
     const bashOnPath = await findBashOnPath();
     if (bashOnPath) {
-        return { shell: bashOnPath, args: ["-c"] };
+        return ok({ shell: bashOnPath, args: ["-c"] });
     }
-    return { shell: "sh", args: ["-c"] };
+    return ok({ shell: "sh", args: ["-c"] });
 }
 function getShellEnv(baseEnv, extraEnv) {
     return {
@@ -138,6 +158,7 @@ function killProcessTree(pid) {
             spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
                 stdio: "ignore",
                 detached: true,
+                windowsHide: true,
             });
         }
         catch {
@@ -166,107 +187,201 @@ export class NodeExecutionEnv {
         this.shellPath = options.shellPath;
         this.shellEnv = options.shellEnv;
     }
+    async absolutePath(path) {
+        return ok(resolvePath(this.cwd, path));
+    }
+    async joinPath(parts) {
+        return ok(join(...parts));
+    }
     async exec(command, options) {
+        if (options?.abortSignal?.aborted)
+            return err(new ExecutionError("aborted", "aborted"));
         const cwd = options?.cwd ? resolvePath(this.cwd, options.cwd) : this.cwd;
-        const { shell, args } = await getShellConfig(this.shellPath);
-        return await new Promise((resolvePromise, reject) => {
+        const shellConfig = await getShellConfig(this.shellPath);
+        if (!shellConfig.ok)
+            return shellConfig;
+        return await new Promise((resolvePromise) => {
             let stdout = "";
             let stderr = "";
             let settled = false;
             let timedOut = false;
-            const child = spawn(shell, [...args, command], {
-                cwd,
-                detached: process.platform !== "win32",
-                env: getShellEnv(this.shellEnv, options?.env),
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            const timeoutId = typeof options?.timeout === "number"
-                ? setTimeout(() => {
-                    timedOut = true;
-                    if (child.pid) {
-                        killProcessTree(child.pid);
-                    }
-                }, options.timeout * 1000)
-                : undefined;
+            let callbackError;
+            let child;
+            let timeoutId;
             const onAbort = () => {
-                if (child.pid) {
+                if (child?.pid) {
                     killProcessTree(child.pid);
                 }
             };
-            if (options?.signal) {
-                if (options.signal.aborted) {
+            const settle = (result) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (options?.abortSignal)
+                    options.abortSignal.removeEventListener("abort", onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                resolvePromise(result);
+            };
+            try {
+                child = spawn(shellConfig.value.shell, [...shellConfig.value.args, command], {
+                    cwd,
+                    detached: process.platform !== "win32",
+                    env: getShellEnv(this.shellEnv, options?.env),
+                    stdio: ["ignore", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                const cause = toError(error);
+                settle(err(new ExecutionError("spawn_error", cause.message, cause)));
+                return;
+            }
+            timeoutId =
+                typeof options?.timeout === "number"
+                    ? setTimeout(() => {
+                        timedOut = true;
+                        if (child?.pid) {
+                            killProcessTree(child.pid);
+                        }
+                    }, options.timeout * 1000)
+                    : undefined;
+            if (options?.abortSignal) {
+                if (options.abortSignal.aborted) {
                     onAbort();
                 }
                 else {
-                    options.signal.addEventListener("abort", onAbort, { once: true });
+                    options.abortSignal.addEventListener("abort", onAbort, { once: true });
                 }
             }
             child.stdout?.setEncoding("utf8");
             child.stderr?.setEncoding("utf8");
             child.stdout?.on("data", (chunk) => {
                 stdout += chunk;
-                options?.onStdout?.(chunk);
+                try {
+                    options?.onStdout?.(chunk);
+                }
+                catch (error) {
+                    const cause = toError(error);
+                    callbackError = new ExecutionError("callback_error", cause.message, cause);
+                    onAbort();
+                }
             });
             child.stderr?.on("data", (chunk) => {
                 stderr += chunk;
-                options?.onStderr?.(chunk);
+                try {
+                    options?.onStderr?.(chunk);
+                }
+                catch (error) {
+                    const cause = toError(error);
+                    callbackError = new ExecutionError("callback_error", cause.message, cause);
+                    onAbort();
+                }
             });
             child.on("error", (error) => {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-                if (options?.signal)
-                    options.signal.removeEventListener("abort", onAbort);
-                if (settled)
-                    return;
-                settled = true;
-                reject(error);
+                settle(err(new ExecutionError("spawn_error", error.message, error)));
             });
             child.on("close", (code) => {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-                if (options?.signal)
-                    options.signal.removeEventListener("abort", onAbort);
-                if (settled)
-                    return;
-                settled = true;
-                if (options?.signal?.aborted) {
-                    reject(new Error("aborted"));
+                if (callbackError) {
+                    settle(err(callbackError));
                     return;
                 }
                 if (timedOut) {
-                    reject(new Error(`timeout:${options?.timeout}`));
+                    settle(err(new ExecutionError("timeout", `timeout:${options?.timeout}`)));
                     return;
                 }
-                resolvePromise({ stdout, stderr, exitCode: code ?? 0 });
+                if (options?.abortSignal?.aborted) {
+                    settle(err(new ExecutionError("aborted", "aborted")));
+                    return;
+                }
+                settle(ok({ stdout, stderr, exitCode: code ?? 0 }));
             });
         });
     }
-    async readTextFile(path) {
+    async readTextFile(path, abortSignal) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        try {
+            return ok(await readFile(resolved, { encoding: "utf8", signal: abortSignal }));
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async readTextLines(path, options) {
         const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(options?.abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        if (options?.maxLines !== undefined && options.maxLines <= 0)
+            return ok([]);
+        let stream;
+        let lineReader;
         try {
-            return await readFile(resolved, "utf8");
+            stream = createReadStream(resolved, { encoding: "utf8", signal: options?.abortSignal });
+            lineReader = createInterface({ input: stream, crlfDelay: Infinity });
+            const lines = [];
+            for await (const line of lineReader) {
+                const loopAbort = abortResult(options?.abortSignal, resolved);
+                if (loopAbort)
+                    return loopAbort;
+                lines.push(line);
+                if (options?.maxLines !== undefined && lines.length >= options.maxLines)
+                    break;
+            }
+            const afterReadAbort = abortResult(options?.abortSignal, resolved);
+            if (afterReadAbort)
+                return afterReadAbort;
+            return ok(lines);
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
+        }
+        finally {
+            lineReader?.close();
+            stream?.destroy();
         }
     }
-    async readBinaryFile(path) {
+    async readBinaryFile(path, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
         try {
-            return await readFile(resolved);
+            return ok(await readFile(resolved, { signal: abortSignal }));
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
         }
     }
-    async writeFile(path, content) {
+    async writeFile(path, content, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
         try {
             await mkdir(resolve(resolved, ".."), { recursive: true });
-            await writeFile(resolved, content);
+            const afterMkdirAbort = abortResult(abortSignal, resolved);
+            if (afterMkdirAbort)
+                return afterMkdirAbort;
+            await writeFile(resolved, content, { signal: abortSignal });
+            return ok(undefined);
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
+        }
+    }
+    async appendFile(path, content) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            await mkdir(resolve(resolved, ".."), { recursive: true });
+            await appendFile(resolved, content);
+            return ok(undefined);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
         }
     }
     async fileInfo(path) {
@@ -275,71 +390,94 @@ export class NodeExecutionEnv {
             return fileInfoFromStats(resolved, await lstat(resolved));
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
         }
     }
-    async listDir(path) {
+    async listDir(path, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
         try {
             const entries = await readdir(resolved, { withFileTypes: true });
             const infos = [];
             for (const entry of entries) {
+                const loopAbort = abortResult(abortSignal, resolved);
+                if (loopAbort)
+                    return loopAbort;
                 const entryPath = resolve(resolved, entry.name);
                 try {
-                    infos.push(fileInfoFromStats(entryPath, await lstat(entryPath)));
+                    const info = fileInfoFromStats(entryPath, await lstat(entryPath));
+                    if (info.ok)
+                        infos.push(info.value);
                 }
                 catch (error) {
-                    if (error instanceof FileError && error.code === "invalid")
-                        continue;
-                    throw error;
+                    return err(toFileError(error, entryPath));
                 }
             }
-            return infos;
+            return ok(infos);
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
         }
     }
-    async realPath(path) {
+    async canonicalPath(path) {
         const resolved = resolvePath(this.cwd, path);
         try {
-            return await realpath(resolved);
+            return ok(await realpath(resolved));
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
         }
     }
     async exists(path) {
+        const result = await this.fileInfo(path);
+        if (result.ok)
+            return ok(true);
+        if (result.error.code === "not_found")
+            return ok(false);
+        return err(result.error);
+    }
+    async createDir(path, options) {
+        const resolved = resolvePath(this.cwd, path);
         try {
-            await this.fileInfo(path);
-            return true;
+            await mkdir(resolved, { recursive: options?.recursive ?? true });
+            return ok(undefined);
         }
         catch (error) {
-            if (error instanceof FileError && error.code === "not_found")
-                return false;
-            throw error;
+            return err(toFileError(error, resolved));
         }
     }
-    async createDir(path, options) {
-        await mkdir(resolvePath(this.cwd, path), { recursive: options?.recursive });
-    }
     async remove(path, options) {
         const resolved = resolvePath(this.cwd, path);
         try {
             await rm(resolved, { recursive: options?.recursive ?? false, force: options?.force ?? false });
+            return ok(undefined);
         }
         catch (error) {
-            throw toFileError(error, resolved);
+            return err(toFileError(error, resolved));
         }
     }
     async createTempDir(prefix = "tmp-") {
-        return await mkdtemp(join(tmpdir(), prefix));
+        try {
+            return ok(await mkdtemp(join(tmpdir(), prefix)));
+        }
+        catch (error) {
+            return err(toFileError(error));
+        }
     }
     async createTempFile(options) {
         const dir = await this.createTempDir("tmp-");
-        const filePath = join(dir, `${options?.prefix ?? ""}${randomUUID()}${options?.suffix ?? ""}`);
-        await writeFile(filePath, "");
-        return filePath;
+        if (!dir.ok)
+            return dir;
+        const filePath = join(dir.value, `${options?.prefix ?? ""}${randomUUID()}${options?.suffix ?? ""}`);
+        try {
+            await writeFile(filePath, "");
+            return ok(filePath);
+        }
+        catch (error) {
+            return err(toFileError(error, filePath));
+        }
     }
     async cleanup() {
         // nothing to clean up for the local node implementation