wave-agent-sdk 1.0.5 → 1.0.7

package/src/utils/cronTasks.ts

@@ -1,128 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-import { CronJob } from "../types/cron.js";
-
-const WAVE_DIR = ".wave";
-const TASKS_FILE = "scheduled_tasks.json";
-
-/**
- * Runtime-only flags that should never be persisted to disk.
- */
-const RUNTIME_FLAGS = ["nextRun", "periodMs"] as const;
-
-function getFilePath(dir: string): string {
-  return join(dir, WAVE_DIR, TASKS_FILE);
-}
-
-export function getCronTasksFilePath(dir: string = process.cwd()): string {
-  return getFilePath(dir);
-}
-
-function ensureWaveDir(dir: string): void {
-  const waveDir = join(dir, WAVE_DIR);
-  if (!existsSync(waveDir)) {
-    mkdirSync(waveDir, { recursive: true });
-  }
-}
-
-function stripRuntimeFlags(job: CronJob): Record<string, unknown> {
-  const stripped: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(job)) {
-    if (!(RUNTIME_FLAGS as readonly string[]).includes(key)) {
-      stripped[key] = value;
-    }
-  }
-  return stripped;
-}
-
-function parseFile(dir: string): CronJob[] {
-  const filePath = getFilePath(dir);
-  if (!existsSync(filePath)) return [];
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.tasks)) {
-      return [];
-    }
-    const tasks: CronJob[] = [];
-    for (const entry of parsed.tasks) {
-      if (
-        typeof entry === "object" &&
-        entry !== null &&
-        typeof entry.id === "string" &&
-        typeof entry.cron === "string" &&
-        typeof entry.prompt === "string" &&
-        typeof entry.recurring === "boolean" &&
-        typeof entry.createdAt === "number"
-      ) {
-        tasks.push(entry as CronJob);
-      }
-      // Drop malformed entries silently
-    }
-    return tasks;
-  } catch {
-    return [];
-  }
-}
-
-function writeToFile(jobs: CronJob[], dir: string): void {
-  ensureWaveDir(dir);
-  const filePath = getFilePath(dir);
-  const payload = {
-    tasks: jobs.map(stripRuntimeFlags),
-  };
-  const json = JSON.stringify(payload, null, 2);
-  // Atomic write: write to temp file then rename
-  const tmpFile = join(dir, WAVE_DIR, `${randomUUID()}.tmp`);
-  writeFileSync(tmpFile, json, "utf-8");
-  renameSync(tmpFile, filePath);
-}
-
-export function readCronTasks(dir: string = process.cwd()): CronJob[] {
-  return parseFile(dir);
-}
-
-export function writeCronTasks(
-  tasks: CronJob[],
-  dir: string = process.cwd(),
-): void {
-  writeToFile(tasks, dir);
-}
-
-export function addCronTask(job: CronJob, dir: string = process.cwd()): void {
-  const existing = readCronTasks(dir);
-  existing.push(job);
-  writeToFile(existing, dir);
-}
-
-export function removeCronTasks(
-  ids: string[],
-  dir: string = process.cwd(),
-): void {
-  const existing = readCronTasks(dir);
-  const idSet = new Set(ids);
-  const filtered = existing.filter((t) => !idSet.has(t.id));
-  writeToFile(filtered, dir);
-}
-
-export function markCronTasksFired(
-  ids: string[],
-  firedAt: number,
-  dir: string = process.cwd(),
-): void {
-  const existing = readCronTasks(dir);
-  const idSet = new Set(ids);
-  for (const task of existing) {
-    if (idSet.has(task.id)) {
-      task.lastFiredAt = firedAt;
-    }
-  }
-  writeToFile(existing, dir);
-}

package/src/utils/cronTasksLock.ts

