wave-agent-sdk 1.0.5 → 1.0.6

package/src/utils/globalLogger.ts

@@ -1,128 +0,0 @@
-/**
- * Global Logger Registry for Agent SDK
- *
- * Provides zero-overhead logging access for utility functions and services
- * without requiring parameter passing. Maintains singleton logger instance
- * accessible across all SDK modules.
- *
- * Features:
- * - Zero overhead when no logger configured (single null check)
- * - Thread-safe in Node.js single-threaded environment
- * - Maintains backward compatibility with existing Logger interface
- * - Direct function delegation when configured
- */
-
-import type { Logger } from "../types/core.js";
-
-/**
- * Module-level storage for the global logger instance
- * null = unconfigured (logging calls are no-ops)
- * Logger = configured (calls are forwarded)
- */
-let globalLogger: Logger | null = null;
-
-// =============================================================================
-// Registry Management API
-// =============================================================================
-
-/**
- * Configure the global logger instance used by utility functions and services
- *
- * @param logger - Logger instance implementing the Logger interface, or null to disable logging
- * @returns void
- *
- * @example
- * ```typescript
- * import { setGlobalLogger } from './utils/globalLogger.js';
- *
- * // Configure logger
- * setGlobalLogger(myLogger);
- *
- * // Disable logging
- * setGlobalLogger(null);
- * ```
- */
-export function setGlobalLogger(logger: Logger | null): void {
-  globalLogger = logger;
-}
-
-/**
- * Reset global logger to unconfigured state
- * Equivalent to setGlobalLogger(null)
- *
- * @example
- * ```typescript
- * clearGlobalLogger(); // All subsequent logging calls become no-ops
- * ```
- */
-export function clearGlobalLogger(): void {
-  globalLogger = null;
-}
-
-/**
- * Check if global logger is currently configured
- *
- * @returns true if logger configured, false otherwise
- *
- * @example
- * ```typescript
- * if (isLoggerConfigured()) {
- *   // Perform expensive logging operation
- *   const debugInfo = generateDebugInfo();
- *   logger.debug(debugInfo);
- * }
- * ```
- */
-export function isLoggerConfigured(): boolean {
-  return globalLogger !== null;
-}
-
-// =============================================================================
-// Zero-Overhead Logging API
-// =============================================================================
-
-/**
- * Zero-overhead logging interface
- *
- * Performance characteristics:
- * - Unconfigured: Single null check + early return (near-zero cost)
- * - Configured: Null check + function delegation
- * - No object creation or intermediate allocations
- */
-export const logger = {
-  /**
-   * Log debug-level message through global logger
-   * No-op when global logger is null (zero overhead)
-   */
-  debug: (...args: unknown[]): void => {
-    if (globalLogger === null) return;
-    globalLogger.debug(...args);
-  },
-
-  /**
-   * Log info-level message through global logger
-   * No-op when global logger is null (zero overhead)
-   */
-  info: (...args: unknown[]): void => {
-    if (globalLogger === null) return;
-    globalLogger.info(...args);
-  },
-
-  /**
-   * Log warning-level message through global logger
-   * No-op when global logger is null (zero overhead)
-   */
-  warn: (...args: unknown[]): void => {
-    if (globalLogger === null) return;
-    globalLogger.warn(...args);
-  },
-
-  /**
-   * Log error-level message through global logger
-   * No-op when global logger is null (zero overhead)
-   */
-  error: (...args: unknown[]): void => {
-    if (globalLogger === null) return;
-    globalLogger.error(...args);
-  },
-} as const;

package/src/utils/groupMessagesByApiRound.ts

