@slopus/rig 0.0.1

package/dist/tools/codex/exec_command.js

@@ -0,0 +1,45 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { runShellCommand, shellOutputToText, shellToolOutputSchema, summarizeShellOutput, } from "../utils/index.js";
+export const codexExecCommandTool = defineTool({
+    name: "exec_command",
+    label: "exec_command",
+    description: "Runs a command in a PTY, returning output or a session ID for ongoing interaction.",
+    arguments: Type.Object({
+        cmd: Type.String({ description: "Shell command to execute." }),
+        workdir: Type.Optional(Type.String({
+            description: "Working directory for the command. Defaults to the turn cwd.",
+        })),
+        tty: Type.Optional(Type.Boolean({
+            description: "True allocates a PTY for the command; false or omitted uses plain pipes.",
+        })),
+        yield_time_ms: Type.Optional(Type.Number({
+            description: "Wait before yielding output. Defaults to 10000 ms; effective range is 250-30000 ms.",
+        })),
+        max_output_tokens: Type.Optional(Type.Number({
+            description: "Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy.",
+        })),
+        shell: Type.Optional(Type.String({
+            description: "Shell binary to launch. Defaults to the user's default shell.",
+        })),
+        login: Type.Optional(Type.Boolean({
+            description: "True runs the shell with -l/-i semantics; false disables them. Defaults to true.",
+        })),
+    }),
+    returnType: shellToolOutputSchema,
+    execute: async ({ cmd, workdir, yield_time_ms, max_output_tokens }, context, execution) => {
+        const options = {
+            maxOutputBytes: Math.max(4_000, (max_output_tokens ?? 10_000) * 4),
+        };
+        if (workdir !== undefined)
+            options.cwd = workdir;
+        if (yield_time_ms !== undefined)
+            options.timeoutMs = yield_time_ms;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        return runShellCommand(cmd, options, context);
+    },
+    toLLM: shellOutputToText,
+    toUI: (result) => summarizeShellOutput(result),
+    locks: [],
+});

package/dist/tools/codex/index.d.ts

@@ -0,0 +1,37 @@
+export { codexApplyPatchTool } from "./apply_patch.js";
+export { codexExecCommandTool } from "./exec_command.js";
+export { codexViewImageTool } from "./view_image.js";
+export { codexWriteStdinTool } from "./write_stdin.js";
+export declare const codexTools: readonly [import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    cmd: import("@sinclair/typebox").TString;
+    workdir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tty: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    yield_time_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    max_output_tokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    shell: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    login: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, 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;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    session_id: import("@sinclair/typebox").TNumber;
+    chars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    yield_time_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    max_output_tokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    patch: import("@sinclair/typebox").TString;
+    workdir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    detail: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"original">]>>;
+}>, import("@sinclair/typebox").TObject<{
+    image_url: import("@sinclair/typebox").TString;
+    detail: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"original">]>;
+}>>];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/codex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sources/tools/codex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAOvD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKb,CAAC"}

package/dist/tools/codex/index.js

@@ -0,0 +1,14 @@
+export { codexApplyPatchTool } from "./apply_patch.js";
+export { codexExecCommandTool } from "./exec_command.js";
+export { codexViewImageTool } from "./view_image.js";
+export { codexWriteStdinTool } from "./write_stdin.js";
+import { codexApplyPatchTool } from "./apply_patch.js";
+import { codexExecCommandTool } from "./exec_command.js";
+import { codexViewImageTool } from "./view_image.js";
+import { codexWriteStdinTool } from "./write_stdin.js";
+export const codexTools = [
+    codexExecCommandTool,
+    codexWriteStdinTool,
+    codexApplyPatchTool,
+    codexViewImageTool,
+];

package/dist/tools/codex/view_image.d.ts

@@ -0,0 +1,8 @@
+export declare const codexViewImageTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    detail: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"original">]>>;
+}>, import("@sinclair/typebox").TObject<{
+    image_url: import("@sinclair/typebox").TString;
+    detail: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"original">]>;
+}>>;
+//# sourceMappingURL=view_image.d.ts.map

