@arnilo/prism-coding-agent 0.0.3

package/dist/edit.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Edit tool: precise text replacement in an existing file via exact-then-fuzzy matching.
+ *
+ * Behavioral port of pi's core/tools/edit for @arnilo/prism-coding-agent, adapted to Prism's
+ * `ToolDefinition` contract. Faithfully ports the access → read → stripBom → line-ending-normalize →
+ * `applyEditsToNormalizedContent` (exact then fuzzy, with duplicate/overlap/empty/no-change guards) →
+ * write flow, serialized per-path via `withFileMutationQueue`. Also ports `prepareEditArguments`
+ * (tolerates models that send `edits` as a JSON string or as legacy top-level `oldText`/`newText`).
+ *
+ * Drops pi's TUI (`renderCall`/`renderResult`, live preview cache, theme/syntax-highlight).
+ *
+ * Deviations from pi (documented):
+ *  - Abort + every failure (missing/unreadable file, no-match, duplicate, overlap, empty oldText,
+ *    no-change) return a Prism `error` result (pi throws/rejects). On no-match the file is untouched
+ *    because `applyEditsToNormalizedContent` throws before `writeFile`.
+ *  - pi's per-tool `details: { diff, patch, firstChangedLine }` (TUI-facing) is surfaced as
+ *    `ToolResult.metadata` (host-readable, keeps model context small — the model only sees the short
+ *    `Successfully replaced N block(s)` confirmation).
+ *  - The post-`writeFile` abort check is dropped (consistent with the write tool): if the write
+ *    completed, the edit is real and is reported as success rather than a misleading "aborted".
+ */
+import { Buffer } from "node:buffer";
+import type { ToolDefinition } from "@arnilo/prism";
+export interface Edit {
+    oldText: string;
+    newText: string;
+}
+/** Display/result details mirrored from pi's `EditToolDetails`, surfaced via `ToolResult.metadata`. */
+export interface EditToolDetails {
+    /** Display-oriented diff of the changes made. */
+    diff: string;
+    /** Standard unified patch of the changes made. */
+    patch: string;
+    /** Line number of the first change in the new file (for editor navigation). */
+    firstChangedLine?: number;
+}
+/**
+ * Pluggable operations for the edit tool. Override to delegate file editing to remote systems
+ * (e.g. SSH) while keeping the tool's matching + per-path serialization behavior.
+ */
+export interface EditOperations {
+    /** Read file contents as a Buffer. */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Write content to a file. */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Check the file is readable and writable (throw if not). */
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    /** Custom operations backend (default: local filesystem). */
+    operations?: EditOperations;
+}
+export declare function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition;

package/dist/edit.js

