wave-agent-sdk 0.0.8 → 0.0.10

package/src/tools/multiEditTool.ts

@@ -2,7 +2,6 @@ import { readFile, writeFile } from "fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { diffLines } from "diff";
 
 interface EditOperation {
   old_string: string;
@@ -182,7 +181,7 @@ export const multiEditTool: ToolPlugin = {
           return {
             success: false,
             content: "",
-            error: `Edit operation ${i + 1}: old_string not found in current content: "${edit.old_string}"`,
+            error: `Edit operation ${i + 1}: old_string not found in current content`,
           };
         }
 
@@ -217,6 +216,42 @@ export const multiEditTool: ToolPlugin = {
         }
       }
 
+      // Permission check after validation but before real operation
+      if (
+        context.permissionManager &&
+        context.permissionMode &&
+        context.permissionMode !== "bypassPermissions"
+      ) {
+        if (context.permissionManager.isRestrictedTool("MultiEdit")) {
+          try {
+            const permissionContext = context.permissionManager.createContext(
+              "MultiEdit",
+              context.permissionMode,
+              context.canUseToolCallback,
+              { file_path: filePath, edits },
+            );
+            const permissionResult =
+              await context.permissionManager.checkPermission(
+                permissionContext,
+              );
+
+            if (permissionResult.behavior === "deny") {
+              return {
+                success: false,
+                content: "",
+                error: `MultiEdit operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+              };
+            }
+          } catch {
+            return {
+              success: false,
+              content: "",
+              error: "Permission check failed",
+            };
+          }
+        }
+      }
+
       // Write file
       try {
         await writeFile(resolvedPath, currentContent, "utf-8");
@@ -228,9 +263,6 @@ export const multiEditTool: ToolPlugin = {
         };
       }
 
-      // Generate diff information
-      const diffResult = diffLines(originalContent, currentContent);
-
       const shortResult = isNewFile
         ? `Created file with ${edits.length} operations`
         : `Applied ${edits.length} edits`;
@@ -244,9 +276,6 @@ export const multiEditTool: ToolPlugin = {
         content: detailedContent,
         shortResult,
         filePath: resolvedPath,
-        originalContent,
-        newContent: currentContent,
-        diffResult,
       };
     } catch (error) {
       const errorMessage =

package/src/tools/readTool.ts

@@ -1,4 +1,5 @@
-import { readFile } from "fs/promises";
+import { readFile, stat } from "fs/promises";
+import { extname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
@@ -6,6 +7,123 @@ import {
   isBinaryDocument,
   getBinaryDocumentError,
 } from "../utils/fileFormat.js";
+import { convertImageToBase64 } from "../utils/messageOperations.js";
+
+/**
+ * Supported image file extensions
+ */
+const SUPPORTED_IMAGE_EXTENSIONS = [
+  "png",
+  "jpeg",
+  "jpg",
+  "gif",
+  "webp",
+] as const;
+
+/**
+ * Check if a file path represents an image file
+ * @param filePath - Path to the file
+ * @returns true if the file is a supported image format
+ */
+function isImageFile(filePath: string): boolean {
+  const ext = extname(filePath).toLowerCase().substring(1);
+  return (SUPPORTED_IMAGE_EXTENSIONS as readonly string[]).includes(ext);
+}
+
+/**
+ * Validate image file size
+ * @param filePath - Path to the image file
+ * @param maxSizeBytes - Maximum allowed file size in bytes (default: 20MB)
+ * @returns Promise<boolean> - true if file size is within limit
+ */
+async function validateImageFileSize(
+  filePath: string,
+  maxSizeBytes: number = 20 * 1024 * 1024,
+): Promise<boolean> {
+  try {
+    const stats = await stat(filePath);
+    return stats.size <= maxSizeBytes;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get MIME type for image file based on extension
+ * @param filePath - Path to the image file
+ * @returns MIME type string
+ */
+function getImageMimeType(filePath: string): string {
+  const ext = extname(filePath).toLowerCase().substring(1);
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    default:
+      return "image/png"; // Default fallback
+  }
+}
+
+/**
+ * Process an image file and return ToolResult with image data
+ * @param filePath - Path to the image file
+ * @param context - Tool execution context
+ * @returns Promise<ToolResult> with image data
+ */
+async function processImageFile(
+  filePath: string,
+  context: ToolContext,
+): Promise<ToolResult> {
+  try {
+    // Resolve path
+    const actualFilePath = filePath.startsWith("/")
+      ? filePath
+      : resolvePath(filePath, context.workdir);
+
+    // Validate file size
+    const isValidSize = await validateImageFileSize(actualFilePath);
+    if (!isValidSize) {
+      const stats = await stat(actualFilePath);
+      const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+      return {
+        success: false,
+        content: "",
+        error: `Image file exceeds 20MB limit (actual: ${sizeMB}MB)`,
+      };
+    }
+
+    // Convert image to base64
+    const imageDataUrl = convertImageToBase64(actualFilePath);
+    const mimeType = getImageMimeType(actualFilePath);
+
+    // Extract base64 data from data URL (remove data:image/type;base64, prefix)
+    const base64Data = imageDataUrl.split(",")[1] || "";
+
+    return {
+      success: true,
+      content: `Image file processed: ${getDisplayPath(filePath, context.workdir)}\nFormat: ${mimeType}\nSize: Available for AI processing`,
+      shortResult: `Image processed (${mimeType})`,
+      images: [
+        {
+          data: base64Data,
+          mediaType: mimeType,
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      success: false,
+      content: "",
+      error: `Failed to process image: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
 
 /**
  * Read Tool Plugin - Read file content
@@ -17,7 +135,7 @@ export const readTool: ToolPlugin = {
     function: {
       name: "Read",
       description:
-        "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.\n- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.",
+        "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Agent to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Agent is a multimodal LLM.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.\n- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.",
       parameters: {
         type: "object",
         properties: {
@@ -65,6 +183,11 @@ export const readTool: ToolPlugin = {
       };
     }
 
+    // Check if this is an image file
+    if (isImageFile(filePath)) {
+      return processImageFile(filePath, context);
+    }
+
     try {
       // Note: New Read tool requires absolute paths, so we don't use resolvePath
       // But for compatibility, if it's not an absolute path, we still try to resolve

package/src/tools/skillTool.ts

@@ -23,11 +23,11 @@ export function createSkillTool(skillManager: SkillManager): ToolPlugin {
   };
 
   return {
-    name: "skill",
+    name: "Skill",
     config: {
       type: "function",
       function: {
-        name: "skill",
+        name: "Skill",
         description: getToolDescription(),
         parameters: {
           type: "object",

package/src/tools/todoWriteTool.ts

@@ -1,4 +1,4 @@
-import type { ToolPlugin, ToolResult } from "./types.js";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 
 interface TodoItem {
   content: string;
@@ -101,6 +101,38 @@ When in doubt, use this tool. Being proactive with task management demonstrates
     },
   },
 
+  formatCompactParams: (
+    params: Record<string, unknown>,
+    context: ToolContext,
+  ) => {
+    void context; // Context not needed for this tool
+    try {
+      const { todos } = params as { todos?: TodoItem[] };
+
+      // Handle invalid or missing tasks array
+      if (!todos || !Array.isArray(todos)) {
+        return "invalid todos";
+      }
+
+      // Handle empty task list
+      if (todos.length === 0) {
+        return "0 tasks";
+      }
+
+      // Count completed tasks
+      const completedCount = todos.filter(
+        (todo) => todo && todo.status === "completed",
+      ).length;
+      const totalCount = todos.length;
+
+      // Format with proper singular/plural
+      const taskWord = totalCount === 1 ? "task" : "tasks";
+      return `${completedCount}/${totalCount} ${taskWord}`;
+    } catch {
+      return "invalid todos";
+    }
+  },
+
   execute: async (args: Record<string, unknown>): Promise<ToolResult> => {
     try {
       // Validate arguments

package/src/tools/types.ts

@@ -3,6 +3,10 @@
  */
 
 import { ChatCompletionFunctionTool } from "openai/resources.js";
+import type {
+  PermissionMode,
+  PermissionCallback,
+} from "../types/permissions.js";
 
 export interface ToolPlugin {
   name: string;
@@ -23,15 +27,7 @@ export interface ToolResult {
   error?: string;
   // Short output, used to display summary information in collapsed state
   shortResult?: string;
-  // Additional properties for file editing tools
-  originalContent?: string;
-  newContent?: string;
-  diffResult?: Array<{
-    count?: number;
-    value: string;
-    added?: boolean;
-    removed?: boolean;
-  }>;
+  // File path for operations that affect files
   filePath?: string;
   // Image data, for supporting multimedia content
   images?: Array<{
@@ -44,4 +40,14 @@ export interface ToolContext {
   abortSignal?: AbortSignal;
   backgroundBashManager?: import("../managers/backgroundBashManager.js").BackgroundBashManager;
   workdir: string;
+  /** Permission mode for this tool execution */
+  permissionMode?: PermissionMode;
+  /** Custom permission callback */
+  canUseToolCallback?: PermissionCallback;
+  /** Permission manager instance for permission checks */
+  permissionManager?: import("../managers/permissionManager.js").PermissionManager;
+  /** MCP manager instance for calling MCP tools */
+  mcpManager?: import("../managers/mcpManager.js").McpManager;
+  /** LSP manager instance for code intelligence */
+  lspManager?: import("../types/lsp.js").ILspManager;
 }

package/src/tools/writeTool.ts

@@ -3,7 +3,6 @@ import { dirname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { diffLines } from "diff";
 
 /**
  * File Write Tool Plugin
@@ -80,9 +79,6 @@ export const writeTool: ToolPlugin = {
           content: `File ${filePath} already has the same content, no changes needed`,
           shortResult: "No changes needed",
           filePath: resolvedPath,
-          originalContent,
-          newContent: content,
-          diffResult: [],
         };
       }
 
@@ -102,6 +98,42 @@ export const writeTool: ToolPlugin = {
         }
       }
 
+      // Permission check after validation but before real operation
+      if (
+        context.permissionManager &&
+        context.permissionMode &&
+        context.permissionMode !== "bypassPermissions"
+      ) {
+        if (context.permissionManager.isRestrictedTool("Write")) {
+          try {
+            const permissionContext = context.permissionManager.createContext(
+              "Write",
+              context.permissionMode,
+              context.canUseToolCallback,
+              { file_path: filePath, content },
+            );
+            const permissionResult =
+              await context.permissionManager.checkPermission(
+                permissionContext,
+              );
+
+            if (permissionResult.behavior === "deny") {
+              return {
+                success: false,
+                content: "",
+                error: `Write operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+              };
+            }
+          } catch {
+            return {
+              success: false,
+              content: "",
+              error: "Permission check failed",
+            };
+          }
+        }
+      }
+
       // Write file
       try {
         await writeFile(resolvedPath, content, "utf-8");
@@ -113,9 +145,6 @@ export const writeTool: ToolPlugin = {
         };
       }
 
-      // Generate diff information
-      const diffResult = diffLines(originalContent, content);
-
       const shortResult = isExistingFile ? "File overwritten" : "File created";
 
       const lines = content.split("\n").length;
@@ -129,9 +158,6 @@ export const writeTool: ToolPlugin = {
         content: detailedContent,
         shortResult,
         filePath: resolvedPath,
-        originalContent,
-        newContent: content,
-        diffResult,
       };
     } catch (error) {
       const errorMessage =

package/src/types/commands.ts

@@ -11,7 +11,6 @@ export interface SlashCommand {
 }
 
 export interface CustomSlashCommandConfig {
-  allowedTools?: string[];
   model?: string;
   description?: string;
 }

package/src/types/config.ts

@@ -3,9 +3,14 @@
  * Dependencies: None
  */
 
+import OpenAI from "openai";
+
 export interface GatewayConfig {
   apiKey: string;
   baseURL: string;
+  defaultHeaders?: Record<string, string>;
+  fetchOptions?: OpenAI["fetchOptions"];
+  fetch?: OpenAI["fetch"];
 }
 
 export interface ModelConfig {

package/src/types/configuration.ts

@@ -0,0 +1,73 @@
+/**
+ * Configuration Management Types
+ *
+ * Types for centralized configuration loading and validation services.
+ * These support the refactored configuration architecture that separates
+ * configuration management from hook execution.
+ */
+
+import type { WaveConfiguration } from "./hooks.js";
+
+/**
+ * Result of configuration loading operations with detailed status information
+ */
+export interface ConfigurationLoadResult {
+  /** The loaded configuration, or null if loading failed */
+  configuration: WaveConfiguration | null;
+  /** Whether the loading operation was successful */
+  success: boolean;
+  /** Error message if loading failed */
+  error?: string;
+  /** Path of the successfully loaded file */
+  sourcePath?: string;
+  /** Non-critical warnings during loading */
+  warnings: string[];
+}
+
+/**
+ * Result of configuration validation operations
+ */
+export interface ValidationResult {
+  /** Whether the configuration is valid */
+  isValid: boolean;
+  /** Critical errors that prevent configuration use */
+  errors: string[];
+  /** Non-critical warnings about the configuration */
+  warnings: string[];
+}
+
+/**
+ * Configuration file paths organized by category
+ */
+export interface ConfigurationPaths {
+  /** User-specific configuration file paths in priority order */
+  userPaths: string[];
+  /** Project-specific configuration file paths in priority order */
+  projectPaths: string[];
+  /** All configuration paths combined */
+  allPaths: string[];
+  /** Only the paths that actually exist on the filesystem */
+  existingPaths: string[];
+}
+
+/**
+ * Options for configuring the ConfigurationService
+ */
+export interface ConfigurationServiceOptions {
+  /** Working directory for resolving project configurations */
+  workdir: string;
+  /** Optional logger for configuration operations */
+  logger?: Logger;
+  /** Whether to enable validation during loading (default: true) */
+  enableValidation?: boolean;
+}
+
+/**
+ * Minimal logger interface for configuration services
+ */
+interface Logger {
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+}

package/src/types/core.ts

@@ -70,6 +70,17 @@ export interface ClaudeUsage extends CompletionUsage {
   };
 }
 
+/**
+ * Represents a diff change for tool parameter-based diff display
+ * Contains the old content and new content for comparison
+ */
+export interface Change {
+  /** The original content (empty string for additions) */
+  oldContent: string;
+  /** The new content (empty string for deletions) */
+  newContent: string;
+}
+
 export class ConfigurationError extends Error {
   constructor(
     message: string,

package/src/types/environment.ts

@@ -58,3 +58,47 @@ export interface EnvironmentMergeOptions {
   /** Whether to validate variable names for common patterns */
   validateVariableNames?: boolean;
 }
+
+/**
+ * Result of environment variable processing operations
+ */
+export interface EnvironmentProcessResult {
+  /** The processed environment variables */
+  processedVars: Record<string, string>;
+  /** Any conflicts that occurred during processing */
+  conflicts: EnvironmentConflict[];
+  /** Non-critical warnings during processing */
+  warnings: string[];
+  /** Whether the variables were successfully applied to process.env */
+  applied: boolean;
+}
+
+/**
+ * Enhanced environment merge context with conflict details
+ */
+export interface EnvironmentMergeContext {
+  /** User-provided environment variables */
+  userVars: Record<string, string>;
+  /** Project-provided environment variables */
+  projectVars: Record<string, string>;
+  /** Final merged environment variables */
+  mergedVars: Record<string, string>;
+  /** Detailed conflict information */
+  conflicts: EnvironmentConflict[];
+}
+
+/**
+ * Detailed information about an environment variable conflict
+ */
+export interface EnvironmentConflict {
+  /** The environment variable key */
+  key: string;
+  /** Value from user configuration */
+  userValue: string;
+  /** Value from project configuration */
+  projectValue: string;
+  /** Final resolved value (which source won) */
+  resolvedValue: string;
+  /** Which source provided the final value */
+  source: "user" | "project";
+}

package/src/types/fileSearch.ts

@@ -0,0 +1,4 @@
+export interface FileItem {
+  path: string;
+  type: "file" | "directory";
+}

package/src/types/hooks.ts

@@ -5,22 +5,14 @@
  * enabling automated actions at specific workflow points.
  */
 
-import { join } from "path";
-import { homedir } from "os";
-
-// Session path utility (simplified version for hooks)
-export function getSessionFilePath(sessionId: string): string {
-  const shortId = sessionId.split("_")[2] || sessionId.slice(-8);
-  return join(homedir(), ".wave", "sessions", `session_${shortId}.json`);
-}
-
 // Hook event types - trigger points in the AI workflow
 export type HookEvent =
   | "PreToolUse"
   | "PostToolUse"
   | "UserPromptSubmit"
   | "Stop"
-  | "SubagentStop";
+  | "SubagentStop"
+  | "Notification";
 
 // Individual hook command configuration
 export interface HookCommand {
@@ -38,6 +30,11 @@ export interface HookEventConfig {
 export interface WaveConfiguration {
   hooks?: Partial<Record<HookEvent, HookEventConfig[]>>;
   env?: Record<string, string>; // Environment variables key-value pairs
+  defaultMode?: "default" | "bypassPermissions" | "acceptEdits"; // Default permission mode for restricted tools
+  /** New field for persistent permissions */
+  permissions?: {
+    allow?: string[];
+  };
 }
 
 // Legacy alias for backward compatibility - will be deprecated
@@ -117,6 +114,7 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "UserPromptSubmit",
     "Stop",
     "SubagentStop",
+    "Notification",
   ].includes(event);
 }
 
@@ -155,7 +153,7 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "Notification"
 
   // Optional fields based on event type
   tool_name?: string; // Present for PreToolUse, PostToolUse
@@ -163,6 +161,8 @@ export interface HookJsonInput {
   tool_response?: unknown; // Present for PostToolUse only
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
+  message?: string; // Present for Notification events
+  notification_type?: string; // Present for Notification events
 }
 
 // Extended context interface for passing additional data to hook executor
@@ -172,8 +172,11 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   cwd?: string; // Current working directory
   toolInput?: unknown; // Tool input parameters (PreToolUse/PostToolUse)
   toolResponse?: unknown; // Tool execution result (PostToolUse only)
+  env?: Record<string, string>; // Additional environment variables (from configuration)
   userPrompt?: string; // User prompt text (UserPromptSubmit only)
   subagentType?: string; // Subagent type when hook is executed by a subagent
+  message?: string; // Notification message (Notification only)
+  notificationType?: string; // Notification type (Notification only)
 }
 
 // Environment variables injected into hook processes

package/src/types/index.ts

@@ -23,3 +23,8 @@ export * from "./skills.js";
 export * from "./config.js";
 export * from "./session.js";
 export * from "./environment.js";
+export * from "./configuration.js"; // New configuration management types
+export * from "./permissions.js";
+export * from "./tools.js"; // Tool parameter types
+export * from "./fileSearch.js"; // File search types
+export * from "./lsp.js";