@sesamespace/hivemind 0.12.2 → 0.12.3

package/dist/commands/fleet.js

@@ -1,8 +1,8 @@
 import {
   runFleetCommand
-} from "../chunk-EJM4KCCY.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-6W56VBXG.js";
+import "../chunk-3SIWFXC7.js";
+import "../chunk-TQYOGZIN.js";
 import "../chunk-DGUM43GV.js";
 export {
   runFleetCommand

package/dist/commands/init.js

@@ -1,8 +1,8 @@
 import {
   runInitCommand
-} from "../chunk-ZI4AN7GT.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-KOSNIWPS.js";
+import "../chunk-3SIWFXC7.js";
+import "../chunk-TQYOGZIN.js";
 import "../chunk-DGUM43GV.js";
 export {
   runInitCommand

package/dist/commands/start.js

@@ -1,8 +1,8 @@
 import {
   runStartCommand
-} from "../chunk-SNW6Z2W4.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-7HOPTFRU.js";
+import "../chunk-3SIWFXC7.js";
+import "../chunk-TQYOGZIN.js";
 import "../chunk-DGUM43GV.js";
 export {
   runStartCommand

package/dist/commands/watchdog.js

@@ -1,8 +1,8 @@
 import {
   runWatchdogCommand
-} from "../chunk-3F7M2BPR.js";
-import "../chunk-ZAPHLG7V.js";
-import "../chunk-R7RHYYOM.js";
+} from "../chunk-EDSK2CG6.js";
+import "../chunk-3SIWFXC7.js";
+import "../chunk-TQYOGZIN.js";
 import "../chunk-DGUM43GV.js";
 export {
   runWatchdogCommand

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   PrimaryMemorySync,
   Watchdog,
   WorkerMemorySync
-} from "./chunk-ZAPHLG7V.js";
+} from "./chunk-3SIWFXC7.js";
 import {
   Agent,
   AutoDebugger,
@@ -34,7 +34,7 @@ import {
   setLogLevel,
   startPipeline,
   startWorker
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-TQYOGZIN.js";
 import "./chunk-DGUM43GV.js";
 export {
   Agent,

package/dist/main.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   runInitCommand
-} from "./chunk-ZI4AN7GT.js";
+} from "./chunk-KOSNIWPS.js";
 import {
   runStartCommand
-} from "./chunk-SNW6Z2W4.js";
+} from "./chunk-7HOPTFRU.js";
 import {
   runFleetCommand
-} from "./chunk-EJM4KCCY.js";
+} from "./chunk-6W56VBXG.js";
 import {
   runServiceCommand
 } from "./chunk-6QZDXOMW.js";
@@ -16,9 +16,9 @@ import {
 } from "./chunk-ICSJNKI6.js";
 import {
   runWatchdogCommand
-} from "./chunk-3F7M2BPR.js";
-import "./chunk-ZAPHLG7V.js";
-import "./chunk-R7RHYYOM.js";
+} from "./chunk-EDSK2CG6.js";
+import "./chunk-3SIWFXC7.js";
+import "./chunk-TQYOGZIN.js";
 import "./chunk-DGUM43GV.js";
 
 // packages/cli/src/commands/session.ts

package/dist/start.js

