wave-agent-sdk 0.0.8 → 0.0.11

package/src/types/lsp.ts

@@ -0,0 +1,96 @@
+/**
+ * LSP (Language Server Protocol) configuration and communication types
+ */
+
+export interface LspServerConfig {
+  command: string;
+  args?: string[];
+  extensionToLanguage: Record<string, string>;
+  transport?: "stdio" | "socket";
+  env?: Record<string, string>;
+  initializationOptions?: unknown;
+  settings?: unknown;
+  workspaceFolder?: string;
+  startupTimeout?: number;
+  shutdownTimeout?: number;
+  restartOnCrash?: boolean;
+  maxRestarts?: number;
+}
+
+export interface LspConfig {
+  [language: string]: LspServerConfig;
+}
+
+export interface LspPosition {
+  line: number;
+  character: number;
+}
+
+export interface LspRange {
+  start: LspPosition;
+  end: LspPosition;
+}
+
+export interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+export interface LspLocationLink {
+  originSelectionRange?: LspRange;
+  targetUri: string;
+  targetRange: LspRange;
+  targetSelectionRange?: LspRange;
+}
+
+export interface LspHover {
+  contents:
+    | string
+    | { kind: string; value: string }
+    | Array<string | { kind: string; value: string }>;
+  range?: LspRange;
+}
+
+export interface LspSymbolInformation {
+  name: string;
+  kind: number;
+  location: LspLocation;
+  containerName?: string;
+}
+
+export interface LspDocumentSymbol {
+  name: string;
+  detail?: string;
+  kind: number;
+  range: LspRange;
+  selectionRange: LspRange;
+  children?: LspDocumentSymbol[];
+}
+
+export interface LspCallHierarchyItem {
+  name: string;
+  kind: number;
+  detail?: string;
+  uri: string;
+  range: LspRange;
+  selectionRange: LspRange;
+}
+
+export interface LspCallHierarchyIncomingCall {
+  from: LspCallHierarchyItem;
+  fromRanges: LspRange[];
+}
+
+export interface LspCallHierarchyOutgoingCall {
+  to: LspCallHierarchyItem;
+  fromRanges: LspRange[];
+}
+
+export interface ILspManager {
+  execute(args: {
+    operation: string;
+    filePath: string;
+    line: number;
+    character: number;
+  }): Promise<{ success: boolean; content: string }>;
+}

package/src/types/messaging.ts

@@ -15,7 +15,7 @@ export interface Message {
   role: "user" | "assistant";
   blocks: MessageBlock[];
   usage?: Usage; // Usage data for this message's AI operation (assistant messages only)
-  metadata?: Record<string, unknown>; // Additional metadata from AI responses
+  additionalFields?: Record<string, unknown>; // Additional metadata from AI responses
 }
 
 export type MessageBlock =
@@ -23,11 +23,11 @@ export type MessageBlock =
   | ErrorBlock
   | ToolBlock
   | ImageBlock
-  | DiffBlock
   | CommandOutputBlock
   | CompressBlock
   | MemoryBlock