package/dist/tools/codex/view_image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_image.d.ts","sourceRoot":"","sources":["../../../sources/tools/codex/view_image.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,kBAAkB;;;;;;GA2D7B,CAAC"}

package/dist/tools/codex/view_image.js

@@ -0,0 +1,64 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { IMAGE_PROCESSING_ERROR_PLACEHOLDER, ImageProcessingError, MAX_PROMPT_IMAGE_INPUT_BYTES, prepareImageForPrompt, } from "../utils/index.js";
+const viewImageReturnSchema = Type.Object({
+    image_url: Type.String(),
+    detail: Type.Union([Type.Literal("high"), Type.Literal("original")]),
+});
+export const codexViewImageTool = defineTool({
+    name: "view_image",
+    label: "view_image",
+    description: "View a local image file from the filesystem when visual inspection is needed. Use this for images already available on disk.",
+    arguments: Type.Object({
+        path: Type.String({ description: "Local filesystem path to an image file." }),
+        detail: Type.Optional(Type.Union([Type.Literal("high"), Type.Literal("original")], {
+            description: "Image detail level. Defaults to `high`; use `original` to preserve exact resolution.",
+        })),
+    }),
+    returnType: viewImageReturnSchema,
+    execute: async ({ path, detail }, context) => {
+        const stat = await context.fs.stat(path);
+        if (!stat.isFile) {
+            throw new Error(`Image path '${path}' is not a file.`);
+        }
+        if (stat.size > MAX_PROMPT_IMAGE_INPUT_BYTES) {
+            return {
+                image_url: IMAGE_PROCESSING_ERROR_PLACEHOLDER,
+                detail: detail ?? "high",
+            };
+        }
+        const bytes = await context.fs.readFileBuffer(path);
+        const resolvedDetail = detail ?? "high";
+        try {
+            const image = await prepareImageForPrompt(bytes, resolvedDetail);
+            return {
+                image_url: `data:${image.mediaType};base64,${image.bytes.toString("base64")}`,
+                detail: resolvedDetail,
+            };
+        }
+        catch (error) {
+            if (error instanceof ImageProcessingError) {
+                return {
+                    image_url: IMAGE_PROCESSING_ERROR_PLACEHOLDER,
+                    detail: resolvedDetail,
+                };
+            }
+            throw error;
+        }
+    },
+    toLLM: (result) => {
+        const match = /^data:([^;]+);base64,(.*)$/.exec(result.image_url);
+        return match
+            ? [
+                {
+                    type: "image",
+                    mediaType: match[1] ?? "image/png",
+                    data: match[2] ?? "",
+                    detail: result.detail,
+                },
+            ]
+            : [{ type: "text", text: result.image_url }];
+    },
+    toUI: (_result, args) => `Viewed ${args.path}`,
+    locks: [],
+});

package/dist/tools/codex/write_stdin.d.ts

@@ -0,0 +1,9 @@
+export declare const codexWriteStdinTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    session_id: import("@sinclair/typebox").TNumber;
+    chars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    yield_time_ms: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    max_output_tokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=write_stdin.d.ts.map

package/dist/tools/codex/write_stdin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_stdin.d.ts","sourceRoot":"","sources":["../../../sources/tools/codex/write_stdin.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;GAqC9B,CAAC"}

package/dist/tools/codex/write_stdin.js

