wave-agent-sdk 0.4.0 → 0.6.1

package/src/services/aiService.ts

@@ -21,10 +21,7 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 
-import {
-  DEFAULT_SYSTEM_PROMPT,
-  buildSystemPrompt,
-} from "../constants/prompts.js";
+import { COMPRESS_MESSAGES_SYSTEM_PROMPT } from "../constants/prompts.js";
 
 /**
  * Interface for debug data saved during 400 errors
@@ -66,28 +63,6 @@ interface ErrorData {
  * Instead of parsing JSON, we use the raw chunk for efficient streaming
  */
 
-/**
- * Check if a directory is a git repository
- * @param dirPath Directory path to check
- * @returns "Yes" if it's a git repo, "No" otherwise
- */
-function isGitRepository(dirPath: string): string {
-  try {
-    // Check if .git directory exists in current directory or any parent directory
-    let currentPath = path.resolve(dirPath);
-    while (currentPath !== path.dirname(currentPath)) {
-      const gitPath = path.join(currentPath, ".git");
-      if (fs.existsSync(gitPath)) {
-        return "Yes";
-      }
-      currentPath = path.dirname(currentPath);
-    }
-    return "No";
-  } catch {
-    return "No";
-  }
-}
-
 /**
  * OpenAI model configuration type, based on OpenAI parameters but excluding messages
  */
