@xandreed/plugin-workspace 0.14.0 → 0.15.1

package/dist/plugin.adapter.d.ts

@@ -1,27 +1,40 @@
 import { Layer } from "effect";
-import { Bash, Capabilities, FileSystem } from "@xandreed/core";
+import { Bash, Capabilities, FileSystem, ImageResizer } from "@xandreed/core";
 /**
  * The machine the agent runs on as its `FileSystem` and `Bash`: the local
  * disk (`FileSystemLive`) and commands run with the configured shell
  * (`BashLive`), built once per agent. Activation fails when the shell is not
- * installed. Commands inherit the host process's environment through
- * `resolveBashEnv`'s allowlist.
+ * installed. Commands inherit `parentEnv` (the host process's environment
+ * when null) through `resolveBashEnv`'s allowlist.
  */
 export declare const localSystemPlugin: import("@xandreed/core").TypedPlugin<{
     readonly shell: string;
     readonly killBackground: boolean;
     readonly exitGraceMs: number;
+    readonly parentEnv: {
+        readonly [x: string]: string;
+    } | null;
 }, {
     readonly shell: string;
     readonly killBackground: boolean;
     readonly exitGraceMs: number;
+    readonly parentEnv: {
+        readonly [x: string]: string;
+    } | null;
 }, FileSystem | Bash, import("@xandreed/core").BashError, never>;
-/** The local system as a typed layer: provides FileSystem and Bash; requires nothing. */
-export declare const LocalSystemPluginLive: (options?: Partial<{
-    readonly shell: string;
-    readonly killBackground: boolean;
-    readonly exitGraceMs: number;
-}> | undefined) => Layer.Layer<FileSystem | Bash, import("@xandreed/core").HarnessError | import("@xandreed/core").BashError, never>;
+/**
+ * The local system as a typed layer: provides FileSystem and Bash; requires nothing.
+ *
+ * @public
+ */
+export declare const LocalSystemPluginLive: (options?: {
+    readonly shell?: string;
+    readonly killBackground?: boolean;
+    readonly exitGraceMs?: number;
+    readonly parentEnv?: {
+        readonly [x: string]: string | undefined;
+    } | null;
+} | undefined) => Layer.Layer<FileSystem | Bash, import("@xandreed/core").HarnessError | import("@xandreed/core").BashError, never>;
 /**
  * The workspace tools (`workspaceTools`): read, ls, find and grep always on,
  * write and edit behind `fs.write`, bash behind `shell.exec`, over the
@@ -32,9 +45,14 @@ export declare const LocalSystemPluginLive: (options?: Partial<{
  * `PermissionGrants`.
  */
 export declare const workspaceToolsPlugin: import("@xandreed/core").TypedPlugin<{
-    readonly tools: readonly ("write" | "find" | "read" | "grep" | "ls" | "edit" | "bash")[];
+    readonly tools: readonly ("find" | "write" | "read" | "grep" | "bash" | "ls" | "edit")[];
     readonly always: readonly ("read" | "edit" | "shell")[];
     readonly confine: boolean;
+    readonly workspaceAccess: "write" | "read";
+    readonly roots: readonly {
+        readonly path: string;
+        readonly access: "write" | "read";
+    }[];
     readonly protect: readonly string[];
     readonly exclude: readonly string[];
     readonly maxLines: number;
@@ -43,8 +61,12 @@ export declare const workspaceToolsPlugin: import("@xandreed/core").TypedPlugin<
     readonly findResults: number;
     readonly grepMatches: number;
     readonly grepLineChars: number;
+    readonly grepEngine: "auto" | "ripgrep" | "builtin";
+    readonly grepTimeoutMs: number;
+    readonly grepIgnoreFiles: boolean;
     readonly maxFileBytes: number;
     readonly readImages: boolean;
+    readonly imageMaxSide: number;
     readonly fuzzyEdit: boolean;
     readonly bashTimeoutMs: number;
     readonly bashMaxTimeoutMs: number;
@@ -60,9 +82,14 @@ export declare const workspaceToolsPlugin: import("@xandreed/core").TypedPlugin<
     readonly environmentSection: boolean;
     readonly sectionOrder: number;
 }, {
-    readonly tools: readonly ("write" | "find" | "read" | "grep" | "ls" | "edit" | "bash")[];
+    readonly tools: readonly ("find" | "write" | "read" | "grep" | "bash" | "ls" | "edit")[];
     readonly always: readonly ("read" | "edit" | "shell")[];
     readonly confine: boolean;
+    readonly workspaceAccess: "write" | "read";
+    readonly roots: readonly {
+        readonly path: string;
+        readonly access: "write" | "read";
+    }[];
     readonly protect: readonly string[];
     readonly exclude: readonly string[];
     readonly maxLines: number;
@@ -71,8 +98,12 @@ export declare const workspaceToolsPlugin: import("@xandreed/core").TypedPlugin<
     readonly findResults: number;
     readonly grepMatches: number;
     readonly grepLineChars: number;
+    readonly grepEngine: "auto" | "ripgrep" | "builtin";
+    readonly grepTimeoutMs: number;
+    readonly grepIgnoreFiles: boolean;
     readonly maxFileBytes: number;
     readonly readImages: boolean;
+    readonly imageMaxSide: number;
     readonly fuzzyEdit: boolean;
     readonly bashTimeoutMs: number;
     readonly bashMaxTimeoutMs: number;
@@ -88,33 +119,65 @@ export declare const workspaceToolsPlugin: import("@xandreed/core").TypedPlugin<
     readonly environmentSection: boolean;
     readonly sectionOrder: number;
 }, Capabilities, import("@xandreed/core").HarnessError, never>;
