wave-agent-sdk 0.8.4 → 0.9.1

package/src/types/hooks.ts

@@ -26,6 +26,8 @@ export type HookEvent =
 export interface HookCommand {
   type: "command";
   command: string;
+  async?: boolean;
+  timeout?: number; // seconds
 }
 
 // Hook event configuration with optional pattern matching
@@ -104,15 +106,29 @@ export function isValidHookEvent(event: string): event is HookEvent {
 }
 
 export function isValidHookCommand(cmd: unknown): cmd is HookCommand {
-  return (
-    typeof cmd === "object" &&
-    cmd !== null &&
-    "type" in cmd &&
-    cmd.type === "command" &&
-    "command" in cmd &&
-    typeof cmd.command === "string" &&
-    cmd.command.length > 0
-  );
+  if (
+    typeof cmd !== "object" ||
+    cmd === null ||
+    !("type" in cmd) ||
+    cmd.type !== "command" ||
+    !("command" in cmd) ||
+    typeof cmd.command !== "string" ||
+    cmd.command.length === 0
+  ) {
+    return false;
+  }
+
+  const hookCmd = cmd as Record<string, unknown>;
+
+  if ("async" in hookCmd && typeof hookCmd.async !== "boolean") {
+    return false;
+  }
+
+  if ("timeout" in hookCmd && typeof hookCmd.timeout !== "number") {
+    return false;
+  }
+
+  return true;
 }
 
 export function isValidHookEventConfig(

package/src/utils/containerSetup.ts

@@ -1,4 +1,3 @@
-import * as fs from "fs/promises";
 import { Container } from "./container.js";
 import { ForegroundTaskManager } from "../managers/foregroundTaskManager.js";
 import { BackgroundTaskManager } from "../managers/backgroundTaskManager.js";
@@ -21,6 +20,7 @@ import { SubagentManager } from "../managers/subagentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { ReversionService } from "../services/reversionService.js";
+import { MemoryService } from "../services/memory.js";
 import type { AgentOptions } from "../types/index.js";
 import type {
   PermissionMode,
@@ -29,7 +29,6 @@ import type {
   BackgroundTask,
   ToolPermissionContext,
 } from "../types/index.js";
-import type { GatewayConfig, ModelConfig } from "../types/config.js";
 
 import { logger } from "./globalLogger.js";
 
@@ -48,12 +47,6 @@ export interface AgentContainerSetupOptions {
   setPermissionMode: (mode: PermissionMode) => void;
   addPermissionRule: (rule: string) => Promise<void>;
   addUsage: (usage: Usage) => void;
-
-  // Getters
-  getGatewayConfig: () => GatewayConfig;
-  getModelConfig: () => ModelConfig;
-  getMaxInputTokens: () => number;
-  getLanguage: () => string | undefined;
 }
 
 export function setupAgentContainer(
@@ -72,10 +65,6 @@ export function setupAgentContainer(
     setPermissionMode,
     addPermissionRule,
     addUsage,
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
   } = setupOptions;
 
   const callbacks = options.callbacks || {};
@@ -85,6 +74,9 @@ export function setupAgentContainer(
   container.register("ForegroundTaskManager", foregroundTaskManager);
   container.register("ConfigurationService", configurationService);
 
+  const memoryService = new MemoryService(container);
+  container.register("MemoryService", memoryService);
+
   const memoryRuleManager = new MemoryRuleManager(container, { workdir });
   container.register("MemoryRuleManager", memoryRuleManager);
 
@@ -139,6 +131,10 @@ export function setupAgentContainer(
   container.register("LspManager", lspManager);
 
   const permissionManager = new PermissionManager(container, { workdir });
+  if (configurationService.resolveAutoMemoryEnabled()) {
+    const autoMemoryDir = memoryService.getAutoMemoryDirectory(workdir);
+    permissionManager.updateAdditionalDirectories([autoMemoryDir]);
+  }
   container.register("PermissionManager", permissionManager);
   permissionManager.setOnConfiguredDefaultModeChange((mode) => {
     handlePlanModeTransition(mode);
@@ -198,17 +194,9 @@ export function setupAgentContainer(
         if (decision.clearContext) {
           messageManager.clearMessages();
           if (planFilePath) {
-            try {
-              const planContent = await fs.readFile(planFilePath, "utf-8");
-              messageManager.addUserMessage({
-                content: `Implement the following plan:\n\n${planContent}`,
-              });
-            } catch (error) {
-              logger.warn("Failed to read plan file for context clearing", {
-                planFilePath,
-                error: error instanceof Error ? error.message : String(error),
-              });
-            }
+            messageManager.addUserMessage({
+              content: `Implement the plan at ${planFilePath}`,
+            });
           }
         }
 
@@ -246,11 +234,6 @@ export function setupAgentContainer(
       onSubagentLatestTotalTokensChange:
         callbacks.onSubagentLatestTotalTokensChange,
     },
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
-    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
     onUsageAdded: (usage: Usage) => addUsage(usage),
   });
   container.register("SubagentManager", subagentManager);
@@ -263,11 +246,6 @@ export function setupAgentContainer(
     workdir,
     systemPrompt,
     stream,
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
-    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
   });
   container.register("AIManager", aiManager);
 

package/src/utils/fileSearch.ts

@@ -1,26 +1,78 @@
-import { globIterate, type Path } from "glob";
+import { spawn } from "child_process";
+import { rgPath } from "@vscode/ripgrep";
+import fuzzysort from "fuzzysort";
 import { getGlobIgnorePatterns } from "./fileFilter.js";
 import type { FileItem } from "../types/fileSearch.js";
+import { logger } from "./globalLogger.js";
 
 /**
- * Convert Path objects to FileItem objects
+ * Execute ripgrep to get all file paths
  */
-export const convertPathsToFileItems = (paths: Path[]): FileItem[] => {
-  return paths.map((pathObj) => {
-    const isDirectory = pathObj.isDirectory();
-    let path = pathObj.relative();
-    if (isDirectory && !path.endsWith("/")) {
-      path += "/";
-    }
-    return {
-      path,
-      type: isDirectory ? "directory" : "file",
-    };
+async function getAllFiles(workingDirectory: string): Promise<string[]> {
+  if (!rgPath) {
+    throw new Error("ripgrep is not available");
+  }
+
+  const ignorePatterns = getGlobIgnorePatterns(workingDirectory);
+  const rgArgs = ["--files", "--color=never", "--hidden"];
+  for (const pattern of ignorePatterns) {
+    rgArgs.push("--glob", `!${pattern}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(rgPath, rgArgs, {
+      cwd: workingDirectory,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0 && code !== 1) {
+        reject(new Error(`ripgrep failed: ${stderr}`));
+        return;
+      }
+      const files = stdout
+        .trim()
+        .split("\n")
+        .filter((f) => f.length > 0)
+        .map((f) => f.replace(/\\/g, "/")); // Normalize to forward slashes
+      resolve(files);
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
   });
-};
+}
+
+/**
+ * Derive directory paths from file paths
+ */
+function deriveDirectories(files: string[]): string[] {
+  const dirs = new Set<string>();
+  for (const file of files) {
+    const parts = file.split("/");
+    // Add all parent directories
+    for (let i = 1; i < parts.length; i++) {
+      const dir = parts.slice(0, i).join("/") + "/";
+      dirs.add(dir);
+    }
+  }
+  return Array.from(dirs);
+}
 
 /**
- * Search files and directories using glob patterns
+ * Search files and directories using fuzzy matching
  */
 export const searchFiles = async (
   query: string,
@@ -32,83 +84,63 @@ export const searchFiles = async (
   const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
 
   try {
-    const globOptions: import("glob").GlobOptionsWithFileTypesTrue = {
-      ignore: getGlobIgnorePatterns(workingDirectory),
-      maxDepth: 10,
-      nocase: true, // Case insensitive
-      dot: true, // Include hidden files and directories
-      cwd: workingDirectory, // Specify search root directory
-      withFileTypes: true, // Get Path objects instead of strings
-    };
-
-    // Build glob patterns based on query
-    let patterns: string[] = [];
+    const files = await getAllFiles(workingDirectory);
 
     if (!query.trim()) {
-      // When query is empty, show some common file types and directories
-      patterns = [
-        "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
-        "*/", // First level directories
-      ];
-    } else {
-      // Build multiple glob patterns to support more flexible search
-      patterns = [
-        // Match files with filenames containing query
-        `**/*${query}*`,
-        // Match files with query in path (match directory names)
-        `**/${query}*/**/*`,
-        // Match directory names containing query
-        `**/*${query}*/`,
-        // Match directories containing query in path
-        `**/${query}*/`,
-      ];
-    }
+      // When query is empty, show some common file types and top-level directories
+      const commonExtensions = new Set([
+        "ts",
+        "tsx",
+        "js",
+        "jsx",
+        "json",
+        "py",
+        "java",
+      ]);
+      const results: FileItem[] = [];
+      const seenDirs = new Set<string>();
 
-    // Collect results until we reach maxResults
-    const collectedPaths: Path[] = [];
-    const seenPaths = new Set<string>();
-
-    // Process each pattern sequentially
-    for (const pattern of patterns) {
-      if (collectedPaths.length >= maxResults) {
-        break;
-      }
-
-      // Use globIterate to get results one by one
-      const iterator = globIterate(pattern, globOptions) as AsyncGenerator<
-        Path,
-        void,
-        void
-      >;
-
-      for await (const pathObj of iterator) {
-        if (collectedPaths.length >= maxResults) {
-          // Stop the iterator when we have enough results
-          break;
+      for (const file of files) {
+        const parts = file.split("/");
+        if (parts.length > 1) {
+          const topDir = parts[0] + "/";
+          if (!seenDirs.has(topDir)) {
+            seenDirs.add(topDir);
+            results.push({ path: topDir, type: "directory" });
+          }
         }
 
-        const relativePath = pathObj.relative();
-        if (!seenPaths.has(relativePath)) {
-          seenPaths.add(relativePath);
-          collectedPaths.push(pathObj);
+        const ext = file.split(".").pop();
+        if (ext && commonExtensions.has(ext)) {
+          results.push({ path: file, type: "file" });
         }
       }
+
+      // Sort: directories first, then files, then alphabetically
+      return results
+        .sort((a, b) => {
+          if (a.type === "directory" && b.type === "file") return -1;
+          if (a.type === "file" && b.type === "directory") return 1;
+          return a.path.localeCompare(b.path);
+        })
+        .slice(0, maxResults);
     }
 
-    // Sort collected paths: directories first, then files
-    collectedPaths.sort((a, b) => {
-      const aIsDir = a.isDirectory();
-      const bIsDir = b.isDirectory();
-      if (aIsDir && !bIsDir) return -1;
-      if (!aIsDir && bIsDir) return 1;
-      return a.relative().localeCompare(b.relative());
+    const directories = deriveDirectories(files);
+    const allItems: FileItem[] = [
+      ...files.map((f) => ({ path: f, type: "file" as const })),
+      ...directories.map((d) => ({ path: d, type: "directory" as const })),
+    ];
+
+    const fuzzyResults = fuzzysort.go(query, allItems, {
+      key: "path",
+      limit: maxResults,
+      threshold: 0,
     });
 
-    // Convert to FileItems
-    const fileItems = convertPathsToFileItems(collectedPaths);
-    return fileItems;
+    return fuzzyResults.map((res) => res.obj);
   } catch (error) {
-    console.error("Glob search error:", error);
+    logger.error("Fuzzy search error:", error);
     return [];
   }
 };

package/src/utils/gitUtils.ts

@@ -41,6 +41,24 @@ export function getGitRepoRoot(cwd: string): string {
   }
 }
 
+/**
+ * Get the common directory of the git repository (handles worktrees)
+ * @param cwd Working directory
+ * @returns Repository common directory path
+ */
+export function getGitCommonDir(cwd: string): string {
+  try {
+    const commonDir = execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return path.resolve(cwd, commonDir);
+  } catch {
+    return getGitRepoRoot(cwd);
+  }
+}
+
 /**
  * Get the default remote branch (e.g., origin/main)
  * @param cwd Working directory

package/src/utils/promptHistory.ts

@@ -22,7 +22,11 @@ export class PromptHistoryManager {
   /**
    * Add a new prompt to history
    */
-  static async addEntry(prompt: string): Promise<void> {
+  static async addEntry(
+    prompt: string,
+    sessionId?: string,
+    longTextMap?: Record<string, string>,
+  ): Promise<void> {
     try {
       if (!prompt.trim()) return;
 
@@ -30,6 +34,8 @@ export class PromptHistoryManager {
       const entry: PromptEntry = {
         prompt,
         timestamp: Date.now(),
+        sessionId,
+        longTextMap,
       };
 
       const line = JSON.stringify(entry) + "\n";
@@ -71,7 +77,7 @@ export class PromptHistoryManager {
   /**
    * Get all history entries
    */
-  static async getHistory(): Promise<PromptEntry[]> {
+  static async getHistory(sessionId?: string): Promise<PromptEntry[]> {
     try {
       if (!fs.existsSync(PROMPT_HISTORY_FILE)) {
         return [];
@@ -91,13 +97,18 @@ export class PromptHistoryManager {
         })
         .filter((entry): entry is PromptEntry => entry !== null);
 
+      // Filter by sessionId if provided
+      const filteredEntries = sessionId
+        ? entries.filter((entry) => entry.sessionId === sessionId)
+        : entries;
+
       // 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];
+      for (let i = filteredEntries.length - 1; i >= 0; i--) {
+        const entry = filteredEntries[i];
         if (!seenPrompts.has(entry.prompt)) {
           uniqueEntries.push(entry);
           seenPrompts.add(entry.prompt);
@@ -114,9 +125,12 @@ export class PromptHistoryManager {
   /**
    * Search history by query
    */
-  static async searchHistory(query: string): Promise<PromptEntry[]> {
+  static async searchHistory(
+    query: string,
+    sessionId?: string,
+  ): Promise<PromptEntry[]> {
     try {
-      const history = await this.getHistory();
+      const history = await this.getHistory(sessionId);
       if (!query.trim()) {
         return history;
       }