@@ -144,7 +119,6 @@ export interface CallAgentOptions {
   messages: ChatCompletionMessageParam[];
   sessionId?: string;
   abortSignal?: AbortSignal;
-  memory?: string; // Memory content parameter, content read from AGENTS.md
   workdir: string; // Current working directory
   tools?: ChatCompletionFunctionTool[]; // Tool configuration
   model?: string; // Custom model
@@ -187,7 +161,6 @@ export async function callAgent(
     modelConfig,
     messages,
     abortSignal,
-    memory,
     workdir,
     tools,
     model,
@@ -216,28 +189,7 @@ export async function callAgent(
     });
 
     // Build system prompt content
-    let systemContent = buildSystemPrompt(
-      systemPrompt || DEFAULT_SYSTEM_PROMPT,
-      tools || [],
-    );
-
-    // Always add environment information
-    systemContent += `
-
-Here is useful information about the environment you are running in:
-<env>
-Working directory: ${workdir}
-Is directory a git repo: ${isGitRepository(workdir)}
-Platform: ${os.platform()}
-OS Version: ${os.type()} ${os.release()}
-Today's date: ${new Date().toISOString().split("T")[0]}
-</env>
-`;
-
-    // If there is memory content, add it to the system prompt
-    if (memory && memory.trim()) {
-      systemContent += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
-    }
+    const systemContent = systemPrompt || "";
 
     // Add system prompt
     const systemMessage: ChatCompletionMessageParam = {
@@ -792,101 +744,7 @@ export async function compressMessages(
         messages: [
           {
             role: "system",
-            content: `Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.
-This summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing development work without losing context.
-
-Before providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:
-
-1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:
-   - The user's explicit requests and intents
-   - Your approach to addressing the user's requests
-   - Key decisions, technical concepts and code patterns
-   - Specific details like:
-     - file names
-     - full code snippets
-     - function signatures
-     - file edits
-  - Errors that you ran into and how you fixed them
-  - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
-2. Double-check for technical accuracy and completeness, addressing each required element thoroughly.
-
-Your summary should include the following sections:
-
-1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
-2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
-3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
-4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
-5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
-6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
-6. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
-7. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
-8. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests or really old requests that were already completed without confirming with the user first.
-                       If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.
-
-Here's an example of how your output should be structured:
-
-<example>
-<analysis>
-[Your thought process, ensuring all points are covered thoroughly and accurately]
-</analysis>
-
-<summary>
-1. Primary Request and Intent:
-   [Detailed description]
-
-2. Key Technical Concepts:
-   - [Concept 1]
-   - [Concept 2]
-   - [...]
-
-3. Files and Code Sections:
-   - [File Name 1]
-      - [Summary of why this file is important]
-      - [Summary of the changes made to this file, if any]
-      - [Important Code Snippet]
-   - [File Name 2]
-      - [Important Code Snippet]
-   - [...]
-
-4. Errors and fixes:
-    - [Detailed description of error 1]:
-      - [How you fixed the error]
-      - [User feedback on the error if any]
-    - [...]
-
-5. Problem Solving:
-   [Description of solved problems and ongoing troubleshooting]
-
-6. All user messages: 
-    - [Detailed non tool use user message]
-    - [...]
-
-7. Pending Tasks:
-   - [Task 1]
-   - [Task 2]
-   - [...]
-
-8. Current Work:
-   [Precise description of current work]
-
-9. Optional Next Step:
-   [Optional Next step to take]
-
-</summary>
-</example>
-
-Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response. 
-
-There may be additional summarization instructions provided in the included context. If so, remember to follow these instructions when creating the above summary. Examples of instructions include:
-<example>
-## Compact Instructions
-When summarizing the conversation focus on typescript code changes and also remember the mistakes you made and how you fixed them.
-</example>
-
-<example>
-# Summary instructions
-When you are using compact - please focus on test output and code changes. Include file reads verbatim.
-</example>`,
+            content: COMPRESS_MESSAGES_SYSTEM_PROMPT,
           },
           ...messages,
           {

package/src/services/memory.ts

@@ -4,54 +4,6 @@ import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
 import { logger } from "../utils/globalLogger.js";
 
 // Project memory related methods
-export const isMemoryMessage = (message: string): boolean => {
-  return message.trim().startsWith("#");
-};
-
-export const addMemory = async (
-  message: string,
-  workdir: string,
-): Promise<void> => {
-  if (!isMemoryMessage(message)) {
-    return;
-  }
-
-  try {
-    const memoryFilePath = path.join(workdir, "AGENTS.md");
-
-    // Format memory entry, starting with -, no timestamp
-    const memoryEntry = `- ${message.substring(1).trim()}\n`;
-
-    // Check if file exists
-    let existingContent = "";
-    try {
-      existingContent = await fs.readFile(memoryFilePath, "utf-8");
-    } catch (error) {
-      // File does not exist, create new file
-      if ((error as NodeJS.ErrnoException).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";
-      } else {
-        throw error;
-      }
-    }
-
-    // Append new memory entry to the end of the file
-    const updatedContent = existingContent + memoryEntry;
-
-    // Write file
-    await fs.writeFile(memoryFilePath, updatedContent, "utf-8");
-
-    logger.debug(`Memory added to ${memoryFilePath}:`, message);
-  } catch (error) {
-    logger.error("Failed to add memory:", error);
-    throw new Error(`Failed to add memory: ${(error as Error).message}`);
-  }
-};
-
 // User memory related methods
 export const ensureUserMemoryFile = async (): Promise<void> => {
   try {
@@ -83,30 +35,6 @@ export const ensureUserMemoryFile = async (): Promise<void> => {
   }
 };
 
-export const addUserMemory = async (message: string): Promise<void> => {
-  try {
-    // Ensure user memory file exists
-    await ensureUserMemoryFile();
-
-    // Format memory entry, starting with -
-    const memoryEntry = `- ${message.substring(1).trim()}\n`;
-
-    // Read existing content
-    const existingContent = await fs.readFile(USER_MEMORY_FILE, "utf-8");
-
-    // Append new memory entry to the end of the file
-    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);
-  } catch (error) {
-    logger.error("Failed to add user memory:", error);
-    throw new Error(`Failed to add user memory: ${(error as Error).message}`);
-  }
-};
-
 export const getUserMemoryContent = async (): Promise<string> => {
   try {
     await ensureUserMemoryFile();
@@ -142,7 +70,7 @@ export const readMemoryFile = async (workdir: string): Promise<string> => {
       return "";
     }
     logger.error("Failed to read memory file", { memoryFilePath, error });
-    throw error;
+    return "";
   }
 };
 

package/src/services/session.ts

@@ -28,6 +28,8 @@ import { logger } from "../utils/globalLogger.js";
 
 export interface SessionData {
   id: string;
+  rootSessionId?: string;
+  parentSessionId?: string;
   messages: Message[];
   metadata: {
     workdir: string;
@@ -38,6 +40,8 @@ export interface SessionData {
 
 export interface SessionMetadata {
   id: string;
+  rootSessionId?: string;
+  parentSessionId?: string;
   sessionType: "main" | "subagent";
   subagentType?: string;
   workdir: string;
@@ -101,6 +105,7 @@ async function updateSessionIndex(
     ...rest,
     lastActiveAt: metadata.lastActiveAt.toISOString(),
     firstMessage: metadata.firstMessage || index.sessions[id]?.firstMessage,
+    parentSessionId: metadata.parentSessionId,
   };
   index.lastUpdated = new Date().toISOString();
 
@@ -191,6 +196,8 @@ 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") {
@@ -252,6 +259,8 @@ export async function appendMessages(
 
   await updateSessionIndex(projectDir.encodedPath, {
     id: sessionId,
+    rootSessionId,
+    parentSessionId,
     sessionType,
     workdir,
     lastActiveAt: new Date(lastMessage.timestamp),
@@ -294,8 +303,28 @@ export async function loadSessionFromJsonl(
     // Extract metadata from messages
     const lastMessage = messages[messages.length - 1];
 
+    // 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: messages.map((msg) => {
         // Remove timestamp property for backward compatibility
         const { timestamp: _ignored, ...messageWithoutTimestamp } = msg;
@@ -841,3 +870,47 @@ export async function handleSessionRestoration(
     process.exit(1);
   }
 }
+
+/**
+ * Load the full message thread by following parentSessionId links
+ * @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
+ */
+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 "compress" 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 "compress" block in session N summarizes session N-1.
+    // So if we have session N-1 and session N, we should probably skip the compress 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 "compress" block.
+      if (allMessages[0].blocks.some((b) => b.type === "compress")) {
+        // Remove the compress 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 };
+}

package/src/services/taskManager.ts

@@ -0,0 +1,188 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { EventEmitter } from "events";
+import { Task } from "../types/tasks.js";
+import { logger } from "../utils/globalLogger.js";
+
+export class TaskManager extends EventEmitter {
+  private readonly baseDir: string;
+  private taskListId: string;
+
+  constructor(taskListId: string) {
+    super();
+    this.taskListId = taskListId;
+    this.baseDir = join(homedir(), ".wave", "tasks");
+  }
+
+  public getTaskListId(): string {
+    return this.taskListId;
+  }
+
+  public setTaskListId(taskListId: string): void {
+    this.taskListId = taskListId;
+  }
+
+  private getSessionDir(): string {
+    return join(this.baseDir, this.taskListId);
+  }
+
+  private getTaskPath(taskId: string): string {
+    return join(this.getSessionDir(), `${taskId}.json`);
+  }
+
+  private getLockPath(): string {
+    return join(this.getSessionDir(), `.lock`);
+  }
+
+  async ensureSessionDir(): Promise<void> {
+    await fs.mkdir(this.getSessionDir(), { recursive: true });
+  }
+
+  private async withLock<T>(operation: () => Promise<T>): Promise<T> {
+    const lockPath = this.getLockPath();
+    let lockHandle;
+    const maxRetries = 100;
+    const retryDelay = process.env.NODE_ENV === "test" ? 10 : 100;
+
+    await this.ensureSessionDir();
+
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        lockHandle = await fs.open(lockPath, "wx");
+        break;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+          if (i === maxRetries - 1) {
+            throw new Error(
+              `Could not acquire lock for task list ${this.taskListId} after ${maxRetries} retries`,
+            );
+          }
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    try {
+      return await operation();
+    } finally {
+      if (lockHandle) {
+        await lockHandle.close();
+      }
+      try {
+        await fs.unlink(lockPath);
+      } catch (error) {
+        logger.error(
+          `Failed to release lock for task list ${this.taskListId}:`,
+          error,
+        );
+      }
+    }
+  }
+
+  private validateTask(task: Task): void {
+    if (!task.id || typeof task.id !== "string")
+      throw new Error("Invalid task ID");
+    if (!task.subject || typeof task.subject !== "string")
+      throw new Error("Invalid task subject");
+    if (!task.description || typeof task.description !== "string")
+      throw new Error("Invalid task description");
+    if (
+      !task.status ||
+      !["pending", "in_progress", "completed", "deleted"].includes(task.status)
+    ) {
+      throw new Error(`Invalid task status: ${task.status}`);
+    }
+  }
+
+  async createTask(task: Omit<Task, "id">): Promise<string> {
+    return await this.withLock(async () => {
+      const taskId = await this.getNextTaskId();
+      const fullTask: Task = { ...task, id: taskId };
+      this.validateTask(fullTask);
+      const taskPath = this.getTaskPath(taskId);
+      const content = JSON.stringify(fullTask, null, 2);
+      await fs.writeFile(taskPath, content, "utf8");
+      this.emit("tasksChange", this.taskListId);
+      logger.info(`Task ${taskId} created in task list ${this.taskListId}`);
+      return taskId;
+    });
+  }
+
+  async getTask(taskId: string): Promise<Task | null> {
+    const taskPath = this.getTaskPath(taskId);
+    try {
+      const content = await fs.readFile(taskPath, "utf8");
+      try {
+        return JSON.parse(content.trim()) as Task;
+      } catch (parseError) {
+        logger.error(`Failed to parse task file ${taskPath}:`, parseError);
+        logger.error(`Corrupted content: ${content}`);
+        throw parseError;
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async updateTask(task: Task): Promise<void> {
+    this.validateTask(task);
+    await this.withLock(async () => {
+      const taskPath = this.getTaskPath(task.id);
+      const content = JSON.stringify(task, null, 2);
+      await fs.writeFile(taskPath, content, "utf8");
+      this.emit("tasksChange", this.taskListId);
+      logger.info(`Task ${task.id} updated in task list ${this.taskListId}`);
+    });
+  }
+
+  async listTasks(): Promise<Task[]> {
+    const sessionDir = this.getSessionDir();
+    try {
+      const files = await fs.readdir(sessionDir);
+      const taskFiles = files.filter((f) => f.endsWith(".json"));
+
+      const tasks = await Promise.all(
+        taskFiles.map(async (file) => {
+          const taskPath = join(sessionDir, file);
+          try {
+            const content = await fs.readFile(taskPath, "utf8");
+            return JSON.parse(content.trim()) as Task;
+          } catch (error) {
+            logger.error(
+              `Failed to read or parse task file ${taskPath}:`,
+              error,
+            );
+            return null;
+          }
+        }),
+      );
+
+      return tasks.filter((t): t is Task => t !== null);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async getNextTaskId(): Promise<string> {
+    const tasks = await this.listTasks();
+    if (tasks.length === 0) {
+      return "1";
+    }
+    const ids = tasks.map((t) => parseInt(t.id, 10)).filter((id) => !isNaN(id));
+
+    if (ids.length === 0) {
+      return (tasks.length + 1).toString();
+    }
+
+    return (Math.max(...ids) + 1).toString();
+  }
+}