@slopus/rig 0.0.1

package/dist/tools/utils/prepareImageForClaude.js

@@ -0,0 +1,195 @@
+import { createHash } from "node:crypto";
+import { LRUCache } from "lru-cache";
+import { getImageProcessor } from "./getImageProcessor.js";
+import { ImageProcessingError } from "./ImageProcessingError.js";
+import { MAX_PROMPT_IMAGE_INPUT_BYTES, } from "./prepareImageForPrompt.js";
+export const CLAUDE_IMAGE_MAX_BASE64_BYTES = 5 * 1024 * 1024;
+export const CLAUDE_IMAGE_MAX_RAW_BYTES = (CLAUDE_IMAGE_MAX_BASE64_BYTES * 3) / 4;
+export const CLAUDE_IMAGE_MAX_DIMENSION = 2000;
+const JPEG_QUALITIES = [80, 60, 40, 20];
+const IMAGE_CACHE = new LRUCache({
+    max: 32,
+    maxSize: 64 * 1024 * 1024,
+    sizeCalculation: (image) => image.bytes.length,
+});
+/** Prepare an image using the same size and dimension policy as Claude Code. */
+export async function prepareImageForClaude(bytes) {
+    const input = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (input.length === 0) {
+        throw new ImageProcessingError("Image file is empty.");
+    }
+    if (input.length > MAX_PROMPT_IMAGE_INPUT_BYTES) {
+        throw new ImageProcessingError("Image exceeds the supported size limit.");
+    }
+    const cacheKey = createHash("sha1").update(input).update("claude").digest("hex");
+    const cached = IMAGE_CACHE.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    try {
+        const sharp = await getImageProcessor();
+        const metadata = await sharp(input, { failOn: "error" }).metadata();
+        const width = metadata.width;
+        const height = metadata.height;
+        if (width === undefined || height === undefined || width < 1 || height < 1) {
+            throw new ImageProcessingError("Image dimensions could not be determined.");
+        }
+        // Metadata alone does not prove the complete image is decodable.
+        await sharp(input, { failOn: "error" }).stats();
+        const sourceMediaType = metadata.format === "jpeg"
+            ? "image/jpeg"
+            : metadata.format === "png"
+                ? "image/png"
+                : metadata.format === "gif"
+                    ? "image/gif"
+                    : metadata.format === "webp"
+                        ? "image/webp"
+                        : undefined;
+        const scale = Math.min(1, CLAUDE_IMAGE_MAX_DIMENSION / width, CLAUDE_IMAGE_MAX_DIMENSION / height);
+        const targetWidth = Math.max(1, Math.round(width * scale));
+        const targetHeight = Math.max(1, Math.round(height * scale));
+        const shouldResize = targetWidth !== width || targetHeight !== height;
+        if (!shouldResize &&
+            input.length <= CLAUDE_IMAGE_MAX_RAW_BYTES &&
+            sourceMediaType !== undefined) {
+            const prepared = {
+                bytes: input,
+                height,
+                mediaType: sourceMediaType,
+                width,
+            };
+            IMAGE_CACHE.set(cacheKey, prepared);
+            return prepared;
+        }
+        if (!shouldResize && metadata.format === "png") {
+            const compressed = await sharp(input, { failOn: "error" })
+                .png({ compressionLevel: 9, palette: true })
+                .toBuffer();
+            if (compressed.length <= CLAUDE_IMAGE_MAX_RAW_BYTES) {
+                const prepared = {
+                    bytes: compressed,
+                    height,
+                    mediaType: "image/png",
+                    width,
+                };
+                IMAGE_CACHE.set(cacheKey, prepared);
+                return prepared;
+            }
+        }
+        if (!shouldResize && input.length > CLAUDE_IMAGE_MAX_RAW_BYTES) {
+            for (const quality of JPEG_QUALITIES) {
+                const compressed = await sharp(input, { failOn: "error" })
+                    .jpeg({ quality })
+                    .toBuffer();
+                if (compressed.length <= CLAUDE_IMAGE_MAX_RAW_BYTES) {
+                    const prepared = {
+                        bytes: compressed,
+                        height,
+                        mediaType: "image/jpeg",
+                        width,
+                    };
+                    IMAGE_CACHE.set(cacheKey, prepared);
+                    return prepared;
+                }
+            }
+        }
+        let resizedPipeline = sharp(input, { failOn: "error" }).resize(targetWidth, targetHeight, {
+            fit: "inside",
+            withoutEnlargement: true,
+        });
+        let resizedMediaType;
+        if (metadata.format === "jpeg") {
+            resizedPipeline = resizedPipeline.jpeg({ quality: 85 });
+            resizedMediaType = "image/jpeg";
+        }
+        else if (metadata.format === "webp") {
+            resizedPipeline = resizedPipeline.webp({ quality: 85 });
+            resizedMediaType = "image/webp";
+        }
+        else if (metadata.format === "gif") {
+            resizedPipeline = resizedPipeline.gif();
+            resizedMediaType = "image/gif";
+        }
+        else {
+            resizedPipeline = resizedPipeline.png();
+            resizedMediaType = "image/png";
+        }
+        const resized = await resizedPipeline.toBuffer();
+        if (resized.length <= CLAUDE_IMAGE_MAX_RAW_BYTES) {
+            const prepared = {
+                bytes: resized,
+                height: targetHeight,
+                mediaType: resizedMediaType,
+                width: targetWidth,
+            };
+            IMAGE_CACHE.set(cacheKey, prepared);
+            return prepared;
+        }
+        if (metadata.format === "png") {
+            const compressed = await sharp(input, { failOn: "error" })
+                .resize(targetWidth, targetHeight, {
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .png({ compressionLevel: 9, palette: true })
+                .toBuffer();
+            if (compressed.length <= CLAUDE_IMAGE_MAX_RAW_BYTES) {
+                const prepared = {
+                    bytes: compressed,
+                    height: targetHeight,
+                    mediaType: "image/png",
+                    width: targetWidth,
+                };
+                IMAGE_CACHE.set(cacheKey, prepared);
+                return prepared;
+            }
+        }
+        for (const quality of JPEG_QUALITIES) {
+            const compressed = await sharp(input, { failOn: "error" })
+                .resize(targetWidth, targetHeight, {
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+                .jpeg({ quality })
+                .toBuffer();
+            if (compressed.length <= CLAUDE_IMAGE_MAX_RAW_BYTES) {
+                const prepared = {
+                    bytes: compressed,
+                    height: targetHeight,
+                    mediaType: "image/jpeg",
+                    width: targetWidth,
+                };
+                IMAGE_CACHE.set(cacheKey, prepared);
+                return prepared;
+            }
+        }
+        const fallbackWidth = Math.min(targetWidth, 1000);
+        const fallbackHeight = Math.max(1, Math.round((targetHeight * fallbackWidth) / targetWidth));
+        const fallback = await sharp(input, { failOn: "error" })
+            .resize(fallbackWidth, fallbackHeight, {
+            fit: "inside",
+            withoutEnlargement: true,
+        })
+            .jpeg({ quality: 20 })
+            .toBuffer();
+        if (fallback.length > CLAUDE_IMAGE_MAX_RAW_BYTES) {
+            throw new ImageProcessingError("Image could not be compressed to Claude's size limit.");
+        }
+        const prepared = {
+            bytes: fallback,
+            height: fallbackHeight,
+            mediaType: "image/jpeg",
+            width: fallbackWidth,
+        };
+        IMAGE_CACHE.set(cacheKey, prepared);
+        return prepared;
+    }
+    catch (error) {
+        if (error instanceof ImageProcessingError) {
+            throw error;
+        }
+        throw new ImageProcessingError("Image could not be decoded or normalized for Claude.", {
+            cause: error,
+        });
+    }
+}

package/dist/tools/utils/prepareImageForPrompt.d.ts

@@ -0,0 +1,12 @@
+export declare const IMAGE_PROCESSING_ERROR_PLACEHOLDER = "image content omitted because it could not be processed";
+export declare const MAX_PROMPT_IMAGE_INPUT_BYTES: number;
+export type PromptImageDetail = "high" | "original";
+export type PromptImageMediaType = "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+export interface PreparedPromptImage {
+    bytes: Buffer;
+    height: number;
+    mediaType: PromptImageMediaType;
+    width: number;
+}
+export declare function prepareImageForPrompt(bytes: Uint8Array, detail: PromptImageDetail): Promise<PreparedPromptImage>;
+//# sourceMappingURL=prepareImageForPrompt.d.ts.map

package/dist/tools/utils/prepareImageForPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareImageForPrompt.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/prepareImageForPrompt.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kCAAkC,4DACc,CAAC;AAC9D,eAAO,MAAM,4BAA4B,QAAmB,CAAC;AAgB7D,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,UAAU,CAAC;AACpD,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;AAE3F,MAAM,WAAW,mBAAmB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,oBAAoB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,qBAAqB,CACvC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,iBAAiB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAoF9B"}

package/dist/tools/utils/prepareImageForPrompt.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { LRUCache } from "lru-cache";
+import { getImageProcessor } from "./getImageProcessor.js";
+import { ImageProcessingError } from "./ImageProcessingError.js";
+import { promptImageOutputDimensions, } from "./promptImageOutputDimensions.js";
+export const IMAGE_PROCESSING_ERROR_PLACEHOLDER = "image content omitted because it could not be processed";
+export const MAX_PROMPT_IMAGE_INPUT_BYTES = 32 * 1024 * 1024;
+const HIGH_DETAIL_LIMITS = {
+    maxDimension: 2048,
+    maxPatches: 2_500,
+};
+const ORIGINAL_DETAIL_LIMITS = {
+    maxDimension: 6000,
+    maxPatches: 10_000,
+};
+const IMAGE_CACHE = new LRUCache({
+    max: 32,
+    maxSize: 64 * 1024 * 1024,
+    sizeCalculation: (image) => image.bytes.length,
+});
+export async function prepareImageForPrompt(bytes, detail) {
+    const input = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (input.length === 0) {
+        throw new ImageProcessingError("Image file is empty.");
+    }
+    if (input.length > MAX_PROMPT_IMAGE_INPUT_BYTES) {
+        throw new ImageProcessingError("Image exceeds the supported size limit.");
+    }
+    const cacheKey = createHash("sha1").update(input).update(detail).digest("hex");
+    const cached = IMAGE_CACHE.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    try {
+        const sharp = await getImageProcessor();
+        const metadata = await sharp(input, { failOn: "error" }).metadata();
+        const width = metadata.width;
+        const height = metadata.height;
+        if (width === undefined || height === undefined || width < 1 || height < 1) {
+            throw new ImageProcessingError("Image dimensions could not be determined.");
+        }
+        const sourceFormat = metadata.format;
+        const preservableMediaType = sourceFormat === "jpeg"
+            ? "image/jpeg"
+            : sourceFormat === "png"
+                ? "image/png"
+                : sourceFormat === "webp"
+                    ? "image/webp"
+                    : undefined;
+        const limits = detail === "original" ? ORIGINAL_DETAIL_LIMITS : HIGH_DETAIL_LIMITS;
+        const target = promptImageOutputDimensions(width, height, limits);
+        const shouldResize = target.width !== width || target.height !== height;
+        if (!shouldResize && preservableMediaType !== undefined) {
+            await sharp(input, { failOn: "error" }).stats();
+            const prepared = {
+                bytes: input,
+                height,
+                mediaType: preservableMediaType,
+                width,
+            };
+            IMAGE_CACHE.set(cacheKey, prepared);
+            return prepared;
+        }
+        let pipeline = sharp(input, { failOn: "error" });
+        if (shouldResize) {
+            pipeline = pipeline.resize(target.width, target.height, {
+                fit: "fill",
+                kernel: sharp.kernel.linear,
+            });
+        }
+        // Match Codex: keep EXIF orientation paired with unrotated pixels instead of baking it in.
+        pipeline = pipeline.keepMetadata();
+        const outputMediaType = preservableMediaType ?? "image/png";
+        if (outputMediaType === "image/jpeg") {
+            pipeline = pipeline.jpeg({ quality: 85 });
+        }
+        else if (outputMediaType === "image/webp") {
+            pipeline = pipeline.webp({ lossless: true });
+        }
+        else {
+            pipeline = pipeline.png();
+        }
+        const prepared = {
+            bytes: await pipeline.toBuffer(),
+            height: target.height,
+            mediaType: outputMediaType,
+            width: target.width,
+        };
+        IMAGE_CACHE.set(cacheKey, prepared);
+        return prepared;
+    }
+    catch (error) {
+        if (error instanceof ImageProcessingError) {
+            throw error;
+        }
+        throw new ImageProcessingError("Image could not be decoded or normalized.", {
+            cause: error,
+        });
+    }
+}

package/dist/tools/utils/promptImageOutputDimensions.d.ts

@@ -0,0 +1,10 @@
+export interface PromptImageResizeLimits {
+    maxDimension: number;
+    maxPatches: number;
+}
+export interface PromptImageDimensions {
+    width: number;
+    height: number;
+}
+export declare function promptImageOutputDimensions(inputWidth: number, inputHeight: number, limits: PromptImageResizeLimits): PromptImageDimensions;
+//# sourceMappingURL=promptImageOutputDimensions.d.ts.map

package/dist/tools/utils/promptImageOutputDimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptImageOutputDimensions.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/promptImageOutputDimensions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB;AAID,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,uBAAuB,GAChC,qBAAqB,CAmCvB"}

package/dist/tools/utils/promptImageOutputDimensions.js

@@ -0,0 +1,26 @@
+const PATCH_SIZE = 32;
+export function promptImageOutputDimensions(inputWidth, inputHeight, limits) {
+    const width = Math.max(1, inputWidth);
+    const height = Math.max(1, inputHeight);
+    const initialPatchCount = Math.ceil(width / PATCH_SIZE) * Math.ceil(height / PATCH_SIZE);
+    if (width <= limits.maxDimension &&
+        height <= limits.maxDimension &&
+        initialPatchCount <= limits.maxPatches) {
+        return { width, height };
+    }
+    const dimensionScale = Math.min(limits.maxDimension / Math.max(width, height), 1);
+    const dimensionWidth = Math.max(1, Math.round(width * dimensionScale));
+    const dimensionHeight = Math.max(1, Math.round(height * dimensionScale));
+    const dimensionPatchCount = Math.ceil(dimensionWidth / PATCH_SIZE) * Math.ceil(dimensionHeight / PATCH_SIZE);
+    if (dimensionPatchCount <= limits.maxPatches) {
+        return { width: dimensionWidth, height: dimensionHeight };
+    }
+    let patchScale = Math.sqrt((PATCH_SIZE * PATCH_SIZE * limits.maxPatches) / dimensionWidth / dimensionHeight);
+    const scaledPatchesWide = (dimensionWidth * patchScale) / PATCH_SIZE;
+    const scaledPatchesHigh = (dimensionHeight * patchScale) / PATCH_SIZE;
+    patchScale *= Math.min(Math.floor(scaledPatchesWide) / scaledPatchesWide, Math.floor(scaledPatchesHigh) / scaledPatchesHigh);
+    return {
+        width: Math.max(1, Math.floor(dimensionWidth * patchScale)),
+        height: Math.max(1, Math.floor(dimensionHeight * patchScale)),
+    };
+}

package/dist/tools/utils/search.d.ts

@@ -0,0 +1,34 @@
+import type { AgentContext } from "../../agent/context/AgentContext.js";
+export interface GrepOptions {
+    pattern: string;
+    path?: string;
+    glob?: string;
+    outputMode?: "content" | "files_with_matches" | "count";
+    before?: number;
+    after?: number;
+    context?: number;
+    lineNumbers?: boolean;
+    ignoreCase?: boolean;
+    literal?: boolean;
+    type?: string;
+    headLimit?: number;
+    offset?: number;
+    multiline?: boolean;
+    cwd?: string;
+    signal?: AbortSignal;
+}
+export interface GrepResult {
+    text: string;
+    matches: number;
+    truncated: boolean;
+}
+export declare function runRipgrep(options: GrepOptions, context: AgentContext): Promise<GrepResult>;
+export interface GlobOptions {
+    pattern: string;
+    path?: string;
+    cwd?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}
+export declare function globFiles(options: GlobOptions, context: AgentContext): Promise<readonly string[]>;
+//# sourceMappingURL=search.d.ts.map

package/dist/tools/utils/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAIxE,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,SAAS,GAAG,oBAAoB,GAAG,OAAO,CAAC;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAmDjG;AAED,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED,wBAAsB,SAAS,CAC3B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,YAAY,GACtB,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAe5B"}

package/dist/tools/utils/search.js

@@ -0,0 +1,133 @@
+import { join, relative, sep } from "node:path";
+import { resolveToolPath } from "./path.js";
+import { runCommand } from "./shell.js";
+export async function runRipgrep(options, context) {
+    const cwd = options.cwd ?? context.bash.cwd;
+    const target = options.path ? resolveToolPath(options.path, cwd) : cwd;
+    const args = [];
+    const outputMode = options.outputMode ?? "files_with_matches";
+    if (outputMode === "files_with_matches") {
+        args.push("--files-with-matches");
+    }
+    else if (outputMode === "count") {
+        args.push("--count");
+    }
+    else if (options.lineNumbers !== false) {
+        args.push("--line-number");
+    }
+    if (options.ignoreCase)
+        args.push("--ignore-case");
+    if (options.literal)
+        args.push("--fixed-strings");
+    if (options.glob)
+        args.push("--glob", options.glob);
+    if (options.type)
+        args.push("--type", options.type);
+    if (options.multiline)
+        args.push("--multiline", "--multiline-dotall");
+    if (options.context !== undefined)
+        args.push("--context", String(options.context));
+    if (options.before !== undefined)
+        args.push("--before-context", String(options.before));
+    if (options.after !== undefined)
+        args.push("--after-context", String(options.after));
+    args.push(options.pattern, target);
+    const commandOptions = {
+        command: "rg",
+        args,
+        cwd,
+        timeoutMs: 30_000,
+        maxOutputBytes: 512_000,
+    };
+    if (options.signal !== undefined) {
+        commandOptions.signal = options.signal;
+    }
+    const command = await runCommand(commandOptions, context);
+    if (command.exitCode !== 0 && command.exitCode !== 1) {
+        throw new Error(command.stderr || command.stdout || `rg exited ${command.exitCode}`);
+    }
+    const lines = command.stdout.length === 0 ? [] : command.stdout.replace(/\n$/, "").split("\n");
+    const offset = Math.max(0, options.offset ?? 0);
+    const headLimit = options.headLimit ?? 250;
+    const limited = headLimit === 0 ? lines.slice(offset) : lines.slice(offset, offset + headLimit);
+    const truncated = headLimit !== 0 && offset + limited.length < lines.length;
+    return {
+        text: limited.join("\n"),
+        matches: lines.length,
+        truncated,
+    };
+}
+export async function globFiles(options, context) {
+    const cwd = options.cwd ?? context.fs.cwd;
+    const root = options.path ? resolveToolPath(options.path, cwd) : cwd;
+    const regex = globToRegExp(options.pattern);
+    const files = [];
+    await walkFiles(root, context, options.signal, async (filePath, mtimeMs) => {
+        const rel = relative(root, filePath).split(sep).join("/");
+        if (regex.test(rel) || regex.test(filePath.split(sep).join("/"))) {
+            files.push({ path: filePath, mtimeMs });
+        }
+    });
+    files.sort((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path));
+    return files.slice(0, options.limit ?? 100).map((file) => file.path);
+}
+async function walkFiles(root, context, signal, onFile) {
+    if (signal?.aborted) {
+        throw new Error("Search aborted.");
+    }
+    const entries = await context.fs.readdir(root);
+    for (const name of entries) {
+        if (signal?.aborted) {
+            throw new Error("Search aborted.");
+        }
+        if (name === ".git" || name === "node_modules") {
+            continue;
+        }
+        const full = join(root, name);
+        const stats = await context.fs.stat(full);
+        if (stats.isDirectory) {
+            await walkFiles(full, context, signal, onFile);
+        }
+        else if (stats.isFile) {
+            await onFile(full, stats.mtimeMs);
+        }
+    }
+}
+function globToRegExp(pattern) {
+    let source = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const next = pattern[i + 1];
+        if (char === "*" && next === "*") {
+            source += ".*";
+            i++;
+        }
+        else if (char === "*") {
+            source += "[^/]*";
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else if (char === "{") {
+            const end = pattern.indexOf("}", i);
+            if (end !== -1) {
+                source += `(${pattern
+                    .slice(i + 1, end)
+                    .split(",")
+                    .map(escapeRegExp)
+                    .join("|")})`;
+                i = end;
+            }
+            else {
+                source += "\\{";
+            }
+        }
+        else {
+            source += escapeRegExp(char ?? "");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}

package/dist/tools/utils/shell.d.ts

@@ -0,0 +1,27 @@
+import { type Static } from "@sinclair/typebox";
+import type { AgentContext } from "../../agent/context/AgentContext.js";
+import type { ContentBlock } from "../../agent/types.js";
+export declare const shellToolOutputSchema: import("@sinclair/typebox").TObject<{
+    stdout: import("@sinclair/typebox").TString;
+    stderr: import("@sinclair/typebox").TString;
+    exitCode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>;
+    timedOut: import("@sinclair/typebox").TBoolean;
+}>;
+export interface RunCommandOptions {
+    command: string;
+    args?: readonly string[];
+    cwd?: string;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    signal?: AbortSignal;
+}
+export interface RunCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export declare function runShellCommand(command: string, options: Omit<RunCommandOptions, "command" | "args"> | undefined, context: AgentContext): Promise<RunCommandResult>;
+export declare function runCommand(options: RunCommandOptions, context: AgentContext): Promise<RunCommandResult>;
+export declare function shellOutputToText(result: Static<typeof shellToolOutputSchema>): readonly ContentBlock[];
+//# sourceMappingURL=shell.d.ts.map

package/dist/tools/utils/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/shell.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED,wBAAsB,eAAe,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,GAAG,MAAM,CAAC,YAAK,EACzD,OAAO,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAS3B;AAED,wBAAsB,UAAU,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAS3B;AAUD,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,MAAM,CAAC,OAAO,qBAAqB,CAAC,GAC7C,SAAS,YAAY,EAAE,CAQzB"}

package/dist/tools/utils/shell.js

@@ -0,0 +1,48 @@
+import { Type } from "@sinclair/typebox";
+export const shellToolOutputSchema = Type.Object({
+    stdout: Type.String(),
+    stderr: Type.String(),
+    exitCode: Type.Union([Type.Number(), Type.Null()]),
+    timedOut: Type.Boolean(),
+});
+export async function runShellCommand(command, options = {}, context) {
+    const runOptions = {
+        command,
+        cwd: options.cwd ?? context.bash.cwd,
+    };
+    if (options.timeoutMs !== undefined)
+        runOptions.timeoutMs = options.timeoutMs;
+    if (options.maxOutputBytes !== undefined)
+        runOptions.maxOutputBytes = options.maxOutputBytes;
+    if (options.signal !== undefined)
+        runOptions.signal = options.signal;
+    return context.bash.run(runOptions);
+}
+export async function runCommand(options, context) {
+    const runOptions = {
+        command: [options.command, ...(options.args ?? []).map(shellQuote)].join(" "),
+        cwd: options.cwd ?? context.bash.cwd,
+    };
+    if (options.timeoutMs !== undefined)
+        runOptions.timeoutMs = options.timeoutMs;
+    if (options.maxOutputBytes !== undefined)
+        runOptions.maxOutputBytes = options.maxOutputBytes;
+    if (options.signal !== undefined)
+        runOptions.signal = options.signal;
+    return context.bash.run(runOptions);
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=@%+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function shellOutputToText(result) {
+    const chunks = [
+        result.stdout ? `stdout:\n${result.stdout}` : "",
+        result.stderr ? `stderr:\n${result.stderr}` : "",
+        `exit_code: ${result.exitCode ?? "null"}`,
+        result.timedOut ? "timed_out: true" : "",
+    ].filter((chunk) => chunk.length > 0);
+    return [{ type: "text", text: chunks.join("\n\n") }];
+}

package/dist/tools/utils/singleLineText.d.ts

@@ -0,0 +1,2 @@
+export declare function singleLineText(text: string): string;
+//# sourceMappingURL=singleLineText.d.ts.map

package/dist/tools/utils/singleLineText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleLineText.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/singleLineText.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/tools/utils/singleLineText.js

@@ -0,0 +1,3 @@
+export function singleLineText(text) {
+    return text.replace(/\s+/gu, " ").trim();
+}

package/dist/tools/utils/summarizeShellOutput.d.ts

@@ -0,0 +1,4 @@
+import type { Static } from "@sinclair/typebox";
+import type { shellToolOutputSchema } from "./shell.js";
+export declare function summarizeShellOutput(result: Static<typeof shellToolOutputSchema>): string;
+//# sourceMappingURL=summarizeShellOutput.d.ts.map

package/dist/tools/utils/summarizeShellOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarizeShellOutput.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/summarizeShellOutput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIxD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,qBAAqB,CAAC,GAAG,MAAM,CAQzF"}

package/dist/tools/utils/summarizeShellOutput.js

@@ -0,0 +1,11 @@
+import { singleLineText } from "./singleLineText.js";
+import { summarizeTextOutput } from "./summarizeTextOutput.js";
+export function summarizeShellOutput(result) {
+    const suffix = result.timedOut
+        ? " (timed out)"
+        : result.exitCode !== null && result.exitCode !== 0
+            ? ` (exit ${result.exitCode})`
+            : "";
+    const output = summarizeTextOutput([result.stdout, result.stderr].filter(Boolean).join("\n"));
+    return singleLineText(`${output}${suffix}`);
+}

package/dist/tools/utils/summarizeTextOutput.d.ts

@@ -0,0 +1,2 @@
+export declare function summarizeTextOutput(text: string, empty?: string): string;
+//# sourceMappingURL=summarizeTextOutput.d.ts.map

package/dist/tools/utils/summarizeTextOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarizeTextOutput.d.ts","sourceRoot":"","sources":["../../../sources/tools/utils/summarizeTextOutput.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAgB,GAAG,MAAM,CAU/E"}

package/dist/tools/utils/summarizeTextOutput.js

@@ -0,0 +1,12 @@
+import { countTextLines } from "./countTextLines.js";
+import { singleLineText } from "./singleLineText.js";
+export function summarizeTextOutput(text, empty = "(no output)") {
+    const lines = text.split(/\r?\n/u);
+    const firstLine = lines.find((line) => line.trim().length > 0);
+    if (firstLine === undefined) {
+        return empty;
+    }
+    const lineCount = countTextLines(text);
+    const suffix = lineCount > 1 ? ` (+${lineCount - 1} lines)` : "";
+    return singleLineText(`${firstLine}${suffix}`);
+}