@199-bio/engram 0.7.0 → 0.7.4

package/src/web/chat-handler.ts

@@ -7,6 +7,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { EngramDatabase, Entity, Memory } from "../storage/database.js";
 import { KnowledgeGraph } from "../graph/knowledge-graph.js";
 import { HybridSearch } from "../retrieval/hybrid.js";
+import { getAnthropicApiKey } from "../settings.js";
 
 // Tool definitions for Claude
 const TOOLS: Anthropic.Tool[] = [
@@ -135,7 +136,7 @@ const TOOLS: Anthropic.Tool[] = [
   },
   {
     name: "delete_memory",
-    description: "Delete a memory by its ID.",
+    description: "Delete a memory by its ID (soft-delete, can be recovered).",
     input_schema: {
       type: "object" as const,
       properties: {
@@ -147,6 +148,87 @@ const TOOLS: Anthropic.Tool[] = [
       required: ["id"],
     },
   },
+  {
+    name: "edit_memory",
+    description: "Edit an existing memory's content or importance.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        id: {
+          type: "string",
+          description: "The memory ID to edit",
+        },
+        content: {
+          type: "string",
+          description: "New content (replaces existing)",
+        },
+        importance: {
+          type: "number",
+          description: "New importance (0-1): 0.9=core identity, 0.8=major, 0.5=normal, 0.3=minor",
+        },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "create_memory",
+    description: "Create a new memory. Use for storing user information, preferences, or facts.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        content: {
+          type: "string",
+          description: "The information to store",
+        },
+        importance: {
+          type: "number",
+          description: "0-1 score: 0.9=core identity, 0.8=major, 0.5=normal (default), 0.3=minor",
+        },
+      },
+      required: ["content"],
+    },
+  },
+  {
+    name: "create_entity",
+    description: "Create a new entity (person, organization, or place).",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        name: {
+          type: "string",
+          description: "The entity name",
+        },
+        type: {
+          type: "string",
+          enum: ["person", "organization", "place"],
+          description: "Entity type",
+        },
+      },
+      required: ["name", "type"],
+    },
+  },
+  {
+    name: "create_relationship",
+    description: "Create a relationship between two entities.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        from: {
+          type: "string",
+          description: "Source entity name",
+        },
+        to: {
+          type: "string",
+          description: "Target entity name",
+        },
+        type: {
+          type: "string",
+          description: "Relationship type (e.g., 'works_at', 'lives_in', 'knows', 'sibling_of')",
+        },
+      },
+      required: ["from", "to", "type"],
+    },
+  },
   {
     name: "find_duplicates",
     description: "Find potential duplicate entities that could be merged.",
@@ -183,12 +265,22 @@ interface ChatMessage {
   content: string;
 }
 
+// Stream event types for SSE
+export interface StreamEvent {
+  type: "text" | "tool_start" | "tool_end" | "error" | "done";
+  content?: string;
+  tool?: string;
+  result?: unknown;
+}
+
 export class ChatHandler {
   private client: Anthropic | null = null;
   private db: EngramDatabase;
   private graph: KnowledgeGraph;
   private search: HybridSearch;
   private conversationHistory: Anthropic.MessageParam[] = [];
+  private isProcessing: boolean = false;
+  private messageQueue: Array<{ message: string; resolve: (value: string) => void; reject: (error: Error) => void }> = [];
 
   constructor(options: {
     db: EngramDatabase;
@@ -199,9 +291,19 @@ export class ChatHandler {
     this.graph = options.graph;
     this.search = options.search;
 
-    const apiKey = process.env.ANTHROPIC_API_KEY;
+    // Initialize client from settings or env var
+    this.refreshClient();
+  }
+
+  /**
+   * Refresh the Anthropic client (call after settings change)
+   */
+  refreshClient(): void {
+    const apiKey = getAnthropicApiKey();
     if (apiKey) {
       this.client = new Anthropic({ apiKey });
+    } else {
+      this.client = null;
     }
   }
 
@@ -209,15 +311,174 @@ export class ChatHandler {
     return this.client !== null;
   }
 
+  isBusy(): boolean {
+    return this.isProcessing;
+  }
+
+  getQueueLength(): number {
+    return this.messageQueue.length;
+  }
+
   clearHistory(): void {
     this.conversationHistory = [];
   }
 
+  // Process message queue
+  private async processQueue(): Promise<void> {
+    if (this.isProcessing || this.messageQueue.length === 0) return;
+
+    const { message, resolve, reject } = this.messageQueue.shift()!;
+    try {
+      const result = await this.processMessage(message);
+      resolve(result);
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+    }
+
+    // Process next in queue
+    this.processQueue();
+  }
+
+  // Queue-aware chat method
   async chat(userMessage: string): Promise<string> {
     if (!this.client) {
       return "Chat is not configured. Set ANTHROPIC_API_KEY environment variable.";
     }
 
+    // If busy, queue the message
+    if (this.isProcessing) {
+      return new Promise((resolve, reject) => {
+        this.messageQueue.push({ message: userMessage, resolve, reject });
+      });
+    }
+
+    return this.processMessage(userMessage);
+  }
+
+  // Streaming chat with callbacks for real-time updates
+  async *chatStream(userMessage: string): AsyncGenerator<StreamEvent> {
+    if (!this.client) {
+      yield { type: "error", content: "Chat is not configured. Set ANTHROPIC_API_KEY environment variable." };
+      return;
+    }
+
+    this.isProcessing = true;
+
+    // Add user message to history
+    this.conversationHistory.push({
+      role: "user",
+      content: userMessage,
+    });
+
+    try {
+      // Keep conversation history manageable
+      if (this.conversationHistory.length > 20) {
+        this.conversationHistory = this.conversationHistory.slice(-20);
+      }
+
+      let continueLoop = true;
+      let fullResponse = "";
+
+      while (continueLoop) {
+        const stream = this.client.messages.stream({
+          model: "claude-haiku-4-5-20241022",
+          max_tokens: 1024,
+          system: SYSTEM_PROMPT,
+          tools: TOOLS,
+          messages: this.conversationHistory,
+        });
+
+        let currentToolUse: { id: string; name: string; input: string } | null = null;
+
+        for await (const event of stream) {
+          if (event.type === "content_block_start") {
+            if (event.content_block.type === "tool_use") {
+              currentToolUse = {
+                id: event.content_block.id,
+                name: event.content_block.name,
+                input: "",
+              };
+              yield { type: "tool_start", tool: event.content_block.name };
+            }
+          } else if (event.type === "content_block_delta") {
+            if (event.delta.type === "text_delta") {
+              fullResponse += event.delta.text;
+              yield { type: "text", content: event.delta.text };
+            } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+              currentToolUse.input += event.delta.partial_json;
+            }
+          } else if (event.type === "content_block_stop") {
+            if (currentToolUse) {
+              // Execute the tool
+              let toolInput: Record<string, unknown> = {};
+              try {
+                toolInput = JSON.parse(currentToolUse.input || "{}");
+              } catch {
+                toolInput = {};
+              }
+
+              const result = await this.executeTool(currentToolUse.name, toolInput);
+              yield { type: "tool_end", tool: currentToolUse.name, result };
+              currentToolUse = null;
+            }
+          }
+        }
+
+        // Get final message to check stop reason
+        const finalMessage = await stream.finalMessage();
+
+        if (finalMessage.stop_reason === "tool_use") {
+          // Process tool results and continue
+          const toolUseBlocks = finalMessage.content.filter(
+            (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
+          );
+
+          const toolResults: Anthropic.ToolResultBlockParam[] = [];
+          for (const toolUse of toolUseBlocks) {
+            const result = await this.executeTool(toolUse.name, toolUse.input as Record<string, unknown>);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: JSON.stringify(result),
+            });
+          }
+
+          // Add to history
+          this.conversationHistory.push({
+            role: "assistant",
+            content: finalMessage.content,
+          });
+          this.conversationHistory.push({
+            role: "user",
+            content: toolResults,
+          });
+        } else {
+          // Done - add final response to history
+          this.conversationHistory.push({
+            role: "assistant",
+            content: finalMessage.content,
+          });
+          continueLoop = false;
+        }
+      }
+
+      yield { type: "done" };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      yield { type: "error", content: message };
+    } finally {
+      this.isProcessing = false;
+      // Process any queued messages
+      this.processQueue();
+    }
+  }
+
+  // Original non-streaming method for backwards compatibility
+  private async processMessage(userMessage: string): Promise<string> {
+    if (!this.client) {
+      return "Chat is not configured. Set ANTHROPIC_API_KEY environment variable.";
+    }
+
     // Add user message to history
     this.conversationHistory.push({
       role: "user",
@@ -427,9 +688,93 @@ export class ChatHandler {
           return { error: `Memory not found: ${id}` };
         }
 
+        // Soft-delete: remove from index and disable
         await this.search.removeFromIndex(id);
-        this.db.deleteMemory(id);
-        return { success: true, deleted_id: id };
+        this.db.updateMemory(id, { disabled: true });
+        return { success: true, disabled_id: id, message: "Memory disabled (soft-deleted)" };
+      }
+
+      case "edit_memory": {
+        const id = input.id as string;
+        const content = input.content as string | undefined;
+        const importance = input.importance as number | undefined;
+
+        const memory = this.db.getMemory(id);
+        if (!memory) {
+          return { error: `Memory not found: ${id}` };
+        }
+
+        const updates: { content?: string; importance?: number } = {};
+        if (content !== undefined) updates.content = content;
+        if (importance !== undefined) updates.importance = importance;
+
+        if (Object.keys(updates).length === 0) {
+          return { error: "No updates provided" };
+        }
+
+        const updated = this.db.updateMemory(id, updates);
+
+        // Re-index if content changed
+        if (content !== undefined && updated) {
+          await this.search.removeFromIndex(id);
+          await this.search.indexMemory(updated);
+        }
+
+        return {
+          success: true,
+          memory_id: id,
+          updated_fields: Object.keys(updates),
+        };
+      }
+
+      case "create_memory": {
+        const content = input.content as string;
+        const importance = (input.importance as number) || 0.5;
+
+        const memory = this.db.createMemory(content, "chat", importance);
+        await this.search.indexMemory(memory);
+
+        return {
+          success: true,
+          memory_id: memory.id,
+          content: memory.content.substring(0, 100) + (memory.content.length > 100 ? "..." : ""),
+        };
+      }
+
+      case "create_entity": {
+        const name = input.name as string;
+        const type = input.type as "person" | "organization" | "place";
+
+        // Check if entity already exists
+        const existing = this.db.findEntityByName(name);
+        if (existing) {
+          return { error: `Entity already exists: ${name}`, existing_id: existing.id };
+        }
+
+        const entity = this.graph.getOrCreateEntity(name, type);
+        return {
+          success: true,
+          entity_id: entity.id,
+          name: entity.name,
+          type: entity.type,
+        };
+      }
+
+      case "create_relationship": {
+        const fromName = input.from as string;
+        const toName = input.to as string;
+        const type = input.type as string;
+
+        // Get or create both entities (default to person type if not existing)
+        const fromEntity = this.graph.getOrCreateEntity(fromName, "person");
+        const toEntity = this.graph.getOrCreateEntity(toName, "person");
+
+        this.graph.relate(fromEntity.name, toEntity.name, type);
+
+        return {
+          success: true,
+          relationship: `${fromName} -[${type}]-> ${toName}`,
+        };
       }
 
       case "find_duplicates": {

package/src/web/server.ts

@@ -6,18 +6,26 @@
 import http from "http";
 import fs from "fs";
 import path from "path";
+import os from "os";
 import { fileURLToPath } from "url";
 import { EngramDatabase } from "../storage/database.js";
 import { KnowledgeGraph } from "../graph/knowledge-graph.js";
 import { HybridSearch } from "../retrieval/hybrid.js";
 import { ChatHandler } from "./chat-handler.js";
 import { Consolidator } from "../consolidation/consolidator.js";
+import { loadSettings, saveSettings, hasAnthropicApiKey } from "../settings.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const STATIC_DIR = path.join(__dirname, "..", "..", "src", "web", "static");
 
+// Port file for discovery - allows finding the running web server
+const PORT_FILE = path.join(
+  process.env.ENGRAM_DB_PATH?.replace("~", os.homedir()) || path.join(os.homedir(), ".engram"),
+  "web-server.json"
+);
+
 const MIME_TYPES: Record<string, string> = {
   ".html": "text/html",
   ".css": "text/css",
@@ -27,6 +35,31 @@ const MIME_TYPES: Record<string, string> = {
   ".svg": "image/svg+xml",
 };
 
+/**
+ * Get the URL of a currently running Engram web server
+ * Returns null if no server is running
+ */
+export function getRunningServerUrl(): string | null {
+  try {
+    if (fs.existsSync(PORT_FILE)) {
+      const data = JSON.parse(fs.readFileSync(PORT_FILE, "utf-8"));
+      const { port, pid } = data;
+
+      // Check if process is still running
+      try {
+        process.kill(pid, 0); // Signal 0 = check if process exists
+        return `http://localhost:${port}`;
+      } catch {
+        // Process not running, clean up stale file
+        fs.unlinkSync(PORT_FILE);
+      }
+    }
+  } catch {
+    // File doesn't exist or can't be read
+  }
+  return null;
+}
+
 interface WebServerOptions {
   db: EngramDatabase;
   graph: KnowledgeGraph;
@@ -61,21 +94,92 @@ export class EngramWebServer {
       return `http://localhost:${this.port}`;
     }
 
+    // Check if another server is already running
+    const existingUrl = getRunningServerUrl();
+    if (existingUrl) {
+      console.error(`[Engram] Web interface already running at ${existingUrl}`);
+      return existingUrl;
+    }
+
     this.server = http.createServer((req, res) => this.handleRequest(req, res));
 
-    return new Promise((resolve, reject) => {
-      this.server!.listen(this.port, () => {
-        const url = `http://localhost:${this.port}`;
-        console.error(`[Engram] Web interface running at ${url}`);
-        resolve(url);
-      });
+    // Try to start on preferred port, auto-increment if taken
+    const maxAttempts = 10;
+    let currentPort = this.port;
 
-      this.server!.on("error", reject);
-    });
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        await new Promise<void>((resolve, reject) => {
+          this.server!.once("error", (err: NodeJS.ErrnoException) => {
+            if (err.code === "EADDRINUSE") {
+              currentPort++;
+              resolve(); // Try next port
+            } else {
+              reject(err);
+            }
+          });
+
+          this.server!.listen(currentPort, () => {
+            resolve();
+          });
+        });
+
+        // If we get here without error, server is listening
+        if (this.server!.listening) {
+          this.port = currentPort;
+          const url = `http://localhost:${this.port}`;
+
+          // Write port file for discovery
+          this.writePortFile();
+
+          console.error(`[Engram] Web interface running at ${url}`);
+          return url;
+        }
+      } catch (err) {
+        if (attempt === maxAttempts - 1) {
+          throw err;
+        }
+      }
+    }
+
+    throw new Error(`Could not find available port after ${maxAttempts} attempts`);
+  }
+
+  private writePortFile(): void {
+    try {
+      // Ensure directory exists
+      const dir = path.dirname(PORT_FILE);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      fs.writeFileSync(PORT_FILE, JSON.stringify({
+        port: this.port,
+        pid: process.pid,
+        started: new Date().toISOString(),
+      }));
+    } catch (err) {
+      console.error("[Engram] Failed to write port file:", err);
+    }
+  }
+
+  private removePortFile(): void {
+    try {
+      if (fs.existsSync(PORT_FILE)) {
+        const data = JSON.parse(fs.readFileSync(PORT_FILE, "utf-8"));
+        // Only remove if we wrote it
+        if (data.pid === process.pid) {
+          fs.unlinkSync(PORT_FILE);
+        }
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
   }
 
   stop(): void {
     if (this.server) {
+      this.removePortFile();
       this.server.close();
       this.server = null;
     }
@@ -134,6 +238,7 @@ export class EngramWebServer {
     if (pathname === "/api/memories" && method === "GET") {
       const query = url.searchParams.get("q");
       const limit = parseInt(url.searchParams.get("limit") || "50");
+      const offset = parseInt(url.searchParams.get("offset") || "0");
 
       if (query) {
         const results = await this.search.search(query, { limit });
@@ -145,7 +250,7 @@ export class EngramWebServer {
           })),
         }));
       } else {
-        const memories = this.db.getAllMemories(limit);
+        const memories = this.db.getAllMemories(limit, false, offset);
         res.end(JSON.stringify({ memories }));
       }
       return;
@@ -275,13 +380,58 @@ export class EngramWebServer {
       return;
     }
 
+    // ============ Settings Endpoints ============
+
+    // GET /api/settings - get current settings (without exposing full API key)
+    if (pathname === "/api/settings" && method === "GET") {
+      const settings = loadSettings();
+      res.end(JSON.stringify({
+        has_api_key: hasAnthropicApiKey(),
+        api_key_preview: settings.anthropic_api_key
+          ? `${settings.anthropic_api_key.slice(0, 12)}...${settings.anthropic_api_key.slice(-4)}`
+          : null,
+        api_key_source: settings.anthropic_api_key
+          ? "settings"
+          : process.env.ANTHROPIC_API_KEY
+            ? "environment"
+            : null,
+      }));
+      return;
+    }
+
+    // POST /api/settings - update settings
+    if (pathname === "/api/settings" && method === "POST") {
+      const { anthropic_api_key } = body as { anthropic_api_key?: string };
+
+      if (anthropic_api_key !== undefined) {
+        const settings = loadSettings();
+        if (anthropic_api_key === "") {
+          // Clear the API key
+          delete settings.anthropic_api_key;
+        } else {
+          settings.anthropic_api_key = anthropic_api_key;
+        }
+        saveSettings(settings);
+
+        // Refresh the chat client
+        this.chat.refreshClient();
+        this.consolidator = new Consolidator(this.db); // Reinit consolidator
+      }
+
+      res.end(JSON.stringify({
+        success: true,
+        configured: this.chat.isConfigured(),
+      }));
+      return;
+    }
+
     // GET /api/chat/status - check if chat is configured
     if (pathname === "/api/chat/status" && method === "GET") {
       res.end(JSON.stringify({
         configured: this.chat.isConfigured(),
         message: this.chat.isConfigured()
           ? "Chat is ready"
-          : "Set ANTHROPIC_API_KEY environment variable to enable chat",
+          : "Configure API key in Settings",
       }));
       return;
     }
@@ -307,6 +457,59 @@ export class EngramWebServer {
       return;
     }
 
+    // POST /api/chat/stream - streaming chat with SSE
+    if (pathname === "/api/chat/stream" && method === "POST") {
+      const { message } = body as { message: string };
+      if (!message) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Message is required" }));
+        return;
+      }
+
+      // Check if chat is busy
+      if (this.chat.isBusy()) {
+        res.writeHead(429, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          error: "Chat is busy",
+          queue_length: this.chat.getQueueLength(),
+        }));
+        return;
+      }
+
+      // Set up SSE headers
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+
+      // Stream events to client
+      try {
+        for await (const event of this.chat.chatStream(message)) {
+          const data = JSON.stringify(event);
+          res.write(`data: ${data}\n\n`);
+        }
+      } catch (error) {
+        const errorEvent = {
+          type: "error",
+          content: error instanceof Error ? error.message : String(error),
+        };
+        res.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
+      }
+
+      res.end();
+      return;
+    }
+
+    // GET /api/chat/queue - check queue status
+    if (pathname === "/api/chat/queue" && method === "GET") {
+      res.end(JSON.stringify({
+        busy: this.chat.isBusy(),
+        queue_length: this.chat.getQueueLength(),
+      }));
+      return;
+    }
+
     // ============ Consolidation Endpoints ============
 
     // GET /api/consolidation/status - get consolidation status