-/** The workspace tools as a typed layer: contributes their capability; its handlers need FileSystem and SessionEnvironment (and Bash for bash) where the tools are opened. */
-export declare const WorkspaceToolsPluginLive: (options?: Partial<{
-    readonly tools: readonly ("write" | "find" | "read" | "grep" | "ls" | "edit" | "bash")[];
-    readonly always: readonly ("read" | "edit" | "shell")[];
-    readonly confine: boolean;
-    readonly protect: readonly string[];
-    readonly exclude: readonly string[];
-    readonly maxLines: number;
-    readonly maxBytes: number;
-    readonly lsEntries: number;
-    readonly findResults: number;
-    readonly grepMatches: number;
-    readonly grepLineChars: number;
-    readonly maxFileBytes: number;
-    readonly readImages: boolean;
-    readonly fuzzyEdit: boolean;
-    readonly bashTimeoutMs: number;
-    readonly bashMaxTimeoutMs: number;
-    readonly bashEnv: {
-        readonly [x: string]: string;
+/**
+ * The workspace tools as a typed layer: contributes their capability; its handlers need FileSystem and SessionEnvironment (and Bash for bash) where the tools are opened.
+ *
+ * @public
+ */
+export declare const WorkspaceToolsPluginLive: (options?: {
+    readonly tools?: readonly ("find" | "write" | "read" | "grep" | "bash" | "ls" | "edit")[];
+    readonly always?: readonly ("read" | "edit" | "shell")[];
+    readonly confine?: boolean;
+    readonly workspaceAccess?: "write" | "read";
+    readonly roots?: readonly {
+        readonly path: string;
+        readonly access: "write" | "read";
+    }[];
+    readonly protect?: readonly string[];
+    readonly exclude?: readonly string[];
+    readonly maxLines?: number;
+    readonly maxBytes?: number;
+    readonly lsEntries?: number;
+    readonly findResults?: number;
+    readonly grepMatches?: number;
+    readonly grepLineChars?: number;
+    readonly grepEngine?: "auto" | "ripgrep" | "builtin";
+    readonly grepTimeoutMs?: number;
+    readonly grepIgnoreFiles?: boolean;
+    readonly maxFileBytes?: number;
+    readonly readImages?: boolean;
+    readonly imageMaxSide?: number;
+    readonly fuzzyEdit?: boolean;
+    readonly bashTimeoutMs?: number;
+    readonly bashMaxTimeoutMs?: number;
+    readonly bashEnv?: {
+        readonly [x: string]: string | undefined;
     };
-    readonly bashInheritEnv: boolean;
-    readonly bashEnvAllow: readonly string[];
-    readonly bashSessionEnv: boolean;
-    readonly spillDir: string | null;
-    readonly spillKeep: number;
-    readonly progressMs: number;
-    readonly environmentSection: boolean;
-    readonly sectionOrder: number;
-}> | undefined) => Layer.Layer<Capabilities, import("@xandreed/core").HarnessError, never>;
+    readonly bashInheritEnv?: boolean;
+    readonly bashEnvAllow?: readonly string[];
+    readonly bashSessionEnv?: boolean;
+    readonly spillDir?: string | null;
+    readonly spillKeep?: number;
+    readonly progressMs?: number;
+    readonly environmentSection?: boolean;
+    readonly sectionOrder?: number;
+} | undefined) => Layer.Layer<Capabilities, import("@xandreed/core").HarnessError, never>;
+/** Optional CLI image fitting on the host's matching Bash and FileSystem. @public */
+export declare const imageResizerPlugin: import("@xandreed/core").TypedPlugin<{
+    readonly tool: "auto" | "magick" | "convert" | "vips" | "sips";
+    readonly tempDir: string | null;
+    readonly timeoutMs: number;
+    readonly maxSourcePixels: number;
+}, {
+    readonly tool: "auto" | "magick" | "convert" | "vips" | "sips";
+    readonly tempDir: string | null;
+    readonly timeoutMs: number;
+    readonly maxSourcePixels: number;
+}, ImageResizer, import("@xandreed/core").HarnessError, FileSystem | Bash>;
+/** @public */
+export declare const ImageResizerPluginLive: (options?: {
+    readonly tool?: "auto" | "magick" | "convert" | "vips" | "sips";
+    readonly tempDir?: string | null;
+    readonly timeoutMs?: number;
+    readonly maxSourcePixels?: number;
+} | undefined) => Layer.Layer<ImageResizer, import("@xandreed/core").HarnessError, FileSystem | Bash>;

package/dist/plugin.adapter.js

@@ -1,13 +1,15 @@
 import { Effect, Layer } from "effect";
-import { Bash, Capabilities, definePlugin, FileSystem, SessionEnvironment } from "@xandreed/core";
+import { Bash, Capabilities, definePlugin, FileSystem, ImageResizer, SessionEnvironment } from "@xandreed/core";
 import { BashLive } from "./bash.adapter.js";
 import { FileSystemLive } from "./file-system.adapter.js";
 import { LocalSystemConfig, localSystemDefaults } from "./local-system.entity.js";
+import { ImageResizerCliLive } from "./image-resizer.adapter.js";
+import { ImageResizerConfig, imageResizerDefaults } from "./image-resizer.entity.js";
 import { workspaceTools } from "./workspace-tools.adapter.js";
 import { WorkspaceToolsConfig, workspaceToolsDefaults } from "./workspace-tools.entity.js";
 export const localSystemPlugin = definePlugin({
   id: "@xandreed/plugin-workspace/local",
-  version: "0.14.0",
+  version: "0.15.1",
   scope: "runtime",
   config: LocalSystemConfig,
   defaults: localSystemDefaults,
@@ -15,13 +17,22 @@ export const localSystemPlugin = definePlugin({
   layer: (config) => Layer.merge(FileSystemLive, BashLive(config))
 }), LocalSystemPluginLive = localSystemPlugin.live, workspaceToolsPlugin = definePlugin({
   id: "@xandreed/plugin-workspace/tools",
-  version: "0.14.0",
+  version: "0.15.1",
   scope: "runtime",
   config: WorkspaceToolsConfig,
   defaults: workspaceToolsDefaults,
   requires: [FileSystem, SessionEnvironment],
-  optional: [Bash],
+  optional: [Bash, ImageResizer],
   provides: [],
   contributes: [Capabilities],
   layer: (config) => Layer.effect(Capabilities, workspaceTools(config).pipe(Effect.map((capability) => [capability])))
-}), WorkspaceToolsPluginLive = workspaceToolsPlugin.live;
+}), WorkspaceToolsPluginLive = workspaceToolsPlugin.live, imageResizerPlugin = definePlugin({
+  id: "@xandreed/plugin-workspace/images",
+  version: "0.15.1",
+  scope: "runtime",
+  config: ImageResizerConfig,
+  defaults: imageResizerDefaults,
+  requires: [FileSystem, Bash],
+  provides: [ImageResizer],
+  layer: (config) => ImageResizerCliLive(config)
+}), ImageResizerPluginLive = imageResizerPlugin.live;

package/dist/read-tools.adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Path, RcMap, Semaphore } from "effect";
-import { Failure } from "@xandreed/core";
+import { Failure, FileSystem, SessionEnvironment } from "@xandreed/core";
 import type { RegisteredTool, Subject } from "@xandreed/core";
 import type { ProtectRule } from "./workspace-path.entity.functions.js";
 import type { WorkspaceToolsConfig } from "./workspace-tools.entity.js";
