@better-fs-tools/pi 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @better-fs-tools/pi
 
-Better FS Tools for the [Pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent). It replaces Pi's built-in `read`, `edit`, and `write` tools, and adds `apply_patch`. Every call is confined to the working directory of that call, and `edit` and `write` need a read first.
+Better FS Tools for the [Pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent). It replaces Pi's built-in `read`, `edit`, and `write` tools, and can add `apply_patch`. Every call is confined to the working directory of that call. A read store, so that `edit` and `write` need a read first, is opt-in.
 
 ## Install
 
@@ -10,7 +10,7 @@ npm install @better-fs-tools/pi @better-fs-tools/read @better-fs-tools/write @ea
 
 `@earendil-works/pi-coding-agent` (`^0.84.2`) and `typebox` (`^1.3.16`) are required peers. The package needs Node 24 or later.
 
-The package has a `pi.extensions` entry. When Pi loads the package, the entry registers `read`, `edit`, `write`, and `apply_patch` from `createPiFsTools()`. The four tools share one in-memory read store, so `edit` and `write` need a read first. Writes stay inside `ctx.cwd`. The entry writes no settings or session file.
+The package has a `pi.extensions` entry. When Pi loads the package, the entry registers `read`, `edit`, and `write` from `createPiFsTools()`, as Pi's own tools are. `read` returns images, as Pi's own `read` does. There is no read store, so `edit` and `write` do not check for a read first. Writes stay inside `ctx.cwd`. The entry writes no settings or session file.
 
 ## Example
 