@@ -0,0 +1,159 @@
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolveToCwd } from "./path-utils.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+};
+function errorResult(toolCallId, message) {
+    return {
+        toolCallId,
+        name: "edit",
+        content: [{ type: "text", text: message }],
+        error: { message },
+    };
+}
+/** Port of pi's `prepareEditArguments`: tolerate model quirks (edits as JSON string; legacy fields). */
+function prepareEditArguments(input) {
+    let edits = input.edits;
+    // Some models send edits as a JSON string instead of an array.
+    if (typeof edits === "string") {
+        try {
+            const parsed = JSON.parse(edits);
+            if (Array.isArray(parsed))
+                edits = parsed;
+        }
+        catch {
+            /* leave as-is; validation will reject */
+        }
+    }
+    const path = typeof input.path === "string" ? input.path : "";
+    // Legacy: top-level oldText/newText instead of edits[].
+    if (typeof input.oldText === "string" && typeof input.newText === "string") {
+        const arr = Array.isArray(edits) ? [...edits] : [];
+        arr.push({ oldText: input.oldText, newText: input.newText });
+        edits = arr;
+    }
+    return { path, edits };
+}
+function validateEdits(edits) {
+    if (!Array.isArray(edits) || edits.length === 0) {
+        return "edits must contain at least one replacement.";
+    }
+    const out = [];
+    for (let i = 0; i < edits.length; i++) {
+        const e = edits[i];
+        if (typeof e?.oldText !== "string" || typeof e?.newText !== "string") {
+            return `edits[${i}] must have string oldText and newText.`;
+        }
+        out.push({ oldText: e.oldText, newText: e.newText });
+    }
+    return out;
+}
+export function createEditTool(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: "edit",
+        description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file to edit (relative or absolute)" },
+                edits: {
+                    type: "array",
+                    description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            oldText: {
+                                type: "string",
+                                description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
+                            },
+                            newText: { type: "string", description: "Replacement text for this targeted edit." },
+                        },
+                        required: ["oldText", "newText"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["path", "edits"],
+            additionalProperties: false,
+        },
+        async execute(args, context) {
+            const toolCallId = context.toolCallId;
+            const prepared = prepareEditArguments(args);
+            if (prepared.path.length === 0) {
+                return errorResult(toolCallId, "path is required and must be a non-empty string.");
+            }
+            const editsOrError = validateEdits(prepared.edits);
+            if (typeof editsOrError === "string") {
+                return errorResult(toolCallId, editsOrError);
+            }
+            const edits = editsOrError;
+            try {
+                const absolutePath = resolveToCwd(prepared.path, cwd);
+                return await withFileMutationQueue(absolutePath, async () => {
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    // Check the file is readable + writable.
+                    try {
+                        await ops.access(absolutePath);
+                    }
+                    catch (error) {
+                        if (context.signal?.aborted)
+                            return errorResult(toolCallId, "Operation aborted");
+                        const err = error;
+                        const errorMessage = error instanceof Error && "code" in error ? `Error code: ${err.code}` : String(error);
+                        return errorResult(toolCallId, `Could not edit file: ${prepared.path}. ${errorMessage}.`);
+                    }
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    const buffer = await ops.readFile(absolutePath);
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    const rawContent = buffer.toString("utf-8");
+                    // The model will not include an invisible BOM in oldText.
+                    const { bom, text: content } = stripBom(rawContent);
+                    const originalEnding = detectLineEnding(content);
+                    const normalizedContent = normalizeToLF(content);
+                    // Apply exact-then-fuzzy matching. Throws on no-match / duplicate / overlap / empty / no-change.
+                    let baseContent;
+                    let newContent;
+                    try {
+                        ({ baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, prepared.path));
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        return errorResult(toolCallId, message);
+                    }
+                    if (context.signal?.aborted)
+                        return errorResult(toolCallId, "Operation aborted");
+                    const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                    await ops.writeFile(absolutePath, finalContent);
+                    const diffResult = generateDiffString(baseContent, newContent);
+                    const patch = generateUnifiedPatch(prepared.path, baseContent, newContent);
+                    return {
+                        toolCallId,
+                        name: "edit",
+                        content: [
+                            { type: "text", text: `Successfully replaced ${edits.length} block(s) in ${prepared.path}.` },
+                        ],
+                        metadata: {
+                            diff: diffResult.diff,
+                            patch,
+                            firstChangedLine: diffResult.firstChangedLine,
+                        },
+                    };
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return errorResult(toolCallId, message);
+            }
+        },
+    };
+}
+//# sourceMappingURL=edit.js.map

package/dist/file-mutation-queue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run `fn` exclusively for `filePath`: concurrent calls with the same path
+ * (or the same realpath) run one after another; calls for different paths run
+ * in parallel. Resolves/rejects with `fn`'s result and always releases the slot.
+ */
+export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;

package/dist/file-mutation-queue.js

@@ -0,0 +1,67 @@
+/**
+ * Serialize file mutation operations targeting the same file.
+ * Operations for different files still run in parallel.
+ *
+ * Behavioral port of pi's core/tools/file-mutation-queue for @arnilo/prism-coding-agent.
+ * stdlib only (node:fs/promises realpath, node:path resolve).
+ *
+ * ponytail: global process-wide Map mutex keyed by realpath. Ceiling: all
+ * mutation queues share one process Map; if a host runs many concurrent
+ * sessions in one process they all share the namespace (intended — same file
+ * must serialize regardless of session). Upgrade path: scope the Map per
+ * ToolRegistry if isolation between registries is ever needed.
+ */
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+const fileMutationQueues = new Map();
+let registrationQueue = Promise.resolve();
+function isMissingPathError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" ||
+            error.code === "ENOTDIR"));
+}
+async function getMutationQueueKey(filePath) {
+    const resolvedPath = resolve(filePath);
+    try {
+        return await realpath(resolvedPath);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return resolvedPath;
+        }
+        throw error;
+    }
+}
+/**
+ * Run `fn` exclusively for `filePath`: concurrent calls with the same path
+ * (or the same realpath) run one after another; calls for different paths run
+ * in parallel. Resolves/rejects with `fn`'s result and always releases the slot.
+ */
+export async function withFileMutationQueue(filePath, fn) {
+    const registration = registrationQueue.then(async () => {
+        const key = await getMutationQueueKey(filePath);
+        const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
+        let releaseNext;
+        const nextQueue = new Promise((resolveQueue) => {
+            releaseNext = resolveQueue;
+        });
+        const chainedQueue = currentQueue.then(() => nextQueue);
+        fileMutationQueues.set(key, chainedQueue);
+        return { key, currentQueue, chainedQueue, releaseNext };
+    });
+    registrationQueue = registration.then(() => undefined, () => undefined);
+    const { key, currentQueue, chainedQueue, releaseNext } = await registration;
+    await currentQueue;
+    try {
+        return await fn();
+    }
+    finally {
+        releaseNext();
+        if (fileMutationQueues.get(key) === chainedQueue) {
+            fileMutationQueues.delete(key);
+        }
+    }
+}
+//# sourceMappingURL=file-mutation-queue.js.map

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { createShellTool, createLocalBashOperations, getShellConfig, killProcessTree, waitForChildProcess, } from "./shell.js";
+export type { ShellToolOptions, ShellConfig, BashOperations, BashExecOptions, BashSpawnContext, BashSpawnHook, } from "./shell.js";
+export { createReadTool, detectSupportedImageMimeType, detectSupportedImageMimeTypeFromFile, } from "./read.js";
+export type { ReadToolOptions, ReadOperations } from "./read.js";
+export { createWriteTool } from "./write.js";
+export type { WriteToolOptions, WriteOperations } from "./write.js";
+export { createEditTool } from "./edit.js";
+export type { EditToolOptions, EditOperations, EditToolDetails, Edit } from "./edit.js";
+export { withFileMutationQueue } from "./file-mutation-queue.js";
+import type { ToolDefinition } from "@arnilo/prism";
+import type { ShellToolOptions } from "./shell.js";
+import type { ReadToolOptions } from "./read.js";
+import type { WriteToolOptions } from "./write.js";
+import type { EditToolOptions } from "./edit.js";
+/** Per-tool options combined for the aggregator factories. */
+export interface ToolsOptions {
+    shell?: ShellToolOptions;
+    read?: ReadToolOptions;
+    write?: WriteToolOptions;
+    edit?: EditToolOptions;
+}
+/**
+ * The four coding tools: `shell`, `read`, `write`, `edit`. Register all of them for a coding agent.
+ */
+export declare function createCodingTools(cwd: string, options?: ToolsOptions): readonly ToolDefinition[];
+/** Read-only subset: `read` only (this package ships no grep/find/ls). */
+export declare function createReadOnlyTools(cwd: string, options?: ToolsOptions): readonly ToolDefinition[];
+/** Every tool this package provides — identical to {@link createCodingTools} for now. */
+export declare function createAllTools(cwd: string, options?: ToolsOptions): readonly ToolDefinition[];

