wave-agent-sdk 0.18.7 → 0.19.0

package/src/services/hook.ts

@@ -89,6 +89,13 @@ async function buildHookJsonInput(
     }
   }
 
+  // Add worktree_path field for WorktreeRemove events
+  if (context.event === "WorktreeRemove") {
+    if (context.worktreePath !== undefined) {
+      jsonInput.worktree_path = context.worktreePath;
+    }
+  }
+
   // Add SessionStart-specific fields
   if (context.event === "SessionStart") {
     if (context.source !== undefined) {

package/src/services/initializationService.ts

@@ -326,9 +326,7 @@ export class InitializationService {
         messageManager.initializeFromSession(sessionToRestore);
 
         // Update task manager with the root session ID to ensure continuity across compactions
-        taskManager.setTaskListId(
-          sessionToRestore.rootSessionId || sessionToRestore.id,
-        );
+        taskManager.setTaskListId(sessionToRestore.id);
 
         // After session is initialized, load tasks for the session
         const tasks = await taskManager.listTasks();

package/src/services/interactionService.ts

@@ -166,7 +166,7 @@ export class InteractionService {
     messageManager.initializeFromSession(sessionData);
 
     // Update task manager with the root session ID to ensure continuity across compactions
-    taskManager.setTaskListId(sessionData.rootSessionId || sessionData.id);
+    taskManager.setTaskListId(sessionData.id);
 
     // 7. Load tasks for the restored session
     const tasks = await taskManager.listTasks();

package/src/services/reversionService.ts

@@ -1,5 +1,5 @@
-import { readFile, writeFile, mkdir, rm } from "fs/promises";
-import { join } from "path";
+import { readFile, writeFile, mkdir, rm, readdir, stat } from "fs/promises";
+import { join, dirname } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
 import { FileSnapshot } from "../types/reversion.js";
@@ -9,50 +9,49 @@ export class ReversionService {
   private rootSessionId: string;
 
   constructor(rootSessionId: string) {
-    this.rootSessionId = rootSessionId;
+    this.rootSessionId = rootSessionId || "default";
     this.historyBaseDir = join(
       homedir(),
       ".wave",
       "file-history",
-      rootSessionId || "default",
+      this.rootSessionId,
     );
   }
 
   private getFilePathHash(filePath: string): string {
-    return createHash("md5").update(filePath).digest("hex");
+    return createHash("sha256").update(filePath).digest("hex").slice(0, 16);
   }
 
-  private async getNextVersion(fileHashDir: string): Promise<number> {
+  private async getNextVersion(filePath: string): Promise<number> {
+    const hash = this.getFilePathHash(filePath);
+    const prefix = `${hash}@v`;
     try {
-      const files = await readFile(join(fileHashDir, "versions"), "utf-8");
-      const versions = files
-        .split("\n")
-        .map((v) => parseInt(v, 10))
-        .filter((v) => !isNaN(v));
-      return versions.length > 0 ? Math.max(...versions) + 1 : 1;
+      const files = await readdir(this.historyBaseDir);
+      let maxVersion = 0;
+      for (const file of files) {
+        if (file.startsWith(prefix)) {
+          const v = parseInt(file.slice(prefix.length), 10);
+          if (!isNaN(v) && v > maxVersion) {
+            maxVersion = v;
+          }
+        }
+      }
+      return maxVersion + 1;
     } catch {
       return 1;
     }
   }
 
-  private async updateVersionsFile(
-    fileHashDir: string,
-    version: number,
-  ): Promise<void> {
-    await appendFile(join(fileHashDir, "versions"), `${version}\n`, "utf-8");
-  }
-
   /**
    * Saves a single snapshot to the file history directory.
    * Returns the snapshot path.
    */
   async saveSnapshot(snapshot: FileSnapshot): Promise<string> {
     const fileHash = this.getFilePathHash(snapshot.filePath);
-    const fileHashDir = join(this.historyBaseDir, fileHash);
-    await this.ensureDirectory(fileHashDir);
+    await this.ensureDirectory(this.historyBaseDir);
 
-    const version = await this.getNextVersion(fileHashDir);
-    const snapshotPath = join(fileHashDir, `v${version}`);
+    const version = await this.getNextVersion(snapshot.filePath);
+    const snapshotPath = join(this.historyBaseDir, `${fileHash}@v${version}`);
 
     const snapshotWithContent = snapshot as FileSnapshot & {
       content: string | null;
@@ -65,7 +64,6 @@ export class ReversionService {
       return ""; // Return empty string to indicate no snapshot file
     }
 
-    await this.updateVersionsFile(fileHashDir, version);
     return snapshotPath;
   }
 
@@ -90,10 +88,35 @@ export class ReversionService {
     await rm(this.historyBaseDir, { recursive: true, force: true });
   }
 
+  /**
+   * Cleans up session directories older than the given number of days.
+   * Skips the current session.
+   */
+  async cleanupOldSessions(days: number = 30): Promise<void> {
+    const threshold = Date.now() - days * 24 * 60 * 60 * 1000;
+    const parentDir = dirname(this.historyBaseDir);
+    try {
+      const entries = await readdir(parentDir);
+      await Promise.all(
+        entries.map(async (entry) => {
+          if (entry === this.rootSessionId) return;
+          const dirPath = join(parentDir, entry);
+          try {
+            const stats = await stat(dirPath);
+            if (stats.isDirectory() && stats.mtimeMs < threshold) {
+              await rm(dirPath, { recursive: true, force: true });
+            }
+          } catch {
+            // ENOENT — concurrently deleted, skip
+          }
+        }),
+      );
+    } catch {
+      // parent dir doesn't exist — nothing to clean
+    }
+  }
+
   private async ensureDirectory(dirPath: string): Promise<void> {
     await mkdir(dirPath, { recursive: true });
   }
 }
-
-// Helper to avoid appendFile import error if not imported
-import { appendFile } from "fs/promises";

package/src/services/session.ts

@@ -28,8 +28,6 @@ import { getMessageContent } from "../utils/messageOperations.js";
 
 export interface SessionData {
   id: string;
-  rootSessionId?: string;
-  parentSessionId?: string;
   messages: Message[];
   metadata: {
     workdir: string;
@@ -40,8 +38,6 @@ export interface SessionData {
 
 export interface SessionMetadata {
   id: string;
-  rootSessionId?: string;
-  parentSessionId?: string;
   sessionType: "main" | "subagent";
   subagentType?: string;
   workdir: string;
@@ -51,17 +47,6 @@ export interface SessionMetadata {
   firstMessage?: string;
 }
 
-export interface SessionIndex {
-  sessions: Record<
-    string,
-    Omit<SessionMetadata, "id" | "lastActiveAt" | "createdAt"> & {
-      lastActiveAt: string;
-      createdAt: string;
-    }
-  >;
-  lastUpdated: string;
-}
-
 /**
  * Generate a new session ID using Node.js native crypto.randomUUID()
  * @returns UUID string for session identification
@@ -82,40 +67,6 @@ export function generateSubagentFilename(sessionId: string): string {
 // Constants
 export const SESSION_DIR = join(homedir(), ".wave", "projects");
 const MAX_SESSION_AGE_DAYS = 14;
-const SESSION_INDEX_FILENAME = "sessions-index.json";
-
-/**
- * Update the session index for a project directory
- */
-async function updateSessionIndex(
-  projectDirPath: string,
-  metadata: SessionMetadata,
-): Promise<void> {
-  const indexPath = join(projectDirPath, SESSION_INDEX_FILENAME);
-  let index: SessionIndex = {
-    sessions: {},
-    lastUpdated: new Date().toISOString(),
-  };
-
-  try {
-    const content = await fs.readFile(indexPath, "utf8");
-    index = JSON.parse(content);
-  } catch {
-    // Index doesn't exist or is invalid, start fresh
-  }
-
-  const { id, ...rest } = metadata;
-  index.sessions[id] = {
-    ...rest,
-    createdAt: metadata.createdAt.toISOString(),
-    lastActiveAt: metadata.lastActiveAt.toISOString(),
-    firstMessage: metadata.firstMessage || index.sessions[id]?.firstMessage,
-    parentSessionId: metadata.parentSessionId,
-  };
-  index.lastUpdated = new Date().toISOString();
-
-  await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-}
 
 /**
  * Ensure session directory exists
@@ -201,8 +152,6 @@ export async function appendMessages(
   newMessages: Message[],
   workdir: string,
   sessionType: "main" | "subagent" = "main",
-  rootSessionId?: string,
-  parentSessionId?: string,
 ): Promise<void> {
   // Do not save session files in test environment
   if (process.env.NODE_ENV === "test") {
@@ -235,50 +184,6 @@ export async function appendMessages(
   await jsonlHandler.append(filePath, newMessages, {
     atomic: false,
   });
-
-  // Update index
-  const encoder = new PathEncoder();
-  const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-  const lastMessage = newMessages[newMessages.length - 1];
-
-  // Get first message content and createdAt from existing index
-  let firstMessage: string | undefined;
-  let createdAt: Date | undefined;
-  try {
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-    const content = await fs.readFile(indexPath, "utf8");
-    const index = JSON.parse(content) as SessionIndex;
-    if (!index.sessions[sessionId]?.firstMessage) {
-      firstMessage =
-        (await getFirstMessageContent(sessionId, workdir)) || undefined;
-    }
-    if (index.sessions[sessionId]?.createdAt) {
-      createdAt = new Date(index.sessions[sessionId].createdAt);
-    }
-  } catch {
-    // If index doesn't exist, this might be the first message
-    firstMessage =
-      (await getFirstMessageContent(sessionId, workdir)) || undefined;
-  }
-
-  // Derive createdAt from session ID if not in index
-  if (!createdAt) {
-    createdAt = new Date();
-  }
-
-  await updateSessionIndex(projectDir.encodedPath, {
-    id: sessionId,
-    rootSessionId,
-    parentSessionId,
-    sessionType,
-    workdir,
-    createdAt,
-    lastActiveAt: new Date(lastMessage.timestamp),
-    latestTotalTokens: lastMessage.usage
-      ? extractLatestTotalTokens([lastMessage])
-      : 0,
-    firstMessage,
-  });
 }
 
 /**
@@ -314,34 +219,25 @@ export async function loadSessionFromJsonl(
       throw error;
     }
 
-    const messages = await jsonlHandler.read(filePath);
+    const allMessages = await jsonlHandler.read(filePath);
+
+    // Find the last compact boundary — only return messages from there forward
+    let lastCompactIndex = -1;
+    for (let i = allMessages.length - 1; i >= 0; i--) {
+      if (allMessages[i].blocks?.some((b) => b.type === "compact")) {
+        lastCompactIndex = i;
+        break;
+      }
+    }
+    const messages =
+      lastCompactIndex >= 0 ? allMessages.slice(lastCompactIndex) : allMessages;
 
     // Extract metadata from messages
     const lastMessage =
       messages.length > 0 ? messages[messages.length - 1] : null;
 
-    // Try to get rootSessionId and parentSessionId from index
-    let rootSessionId: string | undefined;
-    let parentSessionId: string | undefined;
-    try {
-      const encoder = new PathEncoder();
-      const projectDir = await encoder.getProjectDirectory(
-        workdir,
-        SESSION_DIR,
-      );
-      const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-      const indexContent = await fs.readFile(indexPath, "utf8");
-      const index = JSON.parse(indexContent) as SessionIndex;
-      rootSessionId = index.sessions[sessionId]?.rootSessionId;
-      parentSessionId = index.sessions[sessionId]?.parentSessionId;
-    } catch {
-      // Ignore index errors
-    }
-
     const sessionData: SessionData = {
       id: sessionId,
-      rootSessionId: rootSessionId || sessionId,
-      parentSessionId,
       messages,
       metadata: {
         workdir,
@@ -435,33 +331,9 @@ export async function listSessionsFromJsonl(
 
     const projectDir = await encoder.getProjectDirectory(workdir, baseDir);
 
-    // Try to read from index first
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
     const sevenDaysAgo = new Date();
     sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
 
-    try {
-      const indexContent = await fs.readFile(indexPath, "utf8");
-      const index = JSON.parse(indexContent) as SessionIndex;
-      const sessions: SessionMetadata[] = Object.entries(index.sessions)
-        .filter(([, meta]) => {
-          const lastActiveAt = new Date(meta.lastActiveAt);
-          return meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo;
-        })
-        .map(([id, meta]) => ({
-          id,
-          ...meta,
-          createdAt: new Date(meta.createdAt),
-          lastActiveAt: new Date(meta.lastActiveAt),
-        }));
-
-      return sessions.sort(
-        (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
-      );
-    } catch {
-      // Fallback to manual listing if index fails
-    }
-
     let files: string[];
     try {
       files = await fs.readdir(projectDir.encodedPath);
@@ -521,7 +393,7 @@ export async function listSessionsFromJsonl(
         const sessionMeta: SessionMetadata = {
           id: sessionId,
           sessionType: "main",
-          subagentType: undefined, // No longer stored in metadata
+          subagentType: undefined,
           workdir: projectDir.originalPath,
           createdAt: new Date(),
           lastActiveAt,
@@ -530,7 +402,7 @@ export async function listSessionsFromJsonl(
             : 0,
         };
 
-        // Try to get first message content for the fallback/rebuild case
+        // Try to get first message content for display
         try {
           const firstContent = await getFirstMessageContent(sessionId, workdir);
           if (firstContent) {
@@ -548,30 +420,9 @@ export async function listSessionsFromJsonl(
     }
 
     // Sort by last active time (most recently active first)
-    const sortedSessions = sessions.sort(
+    return sessions.sort(
       (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
     );
-
-    // Rebuild index if we had to fall back
-    try {
-      const index: SessionIndex = {
-        sessions: {},
-        lastUpdated: new Date().toISOString(),
-      };
-      for (const session of sessions) {
-        const { id, ...rest } = session;
-        index.sessions[id] = {
-          ...rest,
-          createdAt: session.createdAt.toISOString(),
-          lastActiveAt: session.lastActiveAt.toISOString(),
-        };
-      }
-      await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-    } catch (error) {
-      logger.warn(`Failed to rebuild session index for ${workdir}:`, error);
-    }
-
-    return sortedSessions;
   } catch (error) {
     throw new Error(`Failed to list sessions: ${error}`);
   }
@@ -607,28 +458,52 @@ export async function listAllSessions(): Promise<SessionMetadata[]> {
           continue;
         }
 
-        // Try to read from index first
-        const indexPath = join(projectPath, SESSION_INDEX_FILENAME);
-        try {
-          const indexContent = await fs.readFile(indexPath, "utf8");
-          const index = JSON.parse(indexContent) as SessionIndex;
-          for (const [id, meta] of Object.entries(index.sessions)) {
-            const lastActiveAt = new Date(meta.lastActiveAt);
-            if (meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo) {
-              allSessions.push({
-                id,
-                ...meta,
-                createdAt: new Date(meta.createdAt),
-                lastActiveAt,
-              });
+        // Scan .jsonl files in the project directory
+        const files = await fs.readdir(projectPath);
+
+        for (const file of files) {
+          if (!file.endsWith(".jsonl") || file.startsWith("subagent-")) {
+            continue;
+          }
+
+          try {
+            const filePath = join(projectPath, file);
+            const uuidMatch = file.match(
+              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+            );
+            if (!uuidMatch) continue;
+
+            const sessionId = uuidMatch[1];
+            const jsonlHandler = new JsonlHandler();
+            const lastMessage = await jsonlHandler.getLastMessage(filePath);
+
+            let lastActiveAt: Date;
+            if (lastMessage) {
+              lastActiveAt = new Date(lastMessage.timestamp);
+            } else {
+              const stats = await fs.stat(filePath);
+              lastActiveAt = stats.mtime;
             }
+
+            if (lastActiveAt < sevenDaysAgo) continue;
+
+            allSessions.push({
+              id: sessionId,
+              sessionType: "main" as const,
+              subagentType: undefined,
+              workdir: projectDirName,
+              createdAt: new Date(),
+              lastActiveAt,
+              latestTotalTokens: lastMessage?.usage
+                ? extractLatestTotalTokens([lastMessage])
+                : 0,
+            });
+          } catch {
+            continue;
           }
-        } catch {
-          // If index fails, we skip this project directory
-          // In the future, we could scan for .jsonl files here
         }
       } catch {
-        // Skip if stat fails
+        // Skip if stat/readdir fails
       }
     }
 
@@ -677,38 +552,6 @@ export async function cleanupExpiredSessionsFromJsonl(
         if (fileAge > maxAge) {
           await fs.unlink(filePath);
           deletedCount++;
-
-          // Remove from index if it exists
-          try {
-            const indexPath = join(
-              projectDir.encodedPath,
-              SESSION_INDEX_FILENAME,
-            );
-            const indexContent = await fs.readFile(indexPath, "utf8");
-            const index = JSON.parse(indexContent) as SessionIndex;
-            const uuidMatch = file.match(
-              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-            );
-            const subagentMatch = file.match(
-              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-            );
-            const sessionId = uuidMatch
-              ? uuidMatch[1]
-              : subagentMatch
-                ? subagentMatch[1]
-                : null;
-
-            if (sessionId && index.sessions[sessionId]) {
-              delete index.sessions[sessionId];
-              await fs.writeFile(
-                indexPath,
-                JSON.stringify(index, null, 2),
-                "utf8",
-              );
-            }
-          } catch {
-            // Ignore index update errors during cleanup
-          }
         }
       } catch {
         // Skip failed operations and continue processing other files
@@ -897,21 +740,6 @@ export async function deleteSession(
       throw error;
     }
   }
-
-  // Also remove from index
-  try {
-    const encoder = new PathEncoder();
-    const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-    const indexContent = await fs.readFile(indexPath, "utf8");
-    const index = JSON.parse(indexContent) as SessionIndex;
-    if (index.sessions[sessionId]) {
-      delete index.sessions[sessionId];
-      await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-    }
-  } catch {
-    // Ignore index errors
-  }
 }
 
 /**
@@ -995,7 +823,9 @@ export async function handleSessionRestoration(
 }
 
 /**
- * Load the full message thread by following parentSessionId links
+ * Load the full message thread for a session.
+ * With append-only compaction, all messages are in a single file.
+ * Returns the active messages (post-compact boundary).
  * @param currentSessionId - The ID of the current session
  * @param workdir - Working directory for the session
  * @returns Promise that resolves to an array of all messages in the thread
@@ -1004,36 +834,7 @@ export async function loadFullMessageThread(
   currentSessionId: string,
   workdir: string,
 ): Promise<{ messages: Message[]; sessionIds: string[] }> {
-  const sessionIds: string[] = [];
-  let currentId: string | undefined = currentSessionId;
-  const allMessages: Message[] = [];
-
-  while (currentId) {
-    const sessionData = await loadSessionFromJsonl(currentId, workdir);
-    if (!sessionData) break;
-
-    sessionIds.unshift(currentId);
-    // Add messages from this session to the beginning of the list
-    // But skip the "compact" block if it's not the first session in our traversal (which is the latest)
-    // Actually, we should probably keep all messages and let the UI/logic handle it.
-    // But wait, if we are concatenating, the "compact" block in session N summarizes session N-1.
-    // So if we have session N-1 and session N, we should probably skip the compact block in session N.
-
-    const messages = sessionData.messages;
-    if (allMessages.length > 0) {
-      // If we already have messages (from "later" sessions),
-      // we are now adding messages from an "earlier" session.
-      // The later session's first message might be a "compact" block.
-      if (allMessages[0].blocks.some((b) => b.type === "compact")) {
-        // Remove the compact block from the later session's messages
-        // because we are now providing the actual messages it summarized.
-        allMessages.shift();
-      }
-    }
-
-    allMessages.unshift(...messages);
-    currentId = sessionData.parentSessionId;
-  }
-
-  return { messages: allMessages, sessionIds };
+  const sessionData = await loadSessionFromJsonl(currentSessionId, workdir);
+  if (!sessionData) return { messages: [], sessionIds: [] };
+  return { messages: sessionData.messages, sessionIds: [currentSessionId] };
 }