@@ -9,14 +9,17 @@ export interface WorkspaceToolContext {
     readonly path: Path.Path;
     readonly protect: ReadonlyArray<ProtectRule>;
     readonly locks: RcMap.RcMap<string, Semaphore.Semaphore>;
+    readonly resizesImages: boolean;
 }
+/** The services every workspace tool reads on each call, and the `workspace.environment` section on each render: the file system, and the session's workspace on it (`bash` reads `Bash` too). */
+export declare const WORKSPACE_SERVICES: readonly [typeof FileSystem, typeof SessionEnvironment];
 export declare const failure: (error: string, message: string) => Failure;
 /** The refusal of a path that is neither a regular file nor a directory: reading a pipe, socket or device could wait forever. */
 export declare const notAFile: (display: string, tool: string) => Failure;
 /** A file the result names, for memory to keep track of; none for a name memory could not store as an id. */
 export declare const fileSubjects: (path: string) => ReadonlyArray<Subject>;
 /** `read`: a window of a text file's lines, an image (`readImages`), or what a binary file is. */
-export declare const readTool: ({ config, path }: WorkspaceToolContext) => RegisteredTool;
+export declare const readTool: ({ config, path, resizesImages }: WorkspaceToolContext) => RegisteredTool;
 /** `ls`: a directory's entries by name, at most `lsEntries` of them. */
 export declare const lsTool: ({ config, path }: WorkspaceToolContext) => RegisteredTool;
 /** `find`: the files under a directory whose path matches a glob, as paths relative to the workspace root. */