package/dist/index.js

@@ -0,0 +1,36 @@
+// @arnilo/prism-coding-agent public barrel.
+//
+// First-party coding tools for the Prism agent harness. Factory functions return Prism
+// `ToolDefinition`s that hosts register into a `ToolRegistry` (e.g.
+// `createToolRegistry(createCodingTools(cwd))`). No tools are auto-registered — import what you need.
+// --- per-tool factories & types ---
+export { createShellTool, createLocalBashOperations, getShellConfig, killProcessTree, waitForChildProcess, } from "./shell.js";
+export { createReadTool, detectSupportedImageMimeType, detectSupportedImageMimeTypeFromFile, } from "./read.js";
+export { createWriteTool } from "./write.js";
+export { createEditTool } from "./edit.js";
+// --- generic primitives (re-exported for hosts that want them) ---
+export { withFileMutationQueue } from "./file-mutation-queue.js";
+import { createShellTool } from "./shell.js";
+import { createReadTool } from "./read.js";
+import { createWriteTool } from "./write.js";
+import { createEditTool } from "./edit.js";
+/**
+ * The four coding tools: `shell`, `read`, `write`, `edit`. Register all of them for a coding agent.
+ */
+export function createCodingTools(cwd, options) {
+    return [
+        createShellTool(cwd, options?.shell),
+        createReadTool(cwd, options?.read),
+        createWriteTool(cwd, options?.write),
+        createEditTool(cwd, options?.edit),
+    ];
+}
+/** Read-only subset: `read` only (this package ships no grep/find/ls). */
+export function createReadOnlyTools(cwd, options) {
+    return [createReadTool(cwd, options?.read)];
+}
+/** Every tool this package provides — identical to {@link createCodingTools} for now. */
+export function createAllTools(cwd, options) {
+    return createCodingTools(cwd, options);
+}
+//# sourceMappingURL=index.js.map