@@ -0,0 +1,29 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { singleLineText, textOutputSchema, toTextBlocks } from "../utils/index.js";
+export const codexWriteStdinTool = defineTool({
+    name: "write_stdin",
+    label: "write_stdin",
+    description: "Writes characters to an existing unified exec session and returns recent output.",
+    arguments: Type.Object({
+        session_id: Type.Number({ description: "Identifier of the running unified exec session." }),
+        chars: Type.Optional(Type.String({
+            description: "Bytes to write to stdin. Defaults to empty, which polls without writing.",
+        })),
+        yield_time_ms: Type.Optional(Type.Number({
+            description: "Wait before yielding output. Non-empty writes default to 250 ms and cap at 30000 ms; empty polls wait 5000-300000 ms by default.",
+        })),
+        max_output_tokens: Type.Optional(Type.Number({
+            description: "Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy.",
+        })),
+    }),
+    returnType: textOutputSchema,
+    execute: ({ session_id }) => ({
+        text: `No active Codex unified exec session ${session_id}; this implementation runs exec_command to completion.`,
+    }),
+    toLLM: toTextBlocks,
+    toUI: (result, args) => singleLineText(args.chars === undefined || args.chars.length === 0
+        ? `Polled session ${args.session_id}: ${result.text}`
+        : `Sent input to session ${args.session_id}`),
+    locks: [],
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./claude/index.js";
+export * from "./codex/index.js";
+export * from "./pi/index.js";
+export * from "./testing/createJustBashToolHarness.js";
+export * from "./utils/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../sources/tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,wCAAwC,CAAC;AACvD,cAAc,kBAAkB,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,5 @@
+export * from "./claude/index.js";
+export * from "./codex/index.js";
+export * from "./pi/index.js";
+export * from "./testing/createJustBashToolHarness.js";
+export * from "./utils/index.js";

package/dist/tools/pi/bash.d.ts

@@ -0,0 +1,7 @@
+export declare const piBashTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=bash.d.ts.map

package/dist/tools/pi/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/bash.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,UAAU;;;;;GAyBrB,CAAC"}

package/dist/tools/pi/bash.js

@@ -0,0 +1,31 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { runShellCommand, summarizeTextOutput, textOutputSchema, toTextBlocks, } from "../utils/index.js";
+const DEFAULT_MAX_LINES = 2000;
+const DEFAULT_MAX_BYTES = 50 * 1024;
+export const piBashTool = defineTool({
+    name: "bash",
+    label: "bash",
+    description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+    arguments: Type.Object({
+        command: Type.String({ description: "Bash command to execute" }),
+        timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+    }),
+    returnType: textOutputSchema,
+    execute: async ({ command, timeout }, context, execution) => {
+        const options = { maxOutputBytes: 512_000 };
+        if (timeout !== undefined)
+            options.timeoutMs = timeout * 1000;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        const result = await runShellCommand(command, options, context);
+        const text = [result.stdout, result.stderr].filter(Boolean).join("\n") || "(no output)";
+        if (result.exitCode !== 0 && result.exitCode !== null) {
+            throw new Error(`${text}\n\nCommand exited with code ${result.exitCode}`);
+        }
+        return { text };
+    },
+    toLLM: toTextBlocks,
+    toUI: (result) => summarizeTextOutput(result.text),
+    locks: [],
+});

package/dist/tools/pi/edit.d.ts

@@ -0,0 +1,14 @@
+export declare const piEditTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    edits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        oldText: import("@sinclair/typebox").TString;
+        newText: import("@sinclair/typebox").TString;
+    }>>>;
+    oldText: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    newText: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    replacements: import("@sinclair/typebox").TNumber;
+    fuzzy: import("@sinclair/typebox").TBoolean;
+}>>;
+//# sourceMappingURL=edit.d.ts.map

package/dist/tools/pi/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/edit.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,UAAU;;;;;;;;;;;;GAwCrB,CAAC"}

package/dist/tools/pi/edit.js