@@ -26,8 +29,11 @@ export declare const findTool: ({ config, path }: WorkspaceToolContext) => Regis
  * Files come from a walk that never enters links or excluded names; each is
  * resolved again before it is read and skipped when it leads outside the
  * workspace, is not a regular file, is larger than `maxFileBytes` or is
- * binary. Lines are cut to `grepLineChars` before matching. Searching a
+ * binary; one the file system refuses (permission denied, say) is named in
+ * `unreadable` with the reason, not counted as skipped. Lines are cut to `grepLineChars` before matching. Searching a
  * directory, one file gives at most a quarter of the limit, so one large
- * file cannot fill the result.
+ * file cannot fill the result, however many files the directory holds (as
+ * with ripgrep, which cannot know that ahead). A pattern with a line break
+ * is refused (`singleLinePattern`) whichever engine runs.
  */
 export declare const grepTool: ({ config, path }: WorkspaceToolContext) => RegisteredTool;

package/dist/read-tools.adapter.js

@@ -1,19 +1,21 @@
 import { Tool } from "effect/ai";
 import { Effect, Option, Result } from "effect";
-import { defineTool, Failure } from "@xandreed/core";
-import { compilePattern, searchText } from "./text-search.entity.functions.js";
-import { decodeText, formatBytes, lineWindow, looksBinary } from "./text-window.entity.functions.js";
-import { displayOf, excludesBelow, fsFailure, isWithin, openWorkspace, resolveTarget } from "./workspace-path.entity.functions.js";
-import { FindParams, FindResult, GrepParams, GrepResult, LsParams, LsResult, ReadParams, ReadResult } from "./workspace-tools.entity.js";
-import { binaryRead, compactFind, fileTooLargeHint, compactGrep, compactLs, compactRead, readMedia, renderFind, renderGrep, renderLs, renderRead, toolDescriptions } from "./workspace-tools.entity.functions.js";
-export const failure = (error, message) => ({ error, message }), notAFile = (display, tool) => failure("NotAFile", `${display} is not a regular file (a pipe, socket or device); ${tool} works on regular files only, use bash for it`);
+import { Bash, defineTool, Failure, FileSystem, ImageResizer, SessionEnvironment, SubjectId } from "@xandreed/core";
+import { searchRipgrep } from "./ripgrep.adapter.js";
+import { compilePattern, searchText, singleLinePattern } from "./text-search.entity.functions.js";
+import { decodeText, formatBytes, lineWindow, looksBinary, mediaTypeOf } from "./text-window.entity.functions.js";
+import { displayOf, excludesBelow, fsFailure, isWithin, openWorkspace, resolveTarget, withinAnyRoot } from "./workspace-path.entity.functions.js";
+import { FindResult, GrepResult, LsResult, ReadResult } from "./workspace-tools.entity.js";
+import { binaryRead, compactFind, fileTooLargeHint, compactGrep, compactLs, compactRead, readMedia, renderFind, renderGrep, renderLs, renderRead, toolDescriptions, toolParameters } from "./workspace-tools.entity.functions.js";
+export const WORKSPACE_SERVICES = [FileSystem, SessionEnvironment], failure = (error, message) => ({ error, message }), notAFile = (display, tool) => failure("NotAFile", `${display} is not a regular file (a pipe, socket or device); ${tool} works on regular files only, use bash for it`);
 const walkExcludes = (access, target, excludes) => excludesBelow(excludes, isWithin(access.root, target.path) ? Option.some(access.path.relative(access.root, target.path)) : Option.none());
