wave-agent-sdk 1.0.5 → 1.0.6

package/src/utils/fileSearch.ts

@@ -1,151 +0,0 @@
-import { spawn } from "child_process";
-import { rgPath } from "./ripgrep.js";
-import fuzzysort from "fuzzysort";
-import type { FileItem } from "../types/fileSearch.js";
-import { logger } from "./globalLogger.js";
-
-const EXCLUDED_FILES = [".git", ".DS_Store"];
-
-/**
- * Execute ripgrep to get all file paths
- */
-async function getAllFiles(workingDirectory: string): Promise<string[]> {
-  if (!rgPath) {
-    throw new Error("ripgrep is not available");
-  }
-
-  const rgArgs = ["--files", "--color=never", "--hidden"];
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(rgPath, rgArgs, {
-      cwd: workingDirectory,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      // Exit 2 = some files were unreadable (e.g. device-name files like
-      // "nul" on Windows); stdout still holds usable partial results.
-      // Spawn failures surface via the 'error' listener instead.
-      if (code !== 0 && code !== 1) {
-        logger.warn(
-          `ripgrep exited with code ${code}, keeping partial results: ${stderr.trim()}`,
-        );
-      }
-      const files = stdout
-        .trim()
-        .split("\n")
-        .filter((f) => {
-          if (f.length === 0) return false;
-          const parts = f.split(/[/\\]/);
-          return !parts.some((part) => EXCLUDED_FILES.includes(part));
-        })
-        .map((f) => f.replace(/\\/g, "/")); // Normalize to forward slashes
-      resolve(files);
-    });
-
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
-/**
- * Derive directory paths from file paths
- */
-function deriveDirectories(files: string[]): string[] {
-  const dirs = new Set<string>();
-  for (const file of files) {
-    const parts = file.split("/");
-    // Add all parent directories
-    for (let i = 1; i < parts.length; i++) {
-      const dir = parts.slice(0, i).join("/") + "/";
-      dirs.add(dir);
-    }
-  }
-  return Array.from(dirs);
-}
-
-/**
- * Search files and directories using fuzzy matching
- */
-export const searchFiles = async (
-  query: string,
-  options?: {
-    maxResults?: number;
-    workingDirectory?: string;
-  },
-): Promise<FileItem[]> => {
-  const { maxResults = 100, workingDirectory = process.cwd() } = options || {};
-
-  try {
-    const files = await getAllFiles(workingDirectory);
-
-    if (!query.trim()) {
-      // When query is empty, show some common file types and top-level directories
-      const commonExtensions = new Set([
-        "ts",
-        "tsx",
-        "js",
-        "jsx",
-        "json",
-        "py",
-        "java",
-      ]);
-      const results: FileItem[] = [];
-      const seenDirs = new Set<string>();
-
-      for (const file of files) {
-        const parts = file.split("/");
-        if (parts.length > 1) {
-          const topDir = parts[0] + "/";
-          if (!seenDirs.has(topDir)) {
-            seenDirs.add(topDir);
-            results.push({ path: topDir, type: "directory" });
-          }
-        }
-
-        const ext = file.split(".").pop();
-        if (ext && commonExtensions.has(ext)) {
-          results.push({ path: file, type: "file" });
-        }
-      }
-
-      // Sort: directories first, then files, then alphabetically
-      return results
-        .sort((a, b) => {
-          if (a.type === "directory" && b.type === "file") return -1;
-          if (a.type === "file" && b.type === "directory") return 1;
-          return a.path.localeCompare(b.path);
-        })
-        .slice(0, maxResults);
-    }
-
-    const directories = deriveDirectories(files);
-    const allItems: FileItem[] = [
-      ...files.map((f) => ({ path: f, type: "file" as const })),
-      ...directories.map((d) => ({ path: d, type: "directory" as const })),
-    ];
-
-    const fuzzyResults = fuzzysort.go(query, allItems, {
-      key: "path",
-      limit: maxResults,
-      threshold: 0,
-    });
-
-    return fuzzyResults.map((res) => res.obj);
-  } catch (error) {
-    logger.error("Fuzzy search error:", error);
-    return [];
-  }
-};

package/src/utils/fileUtils.ts

@@ -1,223 +0,0 @@
-import fs from "node:fs/promises";
-import { createReadStream } from "node:fs";
-import path from "node:path";
-import { glob } from "glob";
-
-/**
- * Reads the first line of a file efficiently using Node.js readline.
- *
- * @param {string} filePath - The path to the file.
- * @return {Promise<string>} - The first non-empty line of the file, or an empty string otherwise.
- */
-export async function readFirstLine(filePath: string): Promise<string> {
-  const { createInterface } = await import("node:readline");
-
-  const fileStream = createReadStream(filePath);
-  const rl = createInterface({
-    input: fileStream,
-    crlfDelay: Infinity, // Handle \r\n properly
-  });
-
-  try {
-    for await (const line of rl) {
-      const trimmedLine = line.trim();
-      if (trimmedLine.length > 0) {
-        return trimmedLine;
-      }
-    }
-    return "";
-  } catch {
-    // If reading fails (e.g., file doesn't exist), return empty string
-    return "";
-  } finally {
-    rl.close();
-    fileStream.destroy();
-  }
-}
-
-/**
- * Reads up to N lines from a file using Node.js readline.
- *
- * @param {string} filePath - The path to the file.
- * @param {number} maxLines - Maximum number of non-empty lines to read.
- * @return {Promise<string[]>} - Array of non-empty lines (up to maxLines).
- */
-export async function readFirstNLines(
-  filePath: string,
-  maxLines: number,
-): Promise<string[]> {
-  const { createInterface } = await import("node:readline");
-
-  const fileStream = createReadStream(filePath);
-  const rl = createInterface({
-    input: fileStream,
-    crlfDelay: Infinity,
-  });
-
-  const lines: string[] = [];
-
-  try {
-    for await (const line of rl) {
-      const trimmedLine = line.trim();
-      if (trimmedLine.length > 0) {
-        lines.push(trimmedLine);
-        if (lines.length >= maxLines) {
-          break;
-        }
-      }
-    }
-    return lines;
-  } catch {
-    return lines;
-  } finally {
-    rl.close();
-    fileStream.destroy();
-  }
-}
-
-/**
- * Reads a file from the end and returns the last non-empty line.
- *
- * This version supports files that end with:
- *   - "\n" (Unix-style, including modern macOS)
- *   - "\r\n" (Windows-style)
- *   - "\r" (older Mac-style, HL7, etc.)
- *
- * @param {string} filePath - The path to the file.
- * @param {number} [minLength=1] - Minimum length for the returned line.
- * @return {Promise<string>} - The last non-empty line of the file, or an empty string if no non-empty lines found.
- */
-export async function getLastLine(
-  filePath: string,
-  minLength = 1,
-): Promise<string> {
-  let fileHandle;
-  try {
-    const stats = await fs.stat(filePath);
-    const fileSize = stats.size;
-
-    if (fileSize === 0) return "";
-
-    fileHandle = await fs.open(filePath, "r");
-    const bufferSize = 8 * 1024; // 8KB buffer is usually enough for the last line
-    const buffer = Buffer.alloc(bufferSize);
-
-    let lineEnd: number | null = null;
-    let lineStart: number | null = null;
-    let currentPosition = fileSize;
-
-    while (currentPosition > 0 && lineStart === null) {
-      const readSize = Math.min(bufferSize, currentPosition);
-      currentPosition -= readSize;
-
-      const { bytesRead } = await fileHandle.read(
-        buffer,
-        0,
-        readSize,
-        currentPosition,
-      );
-
-      for (let i = bytesRead - 1; i >= 0; i--) {
-        const charCode = buffer[i];
-        if (lineEnd === null) {
-          // Still looking for the end of the last non-empty line (skip trailing newlines and whitespace)
-          if (charCode > 32) {
-            lineEnd = currentPosition + i + 1;
-          }
-        } else {
-          // Looking for the start of the line (the newline before it)
-          if (charCode === 10 || charCode === 13) {
-            lineStart = currentPosition + i + 1;
-            break;
-          }
-        }
-      }
-    }
-
-    if (lineEnd === null) return "";
-    if (lineStart === null) lineStart = 0;
-
-    const length = lineEnd - lineStart;
-    if (length < minLength) return "";
-
-    const resultBuffer = Buffer.alloc(length);
-    await fileHandle.read(resultBuffer, 0, length, lineStart);
-    const result = resultBuffer.toString("utf8").trim();
-    return result.length >= minLength ? result : "";
-  } catch {
-    // If reading fails (e.g., file doesn't exist), return empty string
-    return "";
-  } finally {
-    if (fileHandle) {
-      await fileHandle.close();
-    }
-  }
-}
-
-/**
- * Simple Levenshtein distance implementation
- */
-function levenshtein(a: string, b: string): number {
-  const matrix = Array.from({ length: a.length + 1 }, () =>
-    Array.from({ length: b.length + 1 }, () => 0),
-  );
-
-  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
-  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
-
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,
-        matrix[i][j - 1] + 1,
-        matrix[i - 1][j - 1] + cost,
-      );
-    }
-  }
-
-  return matrix[a.length][b.length];
-}
-
-/**
- * Suggests similar paths if a file is not found.
- */
-export async function suggestPathUnderCwd(
-  targetPath: string,
-  workdir: string,
-): Promise<string[]> {
-  try {
-    const allFiles = await glob("**/*", {
-      cwd: workdir,
-      nodir: true,
-      dot: true,
-      ignore: ["**/.git/**", "**/node_modules/**"],
-    });
-
-    const targetBasename = path.basename(targetPath);
-    const suggestions = allFiles
-      .map((file) => ({
-        path: file,
-        distance: levenshtein(targetBasename, path.basename(file)),
-      }))
-      .filter((item) => item.distance <= 3) // Threshold for similarity
-      .sort((a, b) => a.distance - b.distance)
-      .slice(0, 5)
-      .map((item) => item.path);
-
-    return suggestions;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Uses fuzzy matching to find the intended file.
- */
-export async function findSimilarFile(
-  targetPath: string,
-  workdir: string,
-): Promise<string | null> {
-  const suggestions = await suggestPathUnderCwd(targetPath, workdir);
-  return suggestions.length > 0 ? suggestions[0] : null;
-}

package/src/utils/gitUtils.ts

@@ -1,315 +0,0 @@
-import * as path from "node:path";
-import * as fsSync from "node:fs";
-import { execFileSync } from "node:child_process";
-
-/**
- * Check if a directory is a git repository
- * @param dirPath Directory path
- * @returns "Yes" if it's a git repository, "No" otherwise
- */
-export function isGitRepository(dirPath: string): string {
-  try {
-    // Check if .git directory exists in current directory or any parent directory
-    let currentPath = path.resolve(dirPath);
-    while (currentPath !== path.dirname(currentPath)) {
-      const gitPath = path.join(currentPath, ".git");
-      if (fsSync.existsSync(gitPath)) {
-        return "Yes";
-      }
-      currentPath = path.dirname(currentPath);
-    }
-    return "No";
-  } catch {
-    return "No";
-  }
-}
-
-/**
- * Get the root directory of the git repository
- * @param cwd Working directory
- * @returns Repository root path
- */
-export function getGitRepoRoot(cwd: string): string {
-  try {
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    return cwd;
-  }
-}
-
-/**
- * Get the common directory of the git repository (handles worktrees)
- * @param cwd Working directory
- * @returns Repository common directory path
- */
-export function getGitCommonDir(cwd: string): string {
-  try {
-    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return path.resolve(cwd, commonDir);
-  } catch {
-    return getGitRepoRoot(cwd);
-  }
-}
-
-/**
- * Get the main repository root directory (the first worktree in the list)
- * @param cwd Working directory
- * @returns Main repository root path
- */
-export function getGitMainRepoRoot(cwd: string): string {
-  try {
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    const lines = output.split("\n");
-    if (lines.length > 0 && lines[0].startsWith("worktree ")) {
-      return lines[0].substring("worktree ".length).trim();
-    }
-    return getGitRepoRoot(cwd);
-  } catch {
-    return getGitRepoRoot(cwd);
-  }
-}
-
-/**
- * Resolve the git directory for a repository by walking up from `cwd`.
- * Handles both normal repos (.git is a directory) and worktrees
- * (.git is a file pointing to the main repo's worktree git dir).
- * For worktrees, reads the `commondir` file to find the common git dir.
- * @param cwd Working directory to start searching from
- * @returns Absolute path to the git directory, or null if not found
- */
-export function resolveGitDir(cwd: string): string | null {
-  let currentPath = path.resolve(cwd);
-  while (currentPath !== path.dirname(currentPath)) {
-    const gitPath = path.join(currentPath, ".git");
-    if (fsSync.existsSync(gitPath)) {
-      const stat = fsSync.statSync(gitPath);
-      if (stat.isDirectory()) {
-        // Normal repo: .git is a directory
-        return gitPath;
-      }
-      // Worktree: .git is a file containing "gitdir: <path>"
-      try {
-        const content = fsSync.readFileSync(gitPath, "utf8").trim();
-        const prefix = "gitdir: ";
-        if (content.startsWith(prefix)) {
-          const worktreeGitDir = content.substring(prefix.length);
-          // Read commondir to find the common git dir
-          const commondirPath = path.join(worktreeGitDir, "commondir");
-          if (fsSync.existsSync(commondirPath)) {
-            const commondirRel = fsSync
-              .readFileSync(commondirPath, "utf8")
-              .trim();
-            return path.resolve(worktreeGitDir, commondirRel);
-          }
-          // Fallback: resolve ../.. from the worktree git dir
-          return path.resolve(worktreeGitDir, "..", "..");
-        }
-      } catch {
-        return null;
-      }
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  return null;
-}
-
-/**
- * Read a symbolic ref file in the git directory.
- * If the file content starts with "ref: ", returns the target ref path.
- * Symbolic refs are never packed in packed-refs, so only loose refs are checked.
- * @param gitDir Absolute path to the git directory
- * @param refPath Relative path to the ref file (e.g., "refs/remotes/origin/HEAD")
- * @returns The symbolic ref target, or null if not a symbolic ref or on error
- */
-function readSymref(gitDir: string, refPath: string): string | null {
-  try {
-    const fullPath = path.join(gitDir, refPath);
-    const content = fsSync.readFileSync(fullPath, "utf8").trim();
-    if (content.startsWith("ref: ")) {
-      return content.substring("ref: ".length);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if a git ref exists, checking both loose refs and packed-refs.
- * @param gitDir Absolute path to the git directory
- * @param refPath Relative path to the ref (e.g., "refs/remotes/origin/main")
- * @returns True if the ref exists, false otherwise
- */
-function refExists(gitDir: string, refPath: string): boolean {
-  // 1. Check loose ref
-  const loosePath = path.join(gitDir, refPath);
-  if (fsSync.existsSync(loosePath)) {
-    return true;
-  }
-  // 2. Check packed-refs
-  try {
-    const packedRefsPath = path.join(gitDir, "packed-refs");
-    const content = fsSync.readFileSync(packedRefsPath, "utf8");
-    for (const line of content.split("\n")) {
-      // Skip comments and peeled lines
-      if (line.startsWith("#") || line.startsWith("^")) {
-        continue;
-      }
-      // Format: <sha> <refPath>
-      const parts = line.split(" ");
-      if (parts.length >= 2 && parts[1] === refPath) {
-        return true;
-      }
-    }
-  } catch {
-    // packed-refs doesn't exist or can't be read
-  }
-  return false;
-}
-
-/**
- * Get the default remote branch (e.g., origin/main) using filesystem reads.
- * No subprocess calls — matches Claude Code's approach.
- *
- * Priority:
- * 1. Read refs/remotes/origin/HEAD symref → extract branch name (verify it exists)
- * 2. Check if refs/remotes/origin/main ref exists
- * 3. Check if refs/remotes/origin/master ref exists
- * 4. Hardcoded "main" fallback
- *
- * @param cwd Working directory
- * @returns Default remote branch name
- */
-export function getDefaultRemoteBranch(cwd: string): string {
-  const gitDir = resolveGitDir(cwd);
-  if (!gitDir) {
-    return "main";
-  }
-
-  // 1. Try reading origin/HEAD symref
-  const symref = readSymref(gitDir, "refs/remotes/origin/HEAD");
-  if (symref) {
-    const branch = symref.replace("refs/remotes/", "");
-    // Verify the resolved branch actually exists (origin/HEAD can be stale)
-    if (refExists(gitDir, symref)) {
-      return branch;
-    }
-  }
-
-  // 2. Check if origin/main exists
-  if (refExists(gitDir, "refs/remotes/origin/main")) {
-    return "origin/main";
-  }
-
-  // 3. Check if origin/master exists
-  if (refExists(gitDir, "refs/remotes/origin/master")) {
-    return "origin/master";
-  }
-
-  // 4. Hardcoded fallback
-  return "main";
-}
-
-/**
- * Module-level set tracking git dirs already processed in this process,
- * to avoid redundant I/O.
- */
-const excludedGitDirs = new Set<string>();
-
-/**
- * Ensure that Wave runtime files are excluded from git status by writing
- * patterns to `.git/info/exclude` (per-repo, not global).
- *
- * Idempotent: if the marker `# wave-runtime` is already present in the
- * exclude file, it skips writing. A module-level Set provides additional
- * per-process dedup to avoid redundant file reads.
- *
- * @param cwd Working directory to start searching from
- */
-export function ensureWaveRuntimeFilesExcluded(cwd: string): void {
-  try {
-    const gitDir = resolveGitDir(cwd);
-    if (!gitDir) return;
-
-    if (excludedGitDirs.has(gitDir)) return;
-
-    const excludePath = path.join(gitDir, "info", "exclude");
-    let content = "";
-    try {
-      content = fsSync.readFileSync(excludePath, "utf8");
-    } catch {
-      // File doesn't exist yet
-    }
-
-    const marker = "# wave-runtime";
-    if (content.includes(marker)) {
-      excludedGitDirs.add(gitDir);
-      return;
-    }
-
-    const block = [
-      marker,
-      "**/.wave/scheduled_tasks.lock",
-      "**/.wave/scheduled_tasks.json",
-      "**/.wave/worktrees/",
-      "**/.wave/settings.local.json",
-      "",
-    ].join("\n");
-
-    fsSync.mkdirSync(path.join(gitDir, "info"), { recursive: true });
-    fsSync.appendFileSync(excludePath, block);
-    excludedGitDirs.add(gitDir);
-  } catch {
-    // Best-effort: ignore all errors
-  }
-}
-
-/**
- * Check if there are uncommitted changes in the working directory
- * @param cwd Working directory
- * @returns True if there are uncommitted changes
- */
-export function hasUncommittedChanges(cwd: string): boolean {
-  try {
-    const status = execFileSync("git", ["status", "--porcelain"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return status.length > 0;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if there are new commits in the current branch that are not in the base branch
- * @param cwd Working directory
- * @param baseBranch Base branch name (e.g., origin/main)
- * @returns True if there are new commits
- */
-export function hasNewCommits(cwd: string, baseBranch?: string): boolean {
-  try {
-    const range = baseBranch ? `${baseBranch}..HEAD` : "@{u}..HEAD";
-    const log = execFileSync("git", ["log", range, "--oneline"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return log.length > 0;
-  } catch {
-    return false;
-  }
-}