wave-agent-sdk 1.0.5 → 1.0.6

package/src/utils/pathEncoder.ts

@@ -1,400 +0,0 @@
-/**
- * Path encoding utility for converting working directory paths to filesystem-safe names
- * Handles cross-platform directory name encoding for project-based session organization
- */
-
-import { resolve, join } from "path";
-import { createHash } from "crypto";
-import { realpath, mkdir } from "fs/promises";
-import { homedir, platform } from "os";
-
-/**
- * Project directory information
- */
-export interface ProjectDirectory {
-  readonly originalPath: string;
-  readonly encodedName: string;
-  readonly encodedPath: string;
-  readonly pathHash?: string; // For collision resolution
-  readonly isSymbolicLink: boolean;
-}
-
-/**
- * Path encoding configuration options
- */
-export interface PathEncodingOptions {
-  maxLength?: number; // Default: 200 characters
-  pathSeparatorReplacement?: string; // Default: '-'
-  spaceReplacement?: string; // Default: '_'
-  invalidCharReplacement?: string; // Default: '_'
-  hashLength?: number; // Default: 8 characters
-}
-
-/**
- * Platform-specific filesystem constraints
- */
-export interface FilesystemConstraints {
-  readonly maxDirectoryNameLength: number;
-  readonly maxPathLength: number;
-  readonly invalidCharacters: string[];
-  readonly reservedNames: string[];
-  readonly caseSensitive: boolean;
-}
-
-/**
- * Path validation result
- */
-export interface PathValidationResult {
-  readonly isValid: boolean;
-  readonly errors: string[];
-  readonly warnings: string[];
-  readonly suggestedFix?: string;
-}
-
-/**
- * PathEncoder class for converting working directory paths to filesystem-safe names
- */
-export class PathEncoder {
-  private readonly options: Required<PathEncodingOptions>;
-  private readonly constraints: FilesystemConstraints;
-
-  constructor(options: PathEncodingOptions = {}) {
-    this.options = {
-      maxLength: options.maxLength ?? 200,
-      pathSeparatorReplacement: options.pathSeparatorReplacement ?? "-",
-      spaceReplacement: options.spaceReplacement ?? "_",
-      invalidCharReplacement: options.invalidCharReplacement ?? "_",
-      hashLength: options.hashLength ?? 8,
-    };
-    this.constraints = this.getFilesystemConstraints();
-  }
-
-  /**
-   * Encode a working directory path to a filesystem-safe directory name
-   */
-  async encode(originalPath: string): Promise<string> {
-    // Resolve symbolic links and normalize path
-    const resolvedPath = await this.resolvePath(originalPath);
-    return this.encodeSync(resolvedPath);
-  }
-
-  /**
-   * Synchronously encode a path to a filesystem-safe directory name
-   * Note: Does not resolve symbolic links - use encode() for full path resolution
-   */
-  encodeSync(pathToEncode: string): string {
-    // Convert to safe directory name
-    let encoded = pathToEncode;
-
-    // Remove Windows drive letter prefix (e.g. "D:") so encoded names are
-    // stable across platforms — path.resolve("/home/user/project") yields
-    // "D:\home\user\project" on Windows and we want the same encoded name
-    // as on Linux ("home-user-project").
-    encoded = encoded.replace(/^[a-zA-Z]:/, "");
-
-    // Remove leading slash/backslash to avoid empty directory names
-    if (encoded.startsWith("/") || encoded.startsWith("\\")) {
-      encoded = encoded.substring(1);
-    }
-
-    // Replace path separators with hyphens
-    encoded = encoded.replace(/[/\\]/g, this.options.pathSeparatorReplacement);
-
-    // Replace spaces with underscores
-    encoded = encoded.replace(/\s+/g, this.options.spaceReplacement);
-
-    // Replace invalid characters with underscores
-    const escapedChars = this.constraints.invalidCharacters
-      .map((c) => `\\${c}`)
-      .join("");
-    const invalidChars = new RegExp(`[${escapedChars}]`, "g");
-    encoded = encoded.replace(
-      invalidChars,
-      this.options.invalidCharReplacement,
-    );
-
-    // Case is preserved
-
-    // Handle length limit with hash
-    if (encoded.length > this.options.maxLength) {
-      const hash = this.generateHash(pathToEncode, this.options.hashLength);
-      const maxBaseLength =
-        this.options.maxLength - this.options.hashLength - 1; // -1 for separator
-      encoded = `${encoded.substring(0, maxBaseLength)}-${hash}`;
-    }
-
-    return encoded;
-  }
-
-  /**
-   * Decode an encoded directory name back to original path (limited functionality)
-   * Note: This is best-effort as encoding is lossy
-   */
-  async decode(encodedName: string): Promise<string | null> {
-    return this.decodeSync(encodedName);
-  }
-
-  /**
-   * Synchronously decode an encoded directory name back to original path (limited functionality)
-   * Note: This is best-effort as encoding is lossy
-   */
-  decodeSync(encodedName: string): string | null {
-    // This is a simplified version - full reversal is not always possible
-    // due to lossy encoding (case changes, character replacements, hashing)
-
-    // Check if this has a hash suffix
-    const hashPattern = new RegExp(`-[a-f0-9]{${this.options.hashLength}}$`);
-    if (hashPattern.test(encodedName)) {
-      // Cannot reliably decode hashed paths
-      return null;
-    }
-
-    // Attempt basic reversal
-    let decoded = encodedName;
-
-    // Reverse path separator replacement
-    decoded = decoded.replace(
-      new RegExp(this.options.pathSeparatorReplacement, "g"),
-      "/",
-    );
-
-    // Reverse space replacement
-    decoded = decoded.replace(
-      new RegExp(this.options.spaceReplacement, "g"),
-      " ",
-    );
-
-    // Add leading slash
-    decoded = `/${decoded}`;
-
-    return decoded;
-  }
-
-  /**
-   * Resolve symbolic links and normalize path before encoding
-   */
-  async resolvePath(path: string): Promise<string> {
-    try {
-      // Expand tilde to home directory
-      const expandedPath = this.expandTilde(path);
-
-      // Resolve to absolute path
-      const absolutePath = resolve(expandedPath);
-
-      // Resolve symbolic links
-      const resolvedPath = await realpath(absolutePath);
-
-      return resolvedPath;
-    } catch (error) {
-      throw new Error(`Failed to resolve path "${path}": ${error}`);
-    }
-  }
-
-  /**
-   * Get project directory info without creating the directory
-   */
-  async getProjectDirectory(
-    originalPath: string,
-    baseSessionDir: string,
-  ): Promise<ProjectDirectory> {
-    // Resolve the original path and check for symbolic links
-    const expandedPath = this.expandTilde(originalPath);
-    const absolutePath = resolve(expandedPath);
-
-    let resolvedPath: string;
-    let isSymbolicLink = false;
-
-    try {
-      resolvedPath = await realpath(absolutePath);
-      isSymbolicLink = resolvedPath !== absolutePath;
-    } catch {
-      // If realpath fails, use the absolute path
-      resolvedPath = absolutePath;
-    }
-
-    // Encode the resolved path. Use encodeSync (pure string transform) rather
-    // than encode(): realpath was already attempted above with its own fallback,
-    // so re-resolving via encode()->resolvePath() would throw ENOENT again when
-    // the workdir no longer exists (e.g. a deleted worktree during agent
-    // shutdown). Session files live under <baseSessionDir>/<encoded>/ regardless
-    // of the workdir's existence, so encoding must not require it to exist.
-    const encodedName = this.encodeSync(resolvedPath);
-    const encodedPath = join(baseSessionDir, encodedName);
-
-    // Generate hash if encoding resulted in truncation
-    let pathHash: string | undefined;
-    if (resolvedPath.length > this.options.maxLength) {
-      pathHash = this.generateHash(resolvedPath, this.options.hashLength);
-    }
-
-    return {
-      originalPath: resolvedPath,
-      encodedName,
-      encodedPath,
-      pathHash,
-      isSymbolicLink,
-    };
-  }
-
-  /**
-   * Create project directory entity from original path
-   */
-  async createProjectDirectory(
-    originalPath: string,
-    baseSessionDir: string,
-  ): Promise<ProjectDirectory> {
-    const projectDirectory = await this.getProjectDirectory(
-      originalPath,
-      baseSessionDir,
-    );
-
-    // Ensure the encoded directory exists
-    try {
-      await mkdir(projectDirectory.encodedPath, { recursive: true });
-    } catch {
-      // Ignore errors if directory already exists
-    }
-
-    return projectDirectory;
-  }
-
-  /**
-   * Validate that an encoded name is filesystem-safe
-   */
-  validateEncodedName(encodedName: string): boolean {
-    // Check length
-    if (encodedName.length > this.constraints.maxDirectoryNameLength) {
-      return false;
-    }
-
-    // Check for invalid characters
-    for (const char of this.constraints.invalidCharacters) {
-      if (encodedName.includes(char)) {
-        return false;
-      }
-    }
-
-    // Check for reserved names
-    const lowerName = encodedName.toLowerCase();
-    if (
-      this.constraints.reservedNames.some(
-        (reserved) => reserved.toLowerCase() === lowerName,
-      )
-    ) {
-      return false;
-    }
-
-    // Check for empty or dots-only names
-    if (!encodedName.trim() || /^\.+$/.test(encodedName)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Handle encoding collisions by generating unique names
-   */
-  resolveCollision(baseName: string, existingNames: Set<string>): string {
-    if (!existingNames.has(baseName)) {
-      return baseName;
-    }
-
-    // Try numbered suffixes first
-    for (let i = 1; i <= 999; i++) {
-      const candidate = `${baseName}-${i}`;
-      if (!existingNames.has(candidate)) {
-        return candidate;
-      }
-    }
-
-    // If all numbered suffixes are taken, use hash
-    const hash = this.generateHash(
-      baseName + Date.now(),
-      this.options.hashLength,
-    );
-    return `${baseName}-${hash}`;
-  }
-
-  /**
-   * Get platform-specific filesystem constraints
-   */
-  private getFilesystemConstraints(): FilesystemConstraints {
-    const currentPlatform = platform();
-
-    switch (currentPlatform) {
-      case "win32":
-        return {
-          maxDirectoryNameLength: 255,
-          maxPathLength: 260,
-          invalidCharacters: ["<", ">", ":", '"', "|", "?", "*"],
-          reservedNames: [
-            "CON",
-            "PRN",
-            "AUX",
-            "NUL",
-            "COM1",
-            "COM2",
-            "COM3",
-            "COM4",
-            "COM5",
-            "COM6",
-            "COM7",
-            "COM8",
-            "COM9",
-            "LPT1",
-            "LPT2",
-            "LPT3",
-            "LPT4",
-            "LPT5",
-            "LPT6",
-            "LPT7",
-            "LPT8",
-            "LPT9",
-          ],
-          caseSensitive: false,
-        };
-      case "darwin":
-        return {
-          maxDirectoryNameLength: 255,
-          maxPathLength: 1024,
-          invalidCharacters: [":"],
-          reservedNames: [],
-          caseSensitive: false, // HFS+ is case-insensitive by default
-        };
-      default: // Linux and other Unix-like systems
-        return {
-          maxDirectoryNameLength: 255,
-          maxPathLength: 4096,
-          invalidCharacters: ["\0"],
-          reservedNames: [],
-          caseSensitive: true,
-        };
-    }
-  }
-
-  /**
-   * Generate hash for collision resolution
-   */
-  private generateHash(input: string, length: number): string {
-    return createHash("sha256")
-      .update(input)
-      .digest("hex")
-      .substring(0, length);
-  }
-
-  /**
-   * Expand tilde (~) to home directory
-   */
-  private expandTilde(path: string): string {
-    if (path.startsWith("~/") || path === "~") {
-      return path.replace(/^~/, homedir());
-    }
-    return path;
-  }
-}
-
-/**
- * Default PathEncoder instance
- */
-export const pathEncoder = new PathEncoder();

package/src/utils/pathSafety.ts

@@ -1,40 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-
-/**
- * Get the real path of a file or directory, even if it doesn't exist.
- * For non-existent paths, it resolves the real path of the nearest existing parent.
- */
-function getSafeRealPath(p: string): string {
-  try {
-    return fs.realpathSync(p);
-  } catch {
-    const parent = path.dirname(p);
-    if (parent === p) return p; // Root reached
-    return path.join(getSafeRealPath(parent), path.basename(p));
-  }
-}
-
-/**
- * Check if a target path is inside a parent directory.
- * Resolves symlinks and handles absolute paths.
- * Returns true if target is the same as parent or is a subdirectory of parent.
- * @param target The path to check
- * @param parent The parent directory path
- * @returns boolean
- */
-export function isPathInside(target: string, parent: string): boolean {
-  try {
-    const absoluteTarget = path.resolve(target);
-    const absoluteParent = path.resolve(parent);
-
-    const realTarget = getSafeRealPath(absoluteTarget);
-    const realParent = getSafeRealPath(absoluteParent);
-
-    const relative = path.relative(realParent, realTarget);
-
-    return !relative.startsWith("..") && !path.isAbsolute(relative);
-  } catch {
-    return false;
-  }
-}

package/src/utils/promptHistory.ts

@@ -1,168 +0,0 @@
-import fs from "fs";
-import { PROMPT_HISTORY_FILE, DATA_DIRECTORY } from "./constants.js";
-import { logger } from "./globalLogger.js";
-import { PromptEntry } from "../types/history.js";
-
-/**
- * Ensure data directory exists
- */
-const ensureDataDirectory = (): void => {
-  try {
-    if (!fs.existsSync(DATA_DIRECTORY)) {
-      fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
-    }
-  } catch (error) {
-    logger.debug("Failed to create data directory:", error);
-  }
-};
-
-const MAX_HISTORY_ENTRIES = 1000;
-
-export class PromptHistoryManager {
-  /**
-   * Add a new prompt to history
-   */
-  static async addEntry(
-    prompt: string,
-    sessionId?: string,
-    longTextMap?: Record<string, string>,
-    workdir?: string,
-  ): Promise<void> {
-    try {
-      if (!prompt.trim()) return;
-
-      ensureDataDirectory();
-      const entry: PromptEntry = {
-        prompt,
-        timestamp: Date.now(),
-        sessionId,
-        longTextMap,
-        workdir,
-      };
-
-      const line = JSON.stringify(entry) + "\n";
-      await fs.promises.appendFile(PROMPT_HISTORY_FILE, line, "utf-8");
-
-      // Periodically trim history file to prevent it from growing too large
-      // We do this randomly (1 in 50 chance) to avoid performance hit on every entry
-      if (Math.random() < 0.02) {
-        await this.trimHistory();
-      }
-    } catch (error) {
-      logger.debug("Failed to add prompt to history:", error);
-    }
-  }
-
-  /**
-   * Trim history file to MAX_HISTORY_ENTRIES
-   */
-  private static async trimHistory(): Promise<void> {
-    try {
-      if (!fs.existsSync(PROMPT_HISTORY_FILE)) return;
-
-      const data = await fs.promises.readFile(PROMPT_HISTORY_FILE, "utf-8");
-      const lines = data.split("\n").filter((line) => line.trim());
-
-      if (lines.length > MAX_HISTORY_ENTRIES * 1.2) {
-        const trimmedLines = lines.slice(-MAX_HISTORY_ENTRIES);
-        await fs.promises.writeFile(
-          PROMPT_HISTORY_FILE,
-          trimmedLines.join("\n") + "\n",
-          "utf-8",
-        );
-      }
-    } catch (error) {
-      logger.debug("Failed to trim prompt history:", error);
-    }
-  }
-
-  /**
-   * Get all history entries
-   */
-  static async getHistory(options?: {
-    sessionId?: string | string[];
-    workdir?: string;
-  }): Promise<PromptEntry[]> {
-    try {
-      if (!fs.existsSync(PROMPT_HISTORY_FILE)) {
-        return [];
-      }
-
-      const data = await fs.promises.readFile(PROMPT_HISTORY_FILE, "utf-8");
-      const lines = data.split("\n").filter((line) => line.trim());
-
-      const entries: PromptEntry[] = lines
-        .map((line) => {
-          try {
-            return JSON.parse(line) as PromptEntry;
-          } catch {
-            logger.debug("Failed to parse history line:", line);
-            return null;
-          }
-        })
-        .filter((entry): entry is PromptEntry => entry !== null);
-
-      // Filter by sessionId if provided
-      let filteredEntries = entries;
-      if (options?.sessionId) {
-        const sessionIds = Array.isArray(options.sessionId)
-          ? options.sessionId
-          : [options.sessionId];
-        filteredEntries = filteredEntries.filter(
-          (entry) => entry.sessionId && sessionIds.includes(entry.sessionId),
-        );
-      }
-
-      // Filter by workdir if provided
-      if (options?.workdir) {
-        filteredEntries = filteredEntries.filter(
-          (entry) => entry.workdir === options.workdir,
-        );
-      }
-
-      // Deduplicate by prompt, keeping the most recent one
-      const uniqueEntries: PromptEntry[] = [];
-      const seenPrompts = new Set<string>();
-
-      // Process from newest to oldest
-      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);
-        }
-      }
-
-      return uniqueEntries;
-    } catch (error) {
-      logger.debug("Failed to load prompt history:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Search history by query
-   */
-  static async searchHistory(
-    query: string,
-    options?: {
-      sessionId?: string | string[];
-      workdir?: string;
-    },
-  ): Promise<PromptEntry[]> {
-    try {
-      const history = await this.getHistory(options);
-      if (!query.trim()) {
-        return history;
-      }
-
-      const normalizedQuery = query.toLowerCase();
-      return history.filter((entry) =>
-        entry.prompt.toLowerCase().includes(normalizedQuery),
-      );
-    } catch (error) {
-      logger.debug("Failed to search prompt history:", error);
-      return [];
-    }
-  }
-}

package/src/utils/ripgrep.ts

@@ -1,35 +0,0 @@
-import path from "path";
-import process from "process";
-import { getPackageRoot } from "./configPaths.js";
-
-/**
- * Detect the current platform and architecture to find the correct bundled ripgrep binary.
- */
-function getPlatformKey(): string {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  if (platform === "darwin") {
-    return arch === "arm64" ? "macos-aarch64" : "macos-x86_64";
-  } else if (platform === "linux") {
-    return arch === "arm64" ? "linux-aarch64" : "linux-x86_64";
-  } else if (platform === "win32") {
-    return arch === "arm64" ? "windows-aarch64" : "windows-x86_64";
-  }
-
-  throw new Error(`Unsupported platform: ${platform}-${arch}`);
-}
-
-const platformKey = getPlatformKey();
-const isWindows = platformKey.startsWith("windows");
-const binaryName = isWindows ? "rg.exe" : "rg";
-
-/**
- * Path to the ripgrep binary bundled in the vendor directory.
- * Uses findUpSync to locate the package root, working correctly even
- * when bundled (e.g. esbuild into a VS Code extension).
- */
-export const rgPath = path.join(
-  getPackageRoot(),
-  `vendor/ripgrep/${platformKey}/${binaryName}`,
-);