wave-agent-sdk 0.0.1

package/src/types.ts

@@ -0,0 +1,260 @@
+import type { ChildProcess } from "child_process";
+
+/**
+ * Logger interface definition
+ * Compatible with OpenAI package Logger interface
+ */
+export interface Logger {
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+}
+
+export interface Message {
+  role: "user" | "assistant";
+  blocks: MessageBlock[];
+}
+
+export type MessageBlock =
+  | TextBlock
+  | ErrorBlock
+  | ToolBlock
+  | ImageBlock
+  | DiffBlock
+  | CommandOutputBlock
+  | CompressBlock
+  | MemoryBlock
+  | CustomCommandBlock;
+
+export interface TextBlock {
+  type: "text";
+  content: string;
+}
+
+export interface ErrorBlock {
+  type: "error";
+  content: string;
+}
+
+export interface ToolBlock {
+  type: "tool";
+  parameters?: string;
+  result?: string;
+  shortResult?: string; // Add shortResult field
+  images?: Array<{
+    // Add image data support
+    data: string; // Base64 encoded image data
+    mediaType?: string; // Media type of the image
+  }>;
+  id?: string;
+  name?: string;
+  isRunning?: boolean; // Mark if tool is actually executing
+  success?: boolean;
+  error?: string | Error;
+  compactParams?: string; // Compact parameter display
+}
+
+export interface ImageBlock {
+  type: "image";
+  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;
+  output: string;
+  isRunning: boolean;
+  exitCode: number | null;
+}
+
+export interface CompressBlock {
+  type: "compress";
+  content: string;
+}
+
+export interface MemoryBlock {
+  type: "memory";
+  content: string;
+  isSuccess: boolean;
+  memoryType?: "project" | "user"; // Memory type
+  storagePath?: string; // Storage path text
+}
+
+export interface CustomCommandBlock {
+  type: "custom_command";
+  commandName: string;
+  content: string; // Complete command content, used when passing to AI
+  originalInput?: string; // Original user input, used for UI display (e.g., "/fix-issue 123 high")
+}
+
+export interface AIRequest {
+  content: string;
+  files: unknown[];
+}
+
+export interface AIResponse {
+  content: string;
+  status: "success" | "error";
+  error?: string;
+}
+
+// MCP related types
+export interface McpServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface McpConfig {
+  mcpServers: Record<string, McpServerConfig>;
+}
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface McpServerStatus {
+  name: string;
+  config: McpServerConfig;
+  status: "disconnected" | "connected" | "connecting" | "error";
+  tools?: McpTool[];
+  toolCount?: number;
+  capabilities?: string[];
+  lastConnected?: number;
+  error?: string;
+}
+
+// Background bash shell related types
+export interface BackgroundShell {
+  id: string;
+  process: ChildProcess;
+  command: string;
+  startTime: number;
+  status: "running" | "completed" | "killed";
+  stdout: string;
+  stderr: string;
+  exitCode?: number;
+  runtime?: number;
+}
+
+// Slash Command related types
+export interface SlashCommand {
+  id: string;
+  name: string;
+  description: string;
+  handler: (args?: string) => Promise<void> | void;
+}
+
+export interface CustomSlashCommandConfig {
+  allowedTools?: string[];
+  model?: string;
+  description?: string;
+}
+
+export interface CustomSlashCommand {
+  id: string;
+  name: string;
+  description?: string; // Add description field
+  filePath: string;
+  content: string;
+  config?: CustomSlashCommandConfig;
+}
+
+// Skill related types
+export interface SkillMetadata {
+  name: string;
+  description: string;
+  type: "personal" | "project";
+  skillPath: string;
+}
+
+export interface Skill extends SkillMetadata {
+  content: string;
+  frontmatter: SkillFrontmatter;
+  isValid: boolean;
+  errors: string[];
+}
+
+export interface SkillFrontmatter {
+  name: string;
+  description: string;
+  [key: string]: unknown;
+}
+
+export interface SkillCollection {
+  type: "personal" | "project";
+  basePath: string;
+  skills: Map<string, SkillMetadata>;
+  errors: SkillError[];
+}
+
+export interface SkillError {
+  skillPath: string;
+  message: string;
+}
+
+export interface SkillValidationResult {
+  isValid: boolean;
+  skill?: Skill;
+  errors: string[];
+}
+
+export interface SkillDiscoveryResult {
+  personalSkills: Map<string, SkillMetadata>;
+  projectSkills: Map<string, SkillMetadata>;
+  errors: SkillError[];
+}
+
+export interface SkillInvocationContext {
+  skillName: string;
+}
+
+export interface SkillToolArgs {
+  skill_name: string;
+}
+
+export interface SkillManagerOptions {
+  personalSkillsPath?: string;
+  scanTimeout?: number;
+  logger?: Logger;
+}
+
+export interface ParsedSkillFile {
+  frontmatter: SkillFrontmatter;
+  content: string;
+  skillMetadata: SkillMetadata;
+  validationErrors: string[];
+  isValid: boolean;
+}
+
+export interface SkillParseOptions {
+  validateMetadata?: boolean;
+  basePath?: string;
+}
+
+export const SKILL_DEFAULTS = {
+  PERSONAL_SKILLS_DIR: ".wave/skills",
+  PROJECT_SKILLS_DIR: ".wave/skills",
+  SKILL_FILE_NAME: "SKILL.md",
+  MAX_NAME_LENGTH: 64,
+  MAX_DESCRIPTION_LENGTH: 1024,
+  MIN_DESCRIPTION_LENGTH: 1,
+  NAME_PATTERN: /^[a-z0-9-]+$/,
+  MAX_METADATA_CACHE: 1000,
+  MAX_CONTENT_CACHE: 100,
+  SCAN_TIMEOUT: 5000,
+  LOAD_TIMEOUT: 2000,
+} as const;