@@ -0,0 +1,73 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { editTextFileBatch } from "../utils/index.js";
+const editItemSchema = Type.Object({
+    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." }),
+}, {});
+const piEditReturnSchema = Type.Object({
+    path: Type.String(),
+    replacements: Type.Number(),
+    fuzzy: Type.Boolean(),
+});
+export const piEditTool = defineTool({
+    name: "edit",
+    label: "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.",
+    arguments: Type.Object({
+        path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+        edits: Type.Optional(Type.Array(editItemSchema, {
+            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.",
+        })),
+        oldText: Type.Optional(Type.String()),
+        newText: Type.Optional(Type.String()),
+    }, {}),
+    returnType: piEditReturnSchema,
+    execute: async (args, context) => {
+        const edits = normalizePiEdits(args);
+        return editTextFileBatch({
+            path: args.path,
+            edits,
+            fuzzy: true,
+        }, context);
+    },
+    toLLM: (result) => [
+        {
+            type: "text",
+            text: `Successfully replaced ${result.replacements} block(s) in ${result.path}.`,
+        },
+    ],
+    toUI: (result) => `Edited ${result.path} (${result.replacements} replacement${result.replacements === 1 ? "" : "s"})`,
+    locks: [(args) => args.path],
+});
+function normalizePiEdits(args) {
+    const edits = [];
+    if (typeof args.edits === "string") {
+        const parsed = JSON.parse(args.edits);
+        if (Array.isArray(parsed)) {
+            for (const edit of parsed) {
+                if (edit &&
+                    typeof edit === "object" &&
+                    typeof edit.oldText === "string" &&
+                    typeof edit.newText === "string") {
+                    edits.push({
+                        oldText: edit.oldText,
+                        newText: edit.newText,
+                    });
+                }
+            }
+        }
+    }
+    else if (Array.isArray(args.edits)) {
+        edits.push(...args.edits);
+    }
+    if (typeof args.oldText === "string" && typeof args.newText === "string") {
+        edits.push({ oldText: args.oldText, newText: args.newText });
+    }
+    if (edits.length === 0) {
+        throw new Error("edit requires edits[] or oldText/newText.");
+    }
+    return edits;
+}

package/dist/tools/pi/find.d.ts

@@ -0,0 +1,8 @@
+export declare const piFindTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=find.d.ts.map

package/dist/tools/pi/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/find.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU;;;;;;GA8BrB,CAAC"}

package/dist/tools/pi/find.js

@@ -0,0 +1,32 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { countTextLines, globFiles, textOutputSchema, toTextBlocks } from "../utils/index.js";
+const DEFAULT_LIMIT = 1000;
+const DEFAULT_MAX_BYTES = 50 * 1024;
+export const piFindTool = defineTool({
+    name: "find",
+    label: "find",
+    description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
+    arguments: Type.Object({
+        pattern: Type.String({
+            description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'",
+        }),
+        path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
+        limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
+    }),
+    returnType: textOutputSchema,
+    execute: async ({ pattern, path, limit }, context, execution) => {
+        const options = { pattern, limit: limit ?? DEFAULT_LIMIT };
+        if (path !== undefined)
+            options.path = path;
+        if (execution.signal !== undefined)
+            options.signal = execution.signal;
+        const files = await globFiles(options, context);
+        return { text: files.length > 0 ? files.join("\n") : "No files found matching pattern" };
+    },
+    toLLM: toTextBlocks,
+    toUI: (result, args) => result.text === "No files found matching pattern"
+        ? `Found files for "${args.pattern}" (0)`
+        : `Found files for "${args.pattern}" (${countTextLines(result.text)})`,
+    locks: [],
+});

package/dist/tools/pi/grep.d.ts

@@ -0,0 +1,12 @@
+export declare const piGrepTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=grep.d.ts.map

package/dist/tools/pi/grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/grep.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,UAAU;;;;;;;;;;GAuDrB,CAAC"}

package/dist/tools/pi/grep.js

