@sesamespace/hivemind 0.6.0 → 0.6.1

package/dist/{chunk-LQ7CYHSQ.js → chunk-7YHRRM5B.js}

@@ -802,192 +802,6 @@ var Agent = class {
     let stripped = message.replace(/^\[.+?\s+in\s+group\s+chat\]:\s*/, "");
     stripped = stripped.replace(/^\[.+?\]:\s*/, "");
     const cmdText = stripped;
-    if (/^hm[:\s]status\b/i.test(cmdText)) {
-      const memoryOk = await this.memory.healthCheck();
-      const contexts = this.contextManager.listContexts();
-      let contextStats = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        contextStats = daemonContexts.map((c) => `  - ${c.name}: ${c.episode_count} episodes`).join("\n");
-      } catch {
-        contextStats = "  (unable to query memory daemon)";
-      }
-      const response = [
-        `## Agent Status`,
-        ``,
-        `**Name:** ${this.config.agent.name}`,
-        `**Active Context:** ${activeCtx}`,
-        `**Memory Daemon:** ${memoryOk ? "\u2705 connected" : "\u274C unreachable"} (${this.config.memory.daemon_url})`,
-        `**Model:** ${this.config.llm.model}`,
-        `**Temperature:** ${this.config.llm.temperature}`,
-        `**Max Tokens:** ${this.config.llm.max_tokens}`,
-        `**Memory Top-K:** ${this.config.memory.top_k}`,
-        `**Messages Processed:** ${this.messageCount}`,
-        `**L1 Contexts in Memory:** ${this.conversationHistories.size}`,
-        ``,
-        `### Contexts`,
-        contextStats
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]memory\s+stats\b/i.test(cmdText)) {
-      try {
-        const contexts = await this.memory.listContexts();
-        let totalEpisodes = 0;
-        let totalL3 = 0;
-        let lines = [];
-        for (const ctx of contexts) {
-          totalEpisodes += ctx.episode_count;
-          let l3Count = 0;
-          try {
-            const l3 = await this.memory.getL3Knowledge(ctx.name);
-            l3Count = l3.length;
-            totalL3 += l3Count;
-          } catch {
-          }
-          lines.push(`  - **${ctx.name}**: ${ctx.episode_count} L2 episodes, ${l3Count} L3 entries`);
-        }
-        const response = [
-          `## Memory Stats`,
-          ``,
-          `**Total L2 Episodes:** ${totalEpisodes}`,
-          `**Total L3 Knowledge:** ${totalL3}`,
-          `**Contexts:** ${contexts.length}`,
-          ``,
-          `### Per Context`,
-          ...lines
-        ].join("\n");
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory stats failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const memSearchMatch = cmdText.match(/^hm[:\s]memory\s+search\s+(.+)/i);
-    if (memSearchMatch) {
-      const query = memSearchMatch[1].trim();
-      try {
-        const results = await this.memory.search(query, activeCtx, this.config.memory.top_k);
-        if (results.length === 0) {
-          return { content: `No memories found for "${query}" in context "${activeCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## Memory Search: "${query}"
-
-`;
-        for (const ep of results) {
-          const ctxLabel = ep.context_name !== activeCtx ? ` [from: ${ep.context_name}]` : "";
-          response += `- **[${ep.role}]** (score: ${ep.score.toFixed(3)})${ctxLabel} ${ep.content.slice(0, 300)}${ep.content.length > 300 ? "..." : ""}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Memory search failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const l3Match = cmdText.match(/^hm[:\s]memory\s+l3(?:\s+(\S+))?/i);
-    if (l3Match) {
-      const targetCtx = l3Match[1] || activeCtx;
-      try {
-        const entries = await this.memory.getL3Knowledge(targetCtx);
-        if (entries.length === 0) {
-          return { content: `No L3 knowledge in context "${targetCtx}".`, model: "system", context: activeCtx };
-        }
-        let response = `## L3 Knowledge: ${targetCtx}
-
-`;
-        for (const entry of entries) {
-          response += `- **[${entry.id.slice(0, 8)}]** (density: ${entry.connection_density}, accesses: ${entry.access_count})
-  ${entry.content}
-`;
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `L3 query failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    if (/^hm[:\s]config\b/i.test(cmdText)) {
-      const response = [
-        `## Configuration`,
-        ``,
-        `**Agent:** ${this.config.agent.name}`,
-        `**Personality:** ${this.config.agent.personality}`,
-        `**Workspace:** ${this.config.agent.workspace || "(none)"}`,
-        ``,
-        `### LLM`,
-        `- Model: ${this.config.llm.model}`,
-        `- Base URL: ${this.config.llm.base_url}`,
-        `- Max Tokens: ${this.config.llm.max_tokens}`,
-        `- Temperature: ${this.config.llm.temperature}`,
-        ``,
-        `### Memory`,
-        `- Daemon URL: ${this.config.memory.daemon_url}`,
-        `- Top-K: ${this.config.memory.top_k}`,
-        `- Embedding Model: ${this.config.memory.embedding_model}`,
-        ``,
-        `### Sesame`,
-        `- API: ${this.config.sesame.api_url}`,
-        `- WebSocket: ${this.config.sesame.ws_url}`,
-        `- API Key: ${this.config.sesame.api_key ? "***" + this.config.sesame.api_key.slice(-4) : "(not set)"}`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]contexts\b/i.test(cmdText)) {
-      const localContexts = this.contextManager.listContexts();
-      let daemonInfo = "";
-      try {
-        const daemonContexts = await this.memory.listContexts();
-        daemonInfo = "\n### Memory Daemon Contexts\n" + daemonContexts.map(
-          (c) => `  - **${c.name}**: ${c.episode_count} episodes (created: ${c.created_at})`
-        ).join("\n");
-      } catch {
-        daemonInfo = "\n(Memory daemon unreachable)";
-      }
-      const localInfo = localContexts.map((c) => {
-        const active = c.name === activeCtx ? " \u2190 active" : "";
-        const historyLen = this.conversationHistories.get(c.name)?.length || 0;
-        return `  - **${c.name}**${active}: ${historyLen / 2} turns in L1`;
-      }).join("\n");
-      const response = [
-        `## Contexts`,
-        ``,
-        `**Active:** ${activeCtx}`,
-        ``,
-        `### Local (L1 Working Memory)`,
-        localInfo,
-        daemonInfo
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
-    if (/^hm[:\s]help\b/i.test(cmdText)) {
-      const response = [
-        `## Available Commands`,
-        ``,
-        `### Introspection`,
-        `- \`hm:status\` \u2014 Agent health, memory status, config summary`,
-        `- \`hm:config\` \u2014 Full configuration details`,
-        `- \`hm:contexts\` \u2014 List all contexts with L1/L2 info`,
-        `- \`hm:memory stats\` \u2014 Episode counts, L3 entries per context`,
-        `- \`hm:memory search <query>\` \u2014 Search L2 memories with scores`,
-        `- \`hm:memory l3 [context]\` \u2014 Show L3 knowledge entries`,
-        `- \`hm:help\` \u2014 This help message`,
-        ``,
-        `### Context Management`,
-        `- \`switch to <name>\` \u2014 Switch active context`,
-        `- \`create context <name>\` \u2014 Create a new context`,
-        `- \`list contexts\` \u2014 List contexts (legacy)`,
-        ``,
-        `### Memory`,
-        `- \`search all: <query>\` \u2014 Cross-context search`,
-        `- \`share <episode_id> with <context>\` \u2014 Share episode across contexts`,
-        ``,
-        `### Tasks`,
-        `- \`task add <title>\` \u2014 Create a task`,
-        `- \`task list [status]\` \u2014 List tasks`,
-        `- \`task start <id>\` \u2014 Start a task`,
-        `- \`task complete <id>\` \u2014 Complete a task`,
-        `- \`task next\` \u2014 Pick up next available task`
-      ].join("\n");
-      return { content: response, model: "system", context: activeCtx };
-    }
     const searchAllMatch = cmdText.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
     if (searchAllMatch) {
       const query = searchAllMatch[1].trim();
@@ -1947,12 +1761,7 @@ 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) {
-        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 (senderId === this.agentId) return;
       if (!this.messageHandler || !msg.content) return;
       const channelInfo = this.channels.get(msg.channelId);
       this.messageHandler({
@@ -2664,6 +2473,157 @@ function registerWebTools(registry, config) {
   );
 }
 
+// packages/runtime/src/tools/memory.ts
+function registerMemoryTools(registry, daemonUrl) {
+  registry.register(
+    "memory_search",
+    "Search your episodic memory for relevant past conversations and experiences. Returns scored results from your memory system. Use this when you want to recall something from a previous conversation or check what you know about a topic.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for in memory"
+        },
+        context: {
+          type: "string",
+          description: "Context to search in (default: current active context)"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results to return (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const query = params.query;
+      const context = params.context || "global";
+      const topK = params.top_k || 10;
+      try {
+        const resp = await fetch(`${daemonUrl}/api/search`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query, context_name: context, top_k: topK })
+        });
+        if (!resp.ok) return `Memory search failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.results?.length) return `No memories found for "${query}" in context "${context}".`;
+        return data.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}] ${r.content.slice(0, 200)}`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_stats",
+    "Get statistics about your memory system \u2014 episode counts, contexts, L3 knowledge entries. Use for self-diagnosis or understanding your memory state.",
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const healthResp = await fetch(`${daemonUrl}/health`);
+        const health = healthResp.ok ? await healthResp.json() : { status: "unreachable" };
+        const ctxResp = await fetch(`${daemonUrl}/api/contexts`);
+        const contexts = ctxResp.ok ? (await ctxResp.json()).contexts : [];
+        const l3Counts = {};
+        for (const ctx of contexts) {
+          try {
+            const l3Resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(ctx.name)}`);
+            if (l3Resp.ok) {
+              const l3Data = await l3Resp.json();
+              l3Counts[ctx.name] = l3Data.entries?.length ?? 0;
+            }
+          } catch {
+          }
+        }
+        const totalEpisodes = contexts.reduce((sum, c) => sum + c.episode_count, 0);
+        const totalL3 = Object.values(l3Counts).reduce((sum, c) => sum + c, 0);
+        let output = `Memory Daemon: ${health.status || "unknown"}
+`;
+        output += `Total Episodes (L2): ${totalEpisodes}
+`;
+        output += `Total Knowledge (L3): ${totalL3}
+`;
+        output += `
+Contexts:
+`;
+        for (const ctx of contexts) {
+          output += `  - ${ctx.name}: ${ctx.episode_count} episodes, ${l3Counts[ctx.name] ?? 0} L3 entries
+`;
+        }
+        return output;
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_l3",
+    "View your promoted L3 knowledge \u2014 high-level patterns, decisions, and insights that have been distilled from your episodic memories. This is your 'long-term wisdom'.",
+    {
+      type: "object",
+      properties: {
+        context: {
+          type: "string",
+          description: "Context to get L3 knowledge for (default: global)"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const context = params.context || "global";
+      try {
+        const resp = await fetch(`${daemonUrl}/api/l3/${encodeURIComponent(context)}`);
+        if (!resp.ok) return `L3 query failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.entries?.length) return `No L3 knowledge in context "${context}".`;
+        return data.entries.map((e, i) => `${i + 1}. ${e.content} (from ${e.source_episodes} episodes, ${e.created_at})`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "memory_cross_search",
+    "Search across ALL memory contexts at once. Useful when you're not sure which context a memory belongs to.",
+    {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for across all contexts"
+        },
+        top_k: {
+          type: "number",
+          description: "Number of results (default: 10)"
+        }
+      },
+      required: ["query"]
+    },
+    async (params) => {
+      const query = params.query;
+      const topK = params.top_k || 10;
+      try {
+        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query, top_k: topK })
+        });
+        if (!resp.ok) return `Cross-context search failed: ${resp.status}`;
+        const data = await resp.json();
+        if (!data.results?.length) return `No memories found across any context for "${query}".`;
+        return data.results.map((r, i) => `${i + 1}. [${r.score.toFixed(3)}] [${r.context_name}] ${r.content.slice(0, 200)}`).join("\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+}
+
 // packages/runtime/src/tools/register.ts
 import { resolve as resolve7 } from "path";
 import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
@@ -2679,6 +2639,7 @@ function registerAllTools(hivemindHome, config) {
   registerShellTool(registry, workspaceDir);
   registerFileTools(registry, workspaceDir);
   registerWebTools(registry, { braveApiKey: config?.braveApiKey });
+  registerMemoryTools(registry, config?.memoryDaemonUrl || "http://localhost:3434");
   return registry;
 }
 
@@ -2759,7 +2720,8 @@ async function startPipeline(configPath) {
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
-    braveApiKey: process.env.BRAVE_API_KEY
+    braveApiKey: process.env.BRAVE_API_KEY,
+    memoryDaemonUrl: config.memory.daemon_url
   });
   agent.setToolRegistry(toolRegistry);
   console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
@@ -3405,4 +3367,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-LQ7CYHSQ.js.map
+//# sourceMappingURL=chunk-7YHRRM5B.js.map