wave-agent-sdk 1.0.5 → 1.0.6

package/src/services/jsonlHandler.ts

@@ -1,295 +0,0 @@
-/**
- * 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 } from "../utils/fileUtils.js";
-
-import type { Message } from "../types/index.js";
-import type { SessionFilename } from "../types/session.js";
-
-/**
- * JSONL write options
- */
-export interface JsonlWriteOptions {
-  // Safety options
-  atomic?: boolean; // Default: true (write to temp file first)
-}
-
-/**
- * JSONL handler class for message persistence operations
- */
-export class JsonlHandler {
-  private readonly defaultWriteOptions: Required<JsonlWriteOptions>;
-
-  constructor() {
-    this.defaultWriteOptions = {
-      atomic: true,
-    };
-  }
-
-  /**
-   * Create a new session file (simplified - no metadata header)
-   */
-  async createSession(filePath: string): Promise<void> {
-    // Ensure directory exists
-    await this.ensureDirectory(dirname(filePath));
-
-    // Create empty file (no metadata line needed)
-    await writeFile(filePath, "", "utf8");
-  }
-
-  /**
-   * Append a single message to JSONL file
-   */
-  async appendMessage(filePath: string, message: Message): Promise<void> {
-    return this.appendMessages(filePath, [message]);
-  }
-
-  /**
-   * Append multiple messages to JSONL file
-   */
-  async appendMessages(filePath: string, messages: Message[]): Promise<void> {
-    if (messages.length === 0) {
-      return;
-    }
-
-    return this.append(filePath, messages);
-  }
-
-  /**
-   * Append messages to JSONL file
-   */
-  async append(
-    filePath: string,
-    messages: Message[],
-    options?: JsonlWriteOptions,
-  ): Promise<void> {
-    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 (compact JSON, timestamp first)
-    const lines = messages.map((message) => {
-      const { timestamp, ...rest } = message;
-      return JSON.stringify({ timestamp, ...rest });
-    });
-
-    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 (simplified - no metadata handling)
-   */
-  async read(filePath: string): Promise<Message[]> {
-    try {
-      const content = await readFile(filePath, "utf8");
-      const lines = content
-        .split(/\r?\n/)
-        .map((line: string) => line.trim())
-        .filter((line: string) => line.length > 0);
-
-      if (lines.length === 0) {
-        return [];
-      }
-
-      const allMessages: Message[] = [];
-
-      // Parse all messages (no metadata line to skip)
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-
-        try {
-          const message = JSON.parse(line) as Message;
-          if (message.timestamp) 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 as NodeJS.ErrnoException).code === "ENOENT") {
-        return [];
-      }
-      throw new Error(`Failed to read JSONL file "${filePath}": ${error}`);
-    }
-  }
-
-  /**
-   * Get the last message from JSONL file using efficient file reading (simplified)
-   */
-  async getLastMessage(filePath: string): Promise<Message | null> {
-    try {
-      // First check if file exists
-      try {
-        await stat(filePath);
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).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);
-        return parsed as Message;
-      } 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}`,
-      );
-    }
-  }
-
-  /**
-   * Validate messages before writing
-   */
-  private validateMessages(messages: Message[]): void {
-    for (let i = 0; i < messages.length; i++) {
-      const message = messages[i];
-
-      if (!message.id) {
-        throw new Error(`Message at index ${i} is missing required field: id`);
-      }
-
-      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
-   */
-  private async ensureDirectory(dirPath: string): Promise<void> {
-    try {
-      await mkdir(dirPath, { recursive: true });
-    } catch (error) {
-      const err = error as NodeJS.ErrnoException;
-      if (err.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * Parse session metadata from filename
-   * @param filePath - Path to the session file
-   * @returns Parsed session filename metadata
-   */
-  parseSessionFilename(filePath: string): SessionFilename {
-    // Extract filename from path
-    const filename = filePath.split("/").pop() || "";
-
-    // Check if it's a subagent session
-    const subagentMatch = filename.match(
-      /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-    );
-    if (subagentMatch) {
-      return {
-        sessionId: subagentMatch[1],
-        sessionType: "subagent",
-      };
-    }
-
-    // Check if it's a main session
-    const mainMatch = filename.match(
-      /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-    );
-    if (mainMatch) {
-      return {
-        sessionId: mainMatch[1],
-        sessionType: "main",
-      };
-    }
-
-    throw new Error(`Invalid session filename format: ${filename}`);
-  }
-
-  /**
-   * Validate filename format
-   * @param filename - Filename to validate
-   * @returns True if valid, false otherwise
-   */
-  isValidSessionFilename(filename: string): boolean {
-    // UUID validation patterns
-    const uuidPattern =
-      /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
-    const subagentPattern =
-      /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
-
-    return uuidPattern.test(filename) || subagentPattern.test(filename);
-  }
-
-  /**
-   * Generate simple filename for sessions
-   * @param sessionId - UUID session identifier
-   * @param sessionType - Type of session ("main" or "subagent")
-   * @returns Generated filename
-   */
-  generateSessionFilename(
-    sessionId: string,
-    sessionType: "main" | "subagent",
-  ): string {
-    // Validate sessionId is a valid UUID
-    const uuidPattern =
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-    if (!uuidPattern.test(sessionId)) {
-      throw new Error(`Invalid session ID format: ${sessionId}`);
-    }
-
-    if (sessionType === "subagent") {
-      return `subagent-${sessionId}.jsonl`;
-    } else {
-      return `${sessionId}.jsonl`;
-    }
-  }
-}

package/src/services/memory.ts

@@ -1,234 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { homedir } from "node:os";
-import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
-import { logger } from "../utils/globalLogger.js";
-import { Container } from "../utils/container.js";
-import { getGitCommonDir } from "../utils/gitUtils.js";
-import { pathEncoder } from "../utils/pathEncoder.js";
-
-export class MemoryService {
-  private _cachedProjectMemory: string | null = null;
-  private _cachedUserMemory: string | null = null;
-  private _cachedCombinedMemory: string | null = null;
-  private _cachedAutoMemoryContent: string | null = null;
-
-  constructor(private container: Container) {}
-
-  public get cachedProjectMemory(): string {
-    return this._cachedProjectMemory ?? "";
-  }
-
-  public get cachedUserMemory(): string {
-    return this._cachedUserMemory ?? "";
-  }
-
-  public clearCache(): void {
-    this._cachedProjectMemory = null;
-    this._cachedUserMemory = null;
-    this._cachedCombinedMemory = null;
-    this._cachedAutoMemoryContent = null;
-  }
-
-  /**
-   * Get the project-specific auto-memory directory.
-   * Uses the git common directory to ensure worktrees share the same memory.
-   */
-  getAutoMemoryDirectory(workdir: string): string {
-    const commonDir = getGitCommonDir(workdir);
-    // If the common directory is a .git directory, use its parent as the project root
-    // for a cleaner encoded name while maintaining stability across worktrees.
-    const projectRoot =
-      path.basename(commonDir) === ".git" ? path.dirname(commonDir) : commonDir;
-    const encodedName = pathEncoder.encodeSync(projectRoot);
-    return path.join(homedir(), ".wave", "projects", encodedName, "memory");
-  }
-
-  /**
-   * Ensure the auto-memory directory and initial MEMORY.md exist.
-   */
-  async ensureAutoMemoryDirectory(workdir: string): Promise<void> {
-    const memoryDir = this.getAutoMemoryDirectory(workdir);
-    const memoryFile = path.join(memoryDir, "MEMORY.md");
-
-    try {
-      await fs.mkdir(memoryDir, { recursive: true });
-
-      try {
-        await fs.access(memoryFile);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-          const initialContent =
-            "# Project Memory\n\nThis file serves as an index for the project's auto-memory. Wave uses this to track knowledge across sessions.\n\n";
-          await fs.writeFile(memoryFile, initialContent, "utf-8");
-          logger.debug(`Created auto-memory file: ${memoryFile}`);
-        } else {
-          throw error;
-        }
-      }
-    } catch (error) {
-      logger.error("Failed to ensure auto-memory directory:", error);
-      throw new Error(
-        `Failed to ensure auto-memory directory: ${(error as Error).message}`,
-      );
-    }
-  }
-
-  /**
-   * Get the first 200 lines of MEMORY.md.
-   */
-  async getAutoMemoryContent(workdir: string): Promise<string> {
-    if (this._cachedAutoMemoryContent !== null) {
-      return this._cachedAutoMemoryContent;
-    }
-    const memoryDir = this.getAutoMemoryDirectory(workdir);
-    const memoryFile = path.join(memoryDir, "MEMORY.md");
-
-    try {
-      const content = await fs.readFile(memoryFile, "utf-8");
-      const lines = content.split("\n").slice(0, 200);
-      this._cachedAutoMemoryContent = lines.join("\n");
-      return this._cachedAutoMemoryContent;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        this._cachedAutoMemoryContent = "";
-        return "";
-      }
-      logger.error("Failed to read auto-memory content:", error);
-      return "";
-    }
-  }
-
-  async ensureUserMemoryFile(): Promise<void> {
-    try {
-      // Ensure data directory exists
-      await fs.mkdir(DATA_DIRECTORY, { recursive: true });
-
-      // Check if user memory file exists
-      try {
-        await fs.access(USER_MEMORY_FILE);
-      } catch (error) {
-        // File does not exist, create new file
-        if ((error as NodeJS.ErrnoException).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}`);
-        } else {
-          throw error;
-        }
-      }
-    } catch (error) {
-      logger.error("Failed to ensure user memory file:", error);
-      throw new Error(
-        `Failed to ensure user memory file: ${(error as Error).message}`,
-      );
-    }
-  }
-
-  async getUserMemoryContent(): Promise<string> {
-    if (this._cachedUserMemory !== null) {
-      return this._cachedUserMemory;
-    }
-    try {
-      await this.ensureUserMemoryFile();
-      const content = await fs.readFile(USER_MEMORY_FILE, "utf-8");
-      logger.debug("User memory content read successfully", {
-        userMemoryFile: USER_MEMORY_FILE,
-        contentLength: content.length,
-      });
-
-      // If the file is still the default empty template, fallback to ~/.claude/AGENTS.md
-      const defaultTemplate =
-        "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
-      if (content === defaultTemplate) {
-        const claudeMemoryPath = path.join(homedir(), ".claude", "AGENTS.md");
-        try {
-          const claudeContent = await fs.readFile(claudeMemoryPath, "utf-8");
-          logger.debug(
-            "User memory content read from ~/.claude/AGENTS.md fallback",
-            {
-              claudeMemoryPath,
-              contentLength: claudeContent.length,
-            },
-          );
-          this._cachedUserMemory = claudeContent;
-          return this._cachedUserMemory;
-        } catch {
-          // CLAUDE.md doesn't exist or can't be read, return the default template
-        }
-      }
-
-      this._cachedUserMemory = content;
-      return this._cachedUserMemory;
-    } catch (error) {
-      logger.error("Failed to read user memory:", error);
-      return "";
-    }
-  }
-
-  async readMemoryFile(workdir: string): Promise<string> {
-    if (this._cachedProjectMemory !== null) {
-      return this._cachedProjectMemory;
-    }
-    const memoryFilePath = path.join(workdir, "AGENTS.md");
-    try {
-      const content = await fs.readFile(memoryFilePath, "utf-8");
-      logger.debug("Memory file read successfully via direct file access", {
-        memoryFilePath,
-        contentLength: content.length,
-      });
-      this._cachedProjectMemory = content;
-      return this._cachedProjectMemory;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        // Fallback to CLAUDE.md
-        const claudeMemoryPath = path.join(workdir, "CLAUDE.md");
-        try {
-          const content = await fs.readFile(claudeMemoryPath, "utf-8");
-          logger.debug("Memory file read from CLAUDE.md fallback", {
-            memoryFilePath: claudeMemoryPath,
-            contentLength: content.length,
-          });
-          this._cachedProjectMemory = content;
-          return this._cachedProjectMemory;
-        } catch (claudeError) {
-          if ((claudeError as NodeJS.ErrnoException).code === "ENOENT") {
-            logger.debug("Neither AGENTS.md nor CLAUDE.md found", {
-              memoryFilePath,
-            });
-            this._cachedProjectMemory = "";
-            return "";
-          }
-          logger.error("Failed to read CLAUDE.md fallback", {
-            memoryFilePath: claudeMemoryPath,
-            error: claudeError,
-          });
-          return "";
-        }
-      }
-      logger.error("Failed to read memory file", { memoryFilePath, error });
-      return "";
-    }
-  }
-
-  async getCombinedMemoryContent(workdir: string): Promise<string> {
-    if (this._cachedCombinedMemory !== null) {
-      return this._cachedCombinedMemory;
-    }
-    const projectMemory = await this.readMemoryFile(workdir);
-    const userMemory = await this.getUserMemoryContent();
-
-    let combined = "";
-    if (projectMemory.trim()) combined += projectMemory;
-    if (userMemory.trim()) {
-      if (combined) combined += "\n\n";
-      combined += userMemory;
-    }
-    this._cachedCombinedMemory = combined;
-    return combined;
-  }
-}