@cursor/july 0.1.103 → 0.1.105

package/dist/internal/factory-resource-channel.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { defineChannel, localDevStrict, POST } from "../channels.js";
+import { tagOutcome } from "./channel-dispatch.js";
+import { attachHostedAdmissionAdapter } from "./hosted-admission-adapter.js";
+import { bindLocalIngressSend } from "./local-ingress.js";
+/**
+ * Shared pack for Factory resource channels that have one event type, no
+ * subscription filter, and the same local-replay / hosted-admission path.
+ */
+export function createFactoryResourceChannel(spec) {
+    const optionsByDefinition = new WeakMap();
+    function dispatchEvent(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield input.options.onEvent(input.event, bindLocalIngressSend(input.args, {
+                identity: input.options.continuation,
+                kind: spec.kind,
+                eventType: input.event.eventType,
+                payload: input.event,
+            }));
+            return tagOutcome(Response.json({ ok: true }), "task");
+        });
+    }
+    function channel(options) {
+        var _a, _b;
+        const routePath = (_a = options.path) !== null && _a !== void 0 ? _a : "/";
+        const definition = defineChannel({
+            auth: (_b = options.auth) !== null && _b !== void 0 ? _b : [localDevStrict()],
+            meta: {
+                kind: spec.kind,
+                factoryEventTypes: spec.eventTypes,
+            },
+            onStart: options.onStart,
+            onStop: options.onStop,
+            routes: [
+                POST(routePath, {
+                    description: spec.replayDescription,
+                    bodySchema: spec.eventSchema,
+                    handler: (_request, args) => __awaiter(this, void 0, void 0, function* () {
+                        return dispatchEvent({
+                            options,
+                            event: args.body,
+                            args,
+                        });
+                    }),
+                }),
+            ],
+        });
+        optionsByDefinition.set(definition, options);
+        attachHostedAdmissionAdapter(definition, {
+            kind: spec.kind,
+            dispatch: (_a) => __awaiter(this, [_a], void 0, function* ({ payload, args }) {
+                const parsed = spec.eventSchema.safeParse(payload);
+                if (!parsed.success) {
+                    return Response.json({ ok: false, error: spec.invalidError }, { status: 400 });
+                }
+                return dispatchEvent({
+                    options,
+                    event: parsed.data,
+                    args,
+                });
+            }),
+        });
+        return definition;
+    }
+    function getOptions(definition) {
+        return optionsByDefinition.get(definition);
+    }
+    return { channel, getOptions };
+}