-  | SubagentBlock;
+  | SubagentBlock
+  | ReasoningBlock;
 
 export interface TextBlock {
   type: "text";
@@ -72,16 +72,6 @@ export interface ImageBlock {
   imageUrls?: string[];
 }
 
-export interface DiffBlock {
-  type: "diff";
-  path: string;
-  diffResult: Array<{
-    value: string;
-    added?: boolean;
-    removed?: boolean;
-  }>;
-}
-
 export interface CommandOutputBlock {
   type: "command_output";
   command: string;
@@ -112,3 +102,8 @@ export interface SubagentBlock {
   sessionId: string;
   configuration: SubagentConfiguration;
 }
+
+export interface ReasoningBlock {
+  type: "reasoning";
+  content: string;
+}

package/src/types/permissions.ts

@@ -0,0 +1,52 @@
+/**
+ * Permission system types for Wave Agent SDK
+ * Dependencies: None
+ */
+
+/** Permission mode configuration */
+export type PermissionMode = "default" | "bypassPermissions" | "acceptEdits";
+
+/** Result of a permission check */
+export interface PermissionDecision {
+  /** Whether to allow or deny the operation */
+  behavior: "allow" | "deny";
+  /** Optional message explaining the decision (required for deny) */
+  message?: string;
+  /** Signal to change the session's permission mode */
+  newPermissionMode?: PermissionMode;
+  /** Signal to persist a new allowed rule */
+  newPermissionRule?: string;
+}
+
+/** Callback function for custom permission logic */
+export type PermissionCallback = (
+  context: ToolPermissionContext,
+) => Promise<PermissionDecision>;
+
+/** Internal context passed to PermissionManager */
+export interface ToolPermissionContext {
+  /** Name of the tool being executed */
+  toolName: string;
+  /** Current permission mode */
+  permissionMode: PermissionMode;
+  /** Custom permission callback if provided */
+  canUseToolCallback?: PermissionCallback;
+  /** Tool input parameters for better context */
+  toolInput?: Record<string, unknown>;
+  /** Suggested prefix for bash commands */
+  suggestedPrefix?: string;
+  /** Whether to hide the persistent permission option (e.g., "Don't ask again") in the UI */
+  hidePersistentOption?: boolean;
+}
+
+/** List of tools that require permission checks in default mode */
+export const RESTRICTED_TOOLS = [
+  "Edit",
+  "MultiEdit",
+  "Delete",
+  "Bash",
+  "Write",
+] as const;
+
+/** Type for restricted tool names */
+export type RestrictedTool = (typeof RESTRICTED_TOOLS)[number];

package/src/types/session.ts

@@ -10,16 +10,11 @@ import type { Message } from "./messaging.js";
 // Enhanced message interface for JSONL storage (extends existing Message)
 export interface SessionMessage extends Message {
   timestamp: string; // ISO 8601 - added for JSONL format
-  // Inherits: role: "user" | "assistant", blocks: MessageBlock[], usage?, metadata?
+  // Inherits: role: "user" | "assistant", blocks: MessageBlock[], usage?, additionalFields?
 }
 
-// Metadata line that appears as the first line in JSONL session files
-export interface SessionMetadataLine {
-  __meta__: true;
+// Session filename structure for simple filename-based metadata
+export interface SessionFilename {
   sessionId: string;
   sessionType: "main" | "subagent";
-  parentSessionId?: string;
-  subagentType?: string;
-  workdir: string;
-  startedAt: string;
 }

package/src/types/skills.ts

@@ -61,6 +61,7 @@ export interface SkillManagerOptions {
   personalSkillsPath?: string;
   scanTimeout?: number;
   logger?: Logger;
+  workdir?: string;
 }
 
 export interface ParsedSkillFile {

package/src/types/tools.ts

@@ -0,0 +1,38 @@
+/**
+ * Tool parameter types for edit and write operations
+ */
+
+/**
+ * Parameters for the Write tool
+ */
+export interface WriteToolParameters {
+  file_path: string;
+  content: string;
+}
+
+/**
+ * Parameters for a single edit operation in the Edit tool
+ */
+export interface EditOperation {
+  old_string: string;
+  new_string: string;
+  replace_all?: boolean;
+}
+
+/**
+ * Parameters for the Edit tool
+ */
+export interface EditToolParameters {
+  file_path: string;
+  old_string: string;
+  new_string: string;
+  replace_all?: boolean;
+}
+
+/**
+ * Parameters for the MultiEdit tool
+ */
+export interface MultiEditToolParameters {
+  file_path: string;
+  edits: EditOperation[];
+}

package/src/utils/abortUtils.ts

@@ -0,0 +1,118 @@
+/**
+ * Utilities for safe AbortSignal listener management to prevent memory leaks
+ */
+
+/**
+ * Safely adds a one-time abort listener that automatically cleans up after firing
+ * @param signal - The AbortSignal to listen to
+ * @param callback - The function to call when aborted
+ * @returns A cleanup function to manually remove the listener if needed
+ */
+export function addOnceAbortListener(
+  signal: AbortSignal,
+  callback: () => void,
+): () => void {
+  if (signal.aborted) {
+    // Signal already aborted, call immediately
+    callback();
+    return () => {}; // No cleanup needed
+  }
+
+  const handler = () => {
+    callback();
+  };
+
+  // Use { once: true } to automatically remove listener after first call
+  signal.addEventListener("abort", handler, { once: true });
+
+  // Return cleanup function for manual removal if needed
+  return () => {
+    signal.removeEventListener("abort", handler);
+  };
+}
+
+/**
+ * Creates a Promise that rejects when the AbortSignal is aborted
+ * Uses once-only listener to prevent accumulation
+ * @param signal - The AbortSignal to listen to
+ * @param errorMessage - Optional custom error message
+ * @returns Promise that rejects on abort
+ */
+export function createAbortPromise(
+  signal: AbortSignal,
+  errorMessage: string = "Operation was aborted",
+): Promise<never> {
+  return new Promise<never>((_, reject) => {
+    if (signal.aborted) {
+      reject(new Error(errorMessage));
+      return;
+    }
+
+    // Use once-only listener to prevent accumulation
+    signal.addEventListener(
+      "abort",
+      () => {
+        reject(new Error(errorMessage));
+      },
+      { once: true },
+    );
+  });
+}
+
+/**
+ * Wrapper that manages abort signal listeners with automatic cleanup
+ * @param signal - The AbortSignal to manage
+ * @param operation - Function that sets up listeners and returns cleanup
+ * @returns Promise that resolves with the operation result
+ */
+export async function withAbortCleanup<T>(
+  signal: AbortSignal,
+  operation: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+  // Track all cleanup functions
+  const cleanups: (() => void)[] = [];
+
+  try {
+    const result = await operation(signal);
+    return result;
+  } finally {
+    // Clean up all listeners
+    cleanups.forEach((cleanup) => cleanup());
+  }
+}
+
+/**
+ * Consolidates multiple abort listeners into a single listener
+ * Useful when multiple handlers need to respond to the same abort signal
+ * @param signal - The AbortSignal to listen to
+ * @param callbacks - Array of functions to call when aborted
+ * @returns Cleanup function to remove the consolidated listener
+ */
+export function addConsolidatedAbortListener(
+  signal: AbortSignal,
+  callbacks: (() => void)[],
+): () => void {
+  if (signal.aborted) {
+    // Signal already aborted, call all callbacks immediately
+    callbacks.forEach((cb) => cb());
+    return () => {}; // No cleanup needed
+  }
+
+  const handler = () => {
+    callbacks.forEach((cb) => {
+      try {
+        cb();
+      } catch (error) {
+        console.error("Error in abort callback:", error);
+      }
+    });
+  };
+
+  // Use { once: true } to automatically remove listener after first call
+  signal.addEventListener("abort", handler, { once: true });
+
+  // Return cleanup function for manual removal if needed
+  return () => {
+    signal.removeEventListener("abort", handler);
+  };
+}

package/src/utils/bashHistory.ts

@@ -153,7 +153,7 @@ export const searchBashHistory = (
     if (!normalizedQuery) {
       // If no search query, return recent commands (deduplicated)
       const deduped = deduplicateCommands(filteredCommands);
-      return deduped.slice(-limit).reverse(); // Latest first
+      return deduped.slice(0, limit); // Latest first
     }
 
     // Search by relevance
@@ -226,9 +226,9 @@ const deduplicateCommands = (
     }
   }
 
-  // Sort by timestamp and return
+  // Sort by timestamp and return (new to old)
   return Array.from(commandMap.values()).sort(
-    (a, b) => a.timestamp - b.timestamp,
+    (a, b) => b.timestamp - a.timestamp,
   );
 };
 
@@ -247,13 +247,37 @@ export const getRecentBashCommands = (
 
     // Return recent commands after deduplication
     const deduped = deduplicateCommands(filtered);
-    return deduped.slice(-limit).reverse(); // Latest first
+    return deduped.slice(0, limit); // Latest first
   } catch (error) {
     logger.debug("Failed to get recent bash commands:", error);
     return [];
   }
 };
 
+/**
+ * Delete a specific command from bash history
+ */
+export const deleteBashCommandFromHistory = (
+  command: string,
+  workdir: string,
+): void => {
+  try {
+    const history = loadBashHistory();
+    const initialLength = history.commands.length;
+
+    history.commands = history.commands.filter(
+      (entry) => !(entry.command === command && entry.workdir === workdir),
+    );
+
+    if (history.commands.length !== initialLength) {
+      saveBashHistory(history);
+      logger.debug("Deleted bash command from history:", { command, workdir });
+    }
+  } catch (error) {
+    logger.debug("Failed to delete bash command from history:", error);
+  }
+};
+
 /**
  * Clear bash history
  */