-export const fileSubjects = (path) => path.length > 0 && path.trim() === path ? [{ kind: "file", id: path, label: Option.none(), data: Option.none() }] : [];
-const ReadTool = (description) => Tool.make("read", { description, parameters: ReadParams, success: ReadResult, failure: Failure, failureMode: "return" }), LsTool = (description) => Tool.make("ls", { description, parameters: LsParams, success: LsResult, failure: Failure, failureMode: "return" }), FindTool = (description) => Tool.make("find", { description, parameters: FindParams, success: FindResult, failure: Failure, failureMode: "return" }), GrepTool = (description) => Tool.make("grep", { description, parameters: GrepParams, success: GrepResult, failure: Failure, failureMode: "return" });
-export const readTool = ({ config, path }) => defineTool({
-  tool: ReadTool(toolDescriptions(config).read),
+export const fileSubjects = (path) => path.length > 0 && path.trim() === path ? [{ kind: "file", id: SubjectId.make(path), label: Option.none(), data: Option.none() }] : [];
+const ReadTool = (config, resizesImages) => Tool.make("read", { description: toolDescriptions(config, resizesImages).read, parameters: toolParameters(config).read, success: ReadResult, failure: Failure, failureMode: "return" }), LsTool = (config) => Tool.make("ls", { description: toolDescriptions(config).ls, parameters: toolParameters(config).ls, success: LsResult, failure: Failure, failureMode: "return" }), FindTool = (config) => Tool.make("find", { description: toolDescriptions(config).find, parameters: toolParameters(config).find, success: FindResult, failure: Failure, failureMode: "return" }), GrepTool = (config) => Tool.make("grep", { description: toolDescriptions(config).grep, parameters: toolParameters(config).grep, success: GrepResult, failure: Failure, failureMode: "return" });
+export const readTool = ({ config, path, resizesImages }) => defineTool({
+  tool: ReadTool(config, resizesImages),
+  requires: resizesImages ? [...WORKSPACE_SERVICES, ImageResizer] : WORKSPACE_SERVICES,
   handler: (params) => Effect.gen(function* () {
-    const access = yield* openWorkspace(path), target = yield* resolveTarget(access, params.path, { confine: config.confine }), info = yield* access.fs.stat(target.path).pipe(Effect.mapError(fsFailure(target.display)));
+    const access = yield* openWorkspace(path, config), target = yield* resolveTarget(access, params.path, { confine: config.confine }), info = yield* access.fs.stat(target.path).pipe(Effect.mapError(fsFailure(target.display)));
     if (info.kind === "directory")
       return yield* Effect.fail(failure("IsDirectory", `${target.display} is a directory; use ls to list it`));
     if (info.kind !== "file")
@@ -22,8 +24,8 @@ export const readTool = ({ config, path }) => defineTool({
       return yield* Effect.fail(failure("FileTooLarge", `${target.display} is ${formatBytes(info.size)}, more than the ${formatBytes(config.maxFileBytes)} read loads; ${fileTooLargeHint(target.display, config.readImages)}`));
     const bytes = yield* access.fs.readBytes(target.path).pipe(Effect.mapError(fsFailure(target.display)));
     if (looksBinary(bytes))
-      return yield* binaryRead(target.display, bytes, config.readImages);
-    const decoded = decodeText(bytes), window = lineWindow(decoded.text, { offset: params.offset ?? 1, limit: Math.min(params.limit ?? config.maxLines, config.maxLines), maxBytes: config.maxBytes });
+      return yield* binaryRead(target.display, bytes, config.readImages, Option.getOrNull(mediaTypeOf(target.display)), resizesImages ? Option.map(yield* Effect.serviceOption(ImageResizer), (resizer) => resizer.fit) : Option.none(), config.imageMaxSide);
+    const decoded = decodeText(bytes), window = lineWindow(decoded.text, { offset: params.offset ?? 1, limit: params.limit ?? config.maxLines, maxBytes: config.maxBytes });
     return yield* Result.match(window, {
       onFailure: (total) => Effect.fail(failure("OffsetPastEnd", `${target.display} has ${total} line${total === 1 ? "" : "s"}; offset must be at most ${Math.max(1, total)}`)),
       onSuccess: (lines) => Effect.succeed({
@@ -40,61 +42,68 @@ export const readTool = ({ config, path }) => defineTool({
       })
     });
   }),
-  view: { version: "1", render: renderRead, compact: compactRead, subjects: (result) => fileSubjects(result.path), media: readMedia },
+  view: { version: "3", render: renderRead, compact: compactRead, subjects: (result) => fileSubjects(result.path), media: readMedia },
   annotations: { readOnly: !0 }
 }), lsTool = ({ config, path }) => defineTool({
-  tool: LsTool(toolDescriptions(config).ls),
+  tool: LsTool(config),
+  requires: WORKSPACE_SERVICES,
   handler: (params) => Effect.gen(function* () {
-    const access = yield* openWorkspace(path), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine }), entries = yield* access.fs.list(target.path).pipe(Effect.mapError((error) => error.reason === "NotDirectory" ? failure("NotDirectory", `${target.display} is not a directory; use read to see a file`) : fsFailure(target.display)(error))), limit = Math.min(params.limit ?? config.lsEntries, config.lsEntries);
+    const access = yield* openWorkspace(path, config), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine }), entries = yield* access.fs.list(target.path).pipe(Effect.mapError((error) => error.reason === "NotDirectory" ? failure("NotDirectory", `${target.display} is not a directory; use read to see a file`) : fsFailure(target.display)(error))), limit = params.limit ?? config.lsEntries;
     return { path: target.display, entries: entries.slice(0, limit).map((entry) => ({ name: entry.name, kind: entry.kind })), total: entries.length };
   }),
-  view: { version: "1", render: renderLs, compact: compactLs },
+  view: { version: "2", render: renderLs, compact: compactLs },
   annotations: { readOnly: !0 }
 }), findTool = ({ config, path }) => defineTool({
-  tool: FindTool(toolDescriptions(config).find),
+  tool: FindTool(config),
+  requires: WORKSPACE_SERVICES,
   handler: (params) => Effect.gen(function* () {
-    const access = yield* openWorkspace(path), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine }), limit = Math.min(params.limit ?? config.findResults, config.findResults), found = yield* access.fs.glob(params.pattern, { cwd: target.path, exclude: walkExcludes(access, target, config.exclude), dot: !0, onlyFiles: !0, limit }).pipe(Effect.mapError((error) => error.reason === "Invalid" ? failure("InvalidPattern", `${params.pattern}: ${error.message}`) : fsFailure(target.display)(error)));
+    const access = yield* openWorkspace(path, config), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine }), limit = params.limit ?? config.findResults, found = yield* access.fs.glob(params.pattern, { cwd: target.path, exclude: walkExcludes(access, target, config.exclude), dot: !0, onlyFiles: !0, limit }).pipe(Effect.mapError((error) => error.reason === "Invalid" ? failure("InvalidPattern", `${params.pattern}: ${error.message}`) : fsFailure(target.display)(error)));
     return { pattern: params.pattern, path: target.display, paths: found.paths.map((relative) => displayOf(access, access.path.join(target.path, relative))), truncated: found.truncated };
   }),
