wave-agent-sdk 0.2.1 → 0.5.0

package/src/utils/editUtils.ts

@@ -3,80 +3,88 @@
  */
 
 /**
- * Find a match in content that is identical to searchString except for a consistent indentation offset.
- *
- * Priority:
- * 1. If exact matches exist, returns searchString (letting the tool handle uniqueness/replaceAll).
- * 2. If no exact match, but exactly one unique indentation-insensitive match exists, returns that match.
- * 3. Otherwise returns null.
+ * Escape regular expression special characters
+ */
+export function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Analyze why an edit failed by finding the best partial match and highlighting mismatches.
  */
-export function findIndentationInsensitiveMatch(
+export function analyzeEditMismatch(
   content: string,
   searchString: string,
-): string | null {
-  // 1. If exact match exists, return it
-  if (content.includes(searchString)) {
-    return searchString;
-  }
-
+): string {
+  const contentLines = content.split("\n");
   const searchLines = searchString.split("\n");
-  if (searchLines.length === 0) return null;
 
-  const contentLines = content.split("\n");
-  let foundMatch: string | null = null;
+  if (searchLines.length === 0 || contentLines.length === 0) {
+    return "old_string not found in file (empty search or content)";
+  }
 
-  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-    let offset: number | null = null;
-    let isMatch = true;
+  let bestMatchIndex = -1;
+  let bestMatchScore = -1;
 
+  // Sliding window to find the best partial match
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    let currentScore = 0;
     for (let j = 0; j < searchLines.length; j++) {
-      const sLine = searchLines[j];
-      const cLine = contentLines[i + j];
-
-      const sTrimmed = sLine.trimStart();
-      const cTrimmed = cLine.trimStart();
-
-      // If trimmed content doesn't match, it's not a match
-      if (sTrimmed !== cTrimmed) {
-        isMatch = false;
-        break;
+      if (contentLines[i + j] === searchLines[j]) {
+        currentScore++;
       }
+    }
 
-      // For non-empty lines, check for consistent indentation offset
-      if (sTrimmed !== "") {
-        const sIndent = sLine.length - sTrimmed.length;
-        const cIndent = cLine.length - cTrimmed.length;
-        const currentOffset = cIndent - sIndent;
+    // Heuristic: prioritize matches where first or last lines match
+    if (contentLines[i] === searchLines[0]) currentScore += 0.5;
+    if (
+      contentLines[i + searchLines.length - 1] ===
+      searchLines[searchLines.length - 1]
+    )
+      currentScore += 0.5;
 
-        if (offset === null) {
-          offset = currentOffset;
-        } else if (offset !== currentOffset) {
-          isMatch = false;
-          break;
-        }
+    // Also consider trimmed matches to catch indentation issues
+    for (let j = 0; j < searchLines.length; j++) {
+      if (
+        contentLines[i + j].trim() === searchLines[j].trim() &&
+        contentLines[i + j] !== searchLines[j]
+      ) {
+        currentScore += 0.1;
       }
     }
 
-    if (isMatch) {
-      const matchCandidate = contentLines
-        .slice(i, i + searchLines.length)
-        .join("\n");
-      if (foundMatch !== null && foundMatch !== matchCandidate) {
-        // Multiple different smart matches found
-        return null;
-      }
-      foundMatch = matchCandidate;
+    if (currentScore > bestMatchScore) {
+      bestMatchScore = currentScore;
+      bestMatchIndex = i;
     }
   }
 
-  // If we found exactly one unique smart match (or multiple instances of the same smart match)
-  // return it. The tool will then check for uniqueness if replaceAll is false.
-  return foundMatch;
-}
+  // If no decent match found (score <= 0), return generic message
+  if (bestMatchScore <= 0) {
+    return "old_string not found in file (no similar block found)";
+  }
 
-/**
- * Escape regular expression special characters
- */
-export function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  // Generate detailed report
+  const reportLines: string[] = [
+    `old_string not found in file. Best partial match found at line ${bestMatchIndex + 1}:`,
+  ];
+
+  for (let j = 0; j < searchLines.length; j++) {
+    const lineNum = bestMatchIndex + j + 1;
+    const actualLine = contentLines[bestMatchIndex + j];
+    const expectedLine = searchLines[j];
+
+    if (actualLine === expectedLine) {
+      reportLines.push(`${lineNum.toString().padStart(4)} | ${actualLine}`);
+    } else {
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | - ${expectedLine} (expected)`,
+      );
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | + ${actualLine} (actual)`,
+      );
+    }
+  }
+
+  return reportLines.join("\n");
 }

package/src/utils/messageOperations.ts

@@ -169,6 +169,7 @@ export const addUserMessageToMessages = ({
   }
 
   const userMessage: Message = {
+    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
     role: "user",
     blocks,
   };
@@ -205,6 +206,7 @@ export const addAssistantMessageToMessages = (
   }
 
   const initialAssistantMessage: Message = {
+    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
     role: "assistant",
     blocks,
     usage, // Include usage data if provided
@@ -502,6 +504,7 @@ export interface AddSubagentBlockParams {
   status: "active" | "completed" | "error" | "aborted";
   sessionId: string;
   configuration: SubagentConfiguration;
+  runInBackground?: boolean;
 }
 
 export interface UpdateSubagentBlockParams {
@@ -518,6 +521,7 @@ export const addSubagentBlockToMessage = ({
   status,
   sessionId,
   configuration,
+  runInBackground,
 }: AddSubagentBlockParams): Message[] => {
   const newMessages = [...messages];
 
@@ -527,6 +531,7 @@ export const addSubagentBlockToMessage = ({
   if (!lastAssistantMessage || lastAssistantMessage.role !== "assistant") {
     // Create new assistant message if the last message is not from assistant
     lastAssistantMessage = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
       role: "assistant",
       blocks: [],
     };
@@ -541,6 +546,7 @@ export const addSubagentBlockToMessage = ({
     status,
     sessionId,
     configuration,
+    runInBackground,
   });
 
   return newMessages;
@@ -552,6 +558,7 @@ export const updateSubagentBlockInMessage = (
   updates: Partial<{
     status: "active" | "completed" | "error" | "aborted";
     sessionId: string;
+    runInBackground: boolean;
   }>,
 ): Message[] => {
   const newMessages = [...messages];
@@ -568,6 +575,9 @@ export const updateSubagentBlockInMessage = (
           if (updates.sessionId !== undefined) {
             block.sessionId = updates.sessionId;
           }
+          if (updates.runInBackground !== undefined) {
+            block.runInBackground = updates.runInBackground;
+          }
           return newMessages;
         }
       }

package/src/utils/openaiClient.ts

@@ -51,7 +51,9 @@ export class OpenAIClient {
               >
             >;
           // Prevent unhandled rejection if only withResponse() is used
-          promise.catch(() => {});
+          promise.catch((e) => {
+            logger.error("Unhandled OpenAI promise rejection:", e);
+          });
           return promise;
         },
       },
@@ -83,24 +85,61 @@ export class OpenAIClient {
     };
 
     const fetchFn = (customFetch as typeof fetch) || fetch;
-    const response = await fetchFn(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(params),
-      signal: options?.signal,
-      ...(fetchOptions as RequestInit),
-    });
-
-    if (!response.ok) {
+    let lastError: (Error & { status?: number; body?: unknown }) | undefined;
+    const maxRetries = 3;
+    const initialDelay = 1000;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = initialDelay * Math.pow(2, attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+
+      const response = await fetchFn(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params),
+        signal: options?.signal,
+        ...(fetchOptions as RequestInit),
+      });
+
+      if (response.ok) {
+        if (params.stream) {
+          return {
+            data: this.streamChatCompletion(response),
+            response,
+          } as unknown as APIResponse<
+            P extends ChatCompletionCreateParamsStreaming
+              ? AsyncIterable<ChatCompletionChunk>
+              : ChatCompletion
+          >;
+        } else {
+          const data = await response.json();
+          return {
+            data,
+            response,
+          } as unknown as APIResponse<
+            P extends ChatCompletionCreateParamsStreaming
+              ? AsyncIterable<ChatCompletionChunk>
+              : ChatCompletion
+          >;
+        }
+      }
+
       let errorBody: unknown;
       try {
         const text = await response.text();
         try {
           errorBody = JSON.parse(text);
-        } catch {
+        } catch (e) {
+          logger.error("Failed to parse error response body as JSON", {
+            error: e,
+            text,
+          });
           errorBody = text;
         }
-      } catch {
+      } catch (e) {
+        logger.error("Failed to read error response text", { error: e });
         errorBody = {};
       }
 
@@ -118,6 +157,21 @@ export class OpenAIClient {
       ) as Error & { status?: number; body?: unknown };
       error.status = response.status;
       error.body = errorBody;
+
+      if (response.status === 429 && attempt < maxRetries) {
+        const responseHeaders: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        logger.warn("OpenAI API 429 Too Many Requests, retrying...", {
+          attempt: attempt + 1,
+          status: response.status,
+          responseHeaders,
+        });
+        lastError = error;
+        continue;
+      }
+
       const responseHeaders: Record<string, string> = {};
       response.headers.forEach((value, key) => {
         responseHeaders[key] = value;
@@ -131,27 +185,7 @@ export class OpenAIClient {
       });
       throw error;
     }
-
-    if (params.stream) {
-      return {
-        data: this.streamChatCompletion(response),
-        response,
-      } as unknown as APIResponse<
-        P extends ChatCompletionCreateParamsStreaming
-          ? AsyncIterable<ChatCompletionChunk>
-          : ChatCompletion
-      >;
-    } else {
-      const data = await response.json();
-      return {
-        data,
-        response,
-      } as unknown as APIResponse<
-        P extends ChatCompletionCreateParamsStreaming
-          ? AsyncIterable<ChatCompletionChunk>
-          : ChatCompletion
-      >;
-    }
+    throw lastError;
   }
 
   private async *streamChatCompletion(
@@ -182,8 +216,8 @@ export class OpenAIClient {
           try {
             const json = JSON.parse(data);
             yield json as ChatCompletionChunk;
-          } catch {
-            // Ignore parse errors for non-JSON lines if any
+          } catch (e) {
+            logger.error("Failed to parse stream chunk", { error: e, data });
           }
         }
       }

package/src/utils/promptHistory.ts

@@ -0,0 +1,133 @@
+import fs from "fs";
+import { PROMPT_HISTORY_FILE, DATA_DIRECTORY } from "./constants.js";
+import { logger } from "./globalLogger.js";
+import { PromptEntry } from "../types/history.js";
+
+/**
+ * Ensure data directory exists
+ */
+const ensureDataDirectory = (): void => {
+  try {
+    if (!fs.existsSync(DATA_DIRECTORY)) {
+      fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
+    }
+  } catch (error) {
+    logger.debug("Failed to create data directory:", error);
+  }
+};
+
+const MAX_HISTORY_ENTRIES = 1000;
+
+export class PromptHistoryManager {
+  /**
+   * Add a new prompt to history
+   */
+  static async addEntry(prompt: string): Promise<void> {
+    try {
+      if (!prompt.trim()) return;
+
+      ensureDataDirectory();
+      const entry: PromptEntry = {
+        prompt,
+        timestamp: Date.now(),
+      };
+
+      const line = JSON.stringify(entry) + "\n";
+      await fs.promises.appendFile(PROMPT_HISTORY_FILE, line, "utf-8");
+
+      // Periodically trim history file to prevent it from growing too large
+      // We do this randomly (1 in 50 chance) to avoid performance hit on every entry
+      if (Math.random() < 0.02) {
+        await this.trimHistory();
+      }
+    } catch (error) {
+      logger.debug("Failed to add prompt to history:", error);
+    }
+  }
+
+  /**
+   * Trim history file to MAX_HISTORY_ENTRIES
+   */
+  private static async trimHistory(): Promise<void> {
+    try {
+      if (!fs.existsSync(PROMPT_HISTORY_FILE)) return;
+
+      const data = await fs.promises.readFile(PROMPT_HISTORY_FILE, "utf-8");
+      const lines = data.split("\n").filter((line) => line.trim());
+
+      if (lines.length > MAX_HISTORY_ENTRIES * 1.2) {
+        const trimmedLines = lines.slice(-MAX_HISTORY_ENTRIES);
+        await fs.promises.writeFile(
+          PROMPT_HISTORY_FILE,
+          trimmedLines.join("\n") + "\n",
+          "utf-8",
+        );
+      }
+    } catch (error) {
+      logger.debug("Failed to trim prompt history:", error);
+    }
+  }
+
+  /**
+   * Get all history entries
+   */
+  static async getHistory(): Promise<PromptEntry[]> {
+    try {
+      if (!fs.existsSync(PROMPT_HISTORY_FILE)) {
+        return [];
+      }
+
+      const data = await fs.promises.readFile(PROMPT_HISTORY_FILE, "utf-8");
+      const lines = data.split("\n").filter((line) => line.trim());
+
+      const entries: PromptEntry[] = lines
+        .map((line) => {
+          try {
+            return JSON.parse(line) as PromptEntry;
+          } catch {
+            logger.debug("Failed to parse history line:", line);
+            return null;
+          }
+        })
+        .filter((entry): entry is PromptEntry => entry !== null);
+
+      // Deduplicate by prompt, keeping the most recent one
+      const uniqueEntries: PromptEntry[] = [];
+      const seenPrompts = new Set<string>();
+
+      // Process from newest to oldest
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (!seenPrompts.has(entry.prompt)) {
+          uniqueEntries.push(entry);
+          seenPrompts.add(entry.prompt);
+        }
+      }
+
+      return uniqueEntries;
+    } catch (error) {
+      logger.debug("Failed to load prompt history:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Search history by query
+   */
+  static async searchHistory(query: string): Promise<PromptEntry[]> {
+    try {
+      const history = await this.getHistory();
+      if (!query.trim()) {
+        return history;
+      }
+
+      const normalizedQuery = query.toLowerCase();
+      return history.filter((entry) =>
+        entry.prompt.toLowerCase().includes(normalizedQuery),
+      );
+    } catch (error) {
+      logger.debug("Failed to search prompt history:", error);
+      return [];
+    }
+  }
+}

package/dist/utils/bashHistory.d.ts

@@ -1,50 +0,0 @@
-/**
- * Bash command history management module
- * Used for persistent storage and searching of bash commands executed by users
- */
-export interface BashHistoryEntry {
-    command: string;
-    timestamp: number;
-    workdir: string;
-}
-export interface BashHistory {
-    commands: BashHistoryEntry[];
-    version: number;
-}
-/**
- * Load bash history
- */
-export declare const loadBashHistory: () => BashHistory;
-/**
- * Save bash history
- */
-export declare const saveBashHistory: (history: BashHistory) => void;
-/**
- * Add command to bash history
- */
-export declare const addBashCommandToHistory: (command: string, workdir: string) => void;
-/**
- * Search bash history by keywords
- */
-export declare const searchBashHistory: (query: string, limit?: number) => BashHistoryEntry[];
-/**
- * Get recently used bash commands
- */
-export declare const getRecentBashCommands: (limit?: number) => BashHistoryEntry[];
-/**
- * Delete a specific command from bash history
- */
-export declare const deleteBashCommandFromHistory: (command: string, workdir?: string) => void;
-/**
- * Clear bash history
- */
-export declare const clearBashHistory: () => void;
-/**
- * Get bash command statistics
- */
-export declare const getBashCommandStats: () => {
-    totalCommands: number;
-    uniqueCommands: number;
-    workdirs: string[];
-};
-//# sourceMappingURL=bashHistory.d.ts.map

package/dist/utils/bashHistory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bashHistory.d.ts","sourceRoot":"","sources":["../../src/utils/bashHistory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;AAkBD;;GAEG;AACH,eAAO,MAAM,eAAe,QAAO,WA+BlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,WAAW,KAAG,IAoBtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,SAAS,MAAM,KACd,IA4BF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,MAAM,EACb,QAAO,MAAW,KACjB,gBAAgB,EAiElB,CAAC;AAwBF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAO,MAAW,KACjB,gBAAgB,EAWlB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACvC,SAAS,MAAM,EACf,UAAU,MAAM,KACf,IAmBF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,IAWnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAO;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CAwBpB,CAAC"}