@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-2

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

@@ -0,0 +1,348 @@
+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 { tmpdir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { FileError } from "../types.js";
+function resolvePath(cwd, path) {
+    return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function fileKindFromStats(stats) {
+    if (stats.isFile())
+        return "file";
+    if (stats.isDirectory())
+        return "directory";
+    if (stats.isSymbolicLink())
+        return "symlink";
+    throw new FileError("invalid", "Unsupported file type");
+}
+function fileInfoFromStats(path, stats) {
+    return {
+        name: path.replace(/\/+$/, "").split("/").pop() ?? path,
+        path,
+        kind: fileKindFromStats(stats),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+    };
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function toFileError(error, path) {
+    if (error instanceof FileError)
+        return error;
+    if (isNodeError(error)) {
+        const message = error.message;
+        switch (error.code) {
+            case "ENOENT":
+                return new FileError("not_found", message, path, { cause: error });
+            case "EACCES":
+            case "EPERM":
+                return new FileError("permission_denied", message, path, { cause: error });
+            case "ENOTDIR":
+                return new FileError("not_directory", message, path, { cause: error });
+            case "EISDIR":
+                return new FileError("is_directory", message, path, { cause: error });
+            case "EINVAL":
+                return new FileError("invalid", message, path, { cause: error });
+        }
+    }
+    return new FileError("unknown", error instanceof Error ? error.message : String(error), path, { cause: error });
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runCommand(command, args, timeoutMs) {
+    return await new Promise((resolve) => {
+        let stdout = "";
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+        const timeout = setTimeout(() => {
+            if (child.pid)
+                killProcessTree(child.pid);
+        }, timeoutMs);
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.on("error", () => {
+            clearTimeout(timeout);
+            resolve({ stdout: "", status: null });
+        });
+        child.on("close", (status) => {
+            clearTimeout(timeout);
+            resolve({ stdout, status });
+        });
+    });
+}
+async function findBashOnPath() {
+    const result = process.platform === "win32"
+        ? await runCommand("where", ["bash.exe"], 5000)
+        : await runCommand("which", ["bash"], 5000);
+    if (result.status !== 0 || !result.stdout)
+        return null;
+    const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+    return firstMatch && (await pathExists(firstMatch)) ? firstMatch : null;
+}
+async function getShellConfig(customShellPath) {
+    if (customShellPath) {
+        if (await pathExists(customShellPath)) {
+            return { shell: customShellPath, args: ["-c"] };
+        }
+        throw new Error(`Custom shell path not found: ${customShellPath}`);
+    }
+    if (process.platform === "win32") {
+        const candidates = [];
+        const programFiles = process.env.ProgramFiles;
+        if (programFiles)
+            candidates.push(`${programFiles}\\Git\\bin\\bash.exe`);
+        const programFilesX86 = process.env["ProgramFiles(x86)"];
+        if (programFilesX86)
+            candidates.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+        for (const candidate of candidates) {
+            if (await pathExists(candidate)) {
+                return { shell: candidate, args: ["-c"] };
+            }
+        }
+        const bashOnPath = await findBashOnPath();
+        if (bashOnPath) {
+            return { shell: bashOnPath, args: ["-c"] };
+        }
+        throw new Error("No bash shell found");
+    }
+    if (await pathExists("/bin/bash")) {
+        return { shell: "/bin/bash", args: ["-c"] };
+    }
+    const bashOnPath = await findBashOnPath();
+    if (bashOnPath) {
+        return { shell: bashOnPath, args: ["-c"] };
+    }
+    return { shell: "sh", args: ["-c"] };
+}
+function getShellEnv(baseEnv, extraEnv) {
+    return {
+        ...process.env,
+        ...baseEnv,
+        ...extraEnv,
+    };
+}
+function killProcessTree(pid) {
+    if (process.platform === "win32") {
+        try {
+            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                stdio: "ignore",
+                detached: true,
+            });
+        }
+        catch {
+            // Ignore errors.
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Process already dead.
+        }
+    }
+}
+export class NodeExecutionEnv {
+    cwd;
+    shellPath;
+    shellEnv;
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.shellPath = options.shellPath;
+        this.shellEnv = options.shellEnv;
+    }
+    async exec(command, options) {
+        const cwd = options?.cwd ? resolvePath(this.cwd, options.cwd) : this.cwd;
+        const { shell, args } = await getShellConfig(this.shellPath);
+        return await new Promise((resolvePromise, reject) => {
+            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;
+            const onAbort = () => {
+                if (child.pid) {
+                    killProcessTree(child.pid);
+                }
+            };
+            if (options?.signal) {
+                if (options.signal.aborted) {
+                    onAbort();
+                }
+                else {
+                    options.signal.addEventListener("abort", onAbort, { once: true });
+                }
+            }
+            child.stdout?.setEncoding("utf8");
+            child.stderr?.setEncoding("utf8");
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk;
+                options?.onStdout?.(chunk);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk;
+                options?.onStderr?.(chunk);
+            });
+            child.on("error", (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (options?.signal)
+                    options.signal.removeEventListener("abort", onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                reject(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"));
+                    return;
+                }
+                if (timedOut) {
+                    reject(new Error(`timeout:${options?.timeout}`));
+                    return;
+                }
+                resolvePromise({ stdout, stderr, exitCode: code ?? 0 });
+            });
+        });
+    }
+    async readTextFile(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return await readFile(resolved, "utf8");
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async readBinaryFile(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return await readFile(resolved);
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async writeFile(path, content) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            await mkdir(resolve(resolved, ".."), { recursive: true });
+            await writeFile(resolved, content);
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async fileInfo(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return fileInfoFromStats(resolved, await lstat(resolved));
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async listDir(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            const entries = await readdir(resolved, { withFileTypes: true });
+            const infos = [];
+            for (const entry of entries) {
+                const entryPath = resolve(resolved, entry.name);
+                try {
+                    infos.push(fileInfoFromStats(entryPath, await lstat(entryPath)));
+                }
+                catch (error) {
+                    if (error instanceof FileError && error.code === "invalid")
+                        continue;
+                    throw error;
+                }
+            }
+            return infos;
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async realPath(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return await realpath(resolved);
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async exists(path) {
+        try {
+            await this.fileInfo(path);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof FileError && error.code === "not_found")
+                return false;
+            throw error;
+        }
+    }
+    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 });
+        }
+        catch (error) {
+            throw toFileError(error, resolved);
+        }
+    }
+    async createTempDir(prefix = "tmp-") {
+        return await mkdtemp(join(tmpdir(), prefix));
+    }
+    async createTempFile(options) {
+        const dir = await this.createTempDir("tmp-");
+        const filePath = join(dir, `${options?.prefix ?? ""}${randomUUID()}${options?.suffix ?? ""}`);
+        await writeFile(filePath, "");
+        return filePath;
+    }
+    async cleanup() {
+        // nothing to clean up for the local node implementation
+    }
+}
+//# sourceMappingURL=nodejs.js.map

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