-  view: { version: "1", render: (result) => renderFind(result, config.maxLines, config.maxBytes), compact: compactFind },
+  view: { version: "2", render: (result) => renderFind(result, config.maxLines, config.maxBytes), compact: compactFind },
   annotations: { readOnly: !0 }
 }), grepTool = ({ config, path }) => defineTool({
-  tool: GrepTool(toolDescriptions(config).grep),
+  tool: GrepTool(config),
+  requires: config.grepEngine === "ripgrep" ? [...WORKSPACE_SERVICES, Bash] : WORKSPACE_SERVICES,
   handler: (params) => Effect.gen(function* () {
-    const access = yield* openWorkspace(path), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine }), pattern = yield* Effect.fromResult(compilePattern(params.pattern, { literal: params.literal ?? !1, ignoreCase: params.ignoreCase ?? !1 })), info = yield* access.fs.stat(target.path).pipe(Effect.mapError(fsFailure(target.display)));
+    const access = yield* openWorkspace(path, config), target = yield* resolveTarget(access, params.path ?? ".", { confine: config.confine });
+    yield* Effect.fromResult(singleLinePattern(params.pattern));
+    const pattern = config.grepEngine === "ripgrep" ? Option.none() : Option.some(yield* Effect.fromResult(compilePattern(params.pattern, { literal: params.literal ?? !1, ignoreCase: params.ignoreCase ?? !1 }))), info = yield* access.fs.stat(target.path).pipe(Effect.mapError(fsFailure(target.display)));
     if (info.kind !== "file" && info.kind !== "directory")
       return yield* Effect.fail(notAFile(target.display, "grep"));
+    if (config.grepEngine === "ripgrep")
+      return yield* searchRipgrep(access, target, info.kind === "directory", params, config);
     const glob = params.glob === void 0 ? "**/*" : params.glob.includes("/") ? params.glob : `**/${params.glob}`, files = info.kind === "file" ? [{ path: target.path, display: target.display }] : yield* access.fs.glob(glob, { cwd: target.path, exclude: walkExcludes(access, target, config.exclude), dot: !0, onlyFiles: !0 }).pipe(Effect.map((found) => found.paths.map((relative) => {
       const absolute = access.path.join(target.path, relative);
       return { path: absolute, display: displayOf(access, absolute) };
-    })), Effect.mapError((error) => error.reason === "Invalid" ? failure("InvalidPattern", `glob ${glob}: ${error.message}`) : fsFailure(target.display)(error))), limit = Math.min(params.limit ?? config.grepMatches, config.grepMatches), perFile = files.length > 1 ? Math.max(1, Math.ceil(limit / 4)) : limit, context = params.context ?? 0, skip = (state) => ({ ...state, skipped: state.skipped + 1 }), searched = yield* Effect.reduce(files, () => ({ lines: [], matches: 0, files: 0, skipped: 0, truncated: !1 }), (state, file) => {
+    })), Effect.mapError((error) => error.reason === "Invalid" ? failure("InvalidPattern", `glob ${params.glob ?? glob}: ${error.message}`) : fsFailure(target.display)(error))), limit = params.limit ?? config.grepMatches, perFile = info.kind === "directory" ? Math.max(1, Math.ceil(limit / 4)) : limit, context = params.context ?? 0, skip = (state) => ({ ...state, skipped: state.skipped + 1 }), searched = yield* Effect.reduce(files, () => ({ lines: [], matches: 0, files: 0, skipped: 0, truncated: !1, unreadable: [] }), (state, file) => {
       if (state.matches >= limit)
         return Effect.succeed({ ...state, truncated: !0 });
       return Effect.gen(function* () {
         const real = yield* access.fs.realPath(file.path);
-        if (config.confine && !isWithin(access.root, real))
+        if (config.confine && !withinAnyRoot(access, real))
           return Option.none();
         const found = yield* access.fs.stat(real);
         if (found.kind !== "file" || found.size > config.maxFileBytes)
           return Option.none();
         const bytes = yield* access.fs.readBytes(real);
         return looksBinary(bytes) ? Option.none() : Option.some(bytes);
-      }).pipe(Effect.option, Effect.map((bytes) => Option.match(Option.flatten(bytes), {
+      }).pipe(Effect.map(Option.match({
         onNone: () => skip(state),
         onSome: (content) => {
-          const found = searchText(decodeText(content).text, pattern, { lineChars: config.grepLineChars, context, cap: Math.min(perFile, limit - state.matches) });
+          const found = searchText(decodeText(content).text, Option.getOrThrow(pattern), { lineChars: config.grepLineChars, context, cap: Math.min(perFile, limit - state.matches) });
           return {
+            ...state,
             lines: [...state.lines, ...found.lines.map((line) => ({ path: file.display, ...line }))],
             matches: state.matches + found.matches,
             files: state.files + (found.matches > 0 ? 1 : 0),
-            skipped: state.skipped,
             truncated: state.truncated || found.capped
           };
         }
-      })));
+      })), Effect.catch((error) => Effect.succeed({ ...state, unreadable: [...state.unreadable, { path: file.display, reason: error.reason }] })));
     });
