fourmis-agents-sdk 0.1.0

package/dist/tools/index.js

@@ -0,0 +1,595 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  getDefinitions() {
+    return [...this.tools.values()].map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+  }
+  async execute(name, input, ctx) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return { content: `Unknown tool: ${name}`, isError: true };
+    }
+    try {
+      return await tool.execute(input, ctx);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Tool error: ${message}`, isError: true };
+    }
+  }
+  list() {
+    return [...this.tools.keys()];
+  }
+}
+
+// src/tools/presets.ts
+var PRESETS = {
+  coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  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 tools;
+}
+
+// src/tools/bash.ts
+var DEFAULT_TIMEOUT = 120000;
+var MAX_TIMEOUT = 600000;
+var MAX_OUTPUT_LENGTH = 30000;
+var BashTool = {
+  name: "Bash",
+  description: "Executes a bash command. Use for system operations, git commands, running scripts, and other terminal tasks. " + "Working directory persists between calls. Commands timeout after 120s by default (max 600s).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The bash command to execute"
+      },
+      description: {
+        type: "string",
+        description: "Brief description of what this command does"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (max 600000)"
+      }
+    },
+    required: ["command"]
+  },
+  async execute(input, ctx) {
+    const { command, timeout: timeoutMs, description } = input;
+    if (!command || typeof command !== "string") {
+      return { content: "Error: command is required", isError: true };
+    }
+    const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    try {
+      const proc = Bun.spawn(["bash", "-c", command], {
+        cwd: ctx.cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, ...ctx.env }
+      });
+      const timeoutId = setTimeout(() => {
+        proc.kill();
+      }, timeout);
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      clearTimeout(timeoutId);
+      let output = "";
+      if (stdout)
+        output += stdout;
+      if (stderr)
+        output += (output ? `
+` : "") + stderr;
+      if (output.length > MAX_OUTPUT_LENGTH) {
+        output = output.slice(0, MAX_OUTPUT_LENGTH) + `
+... (output truncated)`;
+      }
+      if (!output) {
+        output = exitCode === 0 ? "(no output)" : `Command failed with exit code ${exitCode}`;
+      }
+      return {
+        content: output,
+        isError: exitCode !== 0 ? true : undefined,
+        metadata: { exitCode }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error executing command: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/read.ts
+var MAX_LINE_LENGTH = 2000;
+var DEFAULT_LINE_LIMIT = 2000;
+var ReadTool = {
+  name: "Read",
+  description: "Reads a file from the filesystem. Returns content with line numbers (cat -n format). " + "Supports offset/limit for large files. Lines longer than 2000 chars are truncated.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to read"
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-based)"
+      },
+      limit: {
+        type: "number",
+        description: "Number of lines to read"
+      }
+    },
+    required: ["file_path"]
+  },
+  async execute(input, ctx) {
+    const { file_path, offset, limit } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    const resolvedPath = resolvePath(file_path, ctx.cwd);
+    try {
+      const file = Bun.file(resolvedPath);
+      const exists = await file.exists();
+      if (!exists) {
+        return { content: `Error: File not found: ${resolvedPath}`, isError: true };
+      }
+      const text = await file.text();
+      const lines = text.split(`
+`);
+      const startLine = Math.max(1, offset ?? 1);
+      const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+      const endLine = Math.min(lines.length, startLine + lineLimit - 1);
+      const numberedLines = [];
+      for (let i = startLine - 1;i < endLine; i++) {
+        let line = lines[i];
+        if (line.length > MAX_LINE_LENGTH) {
+          line = line.slice(0, MAX_LINE_LENGTH) + "... (truncated)";
+        }
+        const lineNum = String(i + 1).padStart(6, " ");
+        numberedLines.push(`${lineNum}	${line}`);
+      }
+      return { content: numberedLines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error reading file: ${message}`, isError: true };
+    }
+  }
+};
+function resolvePath(filePath, cwd) {
+  if (filePath.startsWith("/"))
+    return filePath;
+  return `${cwd}/${filePath}`;
+}
+
+// src/tools/write.ts
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+var WriteTool = {
+  name: "Write",
+  description: "Writes content to a file. Creates parent directories if needed. " + "Overwrites existing files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to write"
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file"
+      }
+    },
+    required: ["file_path", "content"]
+  },
+  async execute(input, ctx) {
+    const { file_path, content } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    if (content === undefined || content === null) {
+      return { content: "Error: content is required", isError: true };
+    }
+    const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
+    try {
+      const dir = dirname(resolvedPath);
+      await mkdir(dir, { recursive: true });
+      await Bun.write(resolvedPath, content);
+      const lines = content.split(`
+`).length;
+      return {
+        content: `Successfully wrote ${lines} lines to ${resolvedPath}`,
+        metadata: { path: resolvedPath, lines }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing file: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/edit.ts
+var EditTool = {
+  name: "Edit",
+  description: "Performs exact string replacements in files. The old_string must be unique in the file " + "unless replace_all is true. Use this for precise edits to existing files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to edit"
+      },
+      old_string: {
+        type: "string",
+        description: "The exact text to find and replace"
+      },
+      new_string: {
+        type: "string",
+        description: "The replacement text"
+      },
+      replace_all: {
+        type: "boolean",
+        description: "Replace all occurrences (default: false)",
+        default: false
+      }
+    },
+    required: ["file_path", "old_string", "new_string"]
+  },
+  async execute(input, ctx) {
+    const { file_path, old_string, new_string, replace_all = false } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    if (old_string === undefined) {
+      return { content: "Error: old_string is required", isError: true };
+    }
+    if (new_string === undefined) {
+      return { content: "Error: new_string is required", isError: true };
+    }
+    if (old_string === new_string) {
+      return { content: "Error: old_string and new_string are identical", isError: true };
+    }
+    const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
+    try {
+      const file = Bun.file(resolvedPath);
+      const exists = await file.exists();
+      if (!exists) {
+        return { content: `Error: File not found: ${resolvedPath}`, isError: true };
+      }
+      const content = await file.text();
+      let count = 0;
+      let searchFrom = 0;
+      while (true) {
+        const idx = content.indexOf(old_string, searchFrom);
+        if (idx === -1)
+          break;
+        count++;
+        searchFrom = idx + old_string.length;
+      }
+      if (count === 0) {
+        const preview = old_string.length > 100 ? old_string.slice(0, 100) + "..." : old_string;
+        return {
+          content: `Error: old_string not found in ${resolvedPath}. Searched for:
+${preview}`,
+          isError: true
+        };
+      }
+      if (count > 1 && !replace_all) {
+        return {
+          content: `Error: old_string appears ${count} times in the file. Use replace_all: true to replace all occurrences, or provide a longer string with more context to make it unique.`,
+          isError: true
+        };
+      }
+      let newContent;
+      if (replace_all) {
+        newContent = content.replaceAll(old_string, new_string);
+      } else {
+        const idx = content.indexOf(old_string);
+        newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
+      }
+      await Bun.write(resolvedPath, newContent);
+      const replacements = replace_all ? count : 1;
+      return {
+        content: `Successfully replaced ${replacements} occurrence${replacements > 1 ? "s" : ""} in ${resolvedPath}`,
+        metadata: { path: resolvedPath, replacements }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing file: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/glob.ts
+var {Glob } = globalThis.Bun;
+var GlobTool = {
+  name: "Glob",
+  description: "Fast file pattern matching. Supports glob patterns like '**/*.ts' or 'src/**/*.tsx'. " + "Returns matching file paths sorted by modification time.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Glob pattern to match files against"
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in (defaults to cwd)"
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    const { pattern, path } = input;
+    if (!pattern) {
+      return { content: "Error: pattern is required", isError: true };
+    }
+    const searchDir = path ? path.startsWith("/") ? path : `${ctx.cwd}/${path}` : ctx.cwd;
+    try {
+      const glob = new Glob(pattern);
+      const matches = [];
+      for await (const filePath of glob.scan({ cwd: searchDir, dot: false })) {
+        try {
+          const file = Bun.file(`${searchDir}/${filePath}`);
+          const stat = await file.stat();
+          matches.push({ path: filePath, mtime: stat?.mtime?.getTime() ?? 0 });
+        } catch {
+          matches.push({ path: filePath, mtime: 0 });
+        }
+      }
+      matches.sort((a, b) => b.mtime - a.mtime);
+      if (matches.length === 0) {
+        return { content: "No files matched the pattern." };
+      }
+      const result = matches.map((m) => m.path).join(`
+`);
+      return {
+        content: result,
+        metadata: { count: matches.length }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/grep.ts
+var GrepTool = {
+  name: "Grep",
+  description: "Search file contents using regex patterns. Supports multiple output modes: " + "'content' (matching lines), 'files_with_matches' (file paths only, default), 'count' (match counts). " + "Supports context lines, case-insensitive search, glob filtering, and head_limit.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regex pattern to search for"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in (defaults to cwd)"
+      },
+      glob: {
+        type: "string",
+        description: "Glob pattern to filter files (e.g., '*.ts')"
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: "Output mode (default: files_with_matches)"
+      },
+      "-i": {
+        type: "boolean",
+        description: "Case insensitive search"
+      },
+      "-n": {
+        type: "boolean",
+        description: "Show line numbers (for content mode)"
+      },
+      "-A": {
+        type: "number",
+        description: "Lines to show after each match"
+      },
+      "-B": {
+        type: "number",
+        description: "Lines to show before each match"
+      },
+      "-C": {
+        type: "number",
+        description: "Context lines before and after each match"
+      },
+      head_limit: {
+        type: "number",
+        description: "Limit output to first N entries"
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    const opts = input;
+    if (!opts.pattern) {
+      return { content: "Error: pattern is required", isError: true };
+    }
+    const searchPath = opts.path ? opts.path.startsWith("/") ? opts.path : `${ctx.cwd}/${opts.path}` : ctx.cwd;
+    const mode = opts.output_mode ?? "files_with_matches";
+    try {
+      return await runRipgrep(opts, searchPath, mode, ctx);
+    } catch {
+      return await runJsGrep(opts, searchPath, mode, ctx);
+    }
+  }
+};
+async function runRipgrep(opts, searchPath, mode, ctx) {
+  const args = ["rg"];
+  if (mode === "files_with_matches") {
+    args.push("-l");
+  } else if (mode === "count") {
+    args.push("-c");
+  }
+  if (opts["-i"])
+    args.push("-i");
+  if (opts["-n"] !== false && mode === "content")
+    args.push("-n");
+  if (opts["-A"])
+    args.push("-A", String(opts["-A"]));
+  if (opts["-B"])
+    args.push("-B", String(opts["-B"]));
+  if (opts["-C"])
+    args.push("-C", String(opts["-C"]));
+  if (opts.glob)
+    args.push("--glob", opts.glob);
+  args.push("--", opts.pattern, searchPath);
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, ...ctx.env }
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  if (exitCode === 2) {
+    throw new Error(stderr || "ripgrep error");
+  }
+  let output = stdout.trim();
+  if (opts.head_limit && output) {
+    const lines = output.split(`
+`);
+    output = lines.slice(0, opts.head_limit).join(`
+`);
+  }
+  return { content: output || "No matches found." };
+}
+async function runJsGrep(opts, searchPath, mode, ctx) {
+  const flags = opts["-i"] ? "gi" : "g";
+  let regex;
+  try {
+    regex = new RegExp(opts.pattern, flags);
+  } catch (err) {
+    return { content: `Invalid regex: ${opts.pattern}`, isError: true };
+  }
+  const files = await collectFiles(searchPath, opts.glob);
+  const results = [];
+  let totalCount = 0;
+  for (const filePath of files) {
+    try {
+      const content = await Bun.file(filePath).text();
+      const lines = content.split(`
+`);
+      const matchedLines = [];
+      for (let i = 0;i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          matchedLines.push({ num: i + 1, line: lines[i] });
+          regex.lastIndex = 0;
+        }
+      }
+      if (matchedLines.length === 0)
+        continue;
+      totalCount += matchedLines.length;
+      const relativePath = filePath.startsWith(ctx.cwd) ? filePath.slice(ctx.cwd.length + 1) : filePath;
+      if (mode === "files_with_matches") {
+        results.push(relativePath);
+      } else if (mode === "count") {
+        results.push(`${relativePath}:${matchedLines.length}`);
+      } else {
+        for (const { num, line } of matchedLines) {
+          results.push(`${relativePath}:${num}:${line}`);
+        }
+      }
+    } catch {}
+    if (opts.head_limit && results.length >= opts.head_limit) {
+      break;
+    }
+  }
+  let output = results.join(`
+`);
+  if (opts.head_limit) {
+    const entries = output.split(`
+`).slice(0, opts.head_limit);
+    output = entries.join(`
+`);
+  }
+  return { content: output || "No matches found." };
+}
+async function collectFiles(dir, globPattern) {
+  const { Glob: Glob2 } = await Promise.resolve(globalThis.Bun);
+  const pattern = globPattern ?? "**/*";
+  const glob = new Glob2(pattern);
+  const files = [];
+  for await (const path of glob.scan({ cwd: dir, dot: false, onlyFiles: true })) {
+    files.push(`${dir}/${path}`);
+  }
+  return files;
+}
+// src/tools/index.ts
+var ALL_TOOLS = {
+  Bash: BashTool,
+  Read: ReadTool,
+  Write: WriteTool,
+  Edit: EditTool,
+  Glob: GlobTool,
+  Grep: GrepTool
+};
+function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
+  const registry = new ToolRegistry;
+  for (const name of toolNames) {
+    if (allowedTools && !allowedTools.includes(name))
+      continue;
+    if (disallowedTools?.includes(name))
+      continue;
+    const tool = ALL_TOOLS[name];
+    if (tool) {
+      registry.register(tool);
+    }
+  }
+  return registry;
+}
+export {
+  resolveToolNames,
+  buildToolRegistry,
+  WriteTool,
+  ToolRegistry,
+  ReadTool,
+  PRESETS,
+  GrepTool,
+  GlobTool,
+  EditTool,
+  BashTool
+};

package/dist/tools/mcp-resources.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP resource tools — list and read resources from MCP servers.
+ */
+import type { ToolImplementation } from "./registry.js";
+import type { McpClientManager } from "../mcp/client.js";
+export declare function createListMcpResourcesTool(mcpClient: McpClientManager): ToolImplementation;
+export declare function createReadMcpResourceTool(mcpClient: McpClientManager): ToolImplementation;
+//# sourceMappingURL=mcp-resources.d.ts.map

package/dist/tools/mcp-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-resources.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-resources.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,gBAAgB,GAAG,kBAAkB,CA8B1F;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,gBAAgB,GAAG,kBAAkB,CAgCzF"}

package/dist/tools/mcp-resources.js

@@ -0,0 +1,87 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/mcp-resources.ts
+var exports_mcp_resources = {};
+__export(exports_mcp_resources, {
+  createReadMcpResourceTool: () => createReadMcpResourceTool,
+  createListMcpResourcesTool: () => createListMcpResourcesTool
+});
+function createListMcpResourcesTool(mcpClient) {
+  return {
+    name: "mcp__list_resources",
+    description: "List available resources from MCP servers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Optional server name to filter by. If omitted, lists resources from all servers."
+        }
+      }
+    },
+    async execute(input) {
+      const { server } = input ?? {};
+      try {
+        const resources = await mcpClient.listResources(server);
+        if (resources.length === 0) {
+          return { content: "No resources available." };
+        }
+        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
+        return { content: lines.join(`
+`) };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error listing resources: ${message}`, isError: true };
+      }
+    }
+  };
+}
+function createReadMcpResourceTool(mcpClient) {
+  return {
+    name: "mcp__read_resource",
+    description: "Read a specific resource from an MCP server by URI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The MCP server name that hosts the resource."
+        },
+        uri: {
+          type: "string",
+          description: "The resource URI to read."
+        }
+      },
+      required: ["server", "uri"]
+    },
+    async execute(input) {
+      const { server, uri } = input;
+      if (!server || !uri) {
+        return { content: "Both 'server' and 'uri' are required.", isError: true };
+      }
+      try {
+        const content = await mcpClient.readResource(server, uri);
+        return { content };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error reading resource: ${message}`, isError: true };
+      }
+    }
+  };
+}
+export {
+  createReadMcpResourceTool,
+  createListMcpResourcesTool
+};

package/dist/tools/presets.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Named tool presets for common use cases.
+ */
+export declare const PRESETS: Record<string, string[]>;
+export declare function resolveToolNames(tools: string | string[] | undefined): string[];
+//# sourceMappingURL=presets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/tools/presets.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAI5C,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,CAM/E"}