@sesamespace/hivemind 0.10.0 → 0.11.0

package/dist/{chunk-M3A2WRXM.js → chunk-OB6OXLPC.js}

@@ -7874,6 +7874,428 @@ ${output || err.message}`;
   );
 }
 
+// packages/runtime/src/tools/learn.ts
+function slugify(topic) {
+  return topic.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+async function discoverResearch(topic, depth, registry) {
+  if (!registry.has("web_search")) {
+    throw new Error("web_search tool not available \u2014 is BRAVE_API_KEY set?");
+  }
+  const sources = [];
+  const primary = await registry.execute("web_search", { query: topic, count: 8 });
+  if (primary.startsWith("Error:")) throw new Error(primary);
+  sources.push(...parseSearchResults(primary));
+  if (depth === "deep") {
+    const refinedQueries = [
+      `"${topic}" tutorial`,
+      `"${topic}" best practices`
+    ];
+    for (const q of refinedQueries) {
+      const result = await registry.execute("web_search", { query: q, count: 5 });
+      if (!result.startsWith("Error:")) {
+        sources.push(...parseSearchResults(result));
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return sources.filter((s) => {
+    if (seen.has(s.url)) return false;
+    seen.add(s.url);
+    return true;
+  });
+}
+function parseSearchResults(raw) {
+  const entries = [];
+  const blocks = raw.split(/\n\n(?=\d+\.\s)/);
+  for (const block of blocks) {
+    const titleMatch = block.match(/\*\*(.+?)\*\*/);
+    const urlMatch = block.match(/\s+(https?:\/\/\S+)/);
+    const lines = block.split("\n");
+    const snippet = lines.length >= 3 ? lines.slice(2).join(" ").trim() : "";
+    if (titleMatch && urlMatch) {
+      entries.push({
+        title: titleMatch[1],
+        url: urlMatch[1],
+        snippet
+      });
+    }
+  }
+  return entries;
+}
+async function exploreResearch(topic, sources, depth, focusAreas, registry, llm) {
+  if (!registry.has("web_fetch")) {
+    throw new Error("web_fetch tool not available");
+  }
+  const maxSources = depth === "deep" ? 6 : 3;
+  const toFetch = sources.slice(0, maxSources);
+  const findings = [];
+  for (const source of toFetch) {
+    try {
+      const content = await registry.execute("web_fetch", {
+        url: source.url,
+        max_chars: 15e3
+      });
+      if (content.startsWith("Fetch failed:") || content.startsWith("Fetch error:")) {
+        continue;
+      }
+      const focusClause = focusAreas.length > 0 ? `Focus especially on: ${focusAreas.join(", ")}.` : "";
+      const messages = [
+        {
+          role: "system",
+          content: "You are a research assistant. Extract key facts concisely. Return a numbered list of 5-10 key points, one per line."
+        },
+        {
+          role: "user",
+          content: `Extract 5-10 key facts about "${topic}" from this text. ${focusClause}
+
+Source: ${source.title} (${source.url})
+
+${content.slice(0, 12e3)}`
+        }
+      ];
+      const response = await llm.chat(messages);
+      const keyPoints = response.content.split("\n").map((l) => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter((l) => l.length > 0);
+      findings.push({ source: `${source.title} \u2014 ${source.url}`, keyPoints });
+    } catch {
+    }
+  }
+  return findings;
+}
+async function discoverCodebase(topic, registry) {
+  if (!registry.has("shell")) {
+    throw new Error("shell tool not available");
+  }
+  const sources = [];
+  let targetDir = topic;
+  if (topic.startsWith("http://") || topic.startsWith("https://") || topic.startsWith("git@")) {
+    const slug = slugify(topic.split("/").pop()?.replace(".git", "") || "repo");
+    const cloneDir = `/tmp/learn-${slug}`;
+    const cloneResult = await registry.execute("shell", {
+      command: `rm -rf ${cloneDir} && git clone --depth 1 ${topic} ${cloneDir} 2>&1 | tail -1`
+    });
+    if (cloneResult.toLowerCase().includes("fatal")) {
+      throw new Error(`Failed to clone: ${cloneResult}`);
+    }
+    targetDir = cloneDir;
+  }
+  const fileList = await registry.execute("shell", {
+    command: `find ${targetDir} -type f \\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' -o -name '*.py' -o -name '*.rs' -o -name '*.go' -o -name '*.java' \\) ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' ! -path '*/build/*' | head -50`
+  });
+  for (const line of fileList.split("\n").filter(Boolean)) {
+    sources.push({ title: line.split("/").pop() || line, url: line, snippet: "" });
+  }
+  if (registry.has("read_file")) {
+    const readmeResult = await registry.execute("read_file", { path: `${targetDir}/README.md` });
+    if (!readmeResult.startsWith("Error:")) {
+      sources.unshift({ title: "README.md", url: `${targetDir}/README.md`, snippet: readmeResult.slice(0, 200) });
+    }
+  }
+  const manifestCmd = `cat ${targetDir}/package.json 2>/dev/null || cat ${targetDir}/Cargo.toml 2>/dev/null || cat ${targetDir}/go.mod 2>/dev/null || cat ${targetDir}/pyproject.toml 2>/dev/null || echo ""`;
+  const manifestResult = await registry.execute("shell", { command: manifestCmd });
+  if (manifestResult.trim()) {
+    sources.unshift({ title: "manifest", url: `${targetDir}/package.json`, snippet: manifestResult.slice(0, 200) });
+  }
+  return sources;
+}
+async function exploreCodebase(topic, sources, depth, focusAreas, registry, llm) {
+  const maxFiles = depth === "deep" ? 12 : 5;
+  const toRead = sources.slice(0, maxFiles);
+  const findings = [];
+  for (const source of toRead) {
+    try {
+      let content;
+      if (registry.has("read_file")) {
+        content = await registry.execute("read_file", { path: source.url });
+      } else {
+        content = await registry.execute("shell", { command: `cat "${source.url}" 2>/dev/null | head -200` });
+      }
+      if (!content || content.startsWith("Error:")) continue;
+      const focusClause = focusAreas.length > 0 ? `Pay special attention to: ${focusAreas.join(", ")}.` : "";
+      const messages = [
+        {
+          role: "system",
+          content: "You are a code analyst. Analyze the given code file concisely. Return a numbered list of key observations."
+        },
+        {
+          role: "user",
+          content: `Analyze this code file from a project about "${topic}". Extract: purpose, key exports, patterns used, dependencies. ${focusClause}
+
+File: ${source.title}
+
+${content.slice(0, 1e4)}`
+        }
+      ];
+      const response = await llm.chat(messages);
+      const keyPoints = response.content.split("\n").map((l) => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter((l) => l.length > 0);
+      findings.push({ source: source.title, keyPoints });
+    } catch {
+    }
+  }
+  return findings;
+}
+async function synthesize(topic, findings, focusAreas, llm) {
+  const findingText = findings.map((f) => `### ${f.source}
+${f.keyPoints.map((p) => `- ${p}`).join("\n")}`).join("\n\n");
+  const focusClause = focusAreas.length > 0 ? `
+Focus areas: ${focusAreas.join(", ")}` : "";
+  const messages = [
+    {
+      role: "system",
+      content: [
+        "You are a knowledge synthesizer. Distill research findings into structured, actionable knowledge.",
+        "Output format:",
+        "## Core Concepts",
+        "(key ideas and definitions)",
+        "## Key Relationships",
+        "(how concepts connect)",
+        "## Important Details",
+        "(specifics worth remembering)",
+        "## Practical Implications",
+        "(how to apply this knowledge)",
+        "",
+        "Be concise but thorough. Maximum 8000 characters."
+      ].join("\n")
+    },
+    {
+      role: "user",
+      content: `Synthesize all findings about "${topic}" into structured knowledge.${focusClause}
+
+${findingText}`
+    }
+  ];
+  const response = await llm.chat(messages);
+  return response.content.slice(0, 8e3);
+}
+async function storeInMemory(contextName, topic, findings, synthesis, daemonUrl) {
+  const storedIds = [];
+  try {
+    await fetch(`${daemonUrl}/api/contexts`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: contextName,
+        description: `Learned knowledge: ${topic}`
+      })
+    });
+  } catch {
+  }
+  for (const finding of findings) {
+    const content = `[Source: ${finding.source}]
+${finding.keyPoints.join("\n")}`;
+    try {
+      const resp = await fetch(`${daemonUrl}/api/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          context_name: contextName,
+          role: "system",
+          content
+        })
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.id) storedIds.push(data.id);
+      }
+    } catch {
+    }
+  }
+  try {
+    const resp = await fetch(`${daemonUrl}/api/episodes`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        context_name: contextName,
+        role: "assistant",
+        content: `[SYNTHESIS: ${topic}]
+${synthesis}`
+      })
+    });
+    if (resp.ok) {
+      const data = await resp.json();
+      if (data.id) storedIds.push(data.id);
+    }
+  } catch {
+  }
+  try {
+    await fetch(`${daemonUrl}/api/promotion/run?context=${encodeURIComponent(contextName)}`, {
+      method: "POST"
+    });
+  } catch {
+  }
+  return storedIds;
+}
+function registerLearnTools(registry, config) {
+  let llm = null;
+  if (config.llmConfig) {
+    try {
+      llm = new LLMClient({
+        ...config.llmConfig,
+        max_tokens: 2048
+      });
+    } catch {
+    }
+  }
+  let synthesisLlm = null;
+  if (config.llmConfig) {
+    try {
+      synthesisLlm = new LLMClient({
+        ...config.llmConfig,
+        max_tokens: 4096
+      });
+    } catch {
+    }
+  }
+  registry.register(
+    "learn",
+    [
+      "Deeply research a topic and store organized knowledge in memory.",
+      "Supports two modes: 'research' (web search + fetch) and 'codebase' (local/remote repo analysis).",
+      "Findings are synthesized via LLM and stored as L2 episodes in a dedicated memory context,",
+      "eligible for L3 promotion. Use this when you need thorough understanding of a topic."
+    ].join(" "),
+    {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "What to learn about (e.g., 'WebSocket protocol', '/path/to/repo', 'https://github.com/user/repo')"
+        },
+        type: {
+          type: "string",
+          enum: ["research", "codebase"],
+          description: "Learning type: 'research' for web-based topics, 'codebase' for analyzing code (default: research)"
+        },
+        depth: {
+          type: "string",
+          enum: ["shallow", "deep"],
+          description: "How many sources to explore: shallow (3 sources) or deep (6+ sources) (default: shallow)"
+        },
+        context: {
+          type: "string",
+          description: "Custom memory context name (default: auto-generated learn-{slug})"
+        },
+        focus_areas: {
+          type: "array",
+          items: { type: "string" },
+          description: "Specific aspects to focus on (e.g., ['performance', 'security'])"
+        },
+        store: {
+          type: "boolean",
+          description: "Whether to persist findings in memory (default: true)"
+        }
+      },
+      required: ["topic"]
+    },
+    async (params) => {
+      const topic = params.topic;
+      const type = params.type || "research";
+      const depth = params.depth || "shallow";
+      const contextName = params.context || `learn-${slugify(topic)}`;
+      const focusAreas = params.focus_areas || [];
+      const shouldStore = params.store !== false;
+      if (!llm || !synthesisLlm) {
+        return "Error: LLM not configured \u2014 learn tool requires an LLM for synthesis. Check your llm config.";
+      }
+      try {
+        let sources;
+        if (type === "codebase") {
+          sources = await discoverCodebase(topic, registry);
+        } else {
+          sources = await discoverResearch(topic, depth, registry);
+        }
+        if (sources.length === 0) {
+          return `No sources found for "${topic}". Try a different query or check connectivity.`;
+        }
+        let findings;
+        if (type === "codebase") {
+          findings = await exploreCodebase(topic, sources, depth, focusAreas, registry, llm);
+        } else {
+          findings = await exploreResearch(topic, sources, depth, focusAreas, registry, llm);
+        }
+        if (findings.length === 0) {
+          return `Found ${sources.length} sources but could not extract meaningful findings for "${topic}".`;
+        }
+        const synthesis = await synthesize(topic, findings, focusAreas, synthesisLlm);
+        let storageNote = "";
+        if (shouldStore) {
+          const storedIds = await storeInMemory(
+            contextName,
+            topic,
+            findings,
+            synthesis,
+            config.memoryDaemonUrl
+          );
+          storageNote = storedIds.length > 0 ? `
+
+---
+Stored ${storedIds.length} episodes in memory context "${contextName}". Use learn_recall to retrieve later.` : "\n\n---\nNote: Could not store in memory (daemon may be offline). Knowledge is shown above but not persisted.";
+        }
+        return `# Learned: ${topic}
+
+Sources explored: ${findings.length}
+Type: ${type} | Depth: ${depth}
+
+${synthesis}${storageNote}`;
+      } catch (err) {
+        return `Learn failed: ${err.message}`;
+      }
+    }
+  );
+  registry.register(
+    "learn_recall",
+    "Retrieve knowledge from a previous learn session. Searches across learn-* memory contexts for stored findings and synthesis.",
+    {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "Search query to find previously learned knowledge"
+        },
+        context: {
+          type: "string",
+          description: "Specific learn context to search (e.g., 'learn-websocket-protocol'). If omitted, searches all learn contexts."
+        }
+      },
+      required: ["topic"]
+    },
+    async (params) => {
+      const topic = params.topic;
+      const context = params.context;
+      const daemonUrl = config.memoryDaemonUrl;
+      try {
+        if (context) {
+          const resp2 = await fetch(`${daemonUrl}/api/search`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ query: topic, context_name: context, top_k: 10 })
+          });
+          if (!resp2.ok) return `Memory search failed: ${resp2.status}`;
+          const data2 = await resp2.json();
+          if (!data2.results?.length) return `No learned knowledge found for "${topic}" in context "${context}".`;
+          return data2.results.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.role}]
+${r.content.slice(0, 500)}`).join("\n\n");
+        }
+        const resp = await fetch(`${daemonUrl}/api/search/cross-context`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: topic, top_k: 15 })
+        });
+        if (!resp.ok) return `Memory cross-search failed: ${resp.status}`;
+        const data = await resp.json();
+        const learnResults = data.results?.filter((r) => r.context_name.startsWith("learn-")) || [];
+        if (learnResults.length === 0) {
+          return `No previously learned knowledge found for "${topic}". Use the learn tool first.`;
+        }
+        return learnResults.map((r, i) => `${i + 1}. [score: ${r.score.toFixed(3)}] [${r.context_name}] [${r.role}]
+${r.content.slice(0, 500)}`).join("\n\n");
+      } catch (err) {
+        return `Memory daemon unreachable: ${err.message}`;
+      }
+    }
+  );
+}
+
 // packages/runtime/src/tools/register.ts
 import { resolve as resolve18 } from "path";
 import { mkdirSync as mkdirSync13, existsSync as existsSync18 } from "fs";
@@ -7904,6 +8326,11 @@ function registerAllTools(hivemindHome, config) {
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
   registerCodingAgentTools(registry, workspaceDir);
+  registerLearnTools(registry, {
+    llmConfig: config?.llmConfig,
+    memoryDaemonUrl: config?.memoryDaemonUrl || "http://localhost:3434",
+    workspaceDir
+  });
   return registry;
 }
 
@@ -8206,7 +8633,8 @@ async function startPipeline(configPath) {
     workspace: config.agent.workspace || "workspace",
     braveApiKey: process.env.BRAVE_API_KEY,
     memoryDaemonUrl: config.memory.daemon_url,
-    configPath
+    configPath,
+    llmConfig: config.llm
   });
   const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
@@ -8987,4 +9415,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-M3A2WRXM.js.map
+//# sourceMappingURL=chunk-OB6OXLPC.js.map