package/dist/internal/filesystem/errors.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Typed FileSystem throws. Every method error is a {@link PathError}
+ * so composers (`unionFs`) can rewrite `path` without scraping
+ * `error.message`.
+ *
+ * Messages stay the FileSystem contract strings. `path` is the
+ * absolute posix path the error is about (child-root on a mount,
+ * namespace path after `unionFs` remaps it).
+ */
+/**
+ * Base of every FileSystem method throw. Config / factory errors
+ * (`FileSystemConfigError`, empty `overlayFs`) are not PathErrors.
+ */
+export declare class PathError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+    /**
+     * Same error at a rewritten path. `unionFs` prepends the mount
+     * prefix this way. Subclass identity and extra fields stay.
+     */
+    withPath(path: string): this;
+    protected recreate(path: string, message: string): this;
+}
+export declare class FileNotFoundError extends PathError {
+    constructor(path: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+export declare class ReadOnlyMountError extends PathError {
+    constructor(path: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+export declare class NoMountError extends PathError {
+    constructor(path: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+export declare class WriteFailedError extends PathError {
+    constructor(path: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+export declare class DeleteNotSupportedError extends PathError {
+    constructor(path: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+/**
+ * Exact-edit contract failures (`oldText is empty`, uniqueness).
+ * `message` is the contract string; it does not embed `path`.
+ */
+export declare class EditError extends PathError {
+    protected recreate(path: string, message: string): this;
+}
+export declare class InvalidGrepPatternError extends PathError {
+    readonly pattern: string;
+    constructor(pattern: string, path?: string, message?: string);
+    protected recreate(path: string, message: string): this;
+}
+export declare function isFileNotFoundError(error: unknown): boolean;
+export declare function isInvalidGrepPatternError(error: unknown): boolean;
+/**
+ * Remap a child throw onto a mount prefix. Typed {@link PathError}
+ * keeps its class and rewrites `path`. Untyped `Error` still gets
+ * a best-effort message rewrite so older custom trees keep working.
+ */
+export declare function remapPathError(error: unknown, prefix: string): Error;
+//# sourceMappingURL=errors.d.ts.map

package/dist/internal/filesystem/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAoCH;;;GAGG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAIxC;IAED;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAS3B;IAED,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAEtD;CACF;AAED,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAEzC;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAEzC;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,qBAAa,YAAa,SAAQ,SAAS;IACzC,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAEzC;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAEzC;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,qBAAa,uBAAwB,SAAQ,SAAS;IACpD,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAKzC;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED;;;GAGG;AACH,qBAAa,SAAU,SAAQ,SAAS;IACtC,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,qBAAa,uBAAwB,SAAQ,SAAS;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,SAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAGxD;IAED,UAAmB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/D;CACF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK3D;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMjE;AAWD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAQpE"}

package/dist/internal/filesystem/errors.js

@@ -0,0 +1,175 @@
+/**
+ * Typed FileSystem throws. Every method error is a {@link PathError}
+ * so composers (`unionFs`) can rewrite `path` without scraping
+ * `error.message`.
+ *
+ * Messages stay the FileSystem contract strings. `path` is the
+ * absolute posix path the error is about (child-root on a mount,
+ * namespace path after `unionFs` remaps it).
+ */
+import path from "node:path";
+function normalizeErrorPath(input) {
+    const slashes = input.replace(/\\/g, "/");
+    if (slashes === "") {
+        return "/";
+    }
+    const withSlash = slashes.startsWith("/") ? slashes : `/${slashes}`;
+    const resolved = path.posix.normalize(withSlash);
+    if (resolved.length > 1 && resolved.endsWith("/")) {
+        return resolved.slice(0, -1);
+    }
+    return resolved === "." || resolved === "" ? "/" : resolved;
+}
+const ROOT_MESSAGE_PREFIX = /^(not found|read-only mount|write failed|edit failed|no mount for path|delete is not supported): \/$/;
+function rewritePathInMessage(message, from, to) {
+    if (from === to) {
+        return message;
+    }
+    if (from === "/") {
+        return ROOT_MESSAGE_PREFIX.test(message)
+            ? message.replace(/\/$/, to)
+            : message;
+    }
+    return message.includes(from) ? message.split(from).join(to) : message;
+}
+/**
+ * Base of every FileSystem method throw. Config / factory errors
+ * (`FileSystemConfigError`, empty `overlayFs`) are not PathErrors.
+ */
+export class PathError extends Error {
+    constructor(path, message) {
+        super(message);
+        this.name = new.target.name;
+        this.path = normalizeErrorPath(path);
+    }
+    /**
+     * Same error at a rewritten path. `unionFs` prepends the mount
+     * prefix this way. Subclass identity and extra fields stay.
+     */
+    withPath(path) {
+        const next = normalizeErrorPath(path);
+        if (next === this.path) {
+            return this;
+        }
+        return this.recreate(next, rewritePathInMessage(this.message, this.path, next));
+    }
+    recreate(path, message) {
+        return new PathError(path, message);
+    }
+}
+export class FileNotFoundError extends PathError {
+    constructor(path, message) {
+        super(path, message !== null && message !== void 0 ? message : `not found: ${normalizeErrorPath(path)}`);
+    }
+    recreate(path, message) {
+        return new FileNotFoundError(path, message);
+    }
+}
+export class ReadOnlyMountError extends PathError {
+    constructor(path, message) {
+        super(path, message !== null && message !== void 0 ? message : `read-only mount: ${normalizeErrorPath(path)}`);
+    }
+    recreate(path, message) {
+        return new ReadOnlyMountError(path, message);
+    }
+}
+export class NoMountError extends PathError {
+    constructor(path, message) {
+        super(path, message !== null && message !== void 0 ? message : `no mount for path: ${normalizeErrorPath(path)}`);
+    }
+    recreate(path, message) {
+        return new NoMountError(path, message);
+    }
+}
+export class WriteFailedError extends PathError {
+    constructor(path, message) {
+        super(path, message !== null && message !== void 0 ? message : `write failed: ${normalizeErrorPath(path)}`);
+    }
+    recreate(path, message) {
+        return new WriteFailedError(path, message);
+    }
+}
+export class DeleteNotSupportedError extends PathError {
+    constructor(path, message) {
+        super(path, message !== null && message !== void 0 ? message : `delete is not supported: ${normalizeErrorPath(path)}`);
+    }
+    recreate(path, message) {
+        return new DeleteNotSupportedError(path, message);
+    }
+}
+/**
+ * Exact-edit contract failures (`oldText is empty`, uniqueness).
+ * `message` is the contract string; it does not embed `path`.
+ */
+export class EditError extends PathError {
+    recreate(path, message) {
+        return new EditError(path, message);
+    }
+}
+export class InvalidGrepPatternError extends PathError {
+    constructor(pattern, path = "/", message) {
+        super(path, message !== null && message !== void 0 ? message : `invalid grep pattern: ${pattern}`);
+        this.pattern = pattern;
+    }
+    recreate(path, message) {
+        return new InvalidGrepPatternError(this.pattern, path, message);
+    }
+}
+export function isFileNotFoundError(error) {
+    return (error instanceof FileNotFoundError ||
+        (error instanceof Error && error.message.startsWith("not found:")));
+}
+export function isInvalidGrepPatternError(error) {
+    return (error instanceof InvalidGrepPatternError ||
+        (error instanceof Error &&
+            error.message.startsWith("invalid grep pattern:")));
+}
+const CONTRACT_PATH_LABELS = [
+    "not found: ",
+    "read-only mount: ",
+    "write failed: ",
+    "edit failed: ",
+    "no mount for path: ",
+    "delete is not supported: ",
+];
+/**
+ * Remap a child throw onto a mount prefix. Typed {@link PathError}
+ * keeps its class and rewrites `path`. Untyped `Error` still gets
+ * a best-effort message rewrite so older custom trees keep working.
+ */
+export function remapPathError(error, prefix) {
+    if (error instanceof PathError) {
+        return error.withPath(joinMountPath(error.path, prefix));
+    }
+    if (!(error instanceof Error)) {
+        return new PathError(prefix, String(error));
+    }
+    return rewriteUntypedMountError(error, prefix);
+}
+function joinMountPath(childPath, prefix) {
+    const mount = normalizeErrorPath(prefix);
+    const child = normalizeErrorPath(childPath);
+    if (mount === "/") {
+        return child;
+    }
+    if (child === "/") {
+        return mount;
+    }
+    return `${mount}${child}`;
+}
+function rewriteUntypedMountError(error, prefix) {
+    for (const label of CONTRACT_PATH_LABELS) {
+        if (!error.message.startsWith(label)) {
+            continue;
+        }
+        const childPath = error.message.slice(label.length);
+        const next = `${label}${joinMountPath(childPath, prefix)}`;
+        if (next === error.message) {
+            return error;
+        }
+        const rewritten = new Error(next);
+        rewritten.name = error.name;
+        return rewritten;
+    }
+    return error;
+}

package/dist/internal/filesystem/format.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Model-facing strings that match Cursor SDK native tool output
+ * (LocalLsExecutor / read / grep / glob formatters).
+ */
+import type { GrepUnionResult } from "../../filesystem.js";
+import type { LsDirectoryTreeNode } from "./walk.js";
+/**
+ * Number already-sliced Read content. `FileSystem.read` applies offset/
+ * limit; do not window again or line numbers restart at 1.
+ */
+export declare function slicedReadStartLine(totalLines: number, offset?: number): number;
+export declare function formatNumberedLines(content: string, options?: {
+    offset?: number;
+    limit?: number;
+    /** When set, `content` is already the window; number from this line. */
+    startLine?: number;
+    totalLines?: number;
+}): string;
+export declare function formatLsTree(result: LsDirectoryTreeNode): string;
+export declare function formatGlobOutput(dir: string, files: readonly string[]): string;
+export declare function formatGrepOutput(union: GrepUnionResult | undefined): string;
+export declare function formatWriteOutput(path: string): string;
+export declare function formatStrReplaceOutput(args: {
+    path: string;
+    replaceAll: boolean;
+    occurrencesModified: number;
+}): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/internal/filesystem/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAKrD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAQR;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,GACL,MAAM,CAuBR;AAqBD,wBAAgB,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAsChE;AAsED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAmBR;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CA0C3E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,MAAM,CAQT"}

package/dist/internal/filesystem/format.js

@@ -0,0 +1,213 @@
+/**
+ * Model-facing strings that match Cursor SDK native tool output
+ * (LocalLsExecutor / read / grep / glob formatters).
+ */
+import { posix } from "node:path";
+const LS_RENDER_CHARACTER_BUDGET = 10000;
+const GLOB_TOTAL_CHARACTER_BUDGET = 5000;
+/**
+ * Number already-sliced Read content. `FileSystem.read` applies offset/
+ * limit; do not window again or line numbers restart at 1.
+ */
+export function slicedReadStartLine(totalLines, offset) {
+    if (offset === undefined) {
+        return 1;
+    }
+    if (offset < 0) {
+        return Math.max(1, totalLines + offset + 1);
+    }
+    return Math.max(1, offset);
+}
+export function formatNumberedLines(content, options = {}) {
+    var _a;
+    const lines = content === "" ? [] : content.split("\n");
+    if (lines.length === 0) {
+        return "";
+    }
+    const { offset, limit, startLine } = options;
+    let start = 1;
+    let window = lines;
+    const total = (_a = options.totalLines) !== null && _a !== void 0 ? _a : lines.length;
+    if (startLine !== undefined) {
+        start = startLine;
+    }
+    else if (offset !== undefined || limit !== undefined) {
+        const effectiveOffset = offset !== null && offset !== void 0 ? offset : 1;
+        const effectiveLimit = limit !== null && limit !== void 0 ? limit : (effectiveOffset < 0 ? Math.abs(effectiveOffset) : total);
+        start =
+            effectiveOffset < 0
+                ? Math.max(1, total + effectiveOffset + 1)
+                : Math.max(1, effectiveOffset);
+        const end = Math.min(total, start + effectiveLimit - 1);
+        window = lines.slice(start - 1, end);
+    }
+    return renderNumberedWindow(window, start, total);
+}
+function renderNumberedWindow(window, start, total) {
+    const numbered = window.map((line, index) => `${String(start + index).padStart(6, " ")}|${line}`);
+    let result = numbered.join("\n");
+    if (start > 1) {
+        result = `... ${start - 1} ${start - 1 === 1 ? "line" : "lines"} not shown ...\n${result}`;
+    }
+    const end = start + window.length - 1;
+    if (end < total) {
+        result += `\n... ${total - end} ${total - end === 1 ? "line" : "lines"} not shown ...`;
+    }
+    return result;
+}
+export function formatLsTree(result) {
+    if (result.childrenWereProcessed &&
+        result.childrenDirs.length === 0 &&
+        result.childrenFiles.length === 0) {
+        const trailingSlash = result.absPath.endsWith("/") ? "" : "/";
+        return `${result.absPath}${trailingSlash}\n... no children found ...`;
+    }
+    const characterBudget = LS_RENDER_CHARACTER_BUDGET;
+    let toolResponse = renderDirectoryTree(result).result;
+    if (toolResponse.length > characterBudget) {
+        toolResponse = renderDirectoryTree(result, true, 0).result;
+        if (toolResponse.length > characterBudget) {
+            toolResponse = renderDirectoryTree(result, false, 0).result;
+        }
+    }
+    const notes = [];
+    if (!result.childrenWereProcessed || toolResponse.length > characterBudget) {
+        if (toolResponse.length > characterBudget) {
+            toolResponse = toolResponse.slice(0, characterBudget);
+            const lastNewlineIndex = toolResponse.lastIndexOf("\n");
+            if (lastNewlineIndex > 0) {
+                toolResponse = toolResponse.slice(0, lastNewlineIndex + 1);
+            }
+        }
+        toolResponse += "    ...\n";
+        notes.push(`target_directory is too large (either too many children or their names are too long).` +
+            ` Immediate children were truncated. Try doing more specific search or use the script tool.`);
+    }
+    if (notes.length === 1) {
+        toolResponse += `\nNote: ${notes[0]}`;
+    }
+    return toolResponse;
+}
+function renderDirectoryTree(rootDirectory, renderExtensionCounts = true, renderDepthLimit) {
+    function render(dir, depth) {
+        const indent = "  ".repeat(depth);
+        let result;
+        if (depth === 0) {
+            const trailingSep = dir.absPath.endsWith("/") ? "" : "/";
+            result = `${dir.absPath}${trailingSep}\n`;
+        }
+        else {
+            result = `${indent}- ${posix.basename(dir.absPath)}/\n`;
+        }
+        const allChildren = [
+            ...dir.childrenFiles.map((file) => ({ type: "file", name: file.name })),
+            ...dir.childrenDirs.map((childDir) => ({
+                type: "dir",
+                name: posix.basename(childDir.absPath),
+                dir: childDir,
+            })),
+        ];
+        allChildren.sort((left, right) => left.name.localeCompare(right.name));
+        const childIndent = "  ".repeat(depth + 1);
+        for (const child of allChildren) {
+            if (child.type === "file") {
+                result += `${childIndent}- ${child.name}\n`;
+                continue;
+            }
+            const childDir = child.dir;
+            if (childDir.childrenWereProcessed &&
+                (renderDepthLimit === undefined || depth < renderDepthLimit)) {
+                result += render(childDir, depth + 1);
+                continue;
+            }
+            const extensionCounts = Object.entries(childDir.fullSubtreeExtensionCounts);
+            if (extensionCounts.length > 0 && renderExtensionCounts) {
+                const sorted = [...extensionCounts].sort(([, countA], [, countB]) => countB - countA);
+                const shown = sorted.slice(0, 3);
+                const summary = shown
+                    .map(([ext, count]) => `${count} *${ext === "" ? "" : ext}`)
+                    .join(", ");
+                result += `${childIndent}- ${child.name}/ (${childDir.numFiles} files: ${summary})\n`;
+            }
+            else {
+                result += `${childIndent}- ${child.name}/\n`;
+            }
+        }
+        return result;
+    }
+    return { result: render(rootDirectory, 0) };
+}
+export function formatGlobOutput(dir, files) {
+    var _a;
+    const normalizedRoot = dir.replace(/\/+$/, "") || "/";
+    const prefix = normalizedRoot === "/" ? "/" : `${normalizedRoot}/`;
+    const relative = files.map((filePath) => filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath);
+    if (relative.length === 0) {
+        return `Result of search in '${dir}': 0 files found\n`;
+    }
+    let output = `Result of search in '${dir}' (total ${relative.length} file${relative.length === 1 ? "" : "s"}):\n`;
+    for (let i = 0; i < relative.length; i++) {
+        const file = (_a = relative[i]) !== null && _a !== void 0 ? _a : "";
+        if (output.length + file.length > GLOB_TOTAL_CHARACTER_BUDGET) {
+            output += `... ${relative.length - i} more files ... (Do a more specific search if needed)\n`;
+            break;
+        }
+        output += `- ${file}\n`;
+    }
+    return output;
+}
+export function formatGrepOutput(union) {
+    var _a, _b, _c, _d;
+    if (union === undefined) {
+        return "No matches found";
+    }
+    if (union.type === "files") {
+        if (union.output.files.length === 0) {
+            return "No files with matches found";
+        }
+        return union.output.files.join("\n");
+    }
+    if (union.type === "count") {
+        if (union.output.counts.length === 0) {
+            return "No matches found";
+        }
+        return union.output.counts
+            .map((row) => `${row.file}:${row.count}`)
+            .join("\n");
+    }
+    if (union.output.matches.length === 0) {
+        return "No matches found";
+    }
+    const lines = [];
+    let currentFile;
+    for (const match of union.output.matches) {
+        if (match.file !== currentFile) {
+            if (currentFile !== undefined) {
+                lines.push("");
+            }
+            currentFile = match.file;
+            lines.push(match.file);
+        }
+        const before = (_a = match.beforeContext) !== null && _a !== void 0 ? _a : [];
+        const matchLine = (_b = match.lineNumber) !== null && _b !== void 0 ? _b : 1;
+        before.forEach((line, index) => {
+            lines.push(`  ${matchLine - before.length + index}-${line}`);
+        });
+        lines.push(`  ${(_c = match.lineNumber) !== null && _c !== void 0 ? _c : ""}:${match.line}`);
+        ((_d = match.afterContext) !== null && _d !== void 0 ? _d : []).forEach((line, index) => {
+            lines.push(`  ${matchLine + 1 + index}-${line}`);
+        });
+    }
+    return lines.join("\n");
+}
+export function formatWriteOutput(path) {
+    return `Wrote contents to ${path}`;
+}
+export function formatStrReplaceOutput(args) {
+    if (!args.replaceAll) {
+        return `The file ${args.path} has been updated.`;
+    }
+    const occurrenceLabel = args.occurrencesModified === 1 ? "occurrence" : "occurrences";
+    const verb = args.occurrencesModified === 1 ? "has" : "have";
+    return `${args.occurrencesModified} ${occurrenceLabel} in file ${args.path} ${verb} been updated.`;
+}

package/dist/internal/filesystem/merge.d.ts

@@ -0,0 +1,34 @@
+/**
+ * K-way merge of already-sorted streams. Each source must be ordered
+ * under the same `compare`; the merge does not re-sort a source.
+ *
+ * A binary heap of heads keeps the next yield O(log k) in the number of
+ * sources. `unique` skips later copies of a key so an earlier source can
+ * shadow a later one (the union rule).
+ */
+export interface MergeSortedOptions<T> {
+    compare: (left: T, right: T) => number;
+    unique?: boolean;
+}
+/**
+ * Merge already-sorted iterables / async iterables under `compare`.
+ * Equal keys (`compare === 0`) keep source order: earlier `sources`
+ * index wins. With `unique`, those later copies are skipped.
+ */
+export declare function mergeSorted<T>(sources: Array<Iterable<T> | AsyncIterable<T>>, options: MergeSortedOptions<T>): AsyncGenerator<T>;
+/**
+ * Binary min-heap. `compare(a, b) < 0` means `a` is before `b`.
+ * Exported for the invariant tests; composers use {@link mergeSorted}.
+ */
+export declare class MinHeap<T> {
+    private readonly compare;
+    private readonly items;
+    constructor(compare: (left: T, right: T) => number);
+    get size(): number;
+    peek(): T | undefined;
+    push(item: T): void;
+    pop(): T | undefined;
+    private bubbleUp;
+    private bubbleDown;
+}
+//# sourceMappingURL=merge.d.ts.map

package/dist/internal/filesystem/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/internal/filesystem/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAQD;;;;GAIG;AACH,wBAAuB,WAAW,CAAC,CAAC,EAClC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,EAC9C,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC,CAsCnB;AAoCD;;;GAGG;AACH,qBAAa,OAAO,CAAC,CAAC;IAGR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,YAA6B,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EAAI;IAEvE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,CAAC,GAAG,SAAS,CAEpB;IAED,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAGlB;IAED,GAAG,IAAI,CAAC,GAAG,SAAS,CAYnB;IAED,OAAO,CAAC,QAAQ;IAmBhB,OAAO,CAAC,UAAU;CAqCnB"}