wave-agent-sdk 0.0.7 → 0.0.8

package/dist/services/jsonlHandler.js

@@ -0,0 +1,257 @@
+/**
+ * JSONL file operations service
+ * Handles reading and writing JSONL (JSON Lines) session files for improved performance
+ */
+import { appendFile, readFile, writeFile, stat, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { getLastLine, readFirstLine } from "../utils/fileUtils.js";
+/**
+ * JSONL handler class for message persistence operations
+ */
+export class JsonlHandler {
+    constructor() {
+        this.defaultWriteOptions = {
+            atomic: true,
+        };
+    }
+    /**
+     * Create a new session file with metadata header
+     */
+    async createSession(filePath, sessionId, workdir, sessionType = "main", parentSessionId, subagentType) {
+        const metadataLine = {
+            __meta__: true,
+            sessionId,
+            sessionType,
+            ...(parentSessionId && { parentSessionId }),
+            ...(subagentType && { subagentType }),
+            workdir,
+            startedAt: new Date().toISOString(),
+        };
+        // Ensure directory exists
+        await this.ensureDirectory(dirname(filePath));
+        // Write metadata line as first line
+        await writeFile(filePath, JSON.stringify(metadataLine) + "\n", "utf8");
+    }
+    /**
+     * Append a single message to JSONL file
+     */
+    async appendMessage(filePath, message) {
+        return this.appendMessages(filePath, [message]);
+    }
+    /**
+     * Append multiple messages to JSONL file
+     */
+    async appendMessages(filePath, messages) {
+        if (messages.length === 0) {
+            return;
+        }
+        // Convert to SessionMessage format with timestamps
+        const sessionMessages = messages.map((message) => ({
+            ...message,
+            timestamp: new Date().toISOString(),
+        }));
+        return this.append(filePath, sessionMessages);
+    }
+    /**
+     * Append messages to JSONL file
+     */
+    async append(filePath, messages, options) {
+        if (messages.length === 0) {
+            return;
+        }
+        const opts = { ...this.defaultWriteOptions, ...options };
+        // Validate messages (always enabled for data integrity)
+        this.validateMessages(messages);
+        // Ensure directory exists
+        await this.ensureDirectory(dirname(filePath));
+        // Convert messages to JSONL lines (always compact JSON)
+        const lines = messages.map((message) => {
+            const { timestamp: existingTimestamp, ...messageWithoutTimestamp } = message;
+            const messageWithTimestamp = {
+                timestamp: existingTimestamp || new Date().toISOString(),
+                ...messageWithoutTimestamp,
+            };
+            return JSON.stringify(messageWithTimestamp);
+        });
+        const content = lines.join("\n") + "\n";
+        if (opts.atomic) {
+            // Write to temp file first, then rename
+            const tempPath = `${filePath}.tmp`;
+            await writeFile(tempPath, content, "utf8");
+            // Atomic rename
+            const { rename } = await import("fs/promises");
+            await rename(tempPath, filePath);
+        }
+        else {
+            // Direct append
+            await appendFile(filePath, content, "utf8");
+        }
+    }
+    /**
+     * Read all messages from JSONL file
+     * Includes metadata handling for backward compatibility
+     */
+    async read(filePath) {
+        try {
+            const content = await readFile(filePath, "utf8");
+            const lines = content
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            if (lines.length === 0) {
+                return [];
+            }
+            const allMessages = [];
+            // Skip metadata line if present (first line with __meta__: true)
+            let startIndex = 0;
+            if (lines.length > 0) {
+                try {
+                    const firstLine = JSON.parse(lines[0]);
+                    if (firstLine.__meta__ === true) {
+                        startIndex = 1; // Skip metadata line
+                    }
+                }
+                catch (error) {
+                    // If first line is not valid JSON, throw error with line number
+                    if (lines[0].trim().length > 0) {
+                        // Only throw if line is not empty
+                        throw new Error(`Invalid JSON at line 1: ${error}`);
+                    }
+                }
+            }
+            // Parse all messages
+            for (let i = startIndex; i < lines.length; i++) {
+                const line = lines[i];
+                try {
+                    const message = JSON.parse(line);
+                    allMessages.push(message);
+                }
+                catch (error) {
+                    // Throw error for invalid JSON lines with line number
+                    throw new Error(`Invalid JSON at line ${i + 1}: ${error}`);
+                }
+            }
+            return allMessages;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw new Error(`Failed to read JSONL file "${filePath}": ${error}`);
+        }
+    }
+    /**
+     * Get the last message from JSONL file using efficient file reading
+     */
+    async getLastMessage(filePath) {
+        try {
+            // First check if file exists
+            try {
+                await stat(filePath);
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return null;
+                }
+                throw err;
+            }
+            // Use our elegant utility to get the last line
+            const lastLine = await getLastLine(filePath);
+            if (!lastLine) {
+                return null;
+            }
+            try {
+                const parsed = JSON.parse(lastLine);
+                // Skip metadata line
+                if (parsed.__meta__ === true) {
+                    // If the last line is metadata, the file only contains metadata
+                    return null;
+                }
+                // Found a valid message
+                return parsed;
+            }
+            catch (error) {
+                throw new Error(`Invalid JSON in last line of "${filePath}": ${error}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to get last message from "${filePath}": ${error}`);
+        }
+    }
+    /**
+     * Read session metadata from first line (streaming - only reads first line)
+     */
+    async readMetadata(filePath) {
+        try {
+            // First check if file exists
+            try {
+                await stat(filePath);
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return null;
+                }
+                throw err;
+            }
+            // Read the first line efficiently
+            const firstLine = await readFirstLine(filePath);
+            if (!firstLine) {
+                return null; // Empty file or first line
+            }
+            try {
+                const parsed = JSON.parse(firstLine);
+                if (parsed.__meta__ === true) {
+                    return parsed;
+                }
+                else {
+                    return null; // First line is not metadata
+                }
+            }
+            catch {
+                return null; // Invalid JSON on first line
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read metadata from "${filePath}": ${error}`);
+        }
+    }
+    /**
+     * Check if a session file has metadata (first line check only)
+     * Very efficient - only reads first line
+     */
+    async hasMetadata(filePath) {
+        const metadata = await this.readMetadata(filePath);
+        return metadata !== null;
+    }
+    /**
+     * Validate messages before writing
+     */
+    validateMessages(messages) {
+        for (let i = 0; i < messages.length; i++) {
+            const message = messages[i];
+            if (!message.role) {
+                throw new Error(`Message at index ${i} is missing required field: role`);
+            }
+            if (!message.blocks) {
+                throw new Error(`Message at index ${i} is missing required field: blocks`);
+            }
+            if (!Array.isArray(message.blocks)) {
+                throw new Error(`Message at index ${i} has invalid blocks field: must be an array`);
+            }
+        }
+    }
+    /**
+     * Ensure directory exists for the given file path
+     */
+    async ensureDirectory(dirPath) {
+        try {
+            await mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST") {
+                throw error;
+            }
+        }
+    }
+}

package/dist/services/memory.d.ts

@@ -1,3 +1,12 @@
+import { MemoryStoreService } from "./memoryStore.js";
+/**
+ * Initialize global memory store
+ */
+export declare const initializeMemoryStore: (memoryStore: MemoryStoreService) => void;
+/**
+ * Get current memory store instance
+ */
+export declare const getMemoryStore: () => MemoryStoreService | null;
 export declare const isMemoryMessage: (message: string) => boolean;
 export declare const addMemory: (message: string, workdir: string) => Promise<void>;
 export declare const ensureUserMemoryFile: () => Promise<void>;

package/dist/services/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/services/memory.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,OAEjD,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAoCd,CAAC;AAGF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,IAAI,CAyBzD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAsBjE,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,MAAM,CAQ3D,CAAC;AAGF,eAAO,MAAM,cAAc,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,MAAM,CAUpE,CAAC;AAGF,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,CAoBhB,CAAC"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/services/memory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,aAAa,kBAAkB,KAC9B,IAEF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,QAAO,kBAAkB,GAAG,IAEtD,CAAC;AAGF,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,OAEjD,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAqDd,CAAC;AAGF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,IAAI,CA4BzD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAsBjE,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAa,OAAO,CAAC,MAAM,CAa3D,CAAC;AAGF,eAAO,MAAM,cAAc,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,MAAM,CA4CpE,CAAC;AAGF,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,CAoBhB,CAAC"}

package/dist/services/memory.js

@@ -1,6 +1,21 @@
 import { promises as fs } from "fs";
 import path from "path";
 import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
+import { logger } from "../utils/globalLogger.js";
+// Global memory store instance for project memory files
+let globalMemoryStore = null;
+/**
+ * Initialize global memory store
+ */
+export const initializeMemoryStore = (memoryStore) => {
+    globalMemoryStore = memoryStore;
+};
+/**
+ * Get current memory store instance
+ */
+export const getMemoryStore = () => {
+    return globalMemoryStore;
+};
 // Project memory related methods
 export const isMemoryMessage = (message) => {
     return message.trim().startsWith("#");
@@ -21,6 +36,9 @@ export const addMemory = async (message, workdir) => {
         catch (error) {
             // File does not exist, create new file
             if (error.code === "ENOENT") {
+                logger.info("Memory file does not exist, will create new one", {
+                    memoryFilePath,
+                });
                 existingContent =
                     "# Memory\n\nThis is the AI assistant's memory file, recording important information and context.\n\n";
             }
@@ -32,10 +50,22 @@ export const addMemory = async (message, workdir) => {
         const updatedContent = existingContent + memoryEntry;
         // Write file
         await fs.writeFile(memoryFilePath, updatedContent, "utf-8");
-        // logger.debug(`Memory added to ${memoryFilePath}:`, message);
+        // Update memory store if available
+        if (globalMemoryStore) {
+            try {
+                await globalMemoryStore.updateContent(memoryFilePath);
+            }
+            catch (error) {
+                logger.warn(`Failed to update memory store for ${memoryFilePath}:`, error);
+            }
+        }
+        else {
+            logger.debug("No global memory store available, skipping store update");
+        }
+        logger.debug(`Memory added to ${memoryFilePath}:`, message);
     }
     catch (error) {
-        // logger.error("Failed to add memory:", error);
+        logger.error("Failed to add memory:", error);
         throw new Error(`Failed to add memory: ${error.message}`);
     }
 };
@@ -51,9 +81,12 @@ export const ensureUserMemoryFile = async () => {
         catch (error) {
             // File does not exist, create new file
             if (error.code === "ENOENT") {
+                logger.info("Creating new user memory file", {
+                    userMemoryFile: USER_MEMORY_FILE,
+                });
                 const initialContent = "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
                 await fs.writeFile(USER_MEMORY_FILE, initialContent, "utf-8");
-                // logger.debug(`Created user memory file: ${USER_MEMORY_FILE}`);
+                logger.debug(`Created user memory file: ${USER_MEMORY_FILE}`);
             }
             else {
                 throw error;
@@ -61,7 +94,7 @@ export const ensureUserMemoryFile = async () => {
         }
     }
     catch (error) {
-        // logger.error("Failed to ensure user memory file:", error);
+        logger.error("Failed to ensure user memory file:", error);
         throw new Error(`Failed to ensure user memory file: ${error.message}`);
     }
 };
@@ -77,33 +110,69 @@ export const addUserMemory = async (message) => {
         const updatedContent = existingContent + memoryEntry;
         // Write file
         await fs.writeFile(USER_MEMORY_FILE, updatedContent, "utf-8");
-        // logger.debug(`User memory added to ${USER_MEMORY_FILE}:`, message);
+        logger.debug(`User memory added to ${USER_MEMORY_FILE}:`, message);
     }
     catch (error) {
-        // logger.error("Failed to add user memory:", error);
+        logger.error("Failed to add user memory:", error);
         throw new Error(`Failed to add user memory: ${error.message}`);
     }
 };
 export const getUserMemoryContent = async () => {
     try {
         await ensureUserMemoryFile();
-        return await fs.readFile(USER_MEMORY_FILE, "utf-8");
+        const content = await fs.readFile(USER_MEMORY_FILE, "utf-8");
+        logger.debug("User memory content read successfully", {
+            userMemoryFile: USER_MEMORY_FILE,
+            contentLength: content.length,
+        });
+        return content;
     }
-    catch {
-        // logger.error("Failed to read user memory:", error);
+    catch (error) {
+        logger.error("Failed to read user memory:", error);
         return "";
     }
 };
-// Read project memory file content
+// Read project memory file content with memory store optimization
 export const readMemoryFile = async (workdir) => {
+    const memoryFilePath = path.join(workdir, "AGENTS.md");
+    // Use memory store if available for optimized access
+    if (globalMemoryStore) {
+        logger.debug("Using memory store for optimized access", { memoryFilePath });
+        try {
+            const content = await globalMemoryStore.getContent(memoryFilePath);
+            logger.debug("Memory content retrieved from store successfully", {
+                memoryFilePath,
+                contentLength: content.length,
+            });
+            return content;
+        }
+        catch (error) {
+            // Fallback to direct file access on memory store error
+            logger.warn(`Memory store access failed for ${memoryFilePath}, falling back to file system:`, error);
+        }
+    }
+    else {
+        logger.debug("No memory store available, using direct file access", {
+            memoryFilePath,
+        });
+    }
+    // Fallback to direct file access (original behavior)
     try {
-        const memoryFilePath = path.join(workdir, "AGENTS.md");
-        return await fs.readFile(memoryFilePath, "utf-8");
+        const content = await fs.readFile(memoryFilePath, "utf-8");
+        logger.debug("Memory file read successfully via direct file access", {
+            memoryFilePath,
+            contentLength: content.length,
+        });
+        return content;
     }
     catch (error) {
         if (error.code === "ENOENT") {
+            logger.debug("Memory file does not exist, returning empty content", {
+                memoryFilePath,
+            });
             return "";
         }
+        logger.error("Failed to read memory file", { memoryFilePath, error });
         throw error;
     }
 };

package/dist/services/memoryStore.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Memory Store Service
+ *
+ * Provides in-memory storage for file content with automatic updates.
+ * Optimizes performance by keeping frequently accessed files in memory.
+ */
+import { EventEmitter } from "events";
+import type { Logger } from "../types/index.js";
+export interface MemoryStoreEntry {
+    content: string;
+    path: string;
+    lastModified: number;
+    isLoaded: boolean;
+}
+export interface MemoryStoreStats {
+    contentSize: number;
+    lastUpdated: number;
+    updateCount: number;
+    isLoaded: boolean;
+}
+export interface MemoryUpdateEvent {
+    path: string;
+    reason: "file_change" | "initial_load" | "manual_reload";
+    timestamp: number;
+    previousSize?: number;
+    newSize: number;
+}
+export declare class MemoryStoreService extends EventEmitter {
+    private store;
+    private updateCounts;
+    private logger?;
+    constructor(logger?: Logger);
+    /**
+     * Get content from memory store (loads from file if not loaded)
+     * Maps to FR-006: Keep AGENTS.md content in memory to avoid repeated reads
+     */
+    getContent(path: string): Promise<string>;
+    /**
+     * Update memory content from file
+     * Maps to FR-007: Update memory content when file changes
+     */
+    updateContent(path: string): Promise<void>;
+    /**
+     * Get memory store statistics
+     * For monitoring and debugging
+     */
+    getStats(path?: string): MemoryStoreStats;
+    /**
+     * Check if content is loaded in memory
+     * For status checking
+     */
+    isLoaded(path: string): boolean;
+    /**
+     * Manually reload content from file
+     * For force refresh scenarios
+     */
+    reloadContent(path: string): Promise<void>;
+    /**
+     * Remove content from memory store
+     * For cleanup when file is deleted
+     */
+    removeContent(path: string): boolean;
+    /**
+     * Clear all content from memory store
+     * For cleanup and testing
+     */
+    clear(): void;
+    /**
+     * Get all stored paths
+     * For monitoring and debugging
+     */
+    getStoredPaths(): string[];
+    /**
+     * Check if file exists and is accessible
+     */
+    fileExists(path: string): Promise<boolean>;
+    private loadFromFile;
+    private incrementUpdateCount;
+    private emitUpdateEvent;
+}
+//# sourceMappingURL=memoryStore.d.ts.map

package/dist/services/memoryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryStore.d.ts","sourceRoot":"","sources":["../../src/services/memoryStore.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,aAAa,GAAG,cAAc,GAAG,eAAe,CAAC;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,MAAM,CAAC,EAAE,MAAM;IAK3B;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAY/C;;;OAGG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOhD;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB;IAkCzC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAK/B;;;OAGG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOhD;;;OAGG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAWpC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAYb;;;OAGG;IACH,cAAc,IAAI,MAAM,EAAE;IAI1B;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;YASlC,YAAY;IA2E1B,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,eAAe;CAmBxB"}