@ebowwa/glm-daemon 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Autonomous GLM 4.7 daemon with hooks, tools, teammates, and communication channels (Telegram, Discord)",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,11 +57,11 @@
     "status": "bun run dist/bin/manager.js status"
   },
   "dependencies": {
-    "@ebowwa/ai": "^0.1.0",
+    "@ebowwa/ai": "^0.1.2",
     "@ebowwa/channel-types": "^0.1.1",
-    "@ebowwa/codespaces-types": "^1.3.0",
-    "@ebowwa/structured-prompts": "^0.2.9",
-    "@ebowwa/teammates": "^0.1.0",
+    "@ebowwa/codespaces-types": "^1.4.0",
+    "@ebowwa/structured-prompts": "^0.3.2",
+    "@ebowwa/teammates": "^0.1.2",
     "discord.js": "^14.16.3",
     "node-telegram-bot-api": "^0.66.0",
     "zod": "^4.3.5"

package/src/memory.ts

@@ -3,9 +3,18 @@
  *
  * Tracks chat history per user/conversation with persistence.
  * Can be used by Telegram, Discord, or any other channel.
+ *
+ * Storage format: JSONL (JSON Lines)
+ * Each line is a JSON object: {"id": "...", "messages": [...], "lastUpdated": timestamp}
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+} from "fs";
 import { dirname } from "path";
 
 /**
@@ -17,21 +26,35 @@ export interface ConversationMessage {
   timestamp?: number;
 }
 
+/**
+ * Internal storage format for JSONL
+ */
+interface ConversationEntry {
+  id: string;
+  messages: ConversationMessage[];
+  lastUpdated: number;
+}
+
 /**
  * Configuration for ConversationMemory
  */
 export interface ConversationMemoryConfig {
-  /** Path to persistence file (default: ./conversations.json) */
+  /** Path to persistence file (default: ./conversations.jsonl) */
   file?: string;
   /** Maximum messages to keep per conversation (default: 10) */
   maxMessages?: number;
   /** Include timestamps in messages (default: true) */
   includeTimestamps?: boolean;
+  /** Auto-migrate old .json files to .jsonl (default: true) */
+  autoMigrate?: boolean;
 }
 
 /**
  * Generic conversation memory that tracks chat history per conversation ID.
  *
+ * Uses JSONL format for efficient append-only writes and streaming reads.
+ * Automatically migrates from old JSON format on first load.
+ *
  * The ID type is generic (string | number) to support different channel types:
  * - Telegram: number (chatId)
  * - Discord: string (channelId/userId)
@@ -50,28 +73,85 @@ export class ConversationMemory<IdType = string | number> {
   private maxMessages: number;
   private includeTimestamps: boolean;
   private file: string;
+  private needsFullSave = false;
 
   constructor(config: ConversationMemoryConfig = {}) {
-    this.file = config.file || "./conversations.json";
+    // Default to .jsonl extension
+    const defaultFile = "./conversations.jsonl";
+    this.file = config.file || defaultFile;
+
+    // Auto-migrate from .json to .jsonl if needed
+    if (config.autoMigrate !== false && !existsSync(this.file)) {
+      this.migrateFromJson(this.file);
+    }
+
     this.maxMessages = config.maxMessages ?? 10;
     this.includeTimestamps = config.includeTimestamps ?? true;
     this.load();
   }
 
   /**
-   * Load conversations from disk
+   * Migrate from old JSON format to JSONL
+   */
+  private migrateFromJson(jsonlFile: string): void {
+    // Check for old .json file
+    const jsonFile = jsonlFile.replace(/\.jsonl$/, ".json");
+    if (!existsSync(jsonFile)) return;
+
+    try {
+      const data = JSON.parse(readFileSync(jsonFile, "utf-8"));
+      const entries: ConversationEntry[] = [];
+
+      for (const [id, messages] of Object.entries(data)) {
+        entries.push({
+          id,
+          messages: messages as ConversationMessage[],
+          lastUpdated: Date.now(),
+        });
+      }
+
+      // Write as JSONL
+      const dir = dirname(jsonlFile);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const lines = entries.map((e) => JSON.stringify(e)).join("\n");
+      writeFileSync(jsonlFile, lines + (lines ? "\n" : ""));
+
+      // Backup old file instead of deleting
+      const backupFile = jsonFile + ".backup";
+      renameSync(jsonFile, backupFile);
+
+      console.log(`Migrated ${jsonFile} to ${jsonlFile} (${entries.length} conversations)`);
+    } catch (error) {
+      console.error(`Migration failed: ${error}`);
+    }
+  }
+
+  /**
+   * Load conversations from JSONL file
+   * Uses synchronous read for constructor compatibility
    */
   private load(): void {
     if (!existsSync(this.file)) return;
+
     try {
-      const data = JSON.parse(readFileSync(this.file, "utf-8"));
-      for (const [id, messages] of Object.entries(data)) {
-        // Convert string keys back to original type
-        const key = this.parseKey(id);
-        this.conversations.set(key, messages as ConversationMessage[]);
+      const content = readFileSync(this.file, "utf-8");
+      const lines = content.split("\n");
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry: ConversationEntry = JSON.parse(line);
+          const key = this.parseKey(entry.id);
+          this.conversations.set(key, entry.messages);
+        } catch {
+          // Skip malformed lines
+        }
       }
     } catch {
-      // Ignore parse errors - start fresh
+      // Start fresh on error
     }
   }
 
