wave-agent-sdk 0.0.4 → 0.0.6

package/src/managers/subagentManager.ts

@@ -1,6 +1,12 @@
 import { randomUUID } from "crypto";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
-import type { Message, Logger, GatewayConfig, ModelConfig } from "../types.js";
+import type {
+  Message,
+  Logger,
+  GatewayConfig,
+  ModelConfig,
+  Usage,
+} from "../types/index.js";
 import { AIManager } from "./aiManager.js";
 import {
   MessageManager,
@@ -15,7 +21,6 @@ export interface SubagentInstance {
   messageManager: MessageManager;
   toolManager: ToolManager;
   status: "initializing" | "active" | "completed" | "error" | "aborted";
-  taskDescription: string;
   messages: Message[];
 }
 
@@ -27,6 +32,7 @@ export interface SubagentManagerOptions {
   gatewayConfig: GatewayConfig;
   modelConfig: ModelConfig;
   tokenLimit: number;
+  onUsageAdded?: (usage: Usage) => void;
 }
 
 export class SubagentManager {
@@ -40,6 +46,7 @@ export class SubagentManager {
   private gatewayConfig: GatewayConfig;
   private modelConfig: ModelConfig;
   private tokenLimit: number;
+  private onUsageAdded?: (usage: Usage) => void;
 
   constructor(options: SubagentManagerOptions) {
     this.workdir = options.workdir;
@@ -49,6 +56,7 @@ export class SubagentManager {
     this.gatewayConfig = options.gatewayConfig;
     this.modelConfig = options.modelConfig;
     this.tokenLimit = options.tokenLimit;
+    this.onUsageAdded = options.onUsageAdded;
   }
 
   /**
@@ -98,7 +106,11 @@ export class SubagentManager {
    */
   async createInstance(
     configuration: SubagentConfiguration,
-    taskDescription: string,
+    parameters: {
+      description: string;
+      prompt: string;
+      subagent_type: string;
+    },
   ): Promise<SubagentInstance> {
     if (
       !this.parentToolManager ||
@@ -156,6 +168,9 @@ export class SubagentManager {
         agentModel: modelToUse,
       },
       tokenLimit: this.tokenLimit,
+      callbacks: {
+        onUsageAdded: this.onUsageAdded,
+      },
     });
 
     const instance: SubagentInstance = {
@@ -165,7 +180,6 @@ export class SubagentManager {
       messageManager,
       toolManager,
       status: "initializing",
-      taskDescription,
       messages: [],
     };
 
@@ -177,6 +191,7 @@ export class SubagentManager {
       configuration.name,
       "active",
       [],
+      parameters,
     );
 
     return instance;
@@ -191,14 +206,31 @@ export class SubagentManager {
   async executeTask(
     instance: SubagentInstance,
     prompt: string,
+    abortSignal?: AbortSignal,
   ): Promise<string> {
     try {
+      // Check if already aborted before starting
+      if (abortSignal?.aborted) {
+        throw new Error("Task was aborted before execution started");
+      }
+
       // Set status to active and update parent
       this.updateInstanceStatus(instance.subagentId, "active");
       this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
         status: "active",
       });
 
+      // Set up abort handler
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => {
+          this.updateInstanceStatus(instance.subagentId, "aborted");
+          this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+            status: "aborted",
+            messages: instance.messages,
+          });
+        });
+      }
+
       // Add the user's prompt as a message
       instance.messageManager.addUserMessage(prompt);
 
@@ -215,7 +247,9 @@ export class SubagentManager {
       }
 
       // Execute the AI request with tool restrictions
-      await instance.aiManager.sendAIMessage({
+      // The AIManager will handle abort signals through its own abort controllers
+      // We need to abort the AI execution if the external abort signal is triggered
+      const executeAI = instance.aiManager.sendAIMessage({
         allowedTools,
         model:
           instance.configuration.model !== "inherit"
@@ -223,6 +257,25 @@ export class SubagentManager {
             : undefined,
       });
 
+      // If we have an abort signal, race against it
+      if (abortSignal) {
+        await Promise.race([
+          executeAI,
+          new Promise<never>((_, reject) => {
+            if (abortSignal.aborted) {
+              reject(new Error("Task was aborted"));
+            }
+            abortSignal.addEventListener("abort", () => {
+              // Abort the AI execution
+              instance.aiManager.abortAIMessage();
+              reject(new Error("Task was aborted"));
+            });
+          }),
+        ]);
+      } else {
+        await executeAI;
+      }
+
       // Get the latest messages to extract the response
       const messages = instance.messageManager.getMessages();
       const lastAssistantMessage = messages
@@ -286,52 +339,6 @@ export class SubagentManager {
     }
   }
 
-  /**
-   * Abort a running subagent instance
-   */
-  abortInstance(subagentId: string): boolean {
-    const instance = this.instances.get(subagentId);
-    if (!instance) {
-      return false;
-    }
-
-    // Only abort active or initializing instances
-    if (instance.status !== "active" && instance.status !== "initializing") {
-      return false;
-    }
-
-    try {
-      // Abort the AI manager operations
-      instance.aiManager.abortAIMessage();
-
-      // Update status
-      this.updateInstanceStatus(subagentId, "aborted");
-      this.parentMessageManager.updateSubagentBlock(subagentId, {
-        status: "aborted",
-        messages: instance.messages,
-      });
-
-      this.logger?.info(`Aborted subagent instance: ${subagentId}`);
-      return true;
-    } catch (error) {
-      this.logger?.error(
-        `Failed to abort subagent instance ${subagentId}:`,
-        error,
-      );
-      return false;
-    }
-  }
-
-  /**
-   * Abort all active subagent instances
-   */
-  abortAllInstances(): void {
-    const activeInstances = this.getActiveInstances();
-    for (const instance of activeInstances) {
-      this.abortInstance(instance.subagentId);
-    }
-  }
-
   /**
    * Clean up completed, errored, or aborted instances
    */
@@ -361,8 +368,6 @@ export class SubagentManager {
    * Clean up all instances (for session end)
    */
   cleanup(): void {
-    // Abort all active instances before cleanup
-    this.abortAllInstances();
     this.instances.clear();
   }
 }

package/src/managers/toolManager.ts

@@ -14,7 +14,7 @@ import { createTaskTool } from "../tools/taskTool.js";
 import { createSkillTool } from "../tools/skillTool.js";
 import { McpManager } from "./mcpManager.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
-import type { Logger } from "../types.js";
+import type { Logger } from "../types/index.js";
 import type { SubagentManager } from "./subagentManager.js";
 import type { SkillManager } from "./skillManager.js";
 

package/src/services/aiService.ts

@@ -5,7 +5,7 @@ import {
   ChatCompletionMessageParam,
   ChatCompletionFunctionTool,
 } from "openai/resources.js";
-import type { GatewayConfig, ModelConfig } from "../types.js";
+import type { GatewayConfig, ModelConfig } from "../types/index.js";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
@@ -116,7 +116,14 @@ export async function callAgent(
     // Build system prompt content
     let systemContent =
       systemPrompt ||
-      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
+      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+      
+# Tool usage policy
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
+- You should proactively use the Task tool with specialized agents when the task at hand matches the agent's description.
+- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
+
+      `;
 
     // Always add environment information
     systemContent += `
@@ -214,9 +221,18 @@ export interface CompressMessagesOptions {
   abortSignal?: AbortSignal;
 }
 
+export interface CompressMessagesResult {
+  content: string;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
 export async function compressMessages(
   options: CompressMessagesOptions,
-): Promise<string> {
+): Promise<CompressMessagesResult> {
   const { gatewayConfig, modelConfig, messages, abortSignal } = options;
 
   // Create OpenAI client with injected configuration
@@ -294,15 +310,29 @@ For technical conversations, structure as:
       },
     );
 
-    return (
+    const content =
       response.choices[0]?.message?.content?.trim() ||
-      "Failed to compress conversation history"
-    );
+      "Failed to compress conversation history";
+    const usage = response.usage
+      ? {
+          prompt_tokens: response.usage.prompt_tokens,
+          completion_tokens: response.usage.completion_tokens,
+          total_tokens: response.usage.total_tokens,
+        }
+      : undefined;
+
+    return {
+      content,
+      usage,
+    };
   } catch (error) {
     if ((error as Error).name === "AbortError") {
       throw new Error("Compression request was aborted");
     }
     // // logger.error("Failed to compress messages:", error);
-    return "Failed to compress conversation history";
+    return {
+      content: "Failed to compress conversation history",
+      usage: undefined,
+    };
   }
 }

package/src/services/hook.ts

@@ -0,0 +1,360 @@
+/**
+ * Hook Services
+ *
+ * Consolidated hook services providing both execution and configuration functionality.
+ * Combines hook command execution and settings management into a single module.
+ */
+
+import { spawn, type ChildProcess } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import {
+  type HookExecutionContext,
+  type HookExecutionResult,
+  type HookExecutionOptions,
+  type ExtendedHookExecutionContext,
+  type HookJsonInput,
+  type HookConfiguration,
+  type PartialHookConfiguration,
+  getSessionFilePath,
+  isValidHookEvent,
+} from "../types/hooks.js";
+
+// =============================================================================
+// Hook Execution Functions
+// =============================================================================
+
+/**
+ * Build JSON input data for hook stdin
+ */
+function buildHookJsonInput(
+  context: ExtendedHookExecutionContext,
+): HookJsonInput {
+  const jsonInput: HookJsonInput = {
+    session_id: context.sessionId || "unknown",
+    transcript_path:
+      context.transcriptPath ||
+      (context.sessionId ? getSessionFilePath(context.sessionId) : ""),
+    cwd: context.cwd || context.projectDir,
+    hook_event_name: context.event,
+  };
+
+  // Add optional fields based on event type
+  if (context.event === "PreToolUse" || context.event === "PostToolUse") {
+    if (context.toolName) {
+      jsonInput.tool_name = context.toolName;
+    }
+    if (context.toolInput !== undefined) {
+      jsonInput.tool_input = context.toolInput;
+    }
+  }
+
+  if (context.event === "PostToolUse" && context.toolResponse !== undefined) {
+    jsonInput.tool_response = context.toolResponse;
+  }
+
+  if (
+    context.event === "UserPromptSubmit" &&
+    context.userPrompt !== undefined
+  ) {
+    jsonInput.user_prompt = context.userPrompt;
+  }
+
+  return jsonInput;
+}
+
+/**
+ * Execute a single hook command
+ */
+export async function executeCommand(
+  command: string,
+  context: HookExecutionContext | ExtendedHookExecutionContext,
+  options?: HookExecutionOptions,
+): Promise<HookExecutionResult> {
+  const defaultTimeout = 10000; // 10 seconds
+  const maxTimeout = 300000; // 5 minutes
+  const skipExecution =
+    process.env.NODE_ENV === "test" &&
+    process.env.TEST_HOOK_EXECUTION !== "true";
+
+  const startTime = Date.now();
+  const timeout = Math.min(options?.timeout ?? defaultTimeout, maxTimeout);
+
+  // Return mock result if execution is skipped
+  if (skipExecution) {
+    return {
+      success: true,
+      exitCode: 0,
+      stdout: "",
+      stderr: "",
+      duration: 0,
+      timedOut: false,
+    };
+  }
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    // Parse command for shell execution
+    const isWindows = process.platform === "win32";
+    const shell = isWindows ? "cmd.exe" : "/bin/sh";
+    const shellFlag = isWindows ? "/c" : "-c";
+
+    const childProcess: ChildProcess = spawn(shell, [shellFlag, command], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: context.projectDir,
+      env: {
+        ...process.env,
+        HOOK_EVENT: context.event,
+        HOOK_TOOL_NAME: context.toolName || "",
+        HOOK_PROJECT_DIR: context.projectDir,
+      },
+    });
+
+    // Set up timeout
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      childProcess.kill("SIGTERM");
+
+      // Force kill after additional delay
+      setTimeout(() => {
+        if (!childProcess.killed) {
+          childProcess.kill("SIGKILL");
+        }
+      }, 2000);
+    }, timeout);
+
+    // Handle stdout
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+    }
+
+    // Handle stderr
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+    }
+
+    // Send JSON input to stdin if we have extended context
+    if (childProcess.stdin && "sessionId" in context) {
+      try {
+        const jsonInput = buildHookJsonInput(context);
+        childProcess.stdin.write(JSON.stringify(jsonInput, null, 2));
+        childProcess.stdin.end();
+      } catch {
+        // Continue execution even if JSON input fails
+      }
+    } else if (childProcess.stdin) {
+      childProcess.stdin.end();
+    }
+
+    // Handle process completion
+    childProcess.on("close", (code: number | null) => {
+      clearTimeout(timeoutHandle);
+      const duration = Date.now() - startTime;
+
+      resolve({
+        success: !timedOut && (code === 0 || code === null),
+        exitCode: code || 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        duration,
+        timedOut,
+      });
+    });
+
+    // Handle process errors
+    childProcess.on("error", (error: Error) => {
+      clearTimeout(timeoutHandle);
+      const duration = Date.now() - startTime;
+
+      resolve({
+        success: false,
+        exitCode: 1,
+        stdout: stdout.trim(),
+        stderr: error.message,
+        duration,
+        timedOut,
+      });
+    });
+  });
+}
+
+/**
+ * Execute multiple commands in sequence
+ */
+export async function executeCommands(
+  commands: string[],
+  context: HookExecutionContext | ExtendedHookExecutionContext,
+  options?: HookExecutionOptions,
+): Promise<HookExecutionResult[]> {
+  const results: HookExecutionResult[] = [];
+
+  for (const command of commands) {
+    const result = await executeCommand(command, context, options);
+    results.push(result);
+
+    // Stop on first failure unless continueOnFailure is set
+    if (!result.success && !options?.continueOnFailure) {
+      break;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Validate command safety (basic checks)
+ */
+export function isCommandSafe(command: string): boolean {
+  const trimmed = command.trim();
+
+  // Empty commands are safe (no-op)
+  if (!trimmed) {
+    return true;
+  }
+
+  // Check for obviously dangerous patterns
+  const dangerousPatterns = [
+    /rm\s+-rf\s+\//, // rm -rf /
+    /sudo\s+rm/, // sudo rm
+    />\s*\/dev\/sd[a-z]/, // writing to disk devices
+    /dd\s+if=.*of=\/dev/, // dd to devices
+    /mkfs/, // filesystem creation
+    /fdisk/, // disk partitioning
+    /format\s+[a-z]:/, // Windows format command
+  ];
+
+  return !dangerousPatterns.some((pattern) =>
+    pattern.test(trimmed.toLowerCase()),
+  );
+}
+
+// =============================================================================
+// Hook Settings Functions
+// =============================================================================
+
+/**
+ * Get the user-specific hooks configuration file path
+ */
+export function getUserHooksConfigPath(): string {
+  return join(homedir(), ".wave", "settings.json");
+}
+
+/**
+ * Get the project-specific hooks configuration file path
+ */
+export function getProjectHooksConfigPath(workdir: string): string {
+  return join(workdir, ".wave", "settings.json");
+}
+
+/**
+ * Load hooks configuration from a JSON file
+ */
+export function loadHooksConfigFromFile(
+  filePath: string,
+): PartialHookConfiguration | null {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  const content = readFileSync(filePath, "utf-8");
+  const config = JSON.parse(content) as HookConfiguration;
+
+  // Validate basic structure
+  if (!config || typeof config !== "object" || !config.hooks) {
+    throw new Error(`Invalid hooks configuration structure in ${filePath}`);
+  }
+
+  return config.hooks;
+}
+
+/**
+ * Load user-specific hooks configuration
+ */
+export function loadUserHooksConfig(): PartialHookConfiguration | null {
+  return loadHooksConfigFromFile(getUserHooksConfigPath());
+}
+
+/**
+ * Load project-specific hooks configuration
+ */
+export function loadProjectHooksConfig(
+  workdir: string,
+): PartialHookConfiguration | null {
+  return loadHooksConfigFromFile(getProjectHooksConfigPath(workdir));
+}
+
+/**
+ * Load and merge hooks configuration from both user and project sources
+ */
+export function loadMergedHooksConfig(
+  workdir: string,
+): PartialHookConfiguration | null {
+  const userConfig = loadUserHooksConfig();
+  const projectConfig = loadProjectHooksConfig(workdir);
+
+  // No configuration found
+  if (!userConfig && !projectConfig) {
+    return null;
+  }
+
+  // Only one configuration found
+  if (!userConfig) return projectConfig;
+  if (!projectConfig) return userConfig;
+
+  // Merge configurations (project overrides user)
+  const merged: PartialHookConfiguration = {};
+
+  // Combine all hook events
+  const allEvents = new Set([
+    ...Object.keys(userConfig),
+    ...Object.keys(projectConfig),
+  ]);
+
+  for (const event of allEvents) {
+    if (!isValidHookEvent(event)) continue;
+
+    const userEventConfigs = userConfig[event] || [];
+    const projectEventConfigs = projectConfig[event] || [];
+
+    // Project configurations take precedence
+    merged[event] = [...userEventConfigs, ...projectEventConfigs];
+  }
+
+  return merged;
+}
+
+/**
+ * Check if hooks configuration exists (user or project)
+ */
+export function hasHooksConfiguration(workdir: string): boolean {
+  return (
+    existsSync(getUserHooksConfigPath()) ||
+    existsSync(getProjectHooksConfigPath(workdir))
+  );
+}
+
+/**
+ * Get hooks configuration information for debugging
+ */
+export function getHooksConfigurationInfo(workdir: string): {
+  hasUser: boolean;
+  hasProject: boolean;
+  paths: string[];
+} {
+  const userPath = getUserHooksConfigPath();
+  const projectPath = getProjectHooksConfigPath(workdir);
+
+  return {
+    hasUser: existsSync(userPath),
+    hasProject: existsSync(projectPath),
+    paths: [userPath, projectPath],
+  };
+}

package/src/services/memory.ts

@@ -41,7 +41,7 @@ export const addMemory = async (
     // Write file
     await fs.writeFile(memoryFilePath, updatedContent, "utf-8");
 
-    // logger.info(`Memory added to ${memoryFilePath}:`, message);
+    // 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}`);
@@ -63,7 +63,7 @@ export const ensureUserMemoryFile = async (): Promise<void> => {
         const initialContent =
           "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
         await fs.writeFile(USER_MEMORY_FILE, initialContent, "utf-8");
-        // logger.info(`Created user memory file: ${USER_MEMORY_FILE}`);
+        // logger.debug(`Created user memory file: ${USER_MEMORY_FILE}`);
       } else {
         throw error;
       }
@@ -93,7 +93,7 @@ export const addUserMemory = async (message: string): Promise<void> => {
     // Write file
     await fs.writeFile(USER_MEMORY_FILE, updatedContent, "utf-8");
 
-    // logger.info(`User memory added to ${USER_MEMORY_FILE}:`, message);
+    // 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}`);