reasonix 0.4.6 → 0.4.9

package/dist/index.js

@@ -47,8 +47,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3, reject) => {
-    const timer = setTimeout(resolve3, ms);
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(resolve4, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -514,7 +514,7 @@ var ToolRegistry = class {
       }
     }));
   }
-  async dispatch(name, argumentsRaw) {
+  async dispatch(name, argumentsRaw, opts = {}) {
     const tool = this._tools.get(name);
     if (!tool) {
       return JSON.stringify({ error: `unknown tool: ${name}` });
@@ -531,7 +531,7 @@ var ToolRegistry = class {
       args = nestArguments(args);
     }
     try {
-      const result = await tool.fn(args);
+      const result = await tool.fn(args, { signal: opts.signal });
       return typeof result === "string" ? result : JSON.stringify(result);
     } catch (err) {
       return JSON.stringify({
@@ -565,8 +565,20 @@ async function bridgeMcpTools(client, opts = {}) {
       name: registeredName,
       description: mcpTool.description ?? "",
       parameters: mcpTool.inputSchema,
-      fn: async (args) => {
-        const toolResult = await client.callTool(mcpTool.name, args);
+      fn: async (args, ctx) => {
+        const toolResult = await client.callTool(mcpTool.name, args, {
+          // Forward server-side progress frames to the bridge caller,
+          // tagged with the registered name so multi-server UIs can
+          // disambiguate. No-op when `onProgress` isn't configured —
+          // the client then also omits the _meta.progressToken and
+          // the server won't emit progress.
+          onProgress: opts.onProgress ? (info) => opts.onProgress({ toolName: registeredName, ...info }) : void 0,
+          // Thread the tool-dispatch AbortSignal all the way down to
+          // the MCP request so Esc truly cancels in flight — the
+          // client will emit notifications/cancelled AND reject the
+          // pending promise immediately, no "wait for subprocess".
+          signal: ctx?.signal
+        });
         return flattenMcpResult(toolResult, { maxChars: maxResultChars });
       }
     });
@@ -1155,11 +1167,13 @@ var CacheFirstLoop = class {
   _turn = 0;
   _streamPreference;
   /**
-   * Set by {@link abort} to short-circuit the tool-call loop after the
-   * current iteration. Reset at the start of each `step()` so an Esc
-   * during one turn doesn't poison the next.
+   * AbortController per active turn. Threaded through the DeepSeek
+   * HTTP calls AND every tool dispatch so Esc actually cancels the
+   * in-flight network/subprocess work — not "we'll get to it after
+   * the current call finishes." Re-created at the start of each
+   * `step()` (the prior turn's signal has already fired).
    */
-  _aborted = false;
+  _turnAbort = new AbortController();
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1272,14 +1286,15 @@ var CacheFirstLoop = class {
     return msgs;
   }
   /**
-   * Signal the currently-running {@link step} that the user wants to
-   * stop exploring. Takes effect at the next iteration boundary — if a
-   * tool call is mid-flight it will be allowed to finish, then the
-   * loop diverts to the forced-summary path so the user gets an
-   * answer instead of a cliff. Called by the TUI on Esc.
+   * Signal the currently-running {@link step} to stop **now**. Cancels
+   * the in-flight network request (DeepSeek HTTP/SSE) AND any tool call
+   * currently dispatching (MCP `notifications/cancelled` + promise
+   * reject). The loop itself also sees `signal.aborted` at each
+   * iteration boundary and exits quickly instead of looping again.
+   * Called by the TUI on Esc.
    */
   abort() {
-    this._aborted = true;
+    this._turnAbort.abort();
   }
   /**
    * Drop everything in the log after (and including) the most recent
@@ -1317,13 +1332,14 @@ var CacheFirstLoop = class {
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
-    this._aborted = false;
+    this._turnAbort = new AbortController();
+    const signal = this._turnAbort.signal;
     let pendingUser = userInput;
     const toolSpecs = this.prefix.tools();
     const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
     let warnedForIterBudget = false;
     for (let iter = 0; iter < this.maxToolIters; iter++) {
-      if (this._aborted) {
+      if (signal.aborted) {
         yield {
           turn: this._turn,
           role: "warning",
@@ -1386,7 +1402,8 @@ var CacheFirstLoop = class {
             {
               model: this.model,
               messages,
-              tools: toolSpecs.length ? toolSpecs : void 0
+              tools: toolSpecs.length ? toolSpecs : void 0,
+              signal
             },
             {
               ...this.branchOptions,
@@ -1395,8 +1412,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve3) => {
-              waiter = resolve3;
+            const sample = queue.shift() ?? await new Promise((resolve4) => {
+              waiter = resolve4;
             });
             yield {
               turn: this._turn,
@@ -1436,7 +1453,8 @@ var CacheFirstLoop = class {
           for await (const chunk of this.client.stream({
             model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0
+            tools: toolSpecs.length ? toolSpecs : void 0,
+            signal
           })) {
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
@@ -1475,7 +1493,8 @@ var CacheFirstLoop = class {
           const resp = await this.client.chat({
             model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0
+            tools: toolSpecs.length ? toolSpecs : void 0,
+            signal
           });
           assistantContent = resp.content;
           reasoningContent = resp.reasoningContent ?? "";
@@ -1539,7 +1558,7 @@ var CacheFirstLoop = class {
           toolName: name,
           toolArgs: args
         };
-        const result = await this.tools.dispatch(name, args);
+        const result = await this.tools.dispatch(name, args, { signal });
         this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
@@ -1566,8 +1585,9 @@ var CacheFirstLoop = class {
       });
       const resp = await this.client.chat({
         model: this.model,
-        messages
+        messages,
         // no tools → model is forced to answer in text
+        signal: this._turnAbort.signal
       });
       const rawContent = resp.content?.trim() ?? "";
       const cleaned = stripHallucinatedToolMarkup(rawContent);
@@ -1663,13 +1683,298 @@ function formatLoopError(err) {
   return msg;
 }
 
+// src/tools/filesystem.ts
+import { promises as fs } from "fs";
+import * as pathMod from "path";
+var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
+function registerFilesystemTools(registry, opts) {
+  const rootDir = pathMod.resolve(opts.rootDir);
+  const allowWriting = opts.allowWriting !== false;
+  const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
+  const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
+  const safePath = (raw) => {
+    if (typeof raw !== "string" || raw.length === 0) {
+      throw new Error("path must be a non-empty string");
+    }
+    const resolved = pathMod.resolve(rootDir, raw);
+    const normRoot = pathMod.resolve(rootDir);
+    const rel = pathMod.relative(normRoot, resolved);
+    if (rel.startsWith("..") || pathMod.isAbsolute(rel)) {
+      throw new Error(`path escapes sandbox root (${normRoot}): ${raw}`);
+    }
+    return resolved;
+  };
+  registry.register({
+    name: "read_file",
+    description: "Read a file under the sandbox root. Returns the full contents (truncated with a notice if larger than the per-call cap). Paths may be relative to the root or absolute-under-root.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to read (relative to rootDir or absolute)." },
+        head: { type: "integer", description: "If set, return only the first N lines." },
+        tail: { type: "integer", description: "If set, return only the last N lines." }
+      },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const stat = await fs.stat(abs);
+      if (stat.isDirectory()) {
+        throw new Error(`not a file: ${args.path} (it's a directory)`);
+      }
+      const raw = await fs.readFile(abs);
+      if (raw.length > maxReadBytes) {
+        const head = raw.slice(0, maxReadBytes).toString("utf8");
+        return `${head}
+
+[\u2026truncated ${raw.length - maxReadBytes} bytes \u2014 file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail for targeted view.]`;
+      }
+      const text = raw.toString("utf8");
+      if (typeof args.head === "number" && args.head > 0) {
+        return text.split(/\r?\n/).slice(0, args.head).join("\n");
+      }
+      if (typeof args.tail === "number" && args.tail > 0) {
+        let lines = text.split(/\r?\n/);
+        if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+        return lines.slice(Math.max(0, lines.length - args.tail)).join("\n");
+      }
+      return text;
+    }
+  });
+  registry.register({
+    name: "list_directory",
+    description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to list (default: root)." }
+      }
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path ?? ".");
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      const lines = [];
+      for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push(e.isDirectory() ? `${e.name}/` : e.name);
+      }
+      return lines.join("\n") || "(empty directory)";
+    }
+  });
+  registry.register({
+    name: "directory_tree",
+    description: "Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Caps output so a huge tree doesn't drown the context.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Root of the tree (default: sandbox root)." },
+        maxDepth: { type: "integer", description: "Max recursion depth (default 4)." }
+      }
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const maxDepth = typeof args.maxDepth === "number" ? args.maxDepth : 4;
+      const lines = [];
+      let totalBytes = 0;
+      let truncated = false;
+      const walk2 = async (dir, depth) => {
+        if (truncated) return;
+        if (depth > maxDepth) return;
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+          if (truncated) return;
+          const indent = "  ".repeat(depth);
+          const line = e.isDirectory() ? `${indent}${e.name}/` : `${indent}${e.name}`;
+          totalBytes += line.length + 1;
+          if (totalBytes > maxListBytes) {
+            lines.push(`  [\u2026 tree truncated at ${maxListBytes} bytes \u2026]`);
+            truncated = true;
+            return;
+          }
+          lines.push(line);
+          if (e.isDirectory()) {
+            await walk2(pathMod.join(dir, e.name), depth + 1);
+          }
+        }
+      };
+      await walk2(startAbs, 0);
+      return lines.join("\n") || "(empty tree)";
+    }
+  });
+  registry.register({
+    name: "search_files",
+    description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory to start the search at (default: root)." },
+        pattern: {
+          type: "string",
+          description: "Substring (or regex) to match against filenames."
+        }
+      },
+      required: ["pattern"]
+    },
+    fn: async (args) => {
+      const startAbs = safePath(args.path ?? ".");
+      const needle = args.pattern.toLowerCase();
+      let re = null;
+      try {
+        re = new RegExp(args.pattern, "i");
+      } catch {
+        re = null;
+      }
+      const matches = [];
+      let totalBytes = 0;
+      const walk2 = async (dir) => {
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          const full = pathMod.join(dir, e.name);
+          const lower = e.name.toLowerCase();
+          const hit = re ? re.test(e.name) : lower.includes(needle);
+          if (hit) {
+            const rel = pathMod.relative(rootDir, full);
+            if (totalBytes + rel.length + 1 > maxListBytes) {
+              matches.push("[\u2026 search truncated \u2014 refine pattern \u2026]");
+              return;
+            }
+            matches.push(rel);
+            totalBytes += rel.length + 1;
+          }
+          if (e.isDirectory()) await walk2(full);
+        }
+      };
+      await walk2(startAbs);
+      return matches.length === 0 ? "(no matches)" : matches.join("\n");
+    }
+  });
+  registry.register({
+    name: "get_file_info",
+    description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" }
+      },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const st = await fs.lstat(abs);
+      const type = st.isDirectory() ? "directory" : st.isSymbolicLink() ? "symlink" : "file";
+      return JSON.stringify({
+        type,
+        size: st.size,
+        mtime: st.mtime.toISOString()
+      });
+    }
+  });
+  if (!allowWriting) return registry;
+  registry.register({
+    name: "write_file",
+    description: "Create or overwrite a file under the sandbox root with the given content. Parent directories are created as needed.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" }
+      },
+      required: ["path", "content"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(pathMod.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, args.content, "utf8");
+      return `wrote ${args.content.length} chars to ${pathMod.relative(rootDir, abs)}`;
+    }
+  });
+  registry.register({
+    name: "edit_file",
+    description: "Apply a SEARCH/REPLACE edit to an existing file. `search` must match exactly (whitespace sensitive) \u2014 no regex. The match must be unique in the file; otherwise the edit is refused to avoid surprise rewrites. This flat-string shape replaces the `{oldText, newText}[]` JSON array form that previously triggered R1 DSML hallucinations.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        search: { type: "string", description: "Exact text to find (must be unique)." },
+        replace: { type: "string", description: "Text to substitute in place of `search`." }
+      },
+      required: ["path", "search", "replace"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      const before = await fs.readFile(abs, "utf8");
+      if (args.search.length === 0) {
+        throw new Error("edit_file: search cannot be empty");
+      }
+      const firstIdx = before.indexOf(args.search);
+      if (firstIdx < 0) {
+        throw new Error(`edit_file: search text not found in ${pathMod.relative(rootDir, abs)}`);
+      }
+      const nextIdx = before.indexOf(args.search, firstIdx + 1);
+      if (nextIdx >= 0) {
+        throw new Error(
+          `edit_file: search text appears multiple times in ${pathMod.relative(rootDir, abs)} \u2014 include more context to disambiguate`
+        );
+      }
+      const after = before.slice(0, firstIdx) + args.replace + before.slice(firstIdx + args.search.length);
+      await fs.writeFile(abs, after, "utf8");
+      return `edited ${pathMod.relative(rootDir, abs)} (${args.search.length}\u2192${args.replace.length} chars)`;
+    }
+  });
+  registry.register({
+    name: "create_directory",
+    description: "Create a directory (and any missing parents) under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"]
+    },
+    fn: async (args) => {
+      const abs = safePath(args.path);
+      await fs.mkdir(abs, { recursive: true });
+      return `created ${pathMod.relative(rootDir, abs)}/`;
+    }
+  });
+  registry.register({
+    name: "move_file",
+    description: "Rename/move a file or directory under the sandbox root.",
+    parameters: {
+      type: "object",
+      properties: {
+        source: { type: "string" },
+        destination: { type: "string" }
+      },
+      required: ["source", "destination"]
+    },
+    fn: async (args) => {
+      const src = safePath(args.source);
+      const dst = safePath(args.destination);
+      await fs.mkdir(pathMod.dirname(dst), { recursive: true });
+      await fs.rename(src, dst);
+      return `moved ${pathMod.relative(rootDir, src)} \u2192 ${pathMod.relative(rootDir, dst)}`;
+    }
+  });
+  return registry;
+}
+
 // src/env.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync2(resolve(process.cwd(), path), "utf8");
+    raw = readFileSync2(resolve2(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -2199,6 +2504,13 @@ var McpClient = class {
   _serverInfo = { name: "", version: "" };
   _protocolVersion = "";
   _instructions;
+  // Progress-token → handler for notifications/progress routing. Tokens
+  // are minted per call when the caller supplies an onProgress
+  // callback; cleared when the final response lands (or the pending
+  // request rejects). No leaks — the `try/finally` in callTool
+  // guarantees cleanup even on timeout.
+  progressHandlers = /* @__PURE__ */ new Map();
+  nextProgressToken = 1;
   constructor(opts) {
     this.transport = opts.transport;
     this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: "0.3.0-dev" };
@@ -2253,13 +2565,36 @@ var McpClient = class {
     this.assertInitialized();
     return this.request("tools/list", {});
   }
-  /** Invoke a tool by name. Returns the raw MCP result (caller unwraps content). */
-  async callTool(name, args) {
+  /**
+   * Invoke a tool by name. When `onProgress` is supplied, attaches a
+   * fresh progress token so the server can send incremental updates
+   * via `notifications/progress`; they're routed to the callback until
+   * the final response arrives (or the request times out, in which
+   * case the handler is simply dropped — no extra notification).
+   *
+   * When `signal` is supplied, aborting it:
+   *   1) fires `notifications/cancelled` to the server (MCP 2024-11-05
+   *      way of saying "forget this request, I no longer care"), and
+   *   2) rejects the pending promise immediately with an AbortError,
+   *      so the caller doesn't have to wait for the subprocess to
+   *      finish its in-flight file write or network request.
+   * The server MAY still emit a late response; we drop it in dispatch
+   * since the request id is gone from `pending`.
+   */
+  async callTool(name, args, opts = {}) {
     this.assertInitialized();
-    return this.request("tools/call", {
-      name,
-      arguments: args ?? {}
-    });
+    const params = { name, arguments: args ?? {} };
+    let token;
+    if (opts.onProgress) {
+      token = this.nextProgressToken++;
+      this.progressHandlers.set(token, opts.onProgress);
+      params._meta = { progressToken: token };
+    }
+    try {
+      return await this.request("tools/call", params, opts.signal);
+    } finally {
+      if (token !== void 0) this.progressHandlers.delete(token);
+    }
   }
   /**
    * List resources the server exposes. Supports a pagination cursor;
@@ -2313,24 +2648,56 @@ var McpClient = class {
   assertInitialized() {
     if (!this.initialized) throw new Error("MCP client not initialized \u2014 call initialize() first");
   }
-  async request(method, params) {
+  async request(method, params, signal) {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve3, reject) => {
+    let abortHandler = null;
+    const promise = new Promise((resolve4, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
+        if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
         reject(
           new Error(`MCP request ${method} (id=${id}) timed out after ${this.requestTimeoutMs}ms`)
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve3,
+        resolve: resolve4,
         reject,
         timeout
       });
+      if (signal) {
+        if (signal.aborted) {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          reject(new Error(`MCP request ${method} (id=${id}) aborted before send`));
+          return;
+        }
+        abortHandler = () => {
+          this.pending.delete(id);
+          clearTimeout(timeout);
+          void this.transport.send({
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: { requestId: id, reason: "aborted by user" }
+          }).catch(() => {
+          });
+          reject(new Error(`MCP request ${method} (id=${id}) aborted by user`));
+        };
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
     });
-    await this.transport.send(frame);
-    return promise;
+    try {
+      await this.transport.send(frame);
+    } catch (err) {
+      this.pending.delete(id);
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+      throw err;
+    }
+    try {
+      return await promise;
+    } finally {
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
+    }
   }
   startReaderIfNeeded() {
     if (this.readerStarted) return;
@@ -2351,7 +2718,16 @@ var McpClient = class {
     }
   }
   dispatch(msg) {
-    if (!("id" in msg) || msg.id === null || msg.id === void 0) return;
+    if (!("id" in msg) || msg.id === null || msg.id === void 0) {
+      if ("method" in msg && msg.method === "notifications/progress") {
+        const p = msg.params;
+        if (!p || p.progressToken === void 0) return;
+        const handler = this.progressHandlers.get(p.progressToken);
+        if (!handler) return;
+        handler({ progress: p.progress, total: p.total, message: p.message });
+      }
+      return;
+    }
     if (!("result" in msg) && !("error" in msg)) return;
     const pending = this.pending.get(msg.id);
     if (!pending) return;
@@ -2408,12 +2784,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve3();
+        else resolve4();
       });
     });
   }
@@ -2424,8 +2800,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve3) => {
-        this.waiters.push(resolve3);
+      const next = await new Promise((resolve4) => {
+        this.waiters.push(resolve4);
       });
       if (next === null) return;
       yield next;
@@ -2491,8 +2867,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve3, reject) => {
-      this.resolveEndpoint = resolve3;
+    this.endpointReady = new Promise((resolve4, reject) => {
+      this.resolveEndpoint = resolve4;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -2519,8 +2895,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve3) => {
-        this.waiters.push(resolve3);
+      const next = await new Promise((resolve4) => {
+        this.waiters.push(resolve4);
       });
       if (next === null) return;
       yield next;
@@ -2720,7 +3096,7 @@ async function trySection(load) {
 
 // src/code/edit-blocks.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -2738,8 +3114,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve2(rootDir);
-  const absTarget = resolve2(absRoot, block.path);
+  const absRoot = resolve3(rootDir);
+  const absTarget = resolve3(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -2758,7 +3134,7 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync2(dirname2(absTarget), { recursive: true });
+      mkdirSync2(dirname3(absTarget), { recursive: true });
       writeFileSync2(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
@@ -2789,13 +3165,13 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve2(rootDir);
+  const absRoot = resolve3(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve2(absRoot, b.path);
+    const abs = resolve3(absRoot, b.path);
     if (!existsSync2(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
@@ -2809,9 +3185,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve2(rootDir);
+  const absRoot = resolve3(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve2(absRoot, snap.path);
+    const abs = resolve3(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -2845,7 +3221,7 @@ function sep() {
 
 // src/code/prompt.ts
 import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
 
 # When to edit vs. when to explore
@@ -2894,7 +3270,7 @@ Rules:
 - If you need to explore first (list / grep / read), do it with tool calls before writing any prose \u2014 silence while exploring is fine.
 `;
 function codeSystemPrompt(rootDir) {
-  const gitignorePath = join2(rootDir, ".gitignore");
+  const gitignorePath = join3(rootDir, ".gitignore");
   if (!existsSync3(gitignorePath)) return CODE_SYSTEM_PROMPT;
   let content;
   try {
@@ -2920,9 +3296,9 @@ ${truncated}
 // src/config.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname4, join as join4 } from "path";
 function defaultConfigPath() {
-  return join3(homedir2(), ".reasonix", "config.json");
+  return join4(homedir2(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
@@ -2934,7 +3310,7 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync3(dirname3(path), { recursive: true });
+  mkdirSync3(dirname4(path), { recursive: true });
   writeFileSync3(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
@@ -3018,6 +3394,7 @@ export {
   readTranscript,
   recordFromLoopEvent,
   redactKey,
+  registerFilesystemTools,
   renderMarkdown as renderDiffMarkdown,
   renderSummaryTable as renderDiffSummary,
   repairTruncatedJson,