wave-agent-sdk 0.0.6 → 0.0.8

package/src/managers/messageManager.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from "crypto";
 import {
   addAssistantMessageToMessages,
   updateToolBlockInMessage,
@@ -13,20 +12,26 @@ import {
   addSubagentBlockToMessage,
   updateSubagentBlockInMessage,
   removeLastUserMessage,
+  UserMessageParams,
   type AddSubagentBlockParams,
   type UpdateSubagentBlockParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type { Logger, Message, Usage } from "../types/index.js";
+import { join } from "path";
 import {
-  cleanupExpiredSessions,
-  getLatestSession,
-  loadSession,
-  saveSession,
+  cleanupExpiredSessionsFromJsonl,
+  getLatestSessionFromJsonl,
+  loadSessionFromJsonl,
+  appendMessages,
+  createSession,
+  generateSessionId,
   SessionData,
-  getSessionFilePath,
+  SESSION_DIR,
 } from "../services/session.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
+import { pathEncoder } from "../utils/pathEncoder.js";
 
 export interface MessageManagerCallbacks {
   onMessagesChange?: (messages: Message[]) => void;
@@ -35,14 +40,11 @@ export interface MessageManagerCallbacks {
   onUserInputHistoryChange?: (history: string[]) => void;
   onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
-  onUserMessageAdded?: (
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ) => void;
-  onAssistantMessageAdded?: (
-    content?: string,
-    toolCalls?: ChatCompletionMessageFunctionToolCall[],
-  ) => void;
+  onUserMessageAdded?: (params: UserMessageParams) => void;
+  // MODIFIED: Remove arguments for separation of concerns
+  onAssistantMessageAdded?: () => void;
+  // NEW: Streaming content callback - FR-001: receives chunk and accumulated content
+  onAssistantContentUpdated?: (chunk: string, accumulated: string) => void;
   onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
   onDiffBlockAdded?: (filePath: string, diffResult: string) => void;
   onErrorBlockAdded?: (error: string) => void;
@@ -54,12 +56,6 @@ export interface MessageManagerCallbacks {
     type: "project" | "user",
     storagePath: string,
   ) => void;
-  // Custom command callback
-  onCustomCommandAdded?: (
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ) => void;
   // Bash command callback
   onAddCommandOutputMessage?: (command: string) => void;
   onUpdateCommandOutputMessage?: (command: string, output: string) => void;
@@ -75,7 +71,6 @@ export interface MessageManagerCallbacks {
   ) => void;
   onSubAgentBlockUpdated?: (
     subagentId: string,
-    messages: Message[],
     status: "active" | "completed" | "error" | "aborted",
   ) => void;
 }
@@ -84,13 +79,9 @@ export interface MessageManagerOptions {
   callbacks: MessageManagerCallbacks;
   workdir: string;
   logger?: Logger;
-
-  // New: Optional session directory override
-  /**
-   * Custom session directory path
-   * @default join(homedir(), ".wave", "sessions")
-   */
-  sessionDir?: string;
+  sessionType?: "main" | "subagent";
+  parentSessionId?: string;
+  subagentType?: string;
 }
 
 export class MessageManager {
@@ -101,20 +92,32 @@ export class MessageManager {
   private userInputHistory: string[];
   private sessionStartTime: string;
   private workdir: string;
+  private encodedWorkdir: string; // Cached encoded workdir
   private logger?: Logger; // Add optional logger property
   private callbacks: MessageManagerCallbacks;
-  private sessionDir?: string; // Add session directory property
+  private transcriptPath: string; // Cached transcript path
+  private savedMessageCount: number; // Track how many messages have been saved to prevent duplication
+  private sessionType: "main" | "subagent";
+  private parentSessionId?: string;
+  private subagentType?: string;
 
   constructor(options: MessageManagerOptions) {
-    this.sessionId = randomUUID();
+    this.sessionId = generateSessionId();
     this.messages = [];
     this.latestTotalTokens = 0;
     this.userInputHistory = [];
     this.sessionStartTime = new Date().toISOString();
     this.workdir = options.workdir;
+    this.encodedWorkdir = pathEncoder.encodeSync(this.workdir); // Cache encoded workdir
     this.callbacks = options.callbacks;
     this.logger = options.logger;
-    this.sessionDir = options.sessionDir;
+    this.savedMessageCount = 0; // Initialize saved message count tracker
+    this.sessionType = options.sessionType || "main";
+    this.parentSessionId = options.parentSessionId;
+    this.subagentType = options.subagentType;
+
+    // Compute and cache the transcript path
+    this.transcriptPath = this.computeTranscriptPath();
   }
 
   // Getter methods
@@ -134,18 +137,63 @@ export class MessageManager {
     return [...this.userInputHistory];
   }
 
+  public getSessionStartTime(): string {
+    return this.sessionStartTime;
+  }
+
+  public getWorkdir(): string {
+    return this.workdir;
+  }
+
+  public getSessionDir(): string {
+    return SESSION_DIR;
+  }
+
   public getTranscriptPath(): string {
-    return getSessionFilePath(this.sessionId, this.sessionDir);
+    return this.transcriptPath;
+  }
+
+  /**
+   * Compute the transcript path using cached encoded workdir
+   * Called during construction and when sessionId changes
+   */
+  private computeTranscriptPath(): string {
+    const baseDir = join(SESSION_DIR, this.encodedWorkdir);
+
+    // All sessions now go in the same directory
+    // Session type is determined by metadata, not file path
+    return join(baseDir, `${this.sessionId}.jsonl`);
   }
 
   // Setter methods, will trigger callbacks
   public setSessionId(sessionId: string): void {
     if (this.sessionId !== sessionId) {
       this.sessionId = sessionId;
+      // Reset saved message count for new session
+      this.savedMessageCount = 0;
+      // Recompute transcript path since session ID changed
+      this.transcriptPath = this.computeTranscriptPath();
       this.callbacks.onSessionIdChange?.(sessionId);
     }
   }
 
+  /**
+   * Create session if needed (async helper)
+   */
+  private async createSessionIfNeeded(): Promise<void> {
+    try {
+      await createSession(
+        this.sessionId,
+        this.workdir,
+        this.sessionType,
+        this.parentSessionId,
+        this.subagentType,
+      );
+    } catch (error) {
+      this.logger?.error("Failed to create session:", error);
+    }
+  }
+
   public setMessages(messages: Message[]): void {
     this.messages = [...messages];
     this.callbacks.onMessagesChange?.([...messages]);
@@ -156,14 +204,29 @@ export class MessageManager {
    */
   public async saveSession(): Promise<void> {
     try {
-      await saveSession(
+      // Only save messages that haven't been saved yet
+      const unsavedMessages = this.messages.slice(this.savedMessageCount);
+
+      if (unsavedMessages.length === 0) {
+        // No new messages to save
+        return;
+      }
+
+      // Create session if needed (only when we have messages to save)
+      if (this.savedMessageCount === 0) {
+        // This is the first time saving messages, so create the session
+        await this.createSessionIfNeeded();
+      }
+
+      // Use JSONL format for new sessions
+      await appendMessages(
         this.sessionId,
-        this.messages,
+        unsavedMessages, // Only append new messages
         this.workdir,
-        this.latestTotalTokens,
-        this.sessionStartTime,
-        this.sessionDir,
       );
+
+      // Update the saved message count
+      this.savedMessageCount = this.messages.length;
     } catch (error) {
       this.logger?.error("Failed to save session:", error);
     }
@@ -177,11 +240,9 @@ export class MessageManager {
     continueLastSession?: boolean,
   ): Promise<void> {
     // Clean up expired sessions first
-    try {
-      await cleanupExpiredSessions(this.workdir, this.sessionDir);
-    } catch (error) {
+    cleanupExpiredSessionsFromJsonl(this.workdir).catch((error) => {
       this.logger?.warn("Failed to cleanup expired sessions:", error);
-    }
+    });
 
     if (!restoreSessionId && !continueLastSession) {
       return;
@@ -191,16 +252,18 @@ export class MessageManager {
       let sessionToRestore: SessionData | null = null;
 
       if (restoreSessionId) {
-        sessionToRestore = await loadSession(restoreSessionId, this.sessionDir);
+        // Use only JSONL format - no legacy support
+        sessionToRestore = await loadSessionFromJsonl(
+          restoreSessionId,
+          this.workdir,
+        );
         if (!sessionToRestore) {
           console.error(`Session not found: ${restoreSessionId}`);
           process.exit(1);
         }
       } else if (continueLastSession) {
-        sessionToRestore = await getLatestSession(
-          this.workdir,
-          this.sessionDir,
-        );
+        // Use only JSONL format - no legacy support
+        sessionToRestore = await getLatestSessionFromJsonl(this.workdir);
         if (!sessionToRestore) {
           console.error(
             `No previous session found for workdir: ${this.workdir}`,
@@ -213,11 +276,7 @@ export class MessageManager {
         console.log(`Restoring session: ${sessionToRestore.id}`);
 
         // Initialize from session data
-        this.initializeFromSession(
-          sessionToRestore.id,
-          sessionToRestore.messages,
-          sessionToRestore.metadata.latestTotalTokens,
-        );
+        this.initializeFromSession(sessionToRestore);
       }
     } catch (error) {
       console.error("Failed to restore session:", error);
@@ -243,23 +302,27 @@ export class MessageManager {
   public clearMessages(): void {
     this.setMessages([]);
     this.setUserInputHistory([]);
-    this.setSessionId(randomUUID());
+    this.setSessionId(generateSessionId());
     this.setlatestTotalTokens(0);
     this.sessionStartTime = new Date().toISOString();
+    this.savedMessageCount = 0; // Reset saved message count
   }
 
   // Initialize state from session data
-  public initializeFromSession(
-    sessionId: string,
-    messages: Message[],
-    latestTotalTokens: number,
-  ): void {
-    this.setSessionId(sessionId);
-    this.setMessages([...messages]);
-    this.setlatestTotalTokens(latestTotalTokens);
+  public initializeFromSession(sessionData: SessionData): void {
+    this.setSessionId(sessionData.id);
+    this.setMessages([...sessionData.messages]);
+    this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
+
+    // Restore the original session start time
+    this.sessionStartTime = sessionData.metadata.startedAt;
 
     // Extract user input history from session messages
-    this.setUserInputHistory(extractUserInputHistory(messages));
+    this.setUserInputHistory(extractUserInputHistory(sessionData.messages));
+
+    // Set saved message count to the number of loaded messages since they're already saved
+    // This must be done after setSessionId which resets it to 0
+    this.savedMessageCount = sessionData.messages.length;
   }
 
   // Add to input history
@@ -281,68 +344,92 @@ export class MessageManager {
   }
 
   // Encapsulated message operation functions
-  public addUserMessage(
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ): void {
+  public addUserMessage(params: UserMessageParams): void {
     const newMessages = addUserMessageToMessages({
       messages: this.messages,
-      content,
-      images,
+      ...params,
     });
     this.setMessages(newMessages);
-    this.callbacks.onUserMessageAdded?.(content, images);
-  }
+    this.callbacks.onUserMessageAdded?.(params);
 
-  public addCustomCommandMessage(
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ): void {
-    const newMessages = addUserMessageToMessages({
-      messages: this.messages,
-      content: "", // Empty content, as we will use CustomCommandBlock
-      customCommandBlock: {
-        type: "custom_command",
-        commandName,
-        content,
-        originalInput,
-      },
-    });
-    this.setMessages(newMessages);
-    this.callbacks.onCustomCommandAdded?.(commandName, content, originalInput);
+    // Note: Subagent-specific callbacks are now handled by SubagentManager
   }
 
   public addAssistantMessage(
     content?: string,
     toolCalls?: ChatCompletionMessageFunctionToolCall[],
     usage?: Usage,
+    metadata?: Record<string, unknown>,
   ): void {
+    const metadataRecord = metadata
+      ? Object.fromEntries(
+          Object.entries(metadata).filter(([, value]) => value !== undefined),
+        )
+      : undefined;
+
     const newMessages = addAssistantMessageToMessages(
       this.messages,
       content,
       toolCalls,
       usage,
+      metadataRecord,
     );
     this.setMessages(newMessages);
-    this.callbacks.onAssistantMessageAdded?.(content, toolCalls);
+    this.callbacks.onAssistantMessageAdded?.();
+
+    // Note: Subagent-specific callbacks are now handled by SubagentManager
+  }
+
+  public mergeAssistantMetadata(metadata: Record<string, unknown>): void {
+    if (!metadata || Object.keys(metadata).length === 0) {
+      return;
+    }
+
+    const newMessages = [...this.messages];
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+      const message = newMessages[i];
+      if (message.role === "assistant") {
+        const mergedMetadata = {
+          ...(message.metadata || {}),
+        } as Record<string, unknown>;
+
+        for (const [key, value] of Object.entries(metadata)) {
+          if (value === undefined) {
+            continue;
+          }
+          mergedMetadata[key] = value;
+        }
+
+        if (Object.keys(mergedMetadata).length === 0) {
+          return;
+        }
+
+        message.metadata = mergedMetadata;
+        this.setMessages(newMessages);
+        return;
+      }
+    }
   }
 
   public updateToolBlock(params: AgentToolBlockUpdateParams): void {
     const newMessages = updateToolBlockInMessage({
       messages: this.messages,
-      id: params.toolId,
-      parameters: params.args || "",
+      id: params.id,
+      parameters: params.parameters,
       result: params.result,
       success: params.success,
       error: params.error,
-      isRunning: params.isRunning,
+      stage: params.stage,
       name: params.name,
       shortResult: params.shortResult,
+      images: params.images,
       compactParams: params.compactParams,
+      parametersChunk: params.parametersChunk,
     });
     this.setMessages(newMessages);
     this.callbacks.onToolBlockUpdated?.(params);
+
+    // Note: Subagent-specific callbacks are now handled by SubagentManager
   }
 
   public addDiffBlock(
@@ -373,6 +460,7 @@ export class MessageManager {
   public compressMessagesAndUpdateSession(
     insertIndex: number,
     compressedContent: string,
+    usage?: Usage,
   ): void {
     const currentMessages = this.messages;
 
@@ -383,8 +471,10 @@ export class MessageManager {
         {
           type: "compress",
           content: compressedContent,
+          sessionId: this.sessionId,
         },
       ],
+      ...(usage && { usage }),
     };
 
     // Convert negative index to positive index
@@ -398,7 +488,7 @@ export class MessageManager {
     ];
 
     // Update sessionId
-    this.setSessionId(randomUUID());
+    this.setSessionId(generateSessionId());
 
     // Set new message list
     this.setMessages(newMessages);
@@ -458,8 +548,9 @@ export class MessageManager {
   public addSubagentBlock(
     subagentId: string,
     subagentName: string,
+    sessionId: string,
+    configuration: SubagentConfiguration,
     status: "active" | "completed" | "error" = "active",
-    subagentMessages: Message[] = [],
     parameters: {
       description: string;
       prompt: string;
@@ -470,8 +561,9 @@ export class MessageManager {
       messages: this.messages,
       subagentId,
       subagentName,
+      sessionId,
       status,
-      subagentMessages,
+      configuration,
     };
     const updatedMessages = addSubagentBlockToMessage(params);
     this.setMessages(updatedMessages);
@@ -482,7 +574,7 @@ export class MessageManager {
     subagentId: string,
     updates: Partial<{
       status: "active" | "completed" | "error" | "aborted";
-      messages: Message[];
+      sessionId: string;
     }>,
   ): void {
     const updatedMessages = updateSubagentBlockInMessage(
@@ -495,13 +587,8 @@ export class MessageManager {
       messages: this.messages,
       subagentId,
       status: updates.status || "active",
-      subagentMessages: updates.messages || [],
     };
-    this.callbacks.onSubAgentBlockUpdated?.(
-      params.subagentId,
-      params.messages,
-      params.status,
-    );
+    this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.status);
   }
 
   /**
@@ -517,6 +604,56 @@ export class MessageManager {
     this.callbacks.onUsagesChange?.(usages);
   }
 
+  /**
+   * Update the current assistant message content during streaming
+   * This method updates the last assistant message's content without creating a new message
+   * FR-001: Tracks and provides both chunk (new content) and accumulated (total content)
+   */
+  public updateCurrentMessageContent(newAccumulatedContent: string): void {
+    if (this.messages.length === 0) return;
+
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage.role !== "assistant") return;
+
+    // Get the current content to calculate the chunk
+    const textBlockIndex = lastMessage.blocks.findIndex(
+      (block) => block.type === "text",
+    );
+    const currentContent =
+      textBlockIndex >= 0
+        ? (
+            lastMessage.blocks[textBlockIndex] as {
+              type: "text";
+              content: string;
+            }
+          ).content || ""
+        : "";
+
+    // Calculate the chunk (new content since last update)
+    const chunk = newAccumulatedContent.slice(currentContent.length);
+
+    if (textBlockIndex >= 0) {
+      // Update existing text block
+      lastMessage.blocks[textBlockIndex] = {
+        type: "text",
+        content: newAccumulatedContent,
+      };
+    } else {
+      // Add new text block if none exists
+      lastMessage.blocks.unshift({
+        type: "text",
+        content: newAccumulatedContent,
+      });
+    }
+
+    // FR-001: Trigger callbacks with chunk and accumulated content
+    this.callbacks.onAssistantContentUpdated?.(chunk, newAccumulatedContent);
+
+    // Note: Subagent-specific callbacks are now handled by SubagentManager
+
+    this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
+  }
+
   /**
    * Remove the last user message from the conversation
    * Used for hook error handling when the user prompt needs to be erased

package/src/managers/slashCommandManager.ts

@@ -52,9 +52,12 @@ export class SlashCommandManager {
     this.registerCommand({
       id: "clear",
       name: "clear",
-      description: "Clear the chat session",
+      description: "Clear the chat session and terminal",
       handler: () => {
+        // Clear chat messages
         this.messageManager.clearMessages();
+        // Clear terminal screen
+        process.stdout.write("\x1Bc");
       },
     });
   }
@@ -257,15 +260,14 @@ export class SlashCommandManager {
           ? replaceBashCommandsWithOutput(processedContent, bashResults)
           : processedContent;
 
-      // Add custom command block to show the command being executed
+      // Add custom command message to show the command being executed
       const originalInput = args
         ? `/${commandName} ${args}`
         : `/${commandName}`;
-      this.messageManager.addCustomCommandMessage(
-        commandName,
-        finalContent,
-        originalInput,
-      );
+      this.messageManager.addUserMessage({
+        content: originalInput,
+        customCommandContent: finalContent,
+      });
 
       // Execute the AI conversation with custom configuration
       await this.aiManager.sendAIMessage({