@@ -87,20 +167,69 @@ export class ConversationMemory<IdType = string | number> {
   }
 
   /**
-   * Save conversations to disk
+   * Convert IdType to string for storage
    */
-  private save(): void {
+  private stringifyKey(id: IdType): string {
+    return String(id);
+  }
+
+  /**
+   * Save all conversations to disk (full rewrite)
+   * Used when entries are deleted or modified
+   */
+  private saveFull(): void {
     try {
-      // Ensure directory exists
       const dir = dirname(this.file);
       if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
       }
 
-      const data = Object.fromEntries(this.conversations);
-      writeFileSync(this.file, JSON.stringify(data, null, 2));
-    } catch {
-      // Ignore save errors
+      const lines: string[] = [];
+      for (const [id, messages] of this.conversations) {
+        const entry: ConversationEntry = {
+          id: this.stringifyKey(id),
+          messages,
+          lastUpdated: Date.now(),
+        };
+        lines.push(JSON.stringify(entry));
+      }
+
+      writeFileSync(this.file, lines.join("\n") + (lines.length ? "\n" : ""));
+      this.needsFullSave = false;
+    } catch (error) {
+      console.error(`Save failed: ${error}`);
+    }
+  }
+
+  /**
+   * Append a single entry to the file (efficient for adds)
+   */
+  private appendEntry(conversationId: IdType, messages: ConversationMessage[]): void {
+    try {
+      const dir = dirname(this.file);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      const entry: ConversationEntry = {
+        id: this.stringifyKey(conversationId),
+        messages,
+        lastUpdated: Date.now(),
+      };
+
+      // Check if file exists and has content to determine if we need newline
+      const hasContent = existsSync(this.file) && readFileSync(this.file, "utf-8").length > 0;
+      const prefix = hasContent ? "" : "";
+      const line = JSON.stringify(entry) + "\n";
+
+      // We need to do a full save to replace the old entry for this conversation
+      // JSONL doesn't support in-place updates, so we mark for full save
+      this.needsFullSave = true;
+
+      // For now, do a full save since we need to replace the entry
+      this.saveFull();
+    } catch (error) {
+      console.error(`Append failed: ${error}`);
     }
   }
 
@@ -130,7 +259,8 @@ export class ConversationMemory<IdType = string | number> {
       history.splice(0, history.length - this.maxMessages);
     }
 
-    this.save();
+    // Save the updated conversation
+    this.appendEntry(conversationId, history);
   }
 
   /**
@@ -152,7 +282,7 @@ export class ConversationMemory<IdType = string | number> {
    */
   clear(conversationId: IdType): void {
     this.conversations.delete(conversationId);
-    this.save();
+    this.saveFull();
   }
 
   /**
@@ -160,7 +290,7 @@ export class ConversationMemory<IdType = string | number> {
    */
   clearAll(): void {
     this.conversations.clear();
-    this.save();
+    this.saveFull();
   }
 
   /**
@@ -195,6 +325,29 @@ export class ConversationMemory<IdType = string | number> {
       content,
     }));
   }
+
+  /**
+   * Force a full save (useful before shutdown)
+   */
+  flush(): void {
+    if (this.needsFullSave || this.conversations.size > 0) {
+      this.saveFull();
+    }
+  }
+
+  /**
+   * Get the file path being used
+   */
+  getFilePath(): string {
+    return this.file;
+  }
+
+  /**
+   * Check if the storage uses JSONL format
+   */
+  isJsonl(): boolean {
+    return this.file.endsWith(".jsonl");
+  }
 }
 
 /**