@@ -0,0 +1,3 @@
+export { NodeExecutionEnv } from "./env/nodejs.js";
+export { FileError } from "./types.js";
+//# sourceMappingURL=execution-env.js.map

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

@@ -0,0 +1,9 @@
+import { AgentHarness } from "./agent-harness.js";
+import { Session } from "./session/session.js";
+export function createSession(storage) {
+    return new Session(storage);
+}
+export function createAgentHarness(options) {
+    return new AgentHarness(options);
+}
+//# sourceMappingURL=factory.js.map

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

@@ -0,0 +1,102 @@
+export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
+
+<summary>
+`;
+export const COMPACTION_SUMMARY_SUFFIX = `
+</summary>`;
+export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
+`;
+export const BRANCH_SUMMARY_SUFFIX = `</summary>`;
+export function bashExecutionToText(msg) {
+    let text = `Ran \`${msg.command}\`\n`;
+    if (msg.output) {
+        text += `\`\`\`\n${msg.output}\n\`\`\``;
+    }
+    else {
+        text += "(no output)";
+    }
+    if (msg.cancelled) {
+        text += "\n\n(command cancelled)";
+    }
+    else if (msg.exitCode !== null && msg.exitCode !== undefined && msg.exitCode !== 0) {
+        text += `\n\nCommand exited with code ${msg.exitCode}`;
+    }
+    if (msg.truncated && msg.fullOutputPath) {
+        text += `\n\n[Output truncated. Full output: ${msg.fullOutputPath}]`;
+    }
+    return text;
+}
+export function createBranchSummaryMessage(summary, fromId, timestamp) {
+    return {
+        role: "branchSummary",
+        summary,
+        fromId,
+        timestamp: new Date(timestamp).getTime(),
+    };
+}
+export function createCompactionSummaryMessage(summary, tokensBefore, timestamp) {
+    return {
+        role: "compactionSummary",
+        summary,
+        tokensBefore,
+        timestamp: new Date(timestamp).getTime(),
+    };
+}
+export function createCustomMessage(customType, content, display, details, timestamp) {
+    return {
+        role: "custom",
+        customType,
+        content,
+        display,
+        details,
+        timestamp: new Date(timestamp).getTime(),
+    };
+}
+export function convertToLlm(messages) {
+    return messages
+        .map((m) => {
+        switch (m.role) {
+            case "bashExecution":
+                if (m.excludeFromContext) {
+                    return undefined;
+                }
+                return {
+                    role: "user",
+                    content: [{ type: "text", text: bashExecutionToText(m) }],
+                    timestamp: m.timestamp,
+                };
+            case "custom": {
+                const content = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+                return {
+                    role: "user",
+                    content,
+                    timestamp: m.timestamp,
+                };
+            }
+            case "branchSummary":
+                return {
+                    role: "user",
+                    content: [{ type: "text", text: BRANCH_SUMMARY_PREFIX + m.summary + BRANCH_SUMMARY_SUFFIX }],
+                    timestamp: m.timestamp,
+                };
+            case "compactionSummary":
+                return {
+                    role: "user",
+                    content: [
+                        { type: "text", text: COMPACTION_SUMMARY_PREFIX + m.summary + COMPACTION_SUMMARY_SUFFIX },
+                    ],
+                    timestamp: m.timestamp,
+                };
+            case "user":
+            case "assistant":
+            case "toolResult":
+                return m;
+            default:
+                return undefined;
+        }
+    })
+        .filter((m) => m !== undefined);
+}
+//# sourceMappingURL=messages.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/prompt-templates.js