package/src/utils/bashHistory.ts

@@ -0,0 +1,303 @@
+/**
+ * Bash command history management module
+ * Used for persistent storage and searching of bash commands executed by users
+ */
+
+import fs from "fs";
+import { BASH_HISTORY_FILE, DATA_DIRECTORY } from "./constants.js";
+
+export interface BashHistoryEntry {
+  command: string;
+  timestamp: number;
+  workdir: string;
+}
+
+export interface BashHistory {
+  commands: BashHistoryEntry[];
+  version: number;
+}
+
+const HISTORY_VERSION = 1;
+const MAX_HISTORY_SIZE = 1000;
+
+/**
+ * Ensure data directory exists
+ */
+const ensureDataDirectory = (): void => {
+  try {
+    if (!fs.existsSync(DATA_DIRECTORY)) {
+      fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
+    }
+  } catch {
+    // logger.debug("Failed to create data directory:", error);
+  }
+};
+
+/**
+ * Load bash history
+ */
+export const loadBashHistory = (): BashHistory => {
+  try {
+    ensureDataDirectory();
+
+    if (!fs.existsSync(BASH_HISTORY_FILE)) {
+      return {
+        commands: [],
+        version: HISTORY_VERSION,
+      };
+    }
+
+    const data = fs.readFileSync(BASH_HISTORY_FILE, "utf-8");
+    const history: BashHistory = JSON.parse(data);
+
+    // Version compatibility check
+    if (history.version !== HISTORY_VERSION) {
+      // logger.debug("Bash history version mismatch, resetting history");
+      return {
+        commands: [],
+        version: HISTORY_VERSION,
+      };
+    }
+
+    return history;
+  } catch {
+    // logger.debug("Failed to load bash history:", error);
+    return {
+      commands: [],
+      version: HISTORY_VERSION,
+    };
+  }
+};
+
+/**
+ * Save bash history
+ */
+export const saveBashHistory = (history: BashHistory): void => {
+  try {
+    // Skip saving to file when in test environment
+    if (process.env.NODE_ENV === "test") {
+      // logger.debug("Skipping bash history save in test environment");
+      return;
+    }
+
+    ensureDataDirectory();
+
+    // Limit history size
+    if (history.commands.length > MAX_HISTORY_SIZE) {
+      history.commands = history.commands.slice(-MAX_HISTORY_SIZE);
+    }
+
+    const data = JSON.stringify(history, null, 2);
+    fs.writeFileSync(BASH_HISTORY_FILE, data, "utf-8");
+  } catch {
+    // logger.debug("Failed to save bash history:", error);
+  }
+};
+
+/**
+ * Add command to bash history
+ */
+export const addBashCommandToHistory = (
+  command: string,
+  workdir: string,
+): void => {
+  try {
+    // Filter system-generated commands, do not add to history
+    if (command.startsWith("git add . && git commit -m")) {
+      // logger.debug("Skipping system-generated command:", { command, workdir });
+      return;
+    }
+
+    const history = loadBashHistory();
+    const timestamp = Date.now();
+
+    // Check if it's a duplicate consecutive command to avoid duplicate recording
+    const lastCommand = history.commands[history.commands.length - 1];
+    if (
+      lastCommand &&
+      lastCommand.command === command &&
+      lastCommand.workdir === workdir
+    ) {
+      // Update timestamp of the last record
+      lastCommand.timestamp = timestamp;
+    } else {
+      // Add new command record
+      history.commands.push({
+        command,
+        timestamp,
+        workdir,
+      });
+    }
+
+    saveBashHistory(history);
+    // logger.debug("Added bash command to history:", { command, workdir });
+  } catch {
+    // logger.debug("Failed to add bash command to history:", error);
+  }
+};
+
+/**
+ * Search bash history by keywords
+ */
+export const searchBashHistory = (
+  query: string,
+  limit: number = 10,
+  workdir: string,
+): BashHistoryEntry[] => {
+  try {
+    const history = loadBashHistory();
+    const normalizedQuery = query.toLowerCase().trim();
+
+    let filteredCommands = history.commands;
+
+    // Working directory filter
+    filteredCommands = filteredCommands.filter(
+      (entry) => entry.workdir === workdir,
+    );
+
+    if (!normalizedQuery) {
+      // If no search query, return recent commands (deduplicated)
+      const deduped = deduplicateCommands(filteredCommands);
+      return deduped.slice(-limit).reverse(); // Latest first
+    }
+
+    // Search by relevance
+    const matches = filteredCommands
+      .filter((entry) => {
+        // Command content matching
+        const command = entry.command.toLowerCase();
+        return command.includes(normalizedQuery);
+      })
+      .map((entry) => {
+        // Calculate match score
+        const command = entry.command.toLowerCase();
+        let score = 0;
+
+        // Exact match gets higher score
+        if (command.includes(normalizedQuery)) {
+          score += 10;
+        }
+
+        // Command prefix match gets higher score
+        if (command.startsWith(normalizedQuery)) {
+          score += 20;
+        }
+
+        // Word boundary match gets higher score
+        const words = command.split(/\s+/);
+        if (words.some((word) => word.startsWith(normalizedQuery))) {
+          score += 15;
+        }
+
+        // Timestamp influence (newer gets higher score)
+        score += entry.timestamp / 1000000; // Normalize timestamp
+
+        return { entry, score };
+      })
+      .sort((a, b) => b.score - a.score) // Sort by score descending
+      .map((item) => item.entry);
+
+    // Deduplicate search results, keep latest record
+    const dedupedMatches = deduplicateCommands(matches);
+    const result = dedupedMatches.slice(0, limit);
+
+    // logger.debug("Bash history search results:", { query, workdir: process.cwd(), originalCount: matches.length, dedupedCount: result.length });
+
+    return result;
+  } catch {
+    // logger.debug("Failed to search bash history:", error);
+    return [];
+  }
+};
+
+/**
+ * Deduplicate command list, keep latest record for each command
+ */
+const deduplicateCommands = (
+  commands: BashHistoryEntry[],
+): BashHistoryEntry[] => {
+  const commandMap = new Map<string, BashHistoryEntry>();
+
+  // Iterate through all commands, keep latest record for each
+  for (const entry of commands) {
+    const existing = commandMap.get(entry.command);
+    if (!existing || entry.timestamp > existing.timestamp) {
+      commandMap.set(entry.command, entry);
+    }
+  }
+
+  // Sort by timestamp and return
+  return Array.from(commandMap.values()).sort(
+    (a, b) => a.timestamp - b.timestamp,
+  );
+};
+
+/**
+ * Get recently used bash commands
+ */
+export const getRecentBashCommands = (
+  workdir: string,
+  limit: number = 10,
+): BashHistoryEntry[] => {
+  try {
+    const history = loadBashHistory();
+    const filtered = history.commands.filter(
+      (entry) => entry.workdir === workdir,
+    );
+
+    // Return recent commands after deduplication
+    const deduped = deduplicateCommands(filtered);
+    return deduped.slice(-limit).reverse(); // Latest first
+  } catch {
+    // logger.debug("Failed to get recent bash commands:", error);
+    return [];
+  }
+};
+
+/**
+ * Clear bash history
+ */
+export const clearBashHistory = (): void => {
+  try {
+    const history: BashHistory = {
+      commands: [],
+      version: HISTORY_VERSION,
+    };
+    saveBashHistory(history);
+    // logger.debug("Bash history cleared");
+  } catch {
+    // logger.debug("Failed to clear bash history:", error);
+  }
+};
+
+/**
+ * Get bash command statistics
+ */
+export const getBashCommandStats = (): {
+  totalCommands: number;
+  uniqueCommands: number;
+  workdirs: string[];
+} => {
+  try {
+    const history = loadBashHistory();
+    const uniqueCommands = new Set(
+      history.commands.map((entry) => entry.command),
+    );
+    const workdirs = Array.from(
+      new Set(history.commands.map((entry) => entry.workdir)),
+    );
+
+    return {
+      totalCommands: history.commands.length,
+      uniqueCommands: uniqueCommands.size,
+      workdirs,
+    };
+  } catch {
+    // logger.debug("Failed to get bash command stats:", error);
+    return {
+      totalCommands: 0,
+      uniqueCommands: 0,
+      workdirs: [],
+    };
+  }
+};