@@ -19,13 +19,15 @@ To choose your own options, register the tools from your own extension:
 ```ts
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createPiFsTools } from "@better-fs-tools/pi";
-import { denyPaths, unicodeRepair } from "@better-fs-tools/read";
+import { denyPaths, memoryStore, unicodeRepair } from "@better-fs-tools/read";
 import { hashlineFormat } from "@better-fs-tools/read/formats";
 import { protectPaths } from "@better-fs-tools/write";
 
 export default function fsToolsExtension(pi: ExtensionAPI): void {
-  // Four tools with one read store, so edit and write need a read first.
+  // Four tools with one read store, so edit and write need a read first. The
+  // store and apply_patch are opt-in.
   const tools = createPiFsTools({
+    state: memoryStore(),
     read: {
       resolve: unicodeRepair({ note: false }),
       authorize: denyPaths(["**/.env", "**/.env.*"]),
@@ -69,14 +71,15 @@ export default function readExtension(pi: ExtensionAPI): void {
 - `fs`, `cwd`, and `allowedRoots` throw `TypeError`. Each call reads through `nodeFileSystem` with Pi's `ctx.cwd` as the only allowed root. When the working directory changes between calls, the root changes too. The tool keeps the filesystems for the last 8 working directories.
 - Pi's `ExtensionContext` is the host type. Host functions get it as `ctx.call.host`, for example `ctx.call.host.ui.confirm(...)` in `askUser`, or `ctx.call.host.sessionManager.getSessionId()` in a `state` factory.
 - The default signature is `defaultReadSignature({ name: "read" })`. Its schema has integer `offset` and `limit`, so a model that sends `2.5` gets Pi's validation error. `digest` defaults to `nodeDigest()`.
+- `converters` defaults to `[imageConverter()]`, as Pi's own `read` returns images. This holds for `createPiReadTool()`, `createPiFsTools()`, and the extension entry. A list you pass replaces the default, so `converters: []` turns images off, and a list without `imageConverter()` refuses images. In `createPiFsTools()` the option goes under `read`, for example `read: { converters: [] }`.
 - Image parts become Pi `image` parts. Other media becomes a text part that says what was left out.
 - `details.truncation` follows Pi's own read tool for line and byte stops. Its `content` comes from the formatter in `"view"` mode. For other results, or a formatter that returns parts, `details` is `{}`. `toPiReadDetails()` builds the details for your own tool.
 
 ## What the write tools do
 
-- `createPiFsTools(options?)` wraps `createFsTools()` from `@better-fs-tools/write`. It builds `read`, `edit`, `write`, and `apply_patch` with one `memoryStore({ clock })`, one `nodeDigest()`, one lock manager, one clock, and one cache of filesystems over `ctx.cwd`. `state: null` turns read-before-write off. `digest` (default `nodeDigest()`), `locks`, `clock`, and the root options (`denyRoots`, `symlinks`, `hardLinks`, `newFileMode`, `newDirectoryMode`) are set once for all four. Each tool's other options go under `read`, `edit`, `write`, and `applyPatch`. The result also has `state`, `digest`, `locks`, `clock`, and `invalidate(path, call?)`, which returns an `InvalidateOutcome`. Pass the call, so the path resolves under its `ctx.cwd`: in a bash `afterRun` hook it is `ctx.call`. Without it the outcome is `{ ok: false }` with reason `unsupported`. An unknown top-level key, or `state`, `digest`, `locks`, `clock`, or a root option inside a tool's options, throws `TypeError`.
-- `createPiEditTool()`, `createPiWriteTool()`, and `createPiApplyPatchTool()` build one tool each. They default to `state: null`, so every update carries a `read-before-write-off` note. Pass the same `state` as your read tool, or use `createPiFsTools()`.
-- `fs`, `cwd`, and `allowedRoots` throw `TypeError`, as for the read tool. Writes go through `nodeFileSystem` with `ctx.cwd` as the only allowed root, and `hardLinks: "refuse"` by default. `newFileMode` and `newDirectoryMode` set the modes of new files and directories exactly. Without them, a new file is `0o666` and a new directory `0o777`, less the process umask.
+- `createPiFsTools(options?)` wraps `createFsTools()` from `@better-fs-tools/write`. It builds `read`, `edit`, and `write` with one `nodeDigest()`, one lock manager, one clock, and one cache of filesystems over `ctx.cwd`. `applyPatch: true`, or an options object, adds `apply_patch`. `state` defaults to `null`, so read-before-write is off; `state: memoryStore()` turns it on. `digest` (default `nodeDigest()`), `locks`, `clock`, and the root options (`denyRoots`, `symlinks`, `hardLinks`, `newFileMode`, `newDirectoryMode`) are set once for all the tools. Each tool's other options go under `read`, `edit`, `write`, and `applyPatch`. The result also has `applyPatch` (`null` when off), `state`, `digest`, `locks`, `clock`, and `invalidate(path, call?)`, which returns an `InvalidateOutcome`. Pass the call, so the path resolves under its `ctx.cwd`: in a bash `afterRun` hook it is `ctx.call`. Without it the outcome is `{ ok: false }` with reason `unsupported`. An unknown top-level key, or `state`, `digest`, `locks`, `clock`, or a root option inside a tool's options, throws `TypeError`.
+- `createPiEditTool()`, `createPiWriteTool()`, and `createPiApplyPatchTool()` build one tool each. They default to `state: null`, so read-before-write is off. Pass the same `state` as your read tool, or use `createPiFsTools()`.
+- `fs`, `cwd`, and `allowedRoots` throw `TypeError`, as for the read tool. Writes go through `nodeFileSystem` with `ctx.cwd` as the only allowed root, and `hardLinks: "in-place"` by default: a file with more than one hard link is written through the link, not atomically. `hardLinks: "refuse"` fails that write with `DENIED`. `newFileMode` and `newDirectoryMode` set the modes of new files and directories exactly. Without them, a new file is `0o666` and a new directory `0o777`, less the process umask.
 - The default signatures follow Pi's own tools: `edit` takes `path` and `edits: [{ oldText, newText }]` (`multiEditSignature({ name: "edit" })`), and `write` takes `path` and `content`. Their prompt snippets and guidelines are Pi's own, so the system prompt stays the same. `apply_patch` uses `freeformPatchSignature()`: models with grammar-tool support get the Codex patch grammar, and other models get the JSON schema.
 - `edit` and `apply_patch` return `details` in the shape of Pi's `EditToolDetails` (`diff`, `patch`, `firstChangedLine`), so Pi's edit renderer draws the diff. `toPiMutationDetails()` builds them for your own tool. `write` returns no details, as Pi's own `write` does.
 - A tool error becomes Pi content text. The tool does not throw for a tool error.
@@ -105,11 +108,13 @@ With the file tools, a bash `afterRun` hook can make the next edit of a file nee
 ```ts
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createPiBashTool, createPiFsTools } from "@better-fs-tools/pi";
+import { memoryStore } from "@better-fs-tools/read";
 