@@ -0,0 +1,194 @@
+import { parse } from "yaml";
+/**
+ * Load prompt templates from one or more paths.
+ *
+ * Directory inputs load direct `.md` children non-recursively. File inputs load explicit `.md` files. Missing paths and
+ * non-markdown files are skipped. Read and parse failures are returned as diagnostics.
+ */
+export async function loadPromptTemplates(env, paths) {
+    const promptTemplates = [];
+    const diagnostics = [];
+    for (const path of Array.isArray(paths) ? paths : [paths]) {
+        const info = await safeFileInfo(env, path);
+        if (!info)
+            continue;
+        const kind = await resolveKind(env, info);
+        if (kind === "directory") {
+            const result = await loadTemplatesFromDir(env, info.path);
+            promptTemplates.push(...result.promptTemplates);
+            diagnostics.push(...result.diagnostics);
+        }
+        else if (kind === "file" && info.name.endsWith(".md")) {
+            const result = await loadTemplateFromFile(env, info.path);
+            if (result.promptTemplate)
+                promptTemplates.push(result.promptTemplate);
+            diagnostics.push(...result.diagnostics);
+        }
+    }
+    return { promptTemplates, diagnostics };
+}
+/**
+ * Load prompt templates from source-tagged paths.
+ *
+ * Source values are preserved exactly and attached to every loaded prompt template and diagnostic. The agent package does
+ * not interpret source values; applications define their own provenance shape.
+ */
+export async function loadSourcedPromptTemplates(env, inputs) {
+    const promptTemplates = [];
+    const diagnostics = [];
+    for (const input of inputs) {
+        const result = await loadPromptTemplates(env, input.path);
+        for (const promptTemplate of result.promptTemplates)
+            promptTemplates.push({ promptTemplate, source: input.source });
+        for (const diagnostic of result.diagnostics)
+            diagnostics.push({ ...diagnostic, source: input.source });
+    }
+    return { promptTemplates, diagnostics };
+}
+async function loadTemplatesFromDir(env, dir) {
+    const promptTemplates = [];
+    const diagnostics = [];
+    let entries;
+    try {
+        entries = await env.listDir(dir);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: errorMessage(error, "failed to list prompt template directory"),
+            path: dir,
+        });
+        return { promptTemplates, diagnostics };
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const kind = await resolveKind(env, entry);
+        if (kind !== "file" || !entry.name.endsWith(".md"))
+            continue;
+        const result = await loadTemplateFromFile(env, entry.path);
+        if (result.promptTemplate)
+            promptTemplates.push(result.promptTemplate);
+        diagnostics.push(...result.diagnostics);
+    }
+    return { promptTemplates, diagnostics };
+}
+async function loadTemplateFromFile(env, filePath) {
+    const diagnostics = [];
+    try {
+        const rawContent = await env.readTextFile(filePath);
+        const { frontmatter, body } = parseFrontmatter(rawContent);
+        const firstLine = body.split("\n").find((line) => line.trim());
+        let description = typeof frontmatter.description === "string" ? frontmatter.description : "";
+        if (!description && firstLine) {
+            description = firstLine.slice(0, 60);
+            if (firstLine.length > 60)
+                description += "...";
+        }
+        return {
+            promptTemplate: {
+                name: basenameEnvPath(filePath).replace(/\.md$/i, ""),
+                description,
+                content: body,
+            },
+            diagnostics,
+        };
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: errorMessage(error, "failed to load prompt template"),
+            path: filePath,
+        });
+        return { promptTemplate: null, diagnostics };
+    }
+}
+async function safeFileInfo(env, path) {
+    try {
+        return await env.fileInfo(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveKind(env, info) {
+    if (info.kind === "file" || info.kind === "directory")
+        return info.kind;
+    try {
+        const realPath = await env.realPath(info.path);
+        const target = await env.fileInfo(realPath);
+        return target.kind === "file" || target.kind === "directory" ? target.kind : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseFrontmatter(content) {
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return { frontmatter: {}, body: normalized };
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return { frontmatter: {}, body: normalized };
+    const yamlString = normalized.slice(4, endIndex);
+    const body = normalized.slice(endIndex + 4).trim();
+    return { frontmatter: (parse(yamlString) ?? {}), body };
+}
+function basenameEnvPath(path) {
+    const normalized = path.replace(/\/+$/, "");
+    const slashIndex = normalized.lastIndexOf("/");
+    return slashIndex === -1 ? normalized : normalized.slice(slashIndex + 1);
+}
+function errorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+/** Parse slash-command arguments using simple shell-style single and double quotes. */
+export function parseCommandArgs(argsString) {
+    const args = [];
+    let current = "";
+    let inQuote = null;
+    for (let i = 0; i < argsString.length; i++) {
+        const char = argsString[i];
+        if (inQuote) {
+            if (char === inQuote)
+                inQuote = null;
+            else
+                current += char;
+        }
+        else if (char === '"' || char === "'") {
+            inQuote = char;
+        }
+        else if (char === " " || char === "\t") {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        args.push(current);
+    return args;
+}
+/** Substitute prompt template placeholders (`$1`, `$@`, `$ARGUMENTS`, `${@:N}`, `${@:N:L}`) with command arguments. */
+export function substituteArgs(content, args) {
+    let result = content;
+    result = result.replace(/\$(\d+)/g, (_, num) => args[parseInt(num, 10) - 1] ?? "");
+    result = result.replace(/\$\{@:(\d+)(?::(\d+))?\}/g, (_, startStr, lengthStr) => {
+        let start = parseInt(startStr, 10) - 1;
+        if (start < 0)
+            start = 0;
+        if (lengthStr)
+            return args.slice(start, start + parseInt(lengthStr, 10)).join(" ");
+        return args.slice(start).join(" ");
+    });
+    const allArgs = args.join(" ");
+    result = result.replace(/\$ARGUMENTS/g, allArgs);
+    result = result.replace(/\$@/g, allArgs);
+    return result;
+}
+/** Expand a prompt template with positional command arguments. */
+export function expandPromptTemplate(template, args = []) {
+    return substituteArgs(template.content, args);
+}
+//# sourceMappingURL=prompt-templates.js.map