@@ -0,0 +1,55 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { countTextLines, runRipgrep, textOutputSchema, toTextBlocks } from "../utils/index.js";
+const DEFAULT_LIMIT = 100;
+const DEFAULT_MAX_BYTES = 50 * 1024;
+const GREP_MAX_LINE_LENGTH = 500;
+export const piGrepTool = defineTool({
+    name: "grep",
+    label: "grep",
+    description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+    arguments: Type.Object({
+        pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
+        path: Type.Optional(Type.String({
+            description: "Directory or file to search (default: current directory)",
+        })),
+        glob: Type.Optional(Type.String({
+            description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'",
+        })),
+        ignoreCase: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+        literal: Type.Optional(Type.Boolean({
+            description: "Treat pattern as literal string instead of regex (default: false)",
+        })),
+        context: Type.Optional(Type.Number({
+            description: "Number of lines to show before and after each match (default: 0)",
+        })),
+        limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
+    }),
+    returnType: textOutputSchema,
+    execute: async (args, context, execution) => {
+        const grepOptions = {
+            pattern: args.pattern,
+            outputMode: "content",
+            headLimit: args.limit ?? DEFAULT_LIMIT,
+        };
+        if (args.path !== undefined)
+            grepOptions.path = args.path;
+        if (args.glob !== undefined)
+            grepOptions.glob = args.glob;
+        if (args.ignoreCase !== undefined)
+            grepOptions.ignoreCase = args.ignoreCase;
+        if (args.literal !== undefined)
+            grepOptions.literal = args.literal;
+        if (args.context !== undefined)
+            grepOptions.context = args.context;
+        if (execution.signal !== undefined)
+            grepOptions.signal = execution.signal;
+        const result = await runRipgrep(grepOptions, context);
+        return { text: result.text.length > 0 ? result.text : "No matches found" };
+    },
+    toLLM: toTextBlocks,
+    toUI: (result, args) => result.text === "No matches found"
+        ? `Searched "${args.pattern}" (no matches)`
+        : `Searched "${args.pattern}" (${countTextLines(result.text)} matches)`,
+    locks: [],
+});

package/dist/tools/pi/index.d.ts

@@ -0,0 +1,65 @@
+export { piBashTool } from "./bash.js";
+export { piEditTool } from "./edit.js";
+export { piFindTool } from "./find.js";
+export { piGrepTool } from "./grep.js";
+export { piLsTool } from "./ls.js";
+export { piReadTool } from "./read.js";
+export { piWriteTool } from "./write.js";
+export declare const piTools: readonly [import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+    startLine: import("@sinclair/typebox").TNumber;
+    totalLines: import("@sinclair/typebox").TNumber;
+    returnedLines: import("@sinclair/typebox").TNumber;
+    truncated: import("@sinclair/typebox").TBoolean;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    edits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        oldText: import("@sinclair/typebox").TString;
+        newText: import("@sinclair/typebox").TString;
+    }>>>;
+    oldText: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    newText: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    replacements: import("@sinclair/typebox").TNumber;
+    fuzzy: import("@sinclair/typebox").TBoolean;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    created: import("@sinclair/typebox").TBoolean;
+    bytes: import("@sinclair/typebox").TNumber;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/pi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAUzC,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQV,CAAC"}

package/dist/tools/pi/index.js

@@ -0,0 +1,23 @@
+export { piBashTool } from "./bash.js";
+export { piEditTool } from "./edit.js";
+export { piFindTool } from "./find.js";
+export { piGrepTool } from "./grep.js";
+export { piLsTool } from "./ls.js";
+export { piReadTool } from "./read.js";
+export { piWriteTool } from "./write.js";
+import { piBashTool } from "./bash.js";
+import { piEditTool } from "./edit.js";
+import { piFindTool } from "./find.js";
+import { piGrepTool } from "./grep.js";
+import { piLsTool } from "./ls.js";
+import { piReadTool } from "./read.js";
+import { piWriteTool } from "./write.js";
+export const piTools = [
+    piReadTool,
+    piBashTool,
+    piEditTool,
+    piWriteTool,
+    piGrepTool,
+    piFindTool,
+    piLsTool,
+];

package/dist/tools/pi/ls.d.ts

@@ -0,0 +1,7 @@
+export declare const piLsTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/tools/pi/ls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../../sources/tools/pi/ls.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,QAAQ;;;;;GA8BnB,CAAC"}