@@ -1,182 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-  renameSync,
-} from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-import { logger } from "./globalLogger.js";
-
-const WAVE_DIR = ".wave";
-const LOCK_FILE = "scheduled_tasks.lock";
-
-export interface SchedulerLockOptions {
-  dir?: string;
-  sessionId?: string;
-}
-
-interface LockData {
-  sessionId: string;
-  pid: number;
-  acquiredAt: number;
-}
-
-function getLockPath(dir: string): string {
-  return join(dir, WAVE_DIR, LOCK_FILE);
-}
-
-function ensureWaveDir(dir: string): void {
-  const waveDir = join(dir, WAVE_DIR);
-  if (!existsSync(waveDir)) {
-    mkdirSync(waveDir, { recursive: true });
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Try to acquire the scheduler lock using an atomic exclusive create.
- * If the lock already exists, checks PID liveness for stale recovery.
- * Returns true if this process now owns the lock.
- */
-export async function tryAcquireSchedulerLock(
-  opts: SchedulerLockOptions = {},
-): Promise<boolean> {
-  const dir = opts.dir ?? process.cwd();
-  const sessionId = opts.sessionId ?? "unknown";
-  const lockPath = getLockPath(dir);
-
-  ensureWaveDir(dir);
-
-  // Step 1: Try to create lock file with 'wx' flag (exclusive create)
-  try {
-    const lockData: LockData = {
-      sessionId,
-      pid: process.pid,
-      acquiredAt: Date.now(),
-    };
-    const tmpPath = join(dir, WAVE_DIR, `${randomUUID()}.lock.tmp`);
-    writeFileSync(tmpPath, JSON.stringify(lockData), { flag: "wx" });
-    renameSync(tmpPath, lockPath);
-    logger?.info(
-      `CronSchedulerLock: acquired lock (pid=${process.pid}, session=${sessionId})`,
-    );
-    return true;
-  } catch (err: unknown) {
-    // EEXIST: file already exists — check if stale
-    if (
-      err &&
-      typeof err === "object" &&
-      "code" in err &&
-      (err as { code: string }).code !== "EEXIST"
-    ) {
-      logger?.error(`CronSchedulerLock: unexpected error creating lock:`, err);
-      return false;
-    }
-  }
-
-  // Step 2: File exists — read it and check PID liveness
-  try {
-    const raw = readFileSync(lockPath, "utf-8");
-    const existing = JSON.parse(raw) as LockData;
-
-    if (isPidAlive(existing.pid)) {
-      // Another live session owns the lock
-      return false;
-    }
-
-    // Stale lock — delete and retry
-    logger?.info(
-      `CronSchedulerLock: removing stale lock (dead pid=${existing.pid}, session=${existing.sessionId})`,
-    );
-    unlinkSync(lockPath);
-  } catch {
-    // If we can't read the lock, try to delete it anyway
-    try {
-      unlinkSync(lockPath);
-    } catch {
-      // Give up
-      return false;
-    }
-  }
-
-  // Step 3: Retry — try exclusive create again
-  try {
-    const lockData: LockData = {
-      sessionId,
-      pid: process.pid,
-      acquiredAt: Date.now(),
-    };
-    const tmpPath = join(dir, WAVE_DIR, `${randomUUID()}.lock.tmp`);
-    writeFileSync(tmpPath, JSON.stringify(lockData), { flag: "wx" });
-    renameSync(tmpPath, lockPath);
-    logger?.info(
-      `CronSchedulerLock: acquired lock after stale recovery (pid=${process.pid}, session=${sessionId})`,
-    );
-    return true;
-  } catch {
-    // Another process beat us to it during the retry window
-    return false;
-  }
-}
-
-/**
- * Release the scheduler lock if this process owns it.
- */
-export async function releaseSchedulerLock(
-  opts: SchedulerLockOptions = {},
-): Promise<void> {
-  releaseSchedulerLockSync(opts);
-}
-
-/**
- * Synchronous version for use in process exit handlers where async is not available.
- */
-export function releaseSchedulerLockSync(
-  opts: SchedulerLockOptions = {},
-): void {
-  const dir = opts.dir ?? process.cwd();
-  const lockPath = getLockPath(dir);
-
-  try {
-    const raw = readFileSync(lockPath, "utf-8");
-    const existing = JSON.parse(raw) as LockData;
-
-    if (existing.pid === process.pid) {
-      unlinkSync(lockPath);
-      logger?.info(`CronSchedulerLock: released lock (pid=${process.pid})`);
-    }
-  } catch {
-    // Lock doesn't exist or can't be read — nothing to do
-  }
-}
-
-/**
- * Register a cleanup handler to release the lock on process exit.
- * Returns a dispose function to remove the listeners (call in test teardown).
- */
-export function registerSchedulerLockCleanup(
-  opts: SchedulerLockOptions = {},
-): () => void {
-  const handler = () => {
-    releaseSchedulerLockSync(opts);
-  };
-  process.on("exit", handler);
-  process.on("SIGINT", handler);
-  process.on("SIGTERM", handler);
-  return () => {
-    process.off("exit", handler);
-    process.off("SIGINT", handler);
-    process.off("SIGTERM", handler);
-  };
-}

package/src/utils/cronToHuman.ts

@@ -1,99 +0,0 @@
-// Human-readable cron expression display.
-// Intentionally narrow: covers common patterns; falls through to raw cron
-// string for anything else. Based on Claude Code's cronToHuman implementation.
-
-const DAY_NAMES = [
-  "Sunday",
-  "Monday",
-  "Tuesday",
-  "Wednesday",
-  "Thursday",
-  "Friday",
-  "Saturday",
-];
-
-function formatLocalTime(minute: number, hour: number): string {
-  const d = new Date(2000, 0, 1, hour, minute);
-  return d.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" });
-}
-
-/**
- * Convert a cron expression to a human-readable string.
- * Covers common patterns; falls through to raw cron for anything else.
- */
-export function cronToHuman(cron: string): string {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) return cron;
-
-  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts as [
-    string,
-    string,
-    string,
-    string,
-    string,
-  ];
-
-  // Every N minutes: step/N * * * *
-  const everyMinMatch = minute.match(/^\*\/(\d+)$/);
-  if (
-    everyMinMatch &&
-    hour === "*" &&
-    dayOfMonth === "*" &&
-    month === "*" &&
-    dayOfWeek === "*"
-  ) {
-    const n = parseInt(everyMinMatch[1]!, 10);
-    return n === 1 ? "Every minute" : `Every ${n} minutes`;
-  }
-
-  // Every hour: 0 * * * *
-  if (
-    minute.match(/^\d+$/) &&
-    hour === "*" &&
-    dayOfMonth === "*" &&
-    month === "*" &&
-    dayOfWeek === "*"
-  ) {
-    const m = parseInt(minute, 10);
-    if (m === 0) return "Every hour";
-    return `Every hour at :${m.toString().padStart(2, "0")}`;
-  }
-
-  // Every N hours: 0 step/N * * *
-  const everyHourMatch = hour.match(/^\*\/(\d+)$/);
-  if (
-    minute.match(/^\d+$/) &&
-    everyHourMatch &&
-    dayOfMonth === "*" &&
-    month === "*" &&
-    dayOfWeek === "*"
-  ) {
-    const n = parseInt(everyHourMatch[1]!, 10);
-    const m = parseInt(minute, 10);
-    const suffix = m === 0 ? "" : ` at :${m.toString().padStart(2, "0")}`;
-    return n === 1 ? `Every hour${suffix}` : `Every ${n} hours${suffix}`;
-  }
-
-  if (!minute.match(/^\d+$/) || !hour.match(/^\d+$/)) return cron;
-  const m = parseInt(minute, 10);
-  const h = parseInt(hour, 10);
-
-  // Daily at specific time: M H * * *
-  if (dayOfMonth === "*" && month === "*" && dayOfWeek === "*") {
-    return `Every day at ${formatLocalTime(m, h)}`;
-  }
-
-  // Specific day of week: M H * * D
-  if (dayOfMonth === "*" && month === "*" && dayOfWeek.match(/^\d$/)) {
-    const dayIndex = parseInt(dayOfWeek, 10) % 7;
-    const dayName = DAY_NAMES[dayIndex];
-    if (dayName) return `Every ${dayName} at ${formatLocalTime(m, h)}`;
-  }
-
-  // Weekdays: M H * * 1-5
-  if (dayOfMonth === "*" && month === "*" && dayOfWeek === "1-5") {
-    return `Weekdays at ${formatLocalTime(m, h)}`;
-  }
-
-  return cron;
-}

package/src/utils/customCommands.ts

@@ -1,95 +0,0 @@
-import { existsSync, readdirSync, statSync } from "fs";
-import { join, extname, basename } from "path";
-import { homedir } from "os";
-import type { CustomSlashCommand } from "../types/index.js";
-import { parseMarkdownFile } from "./markdownParser.js";
-import { generateCommandId } from "./commandPathResolver.js";
-import { logger } from "./globalLogger.js";
-
-/**
- * Get the project-specific commands directory
- */
-export function getProjectCommandsDir(workdir: string): string {
-  return join(workdir, ".wave", "commands");
-}
-
-/**
- * Get the user-specific commands directory
- */
-export function getUserCommandsDir(): string {
-  return join(homedir(), ".wave", "commands");
-}
-
-/**
- * Scan a directory for markdown command files (flat structure only)
- * @param dirPath - Root commands directory path
- */
-export function scanCommandsDirectory(dirPath: string): CustomSlashCommand[] {
-  if (!existsSync(dirPath)) {
-    return [];
-  }
-
-  const commands: CustomSlashCommand[] = [];
-
-  try {
-    const entries = readdirSync(dirPath);
-
-    for (const entryName of entries) {
-      const fullPath = join(dirPath, entryName);
-
-      try {
-        const stats = statSync(fullPath);
-        if (!stats.isFile() || extname(entryName) !== ".md") {
-          continue;
-        }
-
-        // Process markdown file
-        const commandId = generateCommandId(fullPath, dirPath);
-        const { content, config } = parseMarkdownFile(fullPath);
-
-        commands.push({
-          id: commandId,
-          name: basename(entryName, ".md"),
-          description: config?.description,
-          filePath: fullPath,
-          content,
-          config,
-        });
-      } catch (error) {
-        logger.warn(`Failed to load custom command from ${fullPath}:`, error);
-      }
-    }
-  } catch (error) {
-    logger.warn(`Failed to scan commands directory ${dirPath}:`, error);
-  }
-
-  return commands;
-}
-
-/**
- * Load all custom slash commands from both project and user directories
- */
-export function loadCustomSlashCommands(workdir: string): CustomSlashCommand[] {
-  const userClaudeCommands = scanCommandsDirectory(
-    join(homedir(), ".claude", "commands"),
-  );
-  const userWaveCommands = scanCommandsDirectory(getUserCommandsDir());
-  const projectClaudeCommands = scanCommandsDirectory(
-    join(workdir, ".claude", "commands"),
-  );
-  const projectWaveCommands = scanCommandsDirectory(
-    getProjectCommandsDir(workdir),
-  );
-
-  const commandMap = new Map<string, CustomSlashCommand>();
-  // Write in priority order: lowest first, highest last (overwrites)
-  for (const command of [
-    ...userClaudeCommands,
-    ...userWaveCommands,
-    ...projectClaudeCommands,
-    ...projectWaveCommands,
-  ]) {
-    commandMap.set(command.id, command);
-  }
-  return Array.from(commandMap.values());
-}

package/src/utils/editUtils.ts

@@ -1,20 +0,0 @@
-/**
- * Utility functions for file editing tools
- */
-
-/**
- * Escape regular expression special characters
- */
-export function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * Returns an error message when old_string is not found, including
- * the attempted string to help the model self-correct on retry.
- */
-export function analyzeEditMismatch(oldString: string): string {
-  const displayString =
-    oldString.length > 200 ? oldString.substring(0, 200) + "..." : oldString;
-  return `String to replace not found in file.\nString: ${displayString}`;
-}

package/src/utils/fileFormat.ts

@@ -1,40 +0,0 @@
-import { extname } from "path";
-
-/**
- * List of binary document file extensions that should not be read as text
- */
-export const BINARY_DOCUMENT_EXTENSIONS = [
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".odt",
-  ".ods",
-  ".odp",
-  ".rtf",
-] as const;
-
-/**
- * Check if a file is a binary document format based on its extension
- * @param filePath - The path to the file
- * @returns true if the file is a binary document format, false otherwise
- */
-export function isBinaryDocument(filePath: string): boolean {
-  const fileExtension = extname(filePath).toLowerCase();
-  return (BINARY_DOCUMENT_EXTENSIONS as readonly string[]).includes(
-    fileExtension,
-  );
-}
-
-/**
- * Get a human-readable error message for unsupported binary document formats
- * @param filePath - The path to the file
- * @returns Error message string
- */
-export function getBinaryDocumentError(filePath: string): string {
-  const fileExtension = extname(filePath).toLowerCase();
-  return `Reading binary document files with extension '${fileExtension}' is not supported. Supported formats include text files, code files, images, and Jupyter notebooks.`;
-}