@sesamespace/hivemind 0.5.16 → 0.6.0

package/dist/{chunk-BQCSFDSS.js → chunk-LQ7CYHSQ.js}

@@ -16,28 +16,46 @@ var LLMClient = class {
     this.temperature = config.temperature;
     this.apiKey = config.api_key ?? "";
   }
+  /**
+   * Simple chat completion (no tools). Backwards compatible.
+   */
   async chat(messages) {
+    return this.chatWithTools(messages);
+  }
+  /**
+   * Chat completion with optional tool definitions.
+   * Returns tool_calls if the model wants to use tools.
+   */
+  async chatWithTools(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
     const resp = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
       },
-      body: JSON.stringify({
-        model: this.model,
-        messages,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-      })
+      body: JSON.stringify(body)
     });
     if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`LLM request failed: ${resp.status} ${body}`);
+      const text = await resp.text();
+      throw new Error(`LLM request failed: ${resp.status} ${text}`);
     }
     const data = await resp.json();
+    const choice = data.choices[0];
     return {
-      content: data.choices[0].message.content,
+      content: choice.message.content ?? "",
       model: data.model,
+      tool_calls: choice.message.tool_calls,
+      finish_reason: choice.finish_reason,
       usage: data.usage
     };
   }
@@ -618,11 +636,13 @@ var Agent = class {
   llm;
   memory;
   contextManager;
+  toolRegistry = null;
   // Per-context conversation histories
   conversationHistories = /* @__PURE__ */ new Map();
   messageCount = 0;
   PROMOTION_INTERVAL = 10;
   // Run promotion every N messages
+  MAX_TOOL_ITERATIONS = 25;
   requestLogger = null;
   constructor(config, contextName = "global") {
     this.config = config;
@@ -633,6 +653,13 @@ var Agent = class {
       this.contextManager.switchContext(contextName);
     }
   }
+  setToolRegistry(registry) {
+    this.toolRegistry = registry;
+    const toolCount = registry.getDefinitions().length;
+    if (toolCount > 0) {
+      console.log(`[hivemind] Tool use enabled: ${toolCount} tools registered`);
+    }
+  }
   setRequestLogger(logger) {
     this.requestLogger = logger;
   }
@@ -668,7 +695,31 @@ var Agent = class {
     const systemPromptResult = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
     const messages = buildMessages(systemPromptResult.text, conversationHistory, userMessage);
     const llmStart = Date.now();
-    const response = await this.llm.chat(messages);
+    const toolDefs = this.toolRegistry?.getDefinitions() ?? [];
+    let response = await this.llm.chatWithTools(messages, toolDefs.length > 0 ? toolDefs : void 0);
+    let iterations = 0;
+    while (response.tool_calls && response.tool_calls.length > 0 && iterations < this.MAX_TOOL_ITERATIONS) {
+      iterations++;
+      messages.push({
+        role: "assistant",
+        content: response.content,
+        tool_calls: response.tool_calls
+      });
+      for (const call of response.tool_calls) {
+        console.log(`[tools] ${call.function.name}(${call.function.arguments.slice(0, 100)})`);
+        const result = await this.toolRegistry.executeCall(call);
+        messages.push({
+          role: "tool",
+          content: result.content,
+          tool_call_id: result.tool_call_id
+        });
+        console.log(`[tools] ${call.function.name} \u2192 ${result.content.slice(0, 100)}${result.content.length > 100 ? "..." : ""}`);
+      }
+      response = await this.llm.chatWithTools(messages, toolDefs);
+    }
+    if (iterations > 0) {
+      console.log(`[tools] Completed after ${iterations} tool iteration(s)`);
+    }
     const latencyMs = Date.now() - llmStart;
     if (this.requestLogger) {
       try {
@@ -1896,7 +1947,12 @@ var SesameClient2 = class {
     this.sdk.on("message", (event) => {
       const msg = event.data || event.message || event;
       const senderId = msg.senderId || msg.sender?.id;
-      if (senderId === this.agentId) return;
+      if (senderId === this.agentId) {
+        const content = msg.content?.trim() || "";
+        const isHmCommand = /^hm[:\s]/i.test(content);
+        const isTextCommand = /^(?:list contexts|switch to|create context|search all:|task )/i.test(content);
+        if (!isHmCommand && !isTextCommand) return;
+      }
       if (!this.messageHandler || !msg.content) return;
       const channelInfo = this.channels.get(msg.channelId);
       this.messageHandler({
@@ -2242,14 +2298,398 @@ function startDashboardServer(requestLogger, memoryConfig) {
   });
 }
 
+// packages/runtime/src/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(name, description, parameters, executor) {
+    this.tools.set(name, {
+      definition: {
+        type: "function",
+        function: { name, description, parameters }
+      },
+      executor
+    });
+  }
+  getDefinitions() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return `Error: Unknown tool "${name}"`;
+    }
+    try {
+      return await tool.executor(params);
+    } catch (err) {
+      return `Error executing ${name}: ${err.message}`;
+    }
+  }
+  async executeCall(call) {
+    let params = {};
+    try {
+      params = JSON.parse(call.function.arguments);
+    } catch {
+      return {
+        tool_call_id: call.id,
+        role: "tool",
+        content: `Error: Invalid JSON arguments for ${call.function.name}`
+      };
+    }
+    const result = await this.execute(call.function.name, params);
+    return {
+      tool_call_id: call.id,
+      role: "tool",
+      content: result
+    };
+  }
+};
+
+// packages/runtime/src/tools/shell.ts
+import { execSync } from "child_process";
+import { resolve as resolve5 } from "path";
+var MAX_OUTPUT = 5e4;
+function registerShellTool(registry, workspaceDir) {
+  registry.register(
+    "shell",
+    "Execute a shell command and return stdout/stderr. Use for running programs, checking status, installing packages, git operations, etc.",
+    {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute"
+        },
+        workdir: {
+          type: "string",
+          description: "Working directory (relative to workspace). Defaults to workspace root."
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in seconds. Default: 30"
+        }
+      },
+      required: ["command"]
+    },
+    async (params) => {
+      const command = params.command;
+      const timeout = (params.timeout || 30) * 1e3;
+      const cwd = params.workdir ? resolve5(workspaceDir, params.workdir) : workspaceDir;
+      try {
+        const output = execSync(command, {
+          cwd,
+          timeout,
+          encoding: "utf-8",
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB
+          shell: "/bin/sh",
+          env: { ...process.env, PATH: `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}` }
+        });
+        const trimmed = output.length > MAX_OUTPUT ? output.slice(0, MAX_OUTPUT) + `
+... (truncated, ${output.length} total chars)` : output;
+        return trimmed || "(no output)";
+      } catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        const output = (stdout + "\n" + stderr).trim();
+        const code = err.status ?? "unknown";
+        return `Command failed (exit code ${code}):
+${output || err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/files.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
+var MAX_READ = 1e5;
+function registerFileTools(registry, workspaceDir) {
+  registry.register(
+    "read_file",
+    "Read the contents of a file. Returns the text content. Use offset/limit for large files.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (1-indexed)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of lines to read"
+        }
+      },
+      required: ["path"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      if (!existsSync4(filePath)) {
+        return `Error: File not found: ${filePath}`;
+      }
+      try {
+        let content = readFileSync6(filePath, "utf-8");
+        if (params.offset || params.limit) {
+          const lines = content.split("\n");
+          const start = (params.offset || 1) - 1;
+          const end = params.limit ? start + params.limit : lines.length;
+          content = lines.slice(start, end).join("\n");
+        }
+        if (content.length > MAX_READ) {
+          content = content.slice(0, MAX_READ) + `
+... (truncated, ${content.length} total chars)`;
+        }
+        return content || "(empty file)";
+      } catch (err) {
+        return `Error reading file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "write_file",
+    "Write content to a file. Creates the file and parent directories if they don't exist. Overwrites existing content.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        }
+      },
+      required: ["path", "content"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      try {
+        const dir = dirname5(filePath);
+        if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+        writeFileSync2(filePath, params.content);
+        return `Written ${params.content.length} bytes to ${filePath}`;
+      } catch (err) {
+        return `Error writing file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "edit_file",
+    "Edit a file by finding and replacing exact text. The old text must match exactly (including whitespace).",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path (relative to workspace or absolute)"
+        },
+        old_text: {
+          type: "string",
+          description: "Exact text to find and replace"
+        },
+        new_text: {
+          type: "string",
+          description: "New text to replace with"
+        }
+      },
+      required: ["path", "old_text", "new_text"]
+    },
+    async (params) => {
+      const filePath = resolvePath(workspaceDir, params.path);
+      if (!existsSync4(filePath)) {
+        return `Error: File not found: ${filePath}`;
+      }
+      try {
+        const content = readFileSync6(filePath, "utf-8");
+        const oldText = params.old_text;
+        const newText = params.new_text;
+        if (!content.includes(oldText)) {
+          return `Error: Could not find the exact text to replace in ${filePath}`;
+        }
+        const updated = content.replace(oldText, newText);
+        writeFileSync2(filePath, updated);
+        return `Edited ${filePath}: replaced ${oldText.length} chars with ${newText.length} chars`;
+      } catch (err) {
+        return `Error editing file: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "list_files",
+    "List files and directories in a path.",
+    {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory path (relative to workspace or absolute). Defaults to workspace root."
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const { readdirSync: readdirSync2, statSync } = await import("fs");
+      const dirPath = params.path ? resolvePath(workspaceDir, params.path) : workspaceDir;
+      if (!existsSync4(dirPath)) {
+        return `Error: Directory not found: ${dirPath}`;
+      }
+      try {
+        const entries = readdirSync2(dirPath);
+        const results = [];
+        for (const entry of entries) {
+          if (entry.startsWith(".")) continue;
+          try {
+            const stat = statSync(resolve6(dirPath, entry));
+            results.push(stat.isDirectory() ? `${entry}/` : entry);
+          } catch {
+            results.push(entry);
+          }
+        }
+        return results.join("\n") || "(empty directory)";
+      } catch (err) {
+        return `Error listing directory: ${err.message}`;
+      }
+    }
+  );
+}
+function resolvePath(workspace, path) {
+  if (path.startsWith("/") || path.startsWith("~")) {
+    return path.replace(/^~/, process.env.HOME || "/root");
+  }
+  return resolve6(workspace, path);
+}
+
+// packages/runtime/src/tools/web.ts
+function registerWebTools(registry, config) {
+  registry.register(
+    "web_search",
+    "Search the web using Brave Search API. Returns titles, URLs, and snippets.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query string"
+        },
+        count: {
+          type: "number",
+          description: "Number of results (1-10, default 5)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const apiKey = config?.braveApiKey || process.env.BRAVE_API_KEY;
+      if (!apiKey) {
+        return "Error: No Brave Search API key configured. Set BRAVE_API_KEY env var.";
+      }
+      const query = params.query;
+      const count = Math.min(Math.max(params.count || 5, 1), 10);
+      try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${count}`;
+        const resp = await fetch(url, {
+          headers: { "X-Subscription-Token": apiKey, Accept: "application/json" }
+        });
+        if (!resp.ok) {
+          return `Search failed: ${resp.status} ${await resp.text()}`;
+        }
+        const data = await resp.json();
+        const results = data.web?.results || [];
+        if (results.length === 0) return "No results found.";
+        return results.map((r, i) => `${i + 1}. **${r.title}**
+   ${r.url}
+   ${r.description}`).join("\n\n");
+      } catch (err) {
+        return `Search error: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "web_fetch",
+    "Fetch a URL and extract readable content as markdown/text. Good for reading articles, docs, and web pages.",
+    {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "HTTP or HTTPS URL to fetch"
+        },
+        max_chars: {
+          type: "number",
+          description: "Maximum characters to return (default 20000)"
+        }
+      },
+      required: ["url"]
+    },
+    async (params) => {
+      const url = params.url;
+      const maxChars = params.max_chars || 2e4;
+      try {
+        const resp = await fetch(url, {
+          headers: {
+            "User-Agent": "Hivemind/1.0 (Agent Web Fetcher)",
+            Accept: "text/html,application/xhtml+xml,text/plain,application/json"
+          },
+          redirect: "follow"
+        });
+        if (!resp.ok) {
+          return `Fetch failed: ${resp.status} ${resp.statusText}`;
+        }
+        let text = await resp.text();
+        const contentType = resp.headers.get("content-type") || "";
+        if (contentType.includes("html")) {
+          text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+          text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+          text = text.replace(/<[^>]+>/g, " ");
+          text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+          text = text.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+          text = text.replace(/\s+/g, " ").trim();
+        }
+        if (text.length > maxChars) {
+          text = text.slice(0, maxChars) + `
+... (truncated, ${text.length} total chars)`;
+        }
+        return text || "(empty response)";
+      } catch (err) {
+        return `Fetch error: ${err.message}`;
+      }
+    }
+  );
+}
+
+// packages/runtime/src/tools/register.ts
+import { resolve as resolve7 } from "path";
+import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+function registerAllTools(hivemindHome, config) {
+  const registry = new ToolRegistry();
+  if (config?.enabled === false) {
+    return registry;
+  }
+  const workspaceDir = resolve7(hivemindHome, config?.workspace || "workspace");
+  if (!existsSync5(workspaceDir)) {
+    mkdirSync3(workspaceDir, { recursive: true });
+  }
+  registerShellTool(registry, workspaceDir);
+  registerFileTools(registry, workspaceDir);
+  registerWebTools(registry, { braveApiKey: config?.braveApiKey });
+  return registry;
+}
+
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { resolve as resolve8, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_VERSION = "unknown";
 try {
-  const __dirname2 = dirname5(fileURLToPath3(import.meta.url));
-  const pkg = JSON.parse(readFileSync6(resolve5(__dirname2, "../package.json"), "utf-8"));
+  const __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+  const pkg = JSON.parse(readFileSync7(resolve8(__dirname2, "../package.json"), "utf-8"));
   PACKAGE_VERSION = pkg.version ?? "unknown";
 } catch {
 }
@@ -2280,7 +2720,7 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync2(path, String(process.pid));
+  writeFileSync3(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
@@ -2311,10 +2751,17 @@ async function startPipeline(configPath) {
     memoryConnected = true;
     console.log("[hivemind] Memory daemon connected");
   }
-  const requestLogger = new RequestLogger(resolve5(dirname5(configPath), "data", "dashboard.db"));
+  const requestLogger = new RequestLogger(resolve8(dirname6(configPath), "data", "dashboard.db"));
   startDashboardServer(requestLogger, config.memory);
   const agent = new Agent(config);
   agent.setRequestLogger(requestLogger);
+  const hivemindHome = process.env.HIVEMIND_HOME || resolve8(process.env.HOME || "/root", "hivemind");
+  const toolRegistry = registerAllTools(hivemindHome, {
+    enabled: true,
+    workspace: config.agent.workspace || "workspace",
+    braveApiKey: process.env.BRAVE_API_KEY
+  });
+  agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
   if (config.sesame.api_key) {
     await startSesameLoop(config, agent);
@@ -2462,8 +2909,8 @@ ${response.content}
       console.error("Error:", err.message);
     }
   });
-  return new Promise((resolve6) => {
-    rl.on("close", resolve6);
+  return new Promise((resolve9) => {
+    rl.on("close", resolve9);
   });
 }
 
@@ -2492,20 +2939,20 @@ var WorkerServer = class {
   }
   /** Start listening. */
   async start() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve9, reject) => {
       this.server = createServer3((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve6());
+      this.server.listen(this.port, () => resolve9());
     });
   }
   /** Stop the server. */
   async stop() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve9) => {
       if (!this.server) {
-        resolve6();
+        resolve9();
         return;
       }
-      this.server.close(() => resolve6());
+      this.server.close(() => resolve9());
     });
   }
   getPort() {
@@ -2628,10 +3075,10 @@ var WorkerServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+    req.on("end", () => resolve9(Buffer.concat(chunks).toString("utf-8")));
     req.on("error", reject);
   });
 }
@@ -2958,4 +3405,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-BQCSFDSS.js.map
+//# sourceMappingURL=chunk-LQ7CYHSQ.js.map