-// The four file tools and Pi-shaped bash. After each command, the next edit of
-// package.json needs a read, since the command may have changed it.
+// The file tools with a read store, and Pi-shaped bash. After each command,
+// the next edit of package.json needs a read, since the command may have
+// changed it.
 export default function fsAndBashExtension(pi: ExtensionAPI): void {
-  const tools = createPiFsTools();
+  const tools = createPiFsTools({ state: memoryStore() });
   const bash = createPiBashTool({
     afterRun: [
       {
@@ -125,7 +130,6 @@ export default function fsAndBashExtension(pi: ExtensionAPI): void {
   pi.registerTool(tools.read);
   pi.registerTool(tools.edit);
   pi.registerTool(tools.write);
-  pi.registerTool(tools.applyPatch);
   pi.registerTool(bash);
 }
 ```

package/dist/extension.js

@@ -1,7 +1,8 @@
 /**
  * Pi package extension entry. Installing the package into a Pi project
- * registers read, edit, write, and apply_patch, and nothing else. The four
- * tools share one in-memory read store, so edit and write need a read first.
+ * registers read, edit, and write, as Pi's own tools are, and nothing else.
+ * There is no read store, so edit and write do not check for a read first.
+ * read returns images, as Pi's own read does.
  * Nothing is written outside the process: no settings file, no session file.
  */
 import { createPiFsTools } from "./fs-tools.js";
@@ -10,5 +11,4 @@ export default function fsToolsExtension(pi) {
     pi.registerTool(tools.read);
     pi.registerTool(tools.edit);
     pi.registerTool(tools.write);
-    pi.registerTool(tools.applyPatch);
 }

package/dist/fs-tools.d.ts

@@ -6,7 +6,7 @@ import type { PiRootOptions } from "./roots.ts";
 import type { CreatePiReadToolOptions, PiReadTool } from "./tool.ts";
 type BundleSharedKey = FsToolsSharedKey | keyof PiRootOptions;
 export interface CreatePiFsToolsOptions extends PiRootOptions {
-    /** Default a memory store on the bundle clock. null turns read-before-write off. */
+    /** Default null: no read-before-write. A store, for example memoryStore(), turns it on. */
     readonly state?: ReadStateStore | null;
     /** Default nodeDigest(). */
     readonly digest?: Digest;
@@ -17,13 +17,15 @@ export interface CreatePiFsToolsOptions extends PiRootOptions {
     readonly read?: Omit<CreatePiReadToolOptions, BundleSharedKey>;
     readonly edit?: Omit<CreatePiEditToolOptions, BundleSharedKey>;
     readonly write?: Omit<CreatePiWriteToolOptions, BundleSharedKey>;
-    readonly applyPatch?: Omit<CreatePiApplyPatchToolOptions, BundleSharedKey>;
+    /** Off by default. `true` or an options object adds an apply_patch tool. */
+    readonly applyPatch?: boolean | Omit<CreatePiApplyPatchToolOptions, BundleSharedKey>;
 }
 export interface PiFsTools {
     readonly read: PiReadTool;
     readonly edit: PiMutationTool;
     readonly write: PiMutationTool;
-    readonly applyPatch: PiMutationTool;
+    /** null unless options.applyPatch is true or an object. */
+    readonly applyPatch: PiMutationTool | null;
     readonly state: ReadStateStore | null;
     /** options.digest, or nodeDigest(). */
     readonly digest: Digest;
@@ -37,13 +39,21 @@ export interface PiFsTools {
      */
     invalidate(path: string, call?: ToolCallContext<ExtensionContext>): Promise<InvalidateOutcome>;
 }
+/** The createPiFsTools result when `applyPatch` is true or an object: it is never null. */
+export interface PiFsToolsWithApplyPatch extends PiFsTools {
+    readonly applyPatch: PiMutationTool;
+}
 /**
- * Creates Pi read, edit, write, and apply_patch tools rooted at each call's
- * ctx.cwd. They share one read state store, digest, lock manager, and clock.
+ * Creates Pi read, edit, and write tools rooted at each call's ctx.cwd, and
+ * an apply_patch tool when `applyPatch` is true or an object. They share one
+ * digest, lock manager, and clock, and the read store when `state` is given.
  * Throws TypeError on fs, cwd, or allowedRoots anywhere in the options, on an
  * unknown key, and on a shared option (state, digest, locks, clock, or a root
  * option) inside one tool's options. There is no bash: register
  * createPiBashTool() and call invalidate from its afterRun hook.
  */
+export declare function createPiFsTools(options: CreatePiFsToolsOptions & {
+    readonly applyPatch: true | Omit<CreatePiApplyPatchToolOptions, BundleSharedKey>;
+}): PiFsToolsWithApplyPatch;
 export declare function createPiFsTools(options?: CreatePiFsToolsOptions): PiFsTools;
 export {};

package/dist/fs-tools.js

@@ -15,14 +15,6 @@ const KNOWN_OPTIONS = new Set([
     "applyPatch",
 ]);
 const BUNDLE_SHARED_KEYS = ["state", "digest", "locks", "clock", ...PI_ROOT_KEYS];
-/**
- * Creates Pi read, edit, write, and apply_patch tools rooted at each call's
- * ctx.cwd. They share one read state store, digest, lock manager, and clock.
- * Throws TypeError on fs, cwd, or allowedRoots anywhere in the options, on an
- * unknown key, and on a shared option (state, digest, locks, clock, or a root
- * option) inside one tool's options. There is no bash: register
- * createPiBashTool() and call invalidate from its afterRun hook.
- */
 export function createPiFsTools(options = {}) {
     checkPiOptions(options, "fs");
     for (const key of Object.keys(options)) {
@@ -37,9 +29,15 @@ export function createPiFsTools(options = {}) {
         read: options.read ?? {},
         edit: options.edit ?? {},
         write: options.write ?? {},
-        applyPatch: options.applyPatch ?? {},
+        applyPatch: options.applyPatch === true
+            ? {}
+            : options.applyPatch === false || options.applyPatch === undefined
+                ? null
+                : options.applyPatch,
     };
     for (const [key, value] of Object.entries(given)) {
+        if (value === null)
+            continue;
         checkPiOptions(value, key);
         for (const shared of BUNDLE_SHARED_KEYS) {
             if (Object.hasOwn(value, shared)) {
@@ -52,13 +50,16 @@ export function createPiFsTools(options = {}) {
     const { signature: _readSignature, promptSnippet: _readSnippet, promptGuidelines: _readLines, ...read } = given.read;
     const { signature: _editSignature, promptSnippet: _editSnippet, promptGuidelines: _editLines, ...edit } = given.edit;
     const { signature: _writeSignature, promptSnippet: _writeSnippet, promptGuidelines: _writeLines, ...write } = given.write;
-    const { signature: _patchSignature, promptSnippet: _patchSnippet, promptGuidelines: _patchLines, ...applyPatch } = given.applyPatch;
     const parts = {
         read: piReadParts(given.read),
         edit: piEditParts(given.edit),
         write: piWriteParts(given.write),
-        applyPatch: piApplyPatchParts(given.applyPatch),
     };
+    let patch = null;
+    if (given.applyPatch !== null) {
+        const { signature: _patchSignature, promptSnippet: _patchSnippet, promptGuidelines: _patchLines, ...deps } = given.applyPatch;
+        patch = { deps, parts: piApplyPatchParts(given.applyPatch) };
+    }
     const core = createFsTools({
         fs,
         digest: options.digest ?? nodeDigest(),
@@ -68,13 +69,15 @@ export function createPiFsTools(options = {}) {
         read: { ...read, ...piReadDeps(parts.read) },
         edit: { ...edit, messages: parts.edit.messages },
         write: { ...write, messages: parts.write.messages },
-        applyPatch: { ...applyPatch, messages: parts.applyPatch.messages },
+        ...(patch === null ? {} : { applyPatch: { ...patch.deps, messages: patch.parts.messages } }),
     });
     return Object.freeze({
         read: adaptPiReadTool(parts.read, core.read, core.digest),
         edit: adaptPiMutationTool(parts.edit, core.edit),
         write: adaptPiMutationTool(parts.write, core.write),
-        applyPatch: adaptPiMutationTool(parts.applyPatch, core.applyPatch),
+        applyPatch: patch === null || core.applyPatch === null
+            ? null
+            : adaptPiMutationTool(patch.parts, core.applyPatch),
         state: core.state,
         digest: core.digest,
         locks: core.locks,

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { CreatePiBashToolOptions, PiBashDetails, PiBashTool, PiBashToolResu
 export { toPiReadDetails } from "./details.ts";
 export type { PiReadDetails, PiTruncationResult } from "./details.ts";
 export { createPiFsTools } from "./fs-tools.ts";
-export type { CreatePiFsToolsOptions, PiFsTools } from "./fs-tools.ts";
+export type { CreatePiFsToolsOptions, PiFsTools, PiFsToolsWithApplyPatch } from "./fs-tools.ts";
 export { toPiMutationDetails } from "./mutation-details.ts";
 export type { PiMutationDetails } from "./mutation-details.ts";
 export { createPiApplyPatchTool, createPiEditTool, createPiWriteTool } from "./mutation-tools.ts";

package/dist/mutation-tools.d.ts

@@ -61,7 +61,7 @@ export declare function piApplyPatchParts(options: PartsInput<PatchSignature>):
 /**
  * Creates a Pi edit tool rooted at each call's ctx.cwd. Throws TypeError when
  * options set fs, cwd, or allowedRoots. Read-before-write is off unless you
- * pass a `state`; use createPiFsTools() for a store shared with read.
+ * pass a `state`; use createPiFsTools({ state }) for a store shared with read.
  */
 export declare function createPiEditTool(options?: CreatePiEditToolOptions): PiMutationTool;
 /** Creates a Pi write tool, as createPiEditTool. `details` is always undefined, as for Pi's own write. */

package/dist/mutation-tools.js

@@ -43,7 +43,7 @@ function parts(tool, signature, options, snippet, guidelines) {
 /**
  * Creates a Pi edit tool rooted at each call's ctx.cwd. Throws TypeError when
  * options set fs, cwd, or allowedRoots. Read-before-write is off unless you
- * pass a `state`; use createPiFsTools() for a store shared with read.
+ * pass a `state`; use createPiFsTools({ state }) for a store shared with read.
  */
 export function createPiEditTool(options = {}) {
     checkPiOptions(options, "edit");

package/dist/roots.d.ts

@@ -6,7 +6,7 @@ export interface PiRootOptions {
     /** Added to /dev, /proc, /sys. */
     readonly denyRoots?: readonly string[];
     readonly symlinks?: NodeFileSystemOptions["symlinks"];
-    /** How to replace a file with more than one hard link. Default "refuse". */
+    /** How to replace a file with more than one hard link. Default "in-place". "refuse" fails with DENIED. */
     readonly hardLinks?: "refuse" | "in-place";
     /** Mode of a new file, exactly. Default 0o666 less the process umask. */
     readonly newFileMode?: number;

package/dist/tool.d.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TSchema } from "typebox";
 import type { NodeFileSystemOptions } from "@better-fs-tools/node";
-import type { Digest, JsonObject, ReadFormatter, ReadLimits, ReadMessageCatalog, ReadTool, ReadToolDeps, StateNeedsDigestOrDefault } from "@better-fs-tools/read";
+import type { Converter, Digest, JsonObject, ReadFormatter, ReadLimits, ReadMessageCatalog, ReadTool, ReadToolDeps, StateNeedsDigestOrDefault } from "@better-fs-tools/read";
 import type { ReadSignature } from "@better-fs-tools/read/signature";
 import type { PiReadDetails } from "./details.ts";
 import type { PiContentPart } from "./parts.ts";
@@ -17,7 +17,8 @@ export interface PiReadOptions {
 }
 /**
  * Options for createPiReadTool. digest defaults to nodeDigest(); a state needs
- * a digest that is not null.
+ * a digest that is not null. converters defaults to [imageConverter()], as
+ * Pi's own read shows images. A list you pass replaces it: [] turns images off.
  */
 export type CreatePiReadToolOptions = Omit<ReadToolDeps<ExtensionContext>, "fs"> & StateNeedsDigestOrDefault & PiReadOptions & {
     /** Added to /dev, /proc, /sys. */
@@ -42,7 +43,8 @@ export interface PiReadTool {
 /**
  * Creates a Pi read tool rooted at each call's ctx.cwd. Throws TypeError when
  * options set fs, cwd, or allowedRoots. It keeps no read state by default and
- * writes nothing outside the process.
+ * writes nothing outside the process. An image becomes a Pi image part unless
+ * options.converters leaves imageConverter() out.
  */
 export declare function createPiReadTool(options?: CreatePiReadToolOptions): PiReadTool;
 export interface PiReadParts {
@@ -52,11 +54,13 @@ export interface PiReadParts {
     readonly limits: Readonly<ReadLimits>;
     readonly formatter: ReadFormatter<ExtensionContext>;
     readonly messages: Partial<ReadMessageCatalog>;
+    readonly converters: readonly Converter<ExtensionContext>[];
 }
-export declare function piReadParts(options: PiReadOptions & Pick<Partial<ReadToolDeps<ExtensionContext>>, "limits" | "messages" | "formatter">): PiReadParts;
+export declare function piReadParts(options: PiReadOptions & Pick<Partial<ReadToolDeps<ExtensionContext>>, "limits" | "messages" | "formatter" | "converters">): PiReadParts;
 export declare function piReadDeps(parts: PiReadParts): {
     limits: Readonly<ReadLimits>;
     formatter: ReadFormatter<ExtensionContext>;
     messages: Partial<ReadMessageCatalog>;
+    converters: readonly Converter<ExtensionContext>[];
 };
 export declare function adaptPiReadTool(parts: PiReadParts, read: ReadTool<ExtensionContext>, digest: Digest | null): PiReadTool;

package/dist/tool.js

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { nodeDigest } from "@better-fs-tools/node";
-import { createReadTool, lineNumberFormatter, resolveReadLimits } from "@better-fs-tools/read";
+import { createReadTool, imageConverter, lineNumberFormatter, resolveReadLimits, } from "@better-fs-tools/read";
 import { defaultReadSignature, readSignatureMessages } from "@better-fs-tools/read/signature";
 import { toPiReadDetails } from "./details.js";
 import { toPiPart } from "./parts.js";
@@ -12,7 +12,8 @@ const PI_BUILTIN_READ_GUIDELINES = [
 /**
  * Creates a Pi read tool rooted at each call's ctx.cwd. Throws TypeError when
  * options set fs, cwd, or allowedRoots. It keeps no read state by default and
- * writes nothing outside the process.
+ * writes nothing outside the process. An image becomes a Pi image part unless
+ * options.converters leaves imageConverter() out.
  */
 export function createPiReadTool(options = {}) {
     checkPiOptions(options, "read");
@@ -37,10 +38,17 @@ export function piReadParts(options) {
         limits: resolveReadLimits(options.limits),
         formatter: options.formatter ?? lineNumberFormatter(),
         messages: { ...readSignatureMessages(signature), ...options.messages },
+        // Pi's own read returns images, so the Pi host turns them on.
+        converters: options.converters ?? [imageConverter()],
     };
 }
 export function piReadDeps(parts) {
-    return { limits: parts.limits, formatter: parts.formatter, messages: parts.messages };
+    return {
+        limits: parts.limits,
+        formatter: parts.formatter,
+        messages: parts.messages,
+        converters: parts.converters,
+    };
 }
 export function adaptPiReadTool(parts, read, digest) {
     const { signature, promptSnippet, promptGuidelines, limits, formatter } = parts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-fs-tools/pi",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The Better FS Tools read, edit, write, apply_patch, and bash tools and extension for the Pi coding agent.",
   "license": "MIT",
   "repository": {
@@ -42,13 +42,13 @@
     }
   },
   "dependencies": {
-    "@better-fs-tools/node": "^0.1.0",
-    "@better-fs-tools/read": "^0.1.0",
-    "@better-fs-tools/shell": "^0.1.0",
-    "@better-fs-tools/write": "^0.1.0"
+    "@better-fs-tools/node": "^0.2.0",
+    "@better-fs-tools/read": "^0.2.0",
+    "@better-fs-tools/shell": "^0.2.0",
+    "@better-fs-tools/write": "^0.2.0"
   },
   "devDependencies": {
-    "@better-fs-tools/fs": "^0.1.0",
+    "@better-fs-tools/fs": "^0.2.0",
     "@earendil-works/pi-coding-agent": "^0.84.2",
     "typebox": "^1.3.16"
   },