@@ -3,7 +3,7 @@ import {
   loadConfig,
   startPipeline,
   startWorker
-} from "./chunk-R7RHYYOM.js";
+} from "./chunk-TQYOGZIN.js";
 import "./chunk-DGUM43GV.js";
 
 // packages/runtime/src/start.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sesamespace/hivemind",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "description": "Cognitive architecture for AI agents with multi-layered memory",
   "scripts": {
     "build": "tsup",

package/test/claude-integration.test.ts

@@ -0,0 +1,325 @@
+/**
+ * Test Suite for Claude Code Integration
+ * 
+ * Tests the bidirectional context bridge, memory storage,
+ * and real-time notification systems.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { ClaudeContextBridge } from "../packages/runtime/src/tools/context-bridge.js";
+import { ClaudeNotifier } from "../packages/runtime/src/tools/claude-notifier.js";
+import { MemoryClient } from "../packages/runtime/src/memory-client.js";
+import { Logger } from "../packages/runtime/src/logger.js";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+describe("Claude Code Integration", () => {
+  let contextBridge: ClaudeContextBridge;
+  let memoryClient: MemoryClient;
+  let logger: Logger;
+  let workspaceDir: string;
+  let sessionLogPath: string;
+
+  beforeEach(async () => {
+    // Set up test environment
+    workspaceDir = "/tmp/test-workspace";
+    sessionLogPath = join(homedir(), ".claude", "session.log");
+    
+    // Create mock implementations
+    logger = {
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
+    memoryClient = {
+      search: jest.fn().mockResolvedValue([]),
+      storeEpisode: jest.fn().mockResolvedValue({}),
+    } as any;
+
+    // Create context bridge
+    contextBridge = new ClaudeContextBridge({
+      workspaceDir,
+      memoryClient,
+      logger,
+    });
+    
+    await contextBridge.initialize();
+  });
+
+  afterEach(() => {
+    contextBridge.destroy();
+    // Clean up test files
+    if (existsSync(sessionLogPath)) {
+      unlinkSync(sessionLogPath);
+    }
+  });
+
+  describe("Context Preparation", () => {
+    it("should prepare context with all fields", async () => {
+      const context = {
+        goal: "Fix authentication bug",
+        requirements: ["Must support OAuth", "Handle token refresh"],
+        recentErrors: ["401 Unauthorized on /api/user"],
+        relevantPatterns: ["Use middleware for auth"],
+        workingFiles: ["src/auth.ts", "src/middleware.ts"],
+        knownConstraints: ["JWT tokens expire after 1 hour"],
+      };
+
+      await contextBridge.prepareContext(context);
+
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      expect(existsSync(contextFile)).toBe(true);
+      
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Fix authentication bug");
+      expect(content).toContain("Must support OAuth");
+      expect(content).toContain("401 Unauthorized");
+      expect(content).toContain("Use middleware for auth");
+      expect(content).toContain("src/auth.ts");
+      expect(content).toContain("JWT tokens expire after 1 hour");
+    });
+
+    it("should include memory search results", async () => {
+      // Mock memory search
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "Previous auth implementation used Passport.js" },
+        { content: "Refresh tokens stored in Redis" },
+      ]);
+
+      await contextBridge.prepareContext({ goal: "Implement authentication" });
+
+      expect(memoryClient.search).toHaveBeenCalledWith("Implement authentication", "global", 5);
+      
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Previous auth implementation used Passport.js");
+      expect(content).toContain("Refresh tokens stored in Redis");
+    });
+  });
+
+  describe("Session Log Monitoring", () => {
+    it("should detect and process DISCOVERY entries", (done) => {
+      contextBridge.on('insight', ({ type, content }) => {
+        expect(type).toBe('DISCOVERY');
+        expect(content).toBe('Found JWT validation in middleware');
+        done();
+      });
+
+      // Simulate Claude writing to session log
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "DISCOVERY: Found JWT validation in middleware\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should detect and process NEED entries", (done) => {
+      contextBridge.on('context-request', (need) => {
+        expect(need).toBe('Database schema for users table');
+        done();
+      });
+
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "NEED: Database schema for users table\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should store PATTERN entries in memory", (done) => {
+      contextBridge.on('insight', async ({ type }) => {
+        if (type === 'PATTERN') {
+          // Give it time to store
+          setTimeout(() => {
+            expect(memoryClient.storeEpisode).toHaveBeenCalledWith({
+              context_name: "claude-code-insights",
+              role: "system",
+              content: "PATTERN: Always validate JWT in middleware",
+              metadata: expect.objectContaining({
+                type: "PATTERN",
+                source: "claude-code",
+              }),
+            });
+            done();
+          }, 100);
+        }
+      });
+
+      setTimeout(() => {
+        writeFileSync(sessionLogPath, "PATTERN: Always validate JWT in middleware\n", { flag: 'a' });
+      }, 100);
+    });
+
+    it("should deduplicate identical patterns", async () => {
+      // Write the same pattern twice
+      writeFileSync(sessionLogPath, "PATTERN: Use async/await for DB calls\n");
+      await new Promise(resolve => setTimeout(resolve, 600));
+      writeFileSync(sessionLogPath, "PATTERN: Use async/await for DB calls\n", { flag: 'a' });
+      await new Promise(resolve => setTimeout(resolve, 600));
+
+      // Should only store once
+      expect(memoryClient.storeEpisode).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Real-time Context Injection", () => {
+    it("should append context when Claude needs it", async () => {
+      // Mock memory search for additional context
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "Users table has columns: id, email, password_hash, created_at" },
+      ]);
+
+      // Prepare initial context
+      await contextBridge.prepareContext({ goal: "Fix user query" });
+
+      // Simulate Claude needing more info
+      writeFileSync(sessionLogPath, "NEED: Database schema\n", { flag: 'a' });
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 600));
+
+      // Check that context was appended
+      const contextFile = join(workspaceDir, "CLAUDE_CONTEXT.md");
+      const content = require('fs').readFileSync(contextFile, 'utf-8');
+      expect(content).toContain("Additional Context");
+      expect(content).toContain("You asked about: Database schema");
+      expect(content).toContain("Users table has columns");
+    });
+  });
+
+  describe("Session Summary", () => {
+    it("should retrieve categorized insights", async () => {
+      // Mock memory with various insight types
+      (memoryClient.search as jest.Mock).mockResolvedValue([
+        { content: "DISCOVERY: Auth uses JWT with RS256" },
+        { content: "PATTERN: Validate tokens in middleware" },
+        { content: "ERROR: Missing JWKS endpoint" },
+        { content: "COMPLETE: Implemented token refresh" },
+        { content: "NEED: Public key for verification" },
+      ]);
+
+      const summary = await contextBridge.getSessionSummary();
+
+      expect(summary.discoveries).toContain("Auth uses JWT with RS256");
+      expect(summary.patterns).toContain("Validate tokens in middleware");
+      expect(summary.errors).toContain("Missing JWKS endpoint");
+      expect(summary.completions).toContain("Implemented token refresh");
+      expect(summary.needs).toContain("Public key for verification");
+    });
+  });
+
+  describe("Notification System", () => {
+    it("should emit urgent events for NEED requests", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+        onNeed: async (need) => {
+          expect(need).toBe("API documentation");
+          done();
+        },
+      });
+
+      // Simulate Claude needing something
+      writeFileSync(sessionLogPath, "NEED: API documentation\n", { flag: 'a' });
+    });
+
+    it("should handle critical errors", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+        onError: async (error) => {
+          expect(error).toBe("Cannot find module 'auth'");
+          done();
+        },
+      });
+
+      writeFileSync(sessionLogPath, "ERROR: Cannot find module 'auth'\n", { flag: 'a' });
+    });
+
+    it("should create urgent events", (done) => {
+      const notifier = new ClaudeNotifier({
+        logger,
+        contextBridge,
+      });
+
+      notifier.on('urgent-event', (event) => {
+        expect(event.type).toBe("immediate");
+        expect(event.text).toContain("[Claude Code Urgent]");
+        expect(event.text).toContain("Missing database credentials");
+        done();
+      });
+
+      notifier.createUrgentEvent("Missing database credentials", "test-channel");
+    });
+  });
+
+  describe("End-to-End Integration", () => {
+    it("should handle a complete Claude Code session", async () => {
+      // Prepare context
+      await contextBridge.prepareContext({
+        goal: "Implement user authentication",
+        requirements: ["Support JWT", "Handle refresh tokens"],
+      });
+
+      // Simulate Claude Code session
+      const sessionLog = [
+        "DISCOVERY: Found existing Passport.js setup",
+        "PATTERN: Use httpOnly cookies for refresh tokens",
+        "NEED: Redis connection details",
+        "ERROR: Redis connection failed",
+        "COMPLETE: Implemented JWT authentication",
+      ];
+
+      for (const line of sessionLog) {
+        writeFileSync(sessionLogPath, line + "\n", { flag: 'a' });
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Verify memory storage
+      const storeEpisodeCalls = (memoryClient.storeEpisode as jest.Mock).mock.calls;
+      expect(storeEpisodeCalls.length).toBeGreaterThanOrEqual(2);
+      
+      // Verify discoveries and patterns were stored
+      const storedContent = storeEpisodeCalls.map(call => call[0].content);
+      expect(storedContent).toContain("DISCOVERY: Found existing Passport.js setup");
+      expect(storedContent).toContain("PATTERN: Use httpOnly cookies for refresh tokens");
+
+      // Get session summary
+      const summary = await contextBridge.getSessionSummary();
+      expect(summary.discoveries.length).toBeGreaterThan(0);
+      expect(summary.patterns.length).toBeGreaterThan(0);
+      expect(summary.errors.length).toBeGreaterThan(0);
+      expect(summary.completions.length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe("Test Suite Requirements", () => {
+  it("should cover all critical functionality", () => {
+    const testCategories = [
+      "Context Preparation",
+      "Session Log Monitoring", 
+      "Real-time Context Injection",
+      "Session Summary",
+      "Notification System",
+      "End-to-End Integration"
+    ];
+
+    const criticalFeatures = [
+      "Prepare context with memory search",
+      "Monitor session log in real-time",
+      "Store discoveries and patterns",
+      "Deduplicate patterns",
+      "Inject context on NEED",
+      "Emit notifications for urgent needs",
+      "Generate session summaries",
+      "Handle complete sessions"
+    ];
+
+    // This test just documents what we're testing
+    expect(testCategories.length).toBeGreaterThanOrEqual(6);
+    expect(criticalFeatures.length).toBeGreaterThanOrEqual(8);
+  });
+});