@sesamespace/hivemind 0.2.0 → 0.3.0

package/packages/runtime/src/agent.ts

@@ -0,0 +1,255 @@
+import type { HivemindConfig } from "./config.js";
+import type { ChatMessage } from "./llm-client.js";
+import type { L3Entry } from "./memory-client.js";
+import { LLMClient } from "./llm-client.js";
+import { MemoryClient } from "./memory-client.js";
+import { ContextManager } from "./context.js";
+import type { ContextSwitchResult } from "./context.js";
+import { TaskEngine } from "./task-engine.js";
+import { buildMessages, buildSystemPrompt } from "./prompt.js";
+
+export interface AgentResponse {
+  content: string;
+  model: string;
+  context: string;
+  contextSwitched?: boolean;
+}
+
+export class Agent {
+  private config: HivemindConfig;
+  private llm: LLMClient;
+  private memory: MemoryClient;
+  private contextManager: ContextManager;
+  // Per-context conversation histories
+  private conversationHistories: Map<string, ChatMessage[]> = new Map();
+  private messageCount = 0;
+  private readonly PROMOTION_INTERVAL = 10; // Run promotion every N messages
+
+  constructor(config: HivemindConfig, contextName = "global") {
+    this.config = config;
+    this.llm = new LLMClient(config.llm);
+    this.memory = new MemoryClient(config.memory);
+    this.contextManager = new ContextManager(this.memory);
+
+    if (contextName !== "global") {
+      this.contextManager.switchContext(contextName);
+    }
+  }
+
+  async processMessage(userMessage: string): Promise<AgentResponse> {
+    // Check for special commands first (cross-context, tasks)
+    const specialResult = await this.handleSpecialCommand(userMessage);
+    if (specialResult) return specialResult;
+
+    // Route message to correct context
+    const routing = this.contextManager.routeMessage(userMessage);
+    const contextName = routing.context;
+
+    // If an explicit context switch was requested, handle it
+    if (routing.switched) {
+      // Ensure context exists in daemon
+      try {
+        await this.memory.createContext(contextName);
+      } catch {
+        // Context may already exist
+      }
+    }
+
+    // Get (or create) conversation history for this context
+    if (!this.conversationHistories.has(contextName)) {
+      this.conversationHistories.set(contextName, []);
+    }
+    const conversationHistory = this.conversationHistories.get(contextName)!;
+
+    // 1. Query memory for relevant episodes from active context + global
+    const relevantEpisodes = await this.memory
+      .search(userMessage, contextName, this.config.memory.top_k)
+      .catch((err) => {
+        console.error("Memory search failed, continuing without context:", err.message);
+        return [];
+      });
+
+    // Record access for retrieved episodes (for promotion engine)
+    if (relevantEpisodes.length > 0) {
+      const episodeIds = relevantEpisodes.map((e) => e.id);
+      this.memory.recordCoAccess(episodeIds).catch(() => {});
+      for (const ep of relevantEpisodes) {
+        this.memory.recordAccess(ep.id).catch(() => {});
+      }
+    }
+
+    // Fetch L3 semantic knowledge for this context
+    const l3Knowledge = await this.memory
+      .getL3Knowledge(contextName)
+      .catch(() => [] as L3Entry[]);
+
+    // 2. Build prompt with identity + L2 memories + L3 knowledge + context info
+    const systemPrompt = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
+    const messages = buildMessages(systemPrompt, conversationHistory, userMessage);
+
+    // 3. Call LLM
+    const response = await this.llm.chat(messages);
+
+    // 4. Update conversation history (L1 working memory, per-context)
+    conversationHistory.push(
+      { role: "user", content: userMessage },
+      { role: "assistant", content: response.content },
+    );
+
+    // Keep working memory bounded (last 20 turns = 40 messages)
+    if (conversationHistory.length > 40) {
+      const trimmed = conversationHistory.slice(-40);
+      this.conversationHistories.set(contextName, trimmed);
+    }
+
+    // 5. Store episodes in memory daemon (write-through to L2)
+    await this.storeEpisodes(contextName, userMessage, response.content);
+
+    // 6. Periodically trigger L2→L3 promotion (fire-and-forget)
+    this.messageCount++;
+    if (this.messageCount % this.PROMOTION_INTERVAL === 0) {
+      this.memory.runPromotion(contextName).catch((err) => {
+        console.error("Promotion run failed:", (err as Error).message);
+      });
+    }
+
+    return {
+      content: response.content,
+      model: response.model,
+      context: contextName,
+      contextSwitched: routing.switched,
+    };
+  }
+
+  private async storeEpisodes(
+    contextName: string,
+    userMessage: string,
+    assistantResponse: string,
+  ): Promise<void> {
+    try {
+      await Promise.all([
+        this.memory.storeEpisode({
+          context_name: contextName,
+          role: "user",
+          content: userMessage,
+        }),
+        this.memory.storeEpisode({
+          context_name: contextName,
+          role: "assistant",
+          content: assistantResponse,
+        }),
+      ]);
+    } catch (err) {
+      console.error("Failed to store episodes:", (err as Error).message);
+    }
+  }
+
+  private async handleSpecialCommand(message: string): Promise<AgentResponse | null> {
+    const activeCtx = this.contextManager.getActiveContext();
+
+    // --- Cross-context commands ---
+
+    // "search all: <query>" or "cross-context search: <query>"
+    const searchAllMatch = message.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
+    if (searchAllMatch) {
+      const query = searchAllMatch[1].trim();
+      try {
+        const results = await this.memory.searchCrossContext(query);
+        let response = "## Cross-Context Search Results\n\n";
+        if (results.length === 0) {
+          response += "No results found across any context.";
+        } else {
+          for (const group of results) {
+            response += `### Context: ${group.context}\n`;
+            for (const ep of group.episodes) {
+              response += `- [${ep.role}] ${ep.content.slice(0, 200)}${ep.content.length > 200 ? "..." : ""} (score: ${ep.score.toFixed(3)})\n`;
+            }
+            response += "\n";
+          }
+        }
+        return { content: response, model: "system", context: activeCtx };
+      } catch (err) {
+        return { content: `Cross-context search failed: ${(err as Error).message}`, model: "system", context: activeCtx };
+      }
+    }
+
+    // "share <episode_id> with <context>"
+    const shareMatch = message.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
+    if (shareMatch) {
+      const episodeId = shareMatch[1];
+      const targetContext = shareMatch[2];
+      try {
+        await this.memory.shareEpisode(episodeId, targetContext);
+        return { content: `Shared episode ${episodeId} with context "${targetContext}".`, model: "system", context: activeCtx };
+      } catch (err) {
+        return { content: `Failed to share: ${(err as Error).message}`, model: "system", context: activeCtx };
+      }
+    }
+
+    // --- Task commands ---
+    const taskCmd = TaskEngine.parseTaskCommand(message);
+    if (taskCmd) {
+      const engine = new TaskEngine({ contextName: activeCtx, memory: this.memory });
+      try {
+        switch (taskCmd.action) {
+          case "add": {
+            const task = await engine.addTask(taskCmd.title || "Untitled", taskCmd.description || "");
+            return { content: `Task created: [${task.id.slice(0, 8)}] ${task.title} (status: ${task.status})`, model: "system", context: activeCtx };
+          }
+          case "list": {
+            const tasks = await engine.listTasks(taskCmd.statusFilter);
+            if (tasks.length === 0) {
+              return { content: `No tasks${taskCmd.statusFilter ? ` with status "${taskCmd.statusFilter}"` : ""} in context "${activeCtx}".`, model: "system", context: activeCtx };
+            }
+            let response = `## Tasks in ${activeCtx}\n\n`;
+            for (const t of tasks) {
+              const blockedBy: string[] = Array.isArray(t.blocked_by) ? t.blocked_by : JSON.parse(String(t.blocked_by) || "[]");
+              const blockedStr = blockedBy.length > 0 ? ` (blocked by: ${blockedBy.map((b) => b.slice(0, 8)).join(", ")})` : "";
+              response += `- [${t.status}] ${t.id.slice(0, 8)}: ${t.title}${blockedStr}\n`;
+            }
+            return { content: response, model: "system", context: activeCtx };
+          }
+          case "start": {
+            const task = await engine.startTask(taskCmd.taskId!);
+            return { content: task ? `Task ${taskCmd.taskId!.slice(0, 8)} started.` : "Task not found.", model: "system", context: activeCtx };
+          }
+          case "complete": {
+            const task = await engine.completeTask(taskCmd.taskId!);
+            return { content: task ? `Task ${taskCmd.taskId!.slice(0, 8)} completed.` : "Task not found.", model: "system", context: activeCtx };
+          }
+          case "archive": {
+            const task = await engine.archiveTask(taskCmd.taskId!);
+            return { content: task ? `Task ${taskCmd.taskId!.slice(0, 8)} archived.` : "Task not found.", model: "system", context: activeCtx };
+          }
+          case "next": {
+            const task = await engine.pickAndStartNextTask();
+            if (task) {
+              return { content: `Picked up next task: [${task.id.slice(0, 8)}] ${task.title}`, model: "system", context: activeCtx };
+            }
+            return { content: "No available tasks to pick up.", model: "system", context: activeCtx };
+          }
+        }
+      } catch (err) {
+        return { content: `Task command failed: ${(err as Error).message}`, model: "system", context: activeCtx };
+      }
+    }
+
+    return null;
+  }
+
+  getMemoryClient(): MemoryClient {
+    return this.memory;
+  }
+
+  getContextManager(): ContextManager {
+    return this.contextManager;
+  }
+
+  setContext(name: string): void {
+    this.contextManager.switchContext(name);
+  }
+
+  getActiveContext(): string {
+    return this.contextManager.getActiveContext();
+  }
+}

