@arnilo/prism-coding-agent 0.0.3

package/dist/shell.js

@@ -0,0 +1,370 @@
+/**
+ * Shell tool: execute a command in the host shell.
+ *
+ * Behavioral port of pi's core/tools/bash for @arnilo/prism-coding-agent, adapted to
+ * Prism's `ToolDefinition` contract. Drops pi's TUI (live `onUpdate` streaming,
+ * `renderCall`/`renderResult`) and process-shutdown child tracking; re-ports spawn/
+ * kill/waitForChildProcess directly over stdlib so the package stays self-contained.
+ *
+ * Deviations from pi (documented):
+ *  - Tool named `"shell"` (pi: `"bash"`).
+ *  - `timeout` param is in **seconds** (matches pi).
+ *  - Shell resolution honors `process.env.SHELL` → `/bin/bash` → `sh` (pi forces `/bin/bash`);
+ *    overridable via `options.shellPath`. Rationale: a host integrating the tool usually wants its
+ *    login shell respected; `shellPath` still lets a host force bash for fully predictable POSIX.
+ *  - Non-zero exit is **not** a tool error: returned as a normal `ToolResult` with `exitCode` in
+ *    `metadata` and a status footer in `content` (pi throws). timeout/abort *are* error results
+ *    (the command did not complete). Rationale: `ToolResult.error` should mean the tool call failed,
+ *    not that the command returned non-zero.
+ *  - Drops detached-child PID tracking (`killTrackedDetachedChildren`): the host owns process
+ *    lifecycle; the tool kills the tree only on timeout/abort. Drops the stdin command transport
+ *    (argv `-c` only). Default spawn env is `process.env` (no pi CLI binDir PATH injection).
+ */
+import { spawn } from "node:child_process";
+import { constants, existsSync } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import { OutputAccumulator } from "./output-accumulator.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const EXIT_STDIO_GRACE_MS = 100;
+// --- spawn internals (re-ported from pi utils/shell.js + utils/child-process.js) ---
+/** Resolve the shell binary + args. shellPath → SHELL env → /bin/bash → sh. */
+export function getShellConfig(customShellPath) {
+    if (customShellPath) {
+        if (existsSync(customShellPath))
+            return { shell: customShellPath, args: ["-c"] };
+        throw new Error(`Custom shell path not found: ${customShellPath}`);
+    }
+    const shellEnv = process.env.SHELL;
+    if (shellEnv && existsSync(shellEnv))
+        return { shell: shellEnv, args: ["-c"] };
+    if (existsSync("/bin/bash"))
+        return { shell: "/bin/bash", args: ["-c"] };
+    return { shell: "sh", args: ["-c"] };
+}
+/** Kill a process and all its descendants (cross-platform). */
+export function killProcessTree(pid) {
+    if (process.platform === "win32") {
+        try {
+            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                stdio: "ignore",
+                detached: true,
+                windowsHide: true,
+            });
+        }
+        catch {
+            // ignore — best effort
+        }
+        return;
+    }
+    try {
+        // child is spawned detached, so it is its own process-group leader: -pid targets the group.
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // already dead
+        }
+    }
+}
+/**
+ * Wait for a child to terminate without hanging on inherited stdio handles held by detached descendants.
+ *
+ * A short-lived child can `exit` while a detached descendant keeps its stdout/stderr pipe open. After
+ * `exit` we wait for the pipes to fall idle: the grace timer is re-armed on every chunk, so an actively
+ * writing descendant keeps us reading, while a quiet inherited handle releases us after the grace elapses.
+ */
+export function waitForChildProcess(child) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let exited = false;
+        let exitCode = null;
+        let postExitTimer;
+        let stdoutEnded = child.stdout === null;
+        let stderrEnded = child.stderr === null;
+        const cleanup = () => {
+            if (postExitTimer) {
+                clearTimeout(postExitTimer);
+                postExitTimer = undefined;
+            }
+            child.removeListener("error", onError);
+            child.removeListener("exit", onExit);
+            child.removeListener("close", onClose);
+            child.stdout?.removeListener("end", onStdoutEnd);
+            child.stderr?.removeListener("end", onStderrEnd);
+            child.stdout?.removeListener("data", onData);
+            child.stderr?.removeListener("data", onData);
+        };
+        const finalize = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            resolve(code);
+        };
+        const maybeFinalizeAfterExit = () => {
+            if (!exited || settled)
+                return;
+            if (stdoutEnded && stderrEnded)
+                finalize(exitCode);
+        };
+        const armIdleTimer = () => {
+            if (postExitTimer)
+                clearTimeout(postExitTimer);
+            postExitTimer = setTimeout(() => finalize(exitCode), EXIT_STDIO_GRACE_MS);
+        };
+        const onData = () => {
+            if (exited && !settled)
+                armIdleTimer();
+        };
+        const onStdoutEnd = () => {
+            stdoutEnded = true;
+            maybeFinalizeAfterExit();
+        };
+        const onStderrEnd = () => {
+            stderrEnded = true;
+            maybeFinalizeAfterExit();
+        };
+        const onError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err);
+        };
+        const onExit = (code) => {
+            exited = true;
+            exitCode = code;
+            maybeFinalizeAfterExit();
+            if (!settled)
+                armIdleTimer();
+        };
+        const onClose = (code) => {
+            finalize(code);
+        };
+        child.stdout?.once("end", onStdoutEnd);
+        child.stderr?.once("end", onStderrEnd);
+        child.stdout?.on("data", onData);
+        child.stderr?.on("data", onData);
+        child.once("error", onError);
+        child.once("exit", onExit);
+        child.once("close", onClose);
+    });
+}
+/** Default local-shell operations: spawn the command in a shell, stream combined stdout+stderr. */
+export function createLocalBashOperations(options) {
+    return {
+        exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const shellConfig = getShellConfig(options?.shellPath);
+            try {
+                await fsAccess(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute shell commands.`);
+            }
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
+            const child = spawn(shellConfig.shell, [...shellConfig.args, command], {
+                cwd,
+                detached: process.platform !== "win32",
+                env: env ?? { ...process.env },
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            let timedOut = false;
+            let timeoutHandle;
+            const onAbort = () => {
+                if (child.pid)
+                    killProcessTree(child.pid);
+            };
+            try {
+                if (timeout !== undefined && timeout > 0) {
+                    timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        if (child.pid)
+                            killProcessTree(child.pid);
+                    }, timeout * 1000);
+                }
+                child.stdout?.on("data", onData);
+                child.stderr?.on("data", onData);
+                if (signal) {
+                    if (signal.aborted)
+                        onAbort();
+                    else
+                        signal.addEventListener("abort", onAbort, { once: true });
+                }
+                const exitCode = await waitForChildProcess(child);
+                if (signal?.aborted)
+                    throw new Error("aborted");
+                if (timedOut)
+                    throw new Error(`timeout:${timeout}`);
+                return { exitCode };
+            }
+            finally {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            }
+        },
+    };
+}
+// --- result formatting (adapted from pi, minus TUI) ---
+function formatOutput(snapshot, lastLineBytes, emptyText = "(no output)") {
+    const truncation = snapshot.truncation;
+    let text = snapshot.content || emptyText;
+    if (truncation.truncated) {
+        const startLine = truncation.totalLines - truncation.outputLines + 1;
+        const endLine = truncation.totalLines;
+        if (truncation.lastLinePartial) {
+            const lastLineSize = formatSize(lastLineBytes);
+            text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
+        }
+        else if (truncation.truncatedBy === "lines") {
+            text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
+        }
+        else {
+            text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit). Full output: ${snapshot.fullOutputPath}]`;
+        }
+    }
+    return { text, truncation, fullOutputPath: snapshot.fullOutputPath };
+}
+function appendStatus(text, status) {
+    return text ? `${text}\n\n${status}` : status;
+}
+// --- tool factory ---
+export function createShellTool(cwd, options) {
+    const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
+    const commandPrefix = options?.commandPrefix;
+    const spawnHook = options?.spawnHook;
+    const maxLines = options?.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options?.maxBytes ?? DEFAULT_MAX_BYTES;
+    const tempFilePrefix = options?.tempFilePrefix ?? "prism-shell";
+    return {
+        name: "shell",
+        description: `Execute a shell command in the current working directory. Returns combined stdout and stderr. Output is truncated to the last ${maxLines} lines or ${maxBytes / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        parameters: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Shell command to execute" },
+                timeout: { type: "number", description: "Timeout in seconds (optional, no default timeout)" },
+            },
+            required: ["command"],
+            additionalProperties: false,
+        },
+        async execute(args, context) {
+            const toolCallId = context.toolCallId;
+            const command = typeof args.command === "string" ? args.command : "";
+            const timeout = typeof args.timeout === "number" ? args.timeout : undefined;
+            if (command.length === 0) {
+                return {
+                    toolCallId,
+                    name: "shell",
+                    content: [{ type: "text", text: "Error: command is required and must be a non-empty string." }],
+                    error: { message: "command is required and must be a non-empty string." },
+                };
+            }
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            const spawnContext = spawnHook
+                ? spawnHook({ command: resolvedCommand, cwd, env: { ...process.env } })
+                : { command: resolvedCommand, cwd, env: { ...process.env } };
+            const output = new OutputAccumulator({ maxLines, maxBytes, tempFilePrefix });
+            let acceptingOutput = true;
+            const handleData = (data) => {
+                if (!acceptingOutput)
+                    return;
+                output.append(data);
+            };
+            const finishOutput = async () => {
+                acceptingOutput = false;
+                output.finish();
+                const snapshot = output.snapshot({ persistIfTruncated: true });
+                await output.closeTempFile();
+                return snapshot;
+            };
+            // Safety net: never leak an unhandled throw to the host runtime.
+            try {
+                let exitCode;
+                try {
+                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
+                        onData: handleData,
+                        signal: context.signal,
+                        timeout,
+                        env: spawnContext.env,
+                    });
+                    exitCode = result.exitCode;
+                }
+                catch (err) {
+                    const snapshot = await finishOutput();
+                    const { text } = formatOutput(snapshot, output.getLastLineBytes(), "");
+                    const message = err instanceof Error ? err.message : String(err);
+                    const meta = {
+                        exitCode: null,
+                        truncation: snapshot.truncation,
+                        fullOutputPath: snapshot.fullOutputPath,
+                    };
+                    if (message === "aborted") {
+                        return {
+                            toolCallId,
+                            name: "shell",
+                            content: [{ type: "text", text: appendStatus(text, "[Command aborted]") }],
+                            error: { message: "Command aborted" },
+                            metadata: meta,
+                        };
+                    }
+                    if (message.startsWith("timeout:")) {
+                        const timeoutSecs = message.split(":")[1];
+                        const status = `Command timed out after ${timeoutSecs} seconds`;
+                        return {
+                            toolCallId,
+                            name: "shell",
+                            content: [{ type: "text", text: appendStatus(text, `[${status}]`) }],
+                            error: { message: status },
+                            metadata: meta,
+                        };
+                    }
+                    // Spawn error (missing cwd, shell ENOENT, …): message is already host-friendly.
+                    return {
+                        toolCallId,
+                        name: "shell",
+                        content: [{ type: "text", text: appendStatus(text, message) }],
+                        error: { message },
+                        metadata: meta,
+                    };
+                }
+                const snapshot = await finishOutput();
+                const formatted = formatOutput(snapshot, output.getLastLineBytes());
+                let text = formatted.text;
+                // Non-zero exit is not a tool error: surface exit code in a footer + metadata.
+                if (exitCode !== 0 && exitCode !== null) {
+                    text = appendStatus(text, `[Command exited with code ${exitCode}]`);
+                }
+                return {
+                    toolCallId,
+                    name: "shell",
+                    content: [{ type: "text", text }],
+                    metadata: {
+                        exitCode,
+                        truncation: snapshot.truncation,
+                        fullOutputPath: snapshot.fullOutputPath,
+                    },
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    toolCallId,
+                    name: "shell",
+                    content: [{ type: "text", text: message }],
+                    error: { message },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=shell.js.map

package/dist/truncate.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Behavioral port of pi's core/tools/truncate for @arnilo/prism-coding-agent.
+ * stdlib only (Buffer). Truncation is based on two independent limits — whichever
+ * is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except the documented tail single-line edge case).
+ */
+export declare const DEFAULT_MAX_LINES = 2000;
+export declare const DEFAULT_MAX_BYTES: number;
+export interface TruncationOptions {
+    /** Maximum number of lines (default: 2000) */
+    maxLines?: number;
+    /** Maximum number of bytes (default: 50KB) */
+    maxBytes?: number;
+}
+export interface TruncationResult {
+    /** The truncated content */
+    content: string;
+    /** Whether truncation occurred */
+    truncated: boolean;
+    /** Which limit was hit: "lines", "bytes", or null if not truncated */
+    truncatedBy: "lines" | "bytes" | null;
+    /** Total number of lines in the original content */
+    totalLines: number;
+    /** Total number of bytes in the original content */
+    totalBytes: number;
+    /** Number of complete lines in the truncated output */
+    outputLines: number;
+    /** Number of bytes in the truncated output */
+    outputBytes: number;
+    /** Whether the last line was partially truncated (only for tail truncation edge case) */
+    lastLinePartial: boolean;
+    /** Whether the first line exceeded the byte limit (for head truncation) */
+    firstLineExceedsLimit: boolean;
+    /** The max lines limit that was applied */
+    maxLines: number;
+    /** The max bytes limit that was applied */
+    maxBytes: number;
+}
+/** Format bytes as human-readable size. */
+export declare function formatSize(bytes: number): string;
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If the first line alone exceeds the byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export declare function truncateHead(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for shell output where you want to see the end (errors, final results).
+ *
+ * May return a partial first line if the last line of the original content exceeds
+ * the byte limit.
+ */
+export declare function truncateTail(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Truncate a single line to max characters, adding a `[truncated]` suffix.
+ * Used for long single-line outputs (e.g. grep match lines).
+ */
+export declare function truncateLine(line: string, maxChars?: number): {
+    text: string;
+    wasTruncated: boolean;
+};

package/dist/truncate.js

@@ -0,0 +1,205 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Behavioral port of pi's core/tools/truncate for @arnilo/prism-coding-agent.
+ * stdlib only (Buffer). Truncation is based on two independent limits — whichever
+ * is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except the documented tail single-line edge case).
+ */
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
+/**
+ * Default char cap for {@link truncateLine}. pi names this GREP_MAX_LINE_LENGTH
+ * because grep is its only caller; grep is out of scope for this package, so the
+ * constant stays internal and unprefixed.
+ */
+const DEFAULT_LINE_CHAR_LIMIT = 500;
+function splitLinesForCounting(content) {
+    if (content.length === 0)
+        return [];
+    const lines = content.split("\n");
+    if (content.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
+/** Format bytes as human-readable size. */
+export function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If the first line alone exceeds the byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export function truncateHead(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    // First line alone exceeds the byte limit → nothing fits.
+    const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+    if (firstLineBytes > maxBytes) {
+        return {
+            content: "",
+            truncated: true,
+            truncatedBy: "bytes",
+            totalLines,
+            totalBytes,
+            outputLines: 0,
+            outputBytes: 0,
+            lastLinePartial: false,
+            firstLineExceedsLimit: true,
+            maxLines,
+            maxBytes,
+        };
+    }
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    for (let i = 0; i < lines.length && i < maxLines; i++) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            break;
+        }
+        outputLinesArr.push(line);
+        outputBytesCount += lineBytes;
+    }
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial: false,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for shell output where you want to see the end (errors, final results).
+ *
+ * May return a partial first line if the last line of the original content exceeds
+ * the byte limit.
+ */
+export function truncateTail(content, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    const lines = splitLinesForCounting(content);
+    const totalLines = lines.length;
+    if (totalLines <= maxLines && totalBytes <= maxBytes) {
+        return {
+            content,
+            truncated: false,
+            truncatedBy: null,
+            totalLines,
+            totalBytes,
+            outputLines: totalLines,
+            outputBytes: totalBytes,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines,
+            maxBytes,
+        };
+    }
+    const outputLinesArr = [];
+    let outputBytesCount = 0;
+    let truncatedBy = "lines";
+    let lastLinePartial = false;
+    for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+        const line = lines[i];
+        const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
+        if (outputBytesCount + lineBytes > maxBytes) {
+            truncatedBy = "bytes";
+            // Edge case: no lines added yet and this line alone exceeds maxBytes →
+            // take the end of the line (partial).
+            if (outputLinesArr.length === 0) {
+                const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+                outputLinesArr.unshift(truncatedLine);
+                outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+                lastLinePartial = true;
+            }
+            break;
+        }
+        outputLinesArr.unshift(line);
+        outputBytesCount += lineBytes;
+    }
+    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+        truncatedBy = "lines";
+    }
+    const outputContent = outputLinesArr.join("\n");
+    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+    return {
+        content: outputContent,
+        truncated: true,
+        truncatedBy,
+        totalLines,
+        totalBytes,
+        outputLines: outputLinesArr.length,
+        outputBytes: finalOutputBytes,
+        lastLinePartial,
+        firstLineExceedsLimit: false,
+        maxLines,
+        maxBytes,
+    };
+}
+/**
+ * Truncate a string to fit within a byte limit, keeping the end. Handles
+ * multi-byte UTF-8 characters by advancing to the next character boundary.
+ */
+function truncateStringToBytesFromEnd(str, maxBytes) {
+    const buf = Buffer.from(str, "utf-8");
+    if (buf.length <= maxBytes)
+        return str;
+    let start = buf.length - maxBytes;
+    // Skip continuation bytes (0x80-masked) to land on a character start.
+    while (start < buf.length && (buf[start] & 0xc0) === 0x80)
+        start++;
+    return buf.subarray(start).toString("utf-8");
+}
+/**
+ * Truncate a single line to max characters, adding a `[truncated]` suffix.
+ * Used for long single-line outputs (e.g. grep match lines).
+ */
+export function truncateLine(line, maxChars = DEFAULT_LINE_CHAR_LIMIT) {
+    if (line.length <= maxChars)
+        return { text: line, wasTruncated: false };
+    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+//# sourceMappingURL=truncate.js.map

package/dist/write.d.ts

@@ -0,0 +1,16 @@
+import type { ToolDefinition } from "@arnilo/prism";
+/**
+ * Pluggable operations for the write tool. Override to delegate file writing to remote systems
+ * (e.g. SSH) while keeping the tool's directory-creation + per-path serialization behavior.
+ */
+export interface WriteOperations {
+    /** Write content to a file (creating or overwriting). */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Create a directory recursively. */
+    mkdir: (dir: string) => Promise<void>;
+}
+export interface WriteToolOptions {
+    /** Custom operations backend (default: local filesystem). */
+    operations?: WriteOperations;
+}
+export declare function createWriteTool(cwd: string, options?: WriteToolOptions): ToolDefinition;