package/src/utils/commandArgumentParser.ts

@@ -0,0 +1,153 @@
+/**
+ * Command Argument Parser
+ *
+ * Provides parameter substitution for custom slash commands similar to Claude's system:
+ * - $ARGUMENTS: All arguments as a single string
+ * - $1, $2, $3, etc.: Individual positional arguments
+ * - Supports quoted arguments with spaces
+ * - Handles escaped quotes within arguments
+ */
+
+/**
+ * Parse command arguments from a string, respecting quotes
+ */
+export function parseCommandArguments(argsString: string): string[] {
+  if (!argsString.trim()) {
+    return [];
+  }
+
+  const args: string[] = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let escaped = false;
+
+  for (let i = 0; i < argsString.length; i++) {
+    const char = argsString[i];
+    const nextChar = argsString[i + 1];
+
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      // Handle escape sequences
+      if (inQuotes && (nextChar === quoteChar || nextChar === "\\")) {
+        escaped = true;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+
+    if (!inQuotes && (char === '"' || char === "'")) {
+      // Start quoted string
+      inQuotes = true;
+      quoteChar = char;
+      continue;
+    }
+
+    if (inQuotes && char === quoteChar) {
+      // End quoted string
+      inQuotes = false;
+      quoteChar = "";
+      continue;
+    }
+
+    if (!inQuotes && /\s/.test(char)) {
+      // Whitespace outside quotes - end current argument
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  // Add final argument if any
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+/**
+ * Substitute command parameters in content
+ */
+export function substituteCommandParameters(
+  content: string,
+  argsString: string,
+): string {
+  const args = parseCommandArguments(argsString);
+
+  let result = content;
+
+  // Replace $ARGUMENTS with all arguments
+  result = result.replace(/\$ARGUMENTS/g, argsString);
+
+  // Replace positional parameters $1, $2, etc.
+  // Sort by parameter number (descending) to avoid replacing $10 with $1 + "0"
+  const positionalParams = [...result.matchAll(/\$(\d+)/g)]
+    .map((match) => parseInt(match[1], 10))
+    .filter((value, index, array) => array.indexOf(value) === index) // unique
+    .sort((a, b) => b - a); // descending order
+
+  for (const paramNum of positionalParams) {
+    const paramValue = args[paramNum - 1] || ""; // Arrays are 0-indexed, params are 1-indexed
+    const paramRegex = new RegExp(`\\$${paramNum}`, "g");
+    result = result.replace(paramRegex, paramValue);
+  }
+
+  return result;
+}
+
+/**
+ * Extract command name and arguments from a slash command input
+ * Example: "/fix-issue 123 high-priority" -> { command: "fix-issue", args: "123 high-priority" }
+ */
+export function parseSlashCommandInput(input: string): {
+  command: string;
+  args: string;
+} {
+  const trimmed = input.trim();
+
+  if (!trimmed.startsWith("/")) {
+    throw new Error("Input must start with /");
+  }
+
+  const withoutSlash = trimmed.substring(1);
+  const firstSpaceIndex = withoutSlash.indexOf(" ");
+
+  if (firstSpaceIndex === -1) {
+    // No arguments
+    return {
+      command: withoutSlash,
+      args: "",
+    };
+  }
+
+  return {
+    command: withoutSlash.substring(0, firstSpaceIndex),
+    args: withoutSlash.substring(firstSpaceIndex + 1).trim(),
+  };
+}
+
+/**
+ * Check if content contains parameter placeholders
+ */
+export function hasParameterPlaceholders(content: string): boolean {
+  return /\$(?:ARGUMENTS|\d+)/.test(content);
+}
+
+/**
+ * Get all parameter placeholders used in content
+ */
+export function getUsedParameterPlaceholders(content: string): string[] {
+  const matches = content.match(/\$(?:ARGUMENTS|\d+)/g);
+  return matches ? [...new Set(matches)] : [];
+}