@@ -1,121 +0,0 @@
-import type { Message } from "../types/index.js";
-import { estimateTokens as estimateStrTokens } from "./tokenEstimate.js";
-
-export interface ApiRound {
-  messages: Message[];
-  estimatedTokens: number;
-}
-
-/**
- * Groups messages into "API rounds" — each round corresponds to one API
- * call-response cycle. This is critical because in agentic sessions with a
- * single user prompt, Wave creates a new Message per API round (each recursive
- * sendAIMessage call creates a new assistant message).
- *
- * Boundaries:
- *  - A new `role: "user"` message starts a new round.
- *  - A new `role: "assistant"` message with a different `id` starts a new round.
- *  - A message with a `compact` block is pushed as its own round and starts a
- *    new round after it.
- */
-export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
-  const rounds: ApiRound[] = [];
-  let currentRound: Message[] = [];
-  let lastAssistantId: string | undefined;
-
-  for (const msg of messages) {
-    let startNewRound = false;
-
-    if (msg.role === "user") {
-      startNewRound = true;
-    } else if (msg.role === "assistant") {
-      // Compact block is always its own round
-      const hasCompact = msg.blocks.some((b) => b.type === "compact");
-      if (hasCompact) {
-        startNewRound = true;
-      } else if (msg.id !== lastAssistantId) {
-        // New assistant id starts a new round.
-        // Exception: if the current round is [user] (first assistant after a
-        // user prompt in a normal conversation), keep them together as one
-        // round. But if we already have assistant(s) in this round (agentic
-        // tool loop), the new id starts a new round.
-        const roundHasOtherAssistant = currentRound.some(
-          (m) => m.role === "assistant" && m.id !== msg.id,
-        );
-        if (roundHasOtherAssistant) {
-          startNewRound = true;
-        }
-      }
-      lastAssistantId = msg.id;
-    }
-
-    if (startNewRound && currentRound.length > 0) {
-      rounds.push({
-        messages: currentRound,
-        estimatedTokens: estimateTokens(currentRound),
-      });
-      currentRound = [];
-    }
-
-    currentRound.push(msg);
-
-    // After pushing a compact message as its own round, flush immediately
-    if (
-      msg.role === "assistant" &&
-      msg.blocks.some((b) => b.type === "compact")
-    ) {
-      rounds.push({
-        messages: currentRound,
-        estimatedTokens: estimateTokens(currentRound),
-      });
-      currentRound = [];
-    }
-  }
-
-  if (currentRound.length > 0) {
-    rounds.push({
-      messages: currentRound,
-      estimatedTokens: estimateTokens(currentRound),
-    });
-  }
-
-  return rounds;
-}
-
-/**
- * Returns the last `roundCount` complete API rounds as a flat message array.
- * Never splits a tool_use/tool_result pair. If fewer rounds exist, returns all.
- */
-export function getLastApiRounds(
-  messages: Message[],
-  roundCount: number,
-): Message[] {
-  const rounds = groupMessagesByApiRound(messages);
-  const lastRounds = rounds.slice(-roundCount);
-  return lastRounds.flatMap((r) => r.messages);
-}
-
-/**
- * Estimate token count from message blocks using CJK-aware estimation.
- */
-function estimateTokens(messages: Message[]): number {
-  let combined = "";
-  for (const msg of messages) {
-    for (const block of msg.blocks) {
-      if ("content" in block && typeof block.content === "string") {
-        combined += block.content;
-      }
-      if (
-        block.type === "tool" &&
-        block.parameters &&
-        typeof block.parameters === "string"
-      ) {
-        combined += block.parameters;
-      }
-      if (block.type === "tool" && block.result) {
-        combined += block.result;
-      }
-    }
-  }
-  return estimateStrTokens(combined);
-}

package/src/utils/hookMatcher.ts