package/packages/runtime/src/config.ts

@@ -0,0 +1,130 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { parse } from "@iarna/toml";
+
+export interface AgentConfig {
+  name: string;
+  personality: string;
+  team_charter?: string; // Path to team charter markdown file
+  workspace?: string; // Path to workspace directory containing .md identity files
+}
+
+export interface LLMConfig {
+  base_url: string;
+  model: string;
+  max_tokens: number;
+  temperature: number;
+  api_key?: string;
+}
+
+export interface MemoryConfig {
+  daemon_url: string;
+  top_k: number;
+  embedding_model: string;
+}
+
+export interface OllamaConfig {
+  base_url: string;
+}
+
+export interface SesameConfig {
+  ws_url: string;
+  api_url: string;
+  api_key: string;
+}
+
+export interface WorkerModeConfig {
+  enabled: boolean;
+  primary_url: string;
+  worker_port: number;
+  worker_id: string;
+  max_contexts: number;
+  task_poll_interval_ms: number;
+  status_report_interval_ms: number;
+}
+
+export interface HivemindConfig {
+  agent: AgentConfig;
+  llm: LLMConfig;
+  memory: MemoryConfig;
+  ollama: OllamaConfig;
+  sesame: SesameConfig;
+  worker?: WorkerModeConfig;
+}
+
+function defaultWorkerConfig(): WorkerModeConfig {
+  return {
+    enabled: false,
+    primary_url: "http://localhost:3000",
+    worker_port: 3100,
+    worker_id: `worker-${process.pid}`,
+    max_contexts: 4,
+    task_poll_interval_ms: 5_000,
+    status_report_interval_ms: 15_000,
+  };
+}
+
+function deepMerge(target: any, source: any): any {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])
+        && target[key] && typeof target[key] === "object") {
+      result[key] = deepMerge(target[key], source[key]);
+    } else if (source[key] !== undefined && source[key] !== "") {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+export function loadConfig(path: string): HivemindConfig {
+  const raw = readFileSync(path, "utf-8");
+  let parsed = parse(raw) as unknown as HivemindConfig;
+
+  // Layer: merge local.toml if it exists alongside the config
+  const configDir = dirname(path);
+  const localPath = resolve(configDir, "local.toml");
+  if (existsSync(localPath)) {
+    const localRaw = readFileSync(localPath, "utf-8");
+    const localParsed = parse(localRaw) as Record<string, unknown>;
+    parsed = deepMerge(parsed, localParsed) as HivemindConfig;
+    console.log(`[config] Merged overrides from ${localPath}`);
+  }
+
+  // Allow env overrides
+  if (process.env.AGENT_NAME) {
+    parsed.agent.name = process.env.AGENT_NAME;
+  }
+  if (process.env.LLM_API_KEY) {
+    parsed.llm.api_key = process.env.LLM_API_KEY;
+  }
+  if (process.env.LLM_BASE_URL) {
+    parsed.llm.base_url = process.env.LLM_BASE_URL;
+  }
+  if (process.env.SESAME_API_KEY) {
+    parsed.sesame.api_key = process.env.SESAME_API_KEY;
+  }
+  if (process.env.MEMORY_DAEMON_URL) {
+    parsed.memory.daemon_url = process.env.MEMORY_DAEMON_URL;
+  }
+  if (process.env.WORKER_PRIMARY_URL) {
+    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
+    parsed.worker.primary_url = process.env.WORKER_PRIMARY_URL;
+  }
+  if (process.env.WORKER_PORT) {
+    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
+    parsed.worker.worker_port = parseInt(process.env.WORKER_PORT, 10);
+  }
+  if (process.env.WORKER_ID) {
+    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
+    parsed.worker.worker_id = process.env.WORKER_ID;
+  }
+
+  // Resolve relative workspace path against config directory
+  if (parsed.agent.workspace && !parsed.agent.workspace.startsWith("/")) {
+    const configDir = dirname(path);
+    parsed.agent.workspace = resolve(configDir, "..", parsed.agent.workspace);
+  }
+
+  return parsed;
+}

package/packages/runtime/src/context.ts

@@ -0,0 +1,192 @@
+import type { MemoryClient } from "./memory-client.js";
+
+export interface ContextMetadata {
+  name: string;
+  description: string;
+  created_at: string;
+  last_active: string;
+}
+
+export interface ContextSwitchResult {
+  previousContext: string | null;
+  activeContext: string;
+  isNew: boolean;
+}
+
+const SWITCH_PATTERNS = [
+  /^switch\s+to\s+(\S+)/i,
+  /^context:\s*(\S+)/i,
+  /^@(\S+)\s/,
+  /^working\s+on\s+(\S+)/i,
+];
+
+export class ContextManager {
+  private contexts: Map<string, ContextMetadata> = new Map();
+  private activeContext: string = "global";
+  private memory: MemoryClient;
+
+  constructor(memory: MemoryClient) {
+    this.memory = memory;
+    // Global context always exists
+    this.contexts.set("global", {
+      name: "global",
+      description: "Global context — identity, preferences, cross-cutting knowledge",
+      created_at: new Date().toISOString(),
+      last_active: new Date().toISOString(),
+    });
+  }
+
+  async createContext(name: string, description = ""): Promise<ContextMetadata> {
+    if (this.contexts.has(name)) {
+      return this.contexts.get(name)!;
+    }
+
+    const metadata: ContextMetadata = {
+      name,
+      description,
+      created_at: new Date().toISOString(),
+      last_active: new Date().toISOString(),
+    };
+
+    this.contexts.set(name, metadata);
+
+    // Register context with memory daemon
+    try {
+      await this.memory.createContext(name, description);
+    } catch (err) {
+      console.error(`Failed to register context '${name}' with daemon:`, (err as Error).message);
+    }
+
+    return metadata;
+  }
+
+  async deleteContext(name: string): Promise<boolean> {
+    if (name === "global") {
+      console.error("Cannot delete global context");
+      return false;
+    }
+
+    if (!this.contexts.has(name)) {
+      return false;
+    }
+
+    this.contexts.delete(name);
+
+    if (this.activeContext === name) {
+      this.activeContext = "global";
+    }
+
+    try {
+      await this.memory.deleteContext(name);
+    } catch (err) {
+      console.error(`Failed to delete context '${name}' from daemon:`, (err as Error).message);
+    }
+
+    return true;
+  }
+
+  listContexts(): ContextMetadata[] {
+    return Array.from(this.contexts.values());
+  }
+
+  getContext(name: string): ContextMetadata | undefined {
+    return this.contexts.get(name);
+  }
+
+  getActiveContext(): string {
+    return this.activeContext;
+  }
+
+  switchContext(name: string): ContextSwitchResult {
+    const previousContext = this.activeContext;
+    const isNew = !this.contexts.has(name);
+
+    if (isNew) {
+      this.contexts.set(name, {
+        name,
+        description: "",
+        created_at: new Date().toISOString(),
+        last_active: new Date().toISOString(),
+      });
+    }
+
+    this.activeContext = name;
+    this.touchContext(name);
+
+    return { previousContext, activeContext: name, isNew };
+  }
+
+  /**
+   * Parse a message and determine if it's a context switch command.
+   * Returns the context name if a switch is detected, null otherwise.
+   */
+  parseContextSwitch(message: string): string | null {
+    for (const pattern of SWITCH_PATTERNS) {
+      const match = message.match(pattern);
+      if (match) {
+        return match[1].toLowerCase();
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Infer context from message content by checking known context names.
+   * Returns the best matching context or current active context.
+   */
+  inferContext(message: string): string {
+    const lower = message.toLowerCase();
+    for (const [name] of this.contexts) {
+      if (name === "global") continue;
+      if (lower.includes(name.toLowerCase())) {
+        return name;
+      }
+    }
+    return this.activeContext;
+  }
+
+  /**
+   * Route a message: check for explicit switch, then infer context.
+   * Returns the resolved context name and whether a switch happened.
+   */
+  routeMessage(message: string): { context: string; switched: boolean; switchedTo?: string } {
+    // Check for explicit switch command
+    const switchTarget = this.parseContextSwitch(message);
+    if (switchTarget) {
+      const result = this.switchContext(switchTarget);
+      return { context: switchTarget, switched: true, switchedTo: result.activeContext };
+    }
+
+    // Infer from content
+    const inferred = this.inferContext(message);
+    if (inferred !== this.activeContext) {
+      this.touchContext(inferred);
+      return { context: inferred, switched: false };
+    }
+
+    this.touchContext(this.activeContext);
+    return { context: this.activeContext, switched: false };
+  }
+
+  /**
+   * Returns contexts that should be searched: active context + global.
+   */
+  getSearchContexts(): string[] {
+    const contexts = [this.activeContext];
+    if (this.activeContext !== "global") {
+      contexts.push("global");
+    }
+    return contexts;
+  }
+
+  hasContext(name: string): boolean {
+    return this.contexts.has(name);
+  }
+
+  private touchContext(name: string): void {
+    const ctx = this.contexts.get(name);
+    if (ctx) {
+      ctx.last_active = new Date().toISOString();
+    }
+  }
+}