fourmis-agents-sdk 0.3.0 → 0.4.0

package/dist/tools/index.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -18,6 +33,16 @@ class ToolRegistry {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  clearByPrefix(prefix) {
+    for (const name of this.tools.keys()) {
+      if (name.startsWith(prefix)) {
+        this.tools.delete(name);
+      }
+    }
+  }
   get(name) {
     return this.tools.get(name);
   }
@@ -51,16 +76,34 @@ class ToolRegistry {
 // src/tools/presets.ts
 var PRESETS = {
   coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  claude_code: [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "NotebookEdit",
+    "WebFetch",
+    "WebSearch",
+    "TodoWrite",
+    "Config",
+    "AskUserQuestion",
+    "ExitPlanMode"
+  ],
   readonly: ["Read", "Glob", "Grep"],
   minimal: ["Read", "Write", "Edit", "Glob", "Grep"]
 };
 function resolveToolNames(tools) {
   if (!tools)
-    return PRESETS.coding;
-  if (typeof tools === "string") {
-    return PRESETS[tools] ?? [tools];
+    return PRESETS.claude_code;
+  if (Array.isArray(tools)) {
+    return tools;
   }
-  return tools;
+  if (tools.type === "preset") {
+    return PRESETS[tools.preset] ?? PRESETS.claude_code;
+  }
+  throw new Error("Invalid tools option. Expected string[] or { type: 'preset', preset: 'claude_code' }.");
 }
 
 // src/tools/bash.ts
@@ -84,17 +127,58 @@ var BashTool = {
       timeout: {
         type: "number",
         description: "Timeout in milliseconds (max 600000)"
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "Run command asynchronously and return immediately."
+      },
+      dangerouslyDisableSandbox: {
+        type: "boolean",
+        description: "If true, explicitly request unsandboxed execution."
+      },
+      _simulatedSedEdit: {
+        type: "object",
+        properties: {
+          filePath: { type: "string" },
+          newContent: { type: "string" }
+        },
+        description: "Internal field for precomputed edit previews."
       }
     },
     required: ["command"]
   },
   async execute(input, ctx) {
-    const { command, timeout: timeoutMs, description } = input;
+    const {
+      command,
+      timeout: timeoutMs,
+      run_in_background,
+      description,
+      dangerouslyDisableSandbox,
+      _simulatedSedEdit
+    } = input;
     if (!command || typeof command !== "string") {
       return { content: "Error: command is required", isError: true };
     }
     const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     try {
+      if (run_in_background) {
+        const proc2 = Bun.spawn(["bash", "-c", command], {
+          cwd: ctx.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+          stdin: "ignore",
+          env: { ...process.env, ...ctx.env }
+        });
+        return {
+          content: `Background command started (pid ${proc2.pid ?? "unknown"}).`,
+          metadata: {
+            pid: proc2.pid ?? null,
+            run_in_background: true,
+            dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+            hasSimulatedSedEdit: !!_simulatedSedEdit
+          }
+        };
+      }
       const proc = Bun.spawn(["bash", "-c", command], {
         cwd: ctx.cwd,
         stdout: "pipe",
@@ -126,7 +210,11 @@ var BashTool = {
       return {
         content: output,
         isError: exitCode !== 0 ? true : undefined,
-        metadata: { exitCode }
+        metadata: {
+          exitCode,
+          dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+          hasSimulatedSedEdit: !!_simulatedSedEdit
+        }
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -155,12 +243,17 @@ var ReadTool = {
       limit: {
         type: "number",
         description: "Number of lines to read"
+      },
+      pages: {
+        type: "array",
+        items: { type: "number" },
+        description: "Optional PDF page numbers (1-based)."
       }
     },
     required: ["file_path"]
   },
   async execute(input, ctx) {
-    const { file_path, offset, limit } = input;
+    const { file_path, offset, limit, pages } = input;
     if (!file_path) {
       return { content: "Error: file_path is required", isError: true };
     }
@@ -171,6 +264,12 @@ var ReadTool = {
       if (!exists) {
         return { content: `Error: File not found: ${resolvedPath}`, isError: true };
       }
+      if (Array.isArray(pages) && pages.length > 0 && resolvedPath.toLowerCase().endsWith(".pdf")) {
+        return {
+          content: "Error: PDF page extraction is not implemented in this runtime.",
+          isError: true
+        };
+      }
       const text = await file.text();
       const lines = text.split(`
 `);
@@ -558,6 +657,405 @@ async function collectFiles(dir, globPattern) {
   }
   return files;
 }
+
+// src/tools/notebook-edit.ts
+import { readFile, writeFile } from "fs/promises";
+function toSourceLines(text) {
+  const lines = text.split(`
+`);
+  return lines.map((line, idx) => idx < lines.length - 1 ? `${line}
+` : line);
+}
+var NotebookEditTool = {
+  name: "NotebookEdit",
+  description: "Edit a specific Jupyter notebook cell by id or index.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      notebook_path: { type: "string", description: "Path to .ipynb file." },
+      cell_id: { type: "string", description: "Cell id to edit." },
+      cell_index: { type: "number", description: "Cell index to edit if id is not provided." },
+      new_source: { type: "string", description: "New cell source content." }
+    },
+    required: ["notebook_path", "new_source"]
+  },
+  async execute(input, ctx) {
+    const {
+      notebook_path,
+      cell_id,
+      cell_index,
+      new_source
+    } = input ?? {};
+    if (!notebook_path)
+      return { content: "Error: notebook_path is required", isError: true };
+    if (new_source === undefined)
+      return { content: "Error: new_source is required", isError: true };
+    const filePath = notebook_path.startsWith("/") ? notebook_path : `${ctx.cwd}/${notebook_path}`;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const notebook = JSON.parse(raw);
+      if (!Array.isArray(notebook.cells)) {
+        return { content: "Error: notebook has no cells array", isError: true };
+      }
+      let targetIndex = -1;
+      if (cell_id) {
+        targetIndex = notebook.cells.findIndex((c) => c.id === cell_id);
+      } else if (typeof cell_index === "number") {
+        targetIndex = cell_index;
+      } else {
+        targetIndex = 0;
+      }
+      if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+        return {
+          content: `Error: cell not found (id=${cell_id ?? "n/a"}, index=${String(cell_index ?? "n/a")})`,
+          isError: true
+        };
+      }
+      const cell = notebook.cells[targetIndex];
+      cell.source = toSourceLines(new_source);
+      await writeFile(filePath, JSON.stringify(notebook, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Updated notebook cell ${targetIndex} in ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing notebook: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/web-fetch.ts
+var DEFAULT_TIMEOUT_MS = 20000;
+var MAX_OUTPUT = 80000;
+var WebFetchTool = {
+  name: "WebFetch",
+  description: "Fetches a URL and returns response text.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch."
+      },
+      prompt: {
+        type: "string",
+        description: "Optional fetch intent/instructions."
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Timeout in milliseconds (default 20000)."
+      },
+      max_length: {
+        type: "number",
+        description: "Maximum output length (default 80000)."
+      }
+    },
+    required: ["url"]
+  },
+  async execute(input) {
+    const { url, timeout_ms, max_length } = input ?? {};
+    if (!url)
+      return { content: "Error: url is required", isError: true };
+    const timeout = Math.max(1000, timeout_ms ?? DEFAULT_TIMEOUT_MS);
+    const outLimit = Math.max(1000, max_length ?? MAX_OUTPUT);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      const contentType = res.headers.get("content-type") ?? "unknown";
+      let body = await res.text();
+      if (body.length > outLimit) {
+        body = body.slice(0, outLimit) + `
+... (truncated)`;
+      }
+      return {
+        content: [
+          `Status: ${res.status} ${res.statusText}`,
+          `Content-Type: ${contentType}`,
+          "",
+          body
+        ].join(`
+`),
+        isError: res.ok ? undefined : true
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error fetching URL: ${message}`, isError: true };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/tools/web-search.ts
+var SEARCH_ENDPOINT = "https://duckduckgo.com/html/";
+function stripTags(input) {
+  return input.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").trim();
+}
+var WebSearchTool = {
+  name: "WebSearch",
+  description: "Searches the web and returns top result links.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query."
+      },
+      max_results: {
+        type: "number",
+        description: "Maximum results to return (default 5)."
+      }
+    },
+    required: ["query"]
+  },
+  async execute(input) {
+    const { query, max_results } = input ?? {};
+    if (!query) {
+      return { content: "Error: query is required", isError: true };
+    }
+    const limit = Math.max(1, Math.min(20, max_results ?? 5));
+    try {
+      const url = `${SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}`;
+      const res = await fetch(url, {
+        headers: {
+          "user-agent": "fourmis-agent-sdk/1.0"
+        }
+      });
+      if (!res.ok) {
+        return {
+          content: `Error searching web: ${res.status} ${res.statusText}`,
+          isError: true
+        };
+      }
+      const html = await res.text();
+      const matches = [...html.matchAll(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)];
+      if (matches.length === 0) {
+        return { content: "No search results found." };
+      }
+      const lines = [];
+      for (let i = 0;i < Math.min(limit, matches.length); i++) {
+        const href = stripTags(matches[i][1]);
+        const title = stripTags(matches[i][2]);
+        lines.push(`${i + 1}. ${title}
+   ${href}`);
+      }
+      return { content: lines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error searching web: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/ask-user-question.ts
+var AskUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: "Ask the user a clarifying question and wait for their response.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "Question to ask the user."
+      },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional fixed choices."
+      }
+    },
+    required: ["question"]
+  },
+  async execute(input) {
+    const { question, options } = input ?? {};
+    if (!question) {
+      return { content: "Error: question is required", isError: true };
+    }
+    const choices = Array.isArray(options) && options.length > 0 ? ` Choices: ${options.join(" | ")}` : "";
+    return {
+      content: `User interaction is not available in this runtime. Unanswered question: ${question}.${choices}`,
+      isError: true
+    };
+  }
+};
+
+// src/tools/todo-write.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join } from "path";
+var TodoWriteTool = {
+  name: "TodoWrite",
+  description: "Write/update task todo items for the current session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+            activeForm: { type: "string" }
+          },
+          required: ["content", "status"]
+        }
+      }
+    },
+    required: ["todos"]
+  },
+  async execute(input, ctx) {
+    const { todos } = input ?? {};
+    if (!Array.isArray(todos)) {
+      return { content: "Error: todos must be an array", isError: true };
+    }
+    for (const todo of todos) {
+      if (!todo?.content || !todo?.status) {
+        return { content: "Error: each todo requires content and status", isError: true };
+      }
+    }
+    const filePath = join(ctx.cwd, ".claude", "todos.json");
+    try {
+      await mkdir2(dirname2(filePath), { recursive: true });
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        todos
+      };
+      await writeFile2(filePath, JSON.stringify(payload, null, 2) + `
+`, "utf-8");
+      return {
+        content: `Saved ${todos.length} todo item(s) to ${filePath}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing todos: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/config.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join2, dirname as dirname3 } from "path";
+function scopePath(cwd, scope) {
+  if (scope === "project")
+    return join2(cwd, ".claude", "settings.json");
+  return join2(cwd, ".claude", "settings.local.json");
+}
+function setByPath(obj, keyPath, value) {
+  const keys = keyPath.split(".").filter(Boolean);
+  if (keys.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function getByPath(obj, keyPath) {
+  const keys = keyPath.split(".").filter(Boolean);
+  let current = obj;
+  for (const key of keys) {
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return;
+    current = current[key];
+  }
+  return current;
+}
+var ConfigTool = {
+  name: "Config",
+  description: "Read or update .claude settings values.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["get", "set", "list"]
+      },
+      key: {
+        type: "string",
+        description: "Dot-path key (for get/set)."
+      },
+      value: {
+        description: "Value for set action."
+      },
+      scope: {
+        type: "string",
+        enum: ["local", "project"]
+      }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const {
+      action,
+      key,
+      value,
+      scope = "local"
+    } = input ?? {};
+    if (!action) {
+      return { content: "Error: action is required", isError: true };
+    }
+    const filePath = scopePath(ctx.cwd, scope);
+    let data = {};
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      data = JSON.parse(raw);
+    } catch {
+      data = {};
+    }
+    if (action === "list") {
+      return { content: JSON.stringify(data, null, 2) };
+    }
+    if (!key) {
+      return { content: "Error: key is required for get/set", isError: true };
+    }
+    if (action === "get") {
+      const out = getByPath(data, key);
+      return { content: out === undefined ? "undefined" : JSON.stringify(out, null, 2) };
+    }
+    setByPath(data, key, value);
+    try {
+      await mkdir3(dirname3(filePath), { recursive: true });
+      await writeFile3(filePath, JSON.stringify(data, null, 2) + `
+`, "utf-8");
+      return { content: `Updated ${key} in ${filePath}` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing config: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/exit-plan-mode.ts
+var ExitPlanModeTool = {
+  name: "ExitPlanMode",
+  description: "Exit plan mode and resume normal execution permissions.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  async execute() {
+    return {
+      content: "Exiting plan mode.",
+      metadata: {
+        setPermissionMode: "default"
+      }
+    };
+  }
+};
 // src/tools/index.ts
 var ALL_TOOLS = {
   Bash: BashTool,
@@ -565,7 +1063,14 @@ var ALL_TOOLS = {
   Write: WriteTool,
   Edit: EditTool,
   Glob: GlobTool,
-  Grep: GrepTool
+  Grep: GrepTool,
+  NotebookEdit: NotebookEditTool,
+  WebFetch: WebFetchTool,
+  WebSearch: WebSearchTool,
+  AskUserQuestion: AskUserQuestionTool,
+  TodoWrite: TodoWriteTool,
+  Config: ConfigTool,
+  ExitPlanMode: ExitPlanModeTool
 };
 function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
   const registry = new ToolRegistry;
@@ -583,11 +1088,18 @@ export {
   resolveToolNames,
   buildToolRegistry,
   WriteTool,
+  WebSearchTool,
+  WebFetchTool,
   ToolRegistry,
+  TodoWriteTool,
   ReadTool,
   PRESETS,
+  NotebookEditTool,
   GrepTool,
   GlobTool,
+  ExitPlanModeTool,
   EditTool,
-  BashTool
+  ConfigTool,
+  BashTool,
+  AskUserQuestionTool
 };

package/dist/tools/mcp-resources.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {

package/dist/tools/notebook-edit.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NotebookEdit tool.
+ * Edits code/markdown cell content in a .ipynb notebook.
+ */
+import type { ToolImplementation } from "./registry.js";
+export declare const NotebookEditTool: ToolImplementation;
+//# sourceMappingURL=notebook-edit.d.ts.map

package/dist/tools/notebook-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notebook-edit.d.ts","sourceRoot":"","sources":["../../src/tools/notebook-edit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAA2B,MAAM,eAAe,CAAC;AAkBjF,eAAO,MAAM,gBAAgB,EAAE,kBAqE9B,CAAC"}