@@ -1,176 +0,0 @@
-/**
- * Hook Pattern Matcher
- *
- * Provides pattern matching functionality for hook tool name matching.
- * Supports exact matching, wildcard patterns, and pipe-separated alternatives.
- */
-
-import { minimatch } from "minimatch";
-
-export class HookMatcher {
-  /**
-   * Test if pattern matches tool name
-   * Supports multiple matching strategies:
-   * - Exact matching: "Edit" matches "Edit"
-   * - Pipe alternatives: "Edit|Write" matches "Edit" or "Write"
-   * - Glob patterns: "Edit*" matches "EditFile", "EditText", etc.
-   * - Case insensitive matching
-   */
-  matches(pattern: string, toolName: string): boolean {
-    if (!pattern || !toolName) return false;
-
-    // Handle pipe-separated alternatives (e.g., "Edit|Write|Delete")
-    if (pattern.includes("|")) {
-      const alternatives = pattern.split("|").map((alt) => alt.trim());
-      return alternatives.some((alt) => this.matchesSingle(alt, toolName));
-    }
-
-    return this.matchesSingle(pattern, toolName);
-  }
-
-  /**
-   * Match a single pattern against tool name
-   */
-  private matchesSingle(pattern: string, toolName: string): boolean {
-    // Exact match (case insensitive)
-    if (pattern.toLowerCase() === toolName.toLowerCase()) {
-      return true;
-    }
-
-    // Glob pattern matching using minimatch
-    try {
-      return minimatch(toolName, pattern, {
-        nocase: true, // Case insensitive
-        noglobstar: false, // Allow ** patterns
-        nonegate: true, // Disable negation for security
-      });
-    } catch {
-      // Invalid pattern, fall back to exact match
-      return false;
-    }
-  }
-
-  /**
-   * Validate pattern syntax
-   */
-  isValidPattern(pattern: string): boolean {
-    if (!pattern || typeof pattern !== "string") return false;
-
-    // Empty pattern is invalid
-    if (pattern.trim().length === 0) return false;
-
-    // Handle pipe-separated alternatives
-    if (pattern.includes("|")) {
-      const alternatives = pattern.split("|").map((alt) => alt.trim());
-      return (
-        alternatives.length > 0 &&
-        alternatives.every(
-          (alt) => alt.length > 0 && this.isValidSinglePattern(alt),
-        )
-      );
-    }
-
-    return this.isValidSinglePattern(pattern);
-  }
-
-  /**
-   * Validate single pattern syntax
-   */
-  private isValidSinglePattern(pattern: string): boolean {
-    // Basic validation - non-empty string
-    if (!pattern || pattern.trim().length === 0) return false;
-
-    // Check for dangerous characters that could be used for command injection
-    // Note: [ ] are allowed for glob patterns
-    const dangerousChars = /[;&|`$(){}><]/;
-    if (dangerousChars.test(pattern)) return false;
-
-    // Validate glob pattern syntax using minimatch
-    try {
-      // Test with a dummy string to validate pattern
-      minimatch("test", pattern, { nocase: true });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get pattern type for optimization
-   */
-  getPatternType(pattern: string): "exact" | "glob" | "regex" | "alternatives" {
-    if (!pattern) return "exact";
-
-    // Check for pipe alternatives first
-    if (pattern.includes("|")) {
-      return "alternatives";
-    }
-
-    // Check for regex patterns first (before glob check)
-    if (
-      pattern.startsWith("/") &&
-      pattern.endsWith("/") &&
-      pattern.length > 2
-    ) {
-      return "regex";
-    }
-
-    // Check for glob patterns
-    if (
-      pattern.includes("*") ||
-      pattern.includes("?") ||
-      pattern.includes("[")
-    ) {
-      return "glob";
-    }
-
-    return "exact";
-  }
-
-  /**
-   * Get all tool names that would match this pattern from a given list
-   * Useful for testing and validation
-   */
-  getMatches(pattern: string, tools: string[]): string[] {
-    return tools.filter((toolName) => this.matches(pattern, toolName));
-  }
-
-  /**
-   * Optimize pattern for repeated matching
-   * Returns a compiled matcher function for performance
-   */
-  compile(pattern: string): (toolName: string) => boolean {
-    if (!this.isValidPattern(pattern)) {
-      return () => false;
-    }
-
-    const patternType = this.getPatternType(pattern);
-
-    switch (patternType) {
-      case "exact": {
-        const lowerPattern = pattern.toLowerCase();
-        return (toolName: string) => toolName.toLowerCase() === lowerPattern;
-      }
-
-      case "alternatives": {
-        const alternatives = pattern
-          .split("|")
-          .map((alt) => alt.trim().toLowerCase());
-        return (toolName: string) => {
-          const lowerTool = toolName.toLowerCase();
-          return alternatives.some(
-            (alt) =>
-              lowerTool === alt || minimatch(toolName, alt, { nocase: true }),
-          );
-        };
-      }
-
-      case "glob":
-        return (toolName: string) =>
-          minimatch(toolName, pattern, { nocase: true });
-
-      default:
-        return (toolName: string) => this.matches(pattern, toolName);
-    }
-  }
-}