-    return { pattern: params.pattern, path: target.display, ...searched };
+    return { pattern: params.pattern, path: target.display, ...searched, timedOut: !1 };
   }),
-  view: { version: "1", render: (result, params) => renderGrep(result, (params.context ?? 0) > 0, config.maxLines, config.maxBytes), compact: compactGrep },
+  view: { version: "4", render: (result, params) => renderGrep(result, (params.context ?? 0) > 0, config.maxLines, config.maxBytes), compact: compactGrep },
   annotations: { readOnly: !0 }
 });

package/dist/ripgrep.adapter.d.ts

@@ -0,0 +1,74 @@
+import { Effect } from "effect";
+import { Bash } from "@xandreed/core";
+import type { WorkspaceAccess } from "./workspace-path.entity.functions.js";
+/** A bounded, interruptible search on the same machine as the Bash/FileSystem pair. */
+export declare const searchRipgrep: (access: WorkspaceAccess, target: {
+    readonly path: string;
+    readonly display: string;
+}, directory: boolean, params: {
+    readonly pattern: string;
+    readonly path?: string;
+    readonly limit?: number;
+    readonly context?: number;
+    readonly literal?: boolean;
+    readonly glob?: string;
+    readonly ignoreCase?: boolean;
+}, config: {
+    readonly tools: readonly ("find" | "write" | "read" | "grep" | "bash" | "ls" | "edit")[];
+    readonly always: readonly ("read" | "edit" | "shell")[];
+    readonly confine: boolean;
+    readonly workspaceAccess: "write" | "read";
+    readonly roots: readonly {
+        readonly path: string;
+        readonly access: "write" | "read";
+    }[];
+    readonly protect: readonly string[];
+    readonly exclude: readonly string[];
+    readonly maxLines: number;
+    readonly maxBytes: number;
+    readonly lsEntries: number;
+    readonly findResults: number;
+    readonly grepMatches: number;
+    readonly grepLineChars: number;
+    readonly grepEngine: "auto" | "ripgrep" | "builtin";
+    readonly grepTimeoutMs: number;
+    readonly grepIgnoreFiles: boolean;
+    readonly maxFileBytes: number;
+    readonly readImages: boolean;
+    readonly imageMaxSide: number;
+    readonly fuzzyEdit: boolean;
+    readonly bashTimeoutMs: number;
+    readonly bashMaxTimeoutMs: number;
+    readonly bashEnv: {
+        readonly [x: string]: string;
+    };
+    readonly bashInheritEnv: boolean;
+    readonly bashEnvAllow: readonly string[];
+    readonly bashSessionEnv: boolean;
+    readonly spillDir: string | null;
+    readonly spillKeep: number;
+    readonly progressMs: number;
+    readonly environmentSection: boolean;
+    readonly sectionOrder: number;
+}) => Effect.Effect<{
+    pattern: string;
+    path: string;
+    lines: readonly {
+        readonly path: string;
+        readonly line: number;
+        readonly text: string;
+        readonly match: boolean;
+    }[];
+    matches: number;
+    files: number;
+    skipped: number;
+    truncated: boolean;
+    unreadable: {
+        path: string;
+        reason: "Invalid" | "NotFound" | "Exists" | "IsDirectory" | "NotDirectory" | "NotEmpty" | "Permission" | "Io";
+    }[];
+    timedOut: boolean;
+}, {
+    readonly error: string;
+    readonly message: string;
+}, Bash>;

package/dist/ripgrep.adapter.js

