@sesamespace/hivemind 0.11.5 → 0.12.1

package/dist/{chunk-MWQZTAYA.js → chunk-6IAV6YAV.js}

@@ -7,7 +7,7 @@ import {
   SesameClient2 as SesameClient,
   WORKER_ROUTES,
   createLogger
-} from "./chunk-EKZ3IZU6.js";
+} from "./chunk-7XXV5FKN.js";
 
 // packages/runtime/src/watchdog.ts
 import { execSync } from "child_process";
@@ -1095,4 +1095,4 @@ export {
   WorkerMemorySync,
   PrimaryMemorySync
 };
-//# sourceMappingURL=chunk-MWQZTAYA.js.map
+//# sourceMappingURL=chunk-6IAV6YAV.js.map

package/dist/{chunk-EKZ3IZU6.js → chunk-7XXV5FKN.js}

@@ -4225,12 +4225,12 @@ var LogWatcher = class extends BackgroundProcess {
   }
   savePositions() {
     try {
-      const { mkdirSync: mkdirSync15, writeFileSync: writeFileSync9 } = __require("fs");
+      const { mkdirSync: mkdirSync16, writeFileSync: writeFileSync10 } = __require("fs");
       const { dirname: dirname9 } = __require("path");
       const dir = dirname9(this.positionsFile);
-      if (!existsSync7(dir)) mkdirSync15(dir, { recursive: true });
+      if (!existsSync7(dir)) mkdirSync16(dir, { recursive: true });
       const data = Object.fromEntries(this.tailPositions);
-      writeFileSync9(this.positionsFile, JSON.stringify(data));
+      writeFileSync10(this.positionsFile, JSON.stringify(data));
     } catch (err) {
       log2.warn("failed to save tail positions", {
         error: err.message
@@ -7806,10 +7806,10 @@ function truncate2(text) {
 }
 
 // packages/runtime/src/tools/coding-agent.ts
-import { execSync as execSync9 } from "child_process";
+import { exec as exec2, execSync as execSync9 } from "child_process";
 import { resolve as resolve17 } from "path";
 var MAX_OUTPUT6 = 5e4;
-function registerCodingAgentTools(registry, workspaceDir) {
+function registerCodingAgentTools(registry, workspaceDir, contextBridge) {
   registry.register(
     "coding_agent",
     "Spawn Claude Code CLI to perform a coding task. Use for writing code, debugging, refactoring, or any task that benefits from an AI coding assistant with full filesystem access. Requires the 'claude' CLI to be installed.",
@@ -7827,6 +7827,31 @@ function registerCodingAgentTools(registry, workspaceDir) {
         timeout: {
           type: "number",
           description: "Timeout in seconds. Default: 300"
+        },
+        requirements: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key requirements or constraints for the task"
+        },
+        recentErrors: {
+          type: "array",
+          items: { type: "string" },
+          description: "Recent errors encountered that may be relevant"
+        },
+        relevantPatterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Known patterns or approaches that might help"
+        },
+        workingFiles: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files currently being worked on"
+        },
+        knownConstraints: {
+          type: "array",
+          items: { type: "string" },
+          description: "Known constraints or limitations to consider"
         }
       },
       required: ["task"]
@@ -7835,8 +7860,24 @@ function registerCodingAgentTools(registry, workspaceDir) {
       const task = params.task;
       const timeoutSeconds = params.timeout || 300;
       const cwd = params.workdir ? resolve17(workspaceDir, params.workdir) : workspaceDir;
-      const homedir = process.env.HOME || "/root";
-      const extendedPath = `${homedir}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`;
+      if (contextBridge) {
+        const context = {
+          goal: task,
+          // Extract additional context from params if provided
+          requirements: params.requirements || [],
+          recentErrors: params.recentErrors || [],
+          relevantPatterns: params.relevantPatterns || [],
+          workingFiles: params.workingFiles || [],
+          knownConstraints: params.knownConstraints || []
+        };
+        try {
+          await contextBridge.prepareContext(context);
+        } catch (err) {
+          console.warn("Failed to prepare context for Claude Code:", err);
+        }
+      }
+      const homedir2 = process.env.HOME || "/root";
+      const extendedPath = `${homedir2}/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.PATH}`;
       try {
         execSync9("which claude", { stdio: "ignore", env: { ...process.env, PATH: extendedPath } });
       } catch {
@@ -7845,17 +7886,28 @@ function registerCodingAgentTools(registry, workspaceDir) {
       const escapedTask = task.replace(/'/g, "'\\''");
       const command = `claude --dangerously-skip-permissions -p '${escapedTask}'`;
       try {
-        const output = execSync9(command, {
-          cwd,
-          timeout: timeoutSeconds * 1e3,
-          encoding: "utf-8",
-          maxBuffer: 10 * 1024 * 1024,
-          // 10MB
-          shell: "/bin/sh",
-          env: {
-            ...process.env,
-            PATH: extendedPath
-          }
+        const output = await new Promise((resolve21, reject) => {
+          const child = exec2(command, {
+            cwd,
+            timeout: timeoutSeconds * 1e3,
+            encoding: "utf-8",
+            maxBuffer: 10 * 1024 * 1024,
+            // 10MB
+            shell: "/bin/sh",
+            env: {
+              ...process.env,
+              PATH: extendedPath
+            }
+          }, (error, stdout, stderr) => {
+            if (error) {
+              error.stdout = stdout;
+              error.stderr = stderr;
+              reject(error);
+            } else {
+              resolve21(stdout);
+            }
+          });
+          child.stdin?.end();
         });
         const trimmed = output.length > MAX_OUTPUT6 ? output.slice(0, MAX_OUTPUT6) + `
 ... (truncated, ${output.length} total chars)` : output;
@@ -8328,7 +8380,7 @@ function registerAllTools(hivemindHome, config) {
   registerWatchTools(registry, workspaceDir, dataDir);
   registerMacOSTools(registry, workspaceDir);
   registerDataTools(registry, workspaceDir);
-  registerCodingAgentTools(registry, workspaceDir);
+  registerCodingAgentTools(registry, workspaceDir, config?.contextBridge);
   registerLearnTools(registry, {
     llmConfig: config?.llmConfig,
     memoryDaemonUrl: config?.memoryDaemonUrl || "http://localhost:3434",
@@ -8537,9 +8589,218 @@ Path: ${skillDir}`;
 }
 
 // packages/runtime/src/pipeline.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
 import { resolve as resolve20, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+
+// packages/runtime/src/tools/context-bridge.ts
+import { writeFileSync as writeFileSync8, existsSync as existsSync20, mkdirSync as mkdirSync15, watchFile, unwatchFile, openSync, readSync, closeSync } from "fs";
+import { join as join8 } from "path";
+import { homedir } from "os";
+import { EventEmitter as EventEmitter2 } from "events";
+var ClaudeContextBridge = class extends EventEmitter2 {
+  workspaceDir;
+  memoryClient;
+  logger;
+  sessionLogPath;
+  contextFilePath;
+  constructor(config) {
+    super();
+    this.workspaceDir = config.workspaceDir;
+    this.memoryClient = config.memoryClient;
+    this.logger = config.logger;
+    this.sessionLogPath = join8(homedir(), ".claude", "session.log");
+    this.contextFilePath = join8(this.workspaceDir, "CLAUDE_CONTEXT.md");
+  }
+  /**
+   * Initialize the context bridge
+   */
+  async initialize() {
+    const claudeDir = join8(homedir(), ".claude");
+    if (!existsSync20(claudeDir)) {
+      mkdirSync15(claudeDir, { recursive: true });
+    }
+    await this.setupClaudeSettings();
+    this.startLogMonitoring();
+    this.logger.info("Claude context bridge initialized");
+  }
+  /**
+   * Configure Claude Code to report insights via workspace CLAUDE.md
+   */
+  async setupClaudeSettings() {
+    const instructions = `# Hivemind Context Bridge
+
+When working on tasks, please report significant findings by writing to the session log:
+
+- When you discover architecture/patterns: echo "DISCOVERY: [details]" >> ~/.claude/session.log
+- When you need more context: echo "NEED: [what you need]" >> ~/.claude/session.log
+- When you complete major steps: echo "COMPLETE: [what you did]" >> ~/.claude/session.log
+- When you find reusable solutions: echo "PATTERN: [approach]" >> ~/.claude/session.log
+- When you encounter errors: echo "ERROR: [error details]" >> ~/.claude/session.log
+
+Always check CLAUDE_CONTEXT.md in the workspace for task context and requirements.`;
+    const claudeMdPath = join8(this.workspaceDir, "CLAUDE.md");
+    writeFileSync8(claudeMdPath, instructions);
+    this.logger.info("Claude workspace CLAUDE.md configured for context bridge");
+  }
+  /**
+   * Prepare context for a Claude Code session
+   */
+  async prepareContext(context) {
+    let content = `# Claude Code Context
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Current Goal
+${context.goal}
+`;
+    if (context.requirements?.length) {
+      content += `
+## Requirements
+${context.requirements.map((r) => `- ${r}`).join("\n")}
+`;
+    }
+    if (context.recentErrors?.length) {
+      content += `
+## Recent Errors
+\`\`\`
+${context.recentErrors.join("\n")}
+\`\`\`
+`;
+    }
+    if (context.relevantPatterns?.length) {
+      content += `
+## Known Patterns
+${context.relevantPatterns.map((p) => `- ${p}`).join("\n")}
+`;
+    }
+    if (context.workingFiles?.length) {
+      content += `
+## Working Files
+${context.workingFiles.map((f) => `- ${f}`).join("\n")}
+`;
+    }
+    if (context.knownConstraints?.length) {
+      content += `
+## Known Constraints
+${context.knownConstraints.map((c) => `- ${c}`).join("\n")}
+`;
+    }
+    try {
+      const memories = await this.getRelevantMemories(context.goal);
+      if (memories.length > 0) {
+        content += `
+## Relevant Knowledge
+${memories.join("\n\n")}
+`;
+      }
+    } catch (err) {
+      this.logger.warn("Failed to fetch memories for context", err);
+    }
+    writeFileSync8(this.contextFilePath, content);
+    this.logger.info("Context prepared for Claude Code", { goal: context.goal });
+  }
+  /**
+   * Fetch relevant memories for the task
+   */
+  async getRelevantMemories(goal) {
+    try {
+      const results = await Promise.race([
+        this.memoryClient.search(goal, "global", 5),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Memory search timeout")), 3e3)
+        )
+      ]);
+      return results.map((r) => `- ${r.content}`);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Start monitoring Claude's session log for insights
+   */
+  startLogMonitoring() {
+    if (!existsSync20(this.sessionLogPath)) {
+      writeFileSync8(this.sessionLogPath, "");
+    }
+    let lastSize = 0;
+    watchFile(this.sessionLogPath, { interval: 2e3 }, (curr) => {
+      if (curr.size > lastSize) {
+        try {
+          const fd = openSync(this.sessionLogPath, "r");
+          const buf = Buffer.alloc(curr.size - lastSize);
+          readSync(fd, buf, 0, buf.length, lastSize);
+          closeSync(fd);
+          lastSize = curr.size;
+          const lines = buf.toString("utf-8").split("\n").filter((l) => l.trim());
+          for (const line of lines) {
+            this.processLogLine(line);
+          }
+        } catch (err) {
+          this.logger.warn("Failed to read session log", { error: String(err) });
+        }
+      }
+    });
+    this.logger.info("Started monitoring Claude session log");
+  }
+  /**
+   * Process a line from Claude's session log
+   */
+  processLogLine(line) {
+    const patterns = {
+      DISCOVERY: /^DISCOVERY:\s*(.+)$/,
+      NEED: /^NEED:\s*(.+)$/,
+      COMPLETE: /^COMPLETE:\s*(.+)$/,
+      PATTERN: /^PATTERN:\s*(.+)$/,
+      ERROR: /^ERROR:\s*(.+)$/
+    };
+    for (const [type, pattern] of Object.entries(patterns)) {
+      const match = line.match(pattern);
+      if (match) {
+        const content = match[1];
+        this.handleInsight(type, content).catch((err) => {
+          this.logger.warn("Failed to handle insight", { error: String(err) });
+        });
+        break;
+      }
+    }
+  }
+  /**
+   * Handle an insight from Claude Code
+   */
+  async handleInsight(type, content) {
+    this.logger.info(`Claude insight: ${type}`, { content });
+    this.emit("insight", { type, content });
+    if (["DISCOVERY", "PATTERN"].includes(type)) {
+      try {
+        await this.memoryClient.storeEpisode({
+          context_name: "claude-code",
+          role: "system",
+          content: `Claude Code ${type}: ${content}`
+        });
+      } catch (err) {
+        this.logger.warn("Failed to store Claude insight in memory", err);
+      }
+    }
+    if (type === "NEED") {
+      this.emit("context-request", content);
+    }
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.sessionLogPath && existsSync20(this.sessionLogPath)) {
+      unwatchFile(this.sessionLogPath);
+    }
+  }
+};
+async function createContextBridge(config) {
+  const bridge = new ClaudeContextBridge(config);
+  await bridge.initialize();
+  return bridge;
+}
+
+// packages/runtime/src/pipeline.ts
 var PACKAGE_VERSION = "unknown";
 try {
   const __dirname2 = dirname8(fileURLToPath3(import.meta.url));
@@ -8585,7 +8846,7 @@ function startHealthServer(port) {
   return server;
 }
 function writePidFile(path) {
-  writeFileSync8(path, String(process.pid));
+  writeFileSync9(path, String(process.pid));
   console.log(`[hivemind] PID file written: ${path}`);
 }
 function cleanupPidFile(path) {
@@ -8631,15 +8892,32 @@ async function startPipeline(configPath) {
   startDashboardServer(requestLogger, config.memory, () => agent.getConversationHistories());
   agent.setRequestLogger(requestLogger);
   const hivemindHome = process.env.HIVEMIND_HOME || resolve20(process.env.HOME || "/root", "hivemind");
+  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
+  let contextBridge;
+  if (memoryConnected) {
+    try {
+      contextBridge = await createContextBridge({
+        workspaceDir,
+        memoryClient: memory,
+        logger: createLogger("claude-bridge")
+      });
+      console.log("[hivemind] Claude context bridge initialized");
+    } catch (err) {
+      console.warn("[hivemind] Failed to create Claude context bridge:", err);
+    }
+  }
+  if (contextBridge) {
+    process.on("exit", () => contextBridge.destroy());
+  }
   const toolRegistry = registerAllTools(hivemindHome, {
     enabled: true,
     workspace: config.agent.workspace || "workspace",
     braveApiKey: process.env.BRAVE_API_KEY,
     memoryDaemonUrl: config.memory.daemon_url,
     configPath,
-    llmConfig: config.llm
+    llmConfig: config.llm,
+    contextBridge
   });
-  const workspaceDir = resolve20(hivemindHome, config.agent.workspace || "workspace");
   const skillsEngine = new SkillsEngine(workspaceDir, toolRegistry);
   await skillsEngine.loadAll();
   registerSkillsTools(toolRegistry, skillsEngine, workspaceDir);
@@ -8889,7 +9167,7 @@ async function runSpawnTask(config, configPath) {
     const result = response.content;
     console.log(`[spawn] Task completed (context: ${response.context})`);
     if (spawnDir) {
-      writeFileSync8(resolve20(spawnDir, "result.txt"), result);
+      writeFileSync9(resolve20(spawnDir, "result.txt"), result);
     }
     if (channelId && config.sesame.api_key) {
       try {
@@ -8906,7 +9184,7 @@ async function runSpawnTask(config, configPath) {
     const errorMsg = `[SPAWN ERROR] ${err.message}`;
     console.error(`[spawn] ${errorMsg}`);
     if (spawnDir) {
-      writeFileSync8(resolve20(spawnDir, "result.txt"), errorMsg);
+      writeFileSync9(resolve20(spawnDir, "result.txt"), errorMsg);
     }
     process.exitCode = 1;
   }
@@ -9418,4 +9696,4 @@ smol-toml/dist/index.js:
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *)
 */
-//# sourceMappingURL=chunk-EKZ3IZU6.js.map
+//# sourceMappingURL=chunk-7XXV5FKN.js.map