package/dist/output-accumulator.d.ts

@@ -0,0 +1,51 @@
+import type { TruncationResult } from "./truncate.js";
+export interface OutputAccumulatorOptions {
+    maxLines?: number;
+    maxBytes?: number;
+    tempFilePrefix?: string;
+}
+export interface OutputSnapshot {
+    content: string;
+    truncation: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
+ * tail for display snapshots, and opens a temp file when the full output needs
+ * to be preserved.
+ */
+export declare class OutputAccumulator {
+    private readonly maxLines;
+    private readonly maxBytes;
+    private readonly maxRollingBytes;
+    private readonly tempFilePrefix;
+    private readonly decoder;
+    private rawChunks;
+    private tailText;
+    private tailBytes;
+    private tailStartsAtLineBoundary;
+    private totalRawBytes;
+    private totalDecodedBytes;
+    private completedLines;
+    private totalLines;
+    private currentLineBytes;
+    private hasOpenLine;
+    private finished;
+    private tempFilePath?;
+    private tempFileStream?;
+    constructor(options?: OutputAccumulatorOptions);
+    append(data: Buffer): void;
+    finish(): void;
+    snapshot(options?: {
+        persistIfTruncated?: boolean;
+    }): OutputSnapshot;
+    closeTempFile(): Promise<void>;
+    getLastLineBytes(): number;
+    private appendDecodedText;
+    private trimTail;
+    private getSnapshotText;
+    private shouldUseTempFile;
+    private ensureTempFile;
+}

package/dist/output-accumulator.js

@@ -0,0 +1,198 @@
+/**
+ * Streaming output accumulator with bounded memory.
+ *
+ * Behavioral port of pi's core/tools/output-accumulator for @arnilo/prism-coding-agent.
+ * Appends raw chunks through a streaming UTF-8 decoder, keeps only a decoded tail
+ * for display snapshots, and spills the full output to a temp file once limits are
+ * exceeded. stdlib only (node:crypto/fs/os).
+ *
+ * Single deviation from pi: the default temp-file prefix is `prism-output`
+ * (pi uses `pi-output`) — cosmetic, user-overridable via `tempFilePrefix`.
+ */
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "./truncate.js";
+function defaultTempFilePath(prefix) {
+    const id = randomBytes(8).toString("hex");
+    return join(tmpdir(), `${prefix}-${id}.log`);
+}
+function byteLength(text) {
+    return Buffer.byteLength(text, "utf-8");
+}
+/**
+ * Incrementally tracks streaming output with bounded memory.
+ *
+ * Appends decode chunks with a streaming UTF-8 decoder, keeps only a decoded
+ * tail for display snapshots, and opens a temp file when the full output needs
+ * to be preserved.
+ */
+export class OutputAccumulator {
+    maxLines;
+    maxBytes;
+    maxRollingBytes;
+    tempFilePrefix;
+    decoder = new TextDecoder();
+    rawChunks = [];
+    tailText = "";
+    tailBytes = 0;
+    tailStartsAtLineBoundary = true;
+    totalRawBytes = 0;
+    totalDecodedBytes = 0;
+    completedLines = 0;
+    totalLines = 0;
+    currentLineBytes = 0;
+    hasOpenLine = false;
+    finished = false;
+    tempFilePath;
+    tempFileStream;
+    constructor(options = {}) {
+        this.maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+        this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+        this.maxRollingBytes = Math.max(this.maxBytes * 2, 1);
+        this.tempFilePrefix = options.tempFilePrefix ?? "prism-output";
+    }
+    append(data) {
+        if (this.finished) {
+            throw new Error("Cannot append to a finished output accumulator");
+        }
+        this.totalRawBytes += data.length;
+        this.appendDecodedText(this.decoder.decode(data, { stream: true }));
+        if (this.tempFileStream || this.shouldUseTempFile()) {
+            this.ensureTempFile();
+            this.tempFileStream?.write(data);
+        }
+        else if (data.length > 0) {
+            this.rawChunks.push(data);
+        }
+    }
+    finish() {
+        if (this.finished) {
+            return;
+        }
+        this.finished = true;
+        this.appendDecodedText(this.decoder.decode());
+        if (this.shouldUseTempFile()) {
+            this.ensureTempFile();
+        }
+    }
+    snapshot(options = {}) {
+        const tailTruncation = truncateTail(this.getSnapshotText(), {
+            maxLines: this.maxLines,
+            maxBytes: this.maxBytes,
+        });
+        const truncated = this.totalLines > this.maxLines || this.totalDecodedBytes > this.maxBytes;
+        const truncatedBy = truncated
+            ? (tailTruncation.truncatedBy ?? (this.totalDecodedBytes > this.maxBytes ? "bytes" : "lines"))
+            : null;
+        const truncation = {
+            ...tailTruncation,
+            truncated,
+            truncatedBy,
+            totalLines: this.totalLines,
+            totalBytes: this.totalDecodedBytes,
+            maxLines: this.maxLines,
+            maxBytes: this.maxBytes,
+        };
+        if (options.persistIfTruncated && truncation.truncated) {
+            this.ensureTempFile();
+        }
+        return {
+            content: truncation.content,
+            truncation,
+            fullOutputPath: this.tempFilePath,
+        };
+    }
+    async closeTempFile() {
+        if (!this.tempFileStream) {
+            return;
+        }
+        const stream = this.tempFileStream;
+        this.tempFileStream = undefined;
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                stream.off("finish", onFinish);
+                reject(error);
+            };
+            const onFinish = () => {
+                stream.off("error", onError);
+                resolve();
+            };
+            stream.once("error", onError);
+            stream.once("finish", onFinish);
+            stream.end();
+        });
+    }
+    getLastLineBytes() {
+        return this.currentLineBytes;
+    }
+    appendDecodedText(text) {
+        if (text.length === 0) {
+            return;
+        }
+        const bytes = byteLength(text);
+        this.totalDecodedBytes += bytes;
+        this.tailText += text;
+        this.tailBytes += bytes;
+        if (this.tailBytes > this.maxRollingBytes * 2) {
+            this.trimTail();
+        }
+        let newlines = 0;
+        let lastNewline = -1;
+        for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1)) {
+            newlines++;
+            lastNewline = i;
+        }
+        if (newlines === 0) {
+            this.currentLineBytes += bytes;
+            this.hasOpenLine = true;
+        }
+        else {
+            this.completedLines += newlines;
+            const tail = text.slice(lastNewline + 1);
+            this.currentLineBytes = byteLength(tail);
+            this.hasOpenLine = tail.length > 0;
+        }
+        this.totalLines = this.completedLines + (this.hasOpenLine ? 1 : 0);
+    }
+    trimTail() {
+        const buffer = Buffer.from(this.tailText, "utf-8");
+        if (buffer.length <= this.maxRollingBytes) {
+            this.tailBytes = buffer.length;
+            return;
+        }
+        let start = buffer.length - this.maxRollingBytes;
+        while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) {
+            start++;
+        }
+        this.tailStartsAtLineBoundary =
+            start === 0 ? this.tailStartsAtLineBoundary : buffer[start - 1] === 0x0a;
+        this.tailText = buffer.subarray(start).toString("utf-8");
+        this.tailBytes = byteLength(this.tailText);
+    }
+    getSnapshotText() {
+        if (this.tailStartsAtLineBoundary) {
+            return this.tailText;
+        }
+        const firstNewline = this.tailText.indexOf("\n");
+        return firstNewline === -1 ? this.tailText : this.tailText.slice(firstNewline + 1);
+    }
+    shouldUseTempFile() {
+        return (this.totalRawBytes > this.maxBytes ||
+            this.totalDecodedBytes > this.maxBytes ||
+            this.totalLines > this.maxLines);
+    }
+    ensureTempFile() {
+        if (this.tempFilePath) {
+            return;
+        }
+        this.tempFilePath = defaultTempFilePath(this.tempFilePrefix);
+        this.tempFileStream = createWriteStream(this.tempFilePath);
+        for (const chunk of this.rawChunks) {
+            this.tempFileStream.write(chunk);
+        }
+        this.rawChunks = [];
+    }
+}
+//# sourceMappingURL=output-accumulator.js.map

package/dist/path-utils.d.ts

@@ -0,0 +1,8 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function expandPath(filePath: string): string;
+/**
+ * Resolve a path relative to the given cwd. Handles ~ expansion and absolute paths.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function resolveReadPath(filePath: string, cwd: string): string;
+export declare function resolveReadPathAsync(filePath: string, cwd: string): Promise<string>;