@@ -0,0 +1,56 @@
+import { Effect, Option, Stream } from "effect";
+import { Bash, RunContext } from "@xandreed/core";
+import { rgReasonOf } from "./local-system.entity.functions.js";
+import { decodeRgMessage, emptyRgSearch, foldRgMessage, rgLines, rgRecords, ripgrepCommand } from "./ripgrep.entity.functions.js";
+import { clipHead } from "./text-window.entity.functions.js";
+import { displayOf, excludesBelow, isWithin } from "./workspace-path.entity.functions.js";
+import { bashEnvironment } from "./workspace-tools.entity.functions.js";
+const empty = { search: emptyRgSearch, buffer: "", stderr: "", exit: Option.none(), invalid: !1 }, failure = (error, message) => ({ error, message });
+export const searchRipgrep = Effect.fn("workspace.grep")(function* (access, target, directory, params, config) {
+  const bash = yield* Bash, run = yield* Effect.serviceOption(RunContext), cwd = directory ? target.path : access.path.dirname(target.path), input = directory ? "." : access.path.basename(target.path), exclude = excludesBelow(config.exclude, isWithin(access.root, cwd) ? Option.some(access.path.relative(access.root, cwd)) : Option.none()), limit = params.limit ?? config.grepMatches, perFile = directory ? Math.max(1, Math.ceil(limit / 4)) : limit, options = { limit, perFile, directory, lineChars: config.grepLineChars, display: (path) => displayOf(access, access.path.resolve(cwd, path)) }, fold = (state, event) => {
+    if (event._tag === "BashExit")
+      return { ...state, exit: Option.some(event) };
+    if (event.stream === "stderr")
+      return { ...state, stderr: clipHead(state.stderr + event.text, 16384) };
+    const complete = state.buffer + event.text;
+    if (complete.split(`
+`).some((line) => line.length > config.maxFileBytes * 6 + 65536))
+      return { ...state, invalid: !0 };
+    const parsed = rgRecords("", complete);
+    return { ...state, buffer: parsed.buffer, search: parsed.records.reduce((search, message) => search.stopped ? search : foldRgMessage(search, message, options), state.search) };
+  }, output = yield* bash.stream(ripgrepCommand(config, params, input, perFile, exclude), {
+    cwd,
+    stdin: params.pattern.length === 0 ? `
+` : params.pattern,
+    timeoutMs: config.grepTimeoutMs,
+    ...bashEnvironment(config, Option.map(run, (current) => ({ sessionId: String(current.session.id), runId: current.runId, workspace: access.root })))
+  }).pipe(Stream.mapAccum(() => empty, (state, event) => {
+    const next = fold(state, event);
+    return [next, [next]];
+  }), Stream.takeUntil((state) => state.search.stopped || state.invalid), Stream.runFold(() => empty, (_previous, state) => state), Effect.mapError((error) => failure(error.reason, error.message))), search = Option.match(decodeRgMessage(output.buffer), {
+    onNone: () => output.search,
+    onSome: (message) => foldRgMessage(output.search, message, options)
+  });
+  if (output.invalid)
+    return yield* Effect.fail(failure("SearchFailed", "The search output was too large to read; narrow the path or the pattern and search again"));
+  const timedOut = Option.exists(output.exit, (exit) => exit.termination === "timeout"), unreadable = output.stderr.split(`
+`).flatMap((line) => {
+    const found = /^rg: (.*): .*\(os error (\d+)\)$/.exec(line);
+    return found === null ? [] : [{ path: options.display(found[1] ?? ""), reason: rgReasonOf(Number(found[2])) }];
+  });
+  if (Option.exists(output.exit, (exit) => Option.contains(exit.exitCode, 2)) && search.messages === 0 && unreadable.length === 0)
+    return yield* Effect.fail(failure("InvalidPattern", `The search pattern or glob could not be parsed: ${output.stderr.trim()}. Pass literal: true to search for the pattern as text`));
+  if (Option.exists(output.exit, (exit) => exit.termination === "signal" || exit.termination === "exit" && !Option.exists(exit.exitCode, (code) => code === 0 || code === 1 || code === 2)))
+    return yield* Effect.fail(failure("SearchFailed", "The file search could not finish; try a narrower path or tell the user the search is unavailable"));
+  return {
+    pattern: params.pattern,
+    path: target.display,
+    lines: rgLines(search, params.context ?? 0),
+    matches: [...search.counts.values()].reduce((sum, count) => sum + count, 0),
+    files: search.counts.size,
+    skipped: search.skipped,
+    truncated: search.truncated,
+    unreadable,
+    timedOut
+  };
+});

package/dist/ripgrep.entity.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+/** ripgrep represents non-UTF-8 paths and lines as base64 bytes. */
+export declare const RgText: Schema.Union<readonly [Schema.Struct<{
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly bytes: Schema.StringFromBase64;
+}>]>;
+export type RgText = typeof RgText.Type;
+/** Only the fields the workspace search consumes from ripgrep's JSON stream. */
+export declare const RgMessage: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"begin">;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"match">;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+        readonly lines: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+        readonly line_number: Schema.Int;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"context">;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+        readonly lines: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+        readonly line_number: Schema.Int;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"end">;
+    readonly data: Schema.Struct<{
+        readonly path: Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly bytes: Schema.StringFromBase64;
+        }>]>;
+        readonly binary_offset: Schema.NullOr<Schema.Int>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"summary">;
+    readonly data: Schema.Struct<{}>;
+}>]>;
+export type RgMessage = typeof RgMessage.Type;