wave-agent-sdk 0.0.7 → 0.0.10

package/src/utils/configPaths.ts

@@ -0,0 +1,163 @@
+/**
+ * Configuration Path Utilities
+ *
+ * Centralized utilities for resolving Wave configuration file paths.
+ * Supports both regular settings.json and settings.local.json with proper priority.
+ *
+ * Priority system:
+ * - User configs: ~/.wave/settings.local.json > ~/.wave/settings.json
+ * - Project configs: {workdir}/.wave/settings.local.json > {workdir}/.wave/settings.json
+ * - Project configs override user configs (existing behavior)
+ */
+
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+
+/**
+ * Get the user-specific configuration file path (legacy function)
+ * @deprecated Use getUserConfigPaths() for better priority support
+ */
+export function getUserConfigPath(): string {
+  return join(homedir(), ".wave", "settings.json");
+}
+
+/**
+ * Get the project-specific configuration file path (legacy function)
+ * @deprecated Use getProjectConfigPaths() for better priority support
+ */
+export function getProjectConfigPath(workdir: string): string {
+  return join(workdir, ".wave", "settings.json");
+}
+
+/**
+ * Get the user-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export function getUserConfigPaths(): string[] {
+  const baseDir = join(homedir(), ".wave");
+  return [join(baseDir, "settings.local.json"), join(baseDir, "settings.json")];
+}
+
+/**
+ * Get the project-specific configuration file paths in priority order
+ * Returns array with .local.json first, then .json
+ */
+export function getProjectConfigPaths(workdir: string): string[] {
+  const baseDir = join(workdir, ".wave");
+  return [join(baseDir, "settings.local.json"), join(baseDir, "settings.json")];
+}
+
+/**
+ * Get all configuration file paths (user and project) in priority order
+ * Useful for comprehensive configuration detection
+ */
+export function getAllConfigPaths(workdir: string): {
+  userPaths: string[];
+  projectPaths: string[];
+  allPaths: string[];
+} {
+  const userPaths = getUserConfigPaths();
+  const projectPaths = getProjectConfigPaths(workdir);
+
+  return {
+    userPaths,
+    projectPaths,
+    allPaths: [...userPaths, ...projectPaths],
+  };
+}
+
+/**
+ * Get existing configuration file paths
+ * Returns only the paths that actually exist on the filesystem
+ */
+export function getExistingConfigPaths(workdir: string): {
+  userPaths: string[];
+  projectPaths: string[];
+  existingPaths: string[];
+} {
+  const allPaths = getAllConfigPaths(workdir);
+
+  const existingUserPaths = allPaths.userPaths.filter(existsSync);
+  const existingProjectPaths = allPaths.projectPaths.filter(existsSync);
+  const allExistingPaths = allPaths.allPaths.filter(existsSync);
+
+  return {
+    userPaths: existingUserPaths,
+    projectPaths: existingProjectPaths,
+    existingPaths: allExistingPaths,
+  };
+}
+
+/**
+ * Get the first existing configuration file path with the specified priority
+ * @param paths Array of paths in priority order
+ * @returns The first path that exists, or undefined if none exist
+ */
+export function getFirstExistingPath(paths: string[]): string | undefined {
+  return paths.find((path) => existsSync(path));
+}
+
+/**
+ * Get effective configuration paths (the ones that would actually be used)
+ * Returns the highest priority existing path for each category
+ */
+export function getEffectiveConfigPaths(workdir: string): {
+  userPath?: string;
+  projectPath?: string;
+  effectivePath?: string; // The path that takes final precedence
+} {
+  const userPaths = getUserConfigPaths();
+  const projectPaths = getProjectConfigPaths(workdir);
+
+  const userPath = getFirstExistingPath(userPaths);
+  const projectPath = getFirstExistingPath(projectPaths);
+
+  // Project path takes precedence over user path if both exist
+  const effectivePath = projectPath || userPath;
+
+  return {
+    userPath,
+    projectPath,
+    effectivePath,
+  };
+}
+
+/**
+ * Check if any configuration files exist
+ */
+export function hasAnyConfig(workdir: string): boolean {
+  const { existingPaths } = getExistingConfigPaths(workdir);
+  return existingPaths.length > 0;
+}
+
+/**
+ * Get configuration information for debugging and monitoring
+ */
+export function getConfigurationInfo(workdir: string): {
+  hasUser: boolean;
+  hasProject: boolean;
+  paths: string[];
+  userPaths: string[];
+  projectPaths: string[];
+  existingPaths: string[];
+  effectivePaths: {
+    userPath?: string;
+    projectPath?: string;
+    effectivePath?: string;
+  };
+} {
+  const allPaths = getAllConfigPaths(workdir);
+  const existingPaths = getExistingConfigPaths(workdir);
+  const effectivePaths = getEffectiveConfigPaths(workdir);
+
+  return {
+    hasUser: existingPaths.userPaths.length > 0,
+    hasProject: existingPaths.projectPaths.length > 0,
+    paths: allPaths.allPaths,
+    userPaths: allPaths.userPaths,
+    projectPaths: allPaths.projectPaths,
+    existingPaths: existingPaths.existingPaths,
+    effectivePaths,
+  };
+}

package/src/utils/constants.ts

@@ -24,24 +24,9 @@ export const ERROR_LOG_DIRECTORY = path.join(DATA_DIRECTORY, "error-logs");
 /**
  * User-level memory file path
  */
-export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "user-memory.md");
+export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 
 /**
  * AI related constants
  */
-export const DEFAULT_TOKEN_LIMIT = 64000; // Default token limit
-
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const FAST_MODEL_ID = process.env.AIGW_FAST_MODEL || "gemini-2.5-flash";
-
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const AGENT_MODEL_ID =
-  process.env.AIGW_MODEL || "claude-sonnet-4-20250514";
+export const DEFAULT_TOKEN_LIMIT = 96000; // Default token limit

package/src/utils/convertMessagesForAPI.ts

@@ -6,6 +6,7 @@ import {
   ChatCompletionContentPart,
   ChatCompletionMessageParam,
 } from "openai/resources.js";
+import { logger } from "./globalLogger.js";
 
 /**
  * Safely handle tool call parameters, ensuring a legal JSON string is returned
@@ -21,15 +22,16 @@ function safeToolArguments(args: string): string {
     // Try to parse as JSON to validate format
     JSON.parse(args);
     return args;
-  } catch {
-    // logger.error(`Invalid tool arguments: ${args}`);
+  } catch (error) {
+    logger.error(`Invalid tool arguments: ${args}`, error);
     // If not valid JSON, return a fallback empty object
     return "{}";
   }
 }
 
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered
+ * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
  */
@@ -60,7 +62,7 @@ export function convertMessagesForAPI(
       break;
     }
 
-    // Skip empty assistant messages
+    // Skip empty assistant messages (no blocks or all blocks are empty)
     if (message.role === "assistant" && message.blocks.length === 0) {
       continue;
     }
@@ -75,8 +77,8 @@ export function convertMessagesForAPI(
 
       if (toolBlocks.length > 0) {
         toolBlocks.forEach((toolBlock) => {
-          // Only add completed tool blocks (i.e., not running)
-          if (toolBlock.id && !toolBlock.isRunning) {
+          // Only add completed tool blocks (i.e., stage is 'end')
+          if (toolBlock.id && toolBlock.stage === "end") {
             completedToolIds.add(toolBlock.id);
 
             // Check for image data
@@ -127,12 +129,17 @@ export function convertMessagesForAPI(
       let content = "";
       let tool_calls: ChatCompletionMessageToolCall[] | undefined = undefined;
 
-      // Construct content from text blocks
+      // Construct content from text blocks - filter out empty content
       const textBlocks = message.blocks.filter(
-        (block) => block.type === "text",
+        (block) =>
+          block.type === "text" &&
+          block.content &&
+          block.content.trim().length > 0,
       );
       if (textBlocks.length > 0) {
-        content = textBlocks.map((block) => block.content || "").join("\n");
+        content = textBlocks
+          .map((block) => (block.type === "text" ? block.content : ""))
+          .join("\n");
       }
 
       // Construct tool calls from tool blocks
@@ -157,12 +164,16 @@ export function convertMessagesForAPI(
         }
       }
 
-      // Construct assistant message - only add if there is content or tool calls
-      if (content || tool_calls) {
+      // Construct assistant message - only add if there is meaningful content or tool calls
+      const hasContent = content && content.trim().length > 0;
+      const hasToolCalls = tool_calls && tool_calls.length > 0;
+
+      if (hasContent || hasToolCalls) {
         const assistantMessage: ChatCompletionMessageParam = {
           role: "assistant",
-          content,
+          content: hasContent ? content : undefined,
           tool_calls,
+          ...(message.additionalFields ? { ...message.additionalFields } : {}),
         };
 
         recentMessages.unshift(assistantMessage);
@@ -172,8 +183,12 @@ export function convertMessagesForAPI(
       const contentParts: ChatCompletionContentPart[] = [];
 
       message.blocks.forEach((block) => {
-        // Add text content
-        if (block.type === "text" && block.content) {
+        // Add text content - only if it has meaningful content
+        if (
+          block.type === "text" &&
+          block.content &&
+          block.content.trim().length > 0
+        ) {
           contentParts.push({
             type: "text",
             text: block.customCommandContent || block.content,
@@ -194,7 +209,7 @@ export function convertMessagesForAPI(
               try {
                 finalImageUrl = convertImageToBase64(imageUrl);
               } catch (error) {
-                console.error(
+                logger.error(
                   "Failed to convert image path to base64:",
                   imageUrl,
                   error,
@@ -215,11 +230,22 @@ export function convertMessagesForAPI(
         }
       });
 
+      // Only add user message if there is meaningful content
       if (contentParts.length > 0) {
-        recentMessages.unshift({
-          role: "user",
-          content: contentParts,
+        // Filter out empty text parts
+        const meaningfulParts = contentParts.filter((part) => {
+          if (part.type === "text") {
+            return part.text && part.text.trim().length > 0;
+          }
+          return true; // Keep image parts
         });
+
+        if (meaningfulParts.length > 0) {
+          recentMessages.unshift({
+            role: "user",
+            content: meaningfulParts,
+          });
+        }
       }
     }
   }

package/src/utils/customCommands.ts

@@ -1,8 +1,15 @@
-import { existsSync, readdirSync } from "fs";
+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,
+  getCommandSegments,
+  getNamespace,
+  getDepth,
+} from "./commandPathResolver.js";
+import { logger } from "./globalLogger.js";
 
 /**
  * Get the project-specific commands directory
@@ -19,43 +26,104 @@ export function getUserCommandsDir(): string {
 }
 
 /**
- * Scan a directory for markdown command files
+ * Scan a directory for markdown command files with nested directory support
+ * @param dirPath - Root commands directory path
+ * @param maxDepth - Maximum nesting depth to scan (default: 1)
  */
-function scanCommandsDirectory(dirPath: string): CustomSlashCommand[] {
+function scanCommandsDirectory(
+  dirPath: string,
+  maxDepth: number = 1,
+): CustomSlashCommand[] {
   if (!existsSync(dirPath)) {
     return [];
   }
 
+  return scanCommandsDirectoryRecursive(dirPath, dirPath, 0, maxDepth);
+}
+
+/**
+ * Recursively scan directory for commands with depth control
+ * @param currentPath - Current directory being scanned
+ * @param rootPath - Root commands directory (for relative path calculation)
+ * @param currentDepth - Current nesting depth
+ * @param maxDepth - Maximum allowed depth
+ */
+function scanCommandsDirectoryRecursive(
+  currentPath: string,
+  rootPath: string,
+  currentDepth: number,
+  maxDepth: number,
+): CustomSlashCommand[] {
   const commands: CustomSlashCommand[] = [];
 
   try {
-    const files = readdirSync(dirPath);
+    const entries = readdirSync(currentPath);
 
-    for (const file of files) {
-      if (extname(file) !== ".md") {
-        continue;
-      }
+    for (const entryName of entries) {
+      const fullPath = join(currentPath, entryName);
 
-      const filePath = join(dirPath, file);
-      const commandName = basename(file, ".md");
+      let isDirectory = false;
+      let isFile = false;
 
       try {
-        const { content, config } = parseMarkdownFile(filePath);
-
-        commands.push({
-          id: commandName,
-          name: commandName,
-          description: config?.description, // Use description from frontmatter
-          filePath,
-          content,
-          config,
-        });
+        const stats = statSync(fullPath);
+        isDirectory = stats.isDirectory();
+        isFile = stats.isFile();
       } catch (error) {
-        console.warn(`Failed to load custom command from ${filePath}:`, error);
+        // Skip entries that cannot be stat'd
+        logger.warn(`Cannot access ${fullPath}:`, error);
+        continue;
+      }
+
+      if (isDirectory) {
+        // Skip subdirectories if we're at max depth
+        if (currentDepth >= maxDepth) {
+          logger.warn(
+            `Skipping directory ${fullPath}: exceeds maximum nesting depth of ${maxDepth}`,
+          );
+          continue;
+        }
+
+        // Recursively scan subdirectory
+        const nestedCommands = scanCommandsDirectoryRecursive(
+          fullPath,
+          rootPath,
+          currentDepth + 1,
+          maxDepth,
+        );
+        commands.push(...nestedCommands);
+      } else if (isFile && extname(entryName) === ".md") {
+        // Process markdown file
+        try {
+          const commandId = generateCommandId(fullPath, rootPath);
+          const segments = getCommandSegments(fullPath, rootPath);
+          const namespace = getNamespace(segments);
+          const depth = getDepth(segments);
+
+          const { content, config } = parseMarkdownFile(fullPath);
+
+          commands.push({
+            id: commandId,
+            name: basename(entryName, ".md"),
+            description: config?.description,
+            filePath: fullPath,
+            content,
+            config,
+
+            // Nested command metadata
+            namespace,
+            isNested: depth > 0,
+            depth,
+            segments,
+          });
+        } catch (error) {
+          logger.warn(`Failed to load custom command from ${fullPath}:`, error);
+        }
       }
+      // Skip non-markdown files silently
     }
   } catch (error) {
-    console.warn(`Failed to scan commands directory ${dirPath}:`, error);
+    logger.warn(`Failed to scan commands directory ${currentPath}:`, error);
   }
 
   return commands;

package/src/utils/fileSearch.ts

@@ -0,0 +1,107 @@
+import { globIterate, type Path } from "glob";
+import { getGlobIgnorePatterns } from "./fileFilter.js";
+import type { FileItem } from "../types/fileSearch.js";
+
+/**
+ * Convert Path objects to FileItem objects
+ */
+export const convertPathsToFileItems = (paths: Path[]): FileItem[] => {
+  return paths.map((pathObj) => ({
+    path: pathObj.relative(),
+    type: pathObj.isDirectory() ? "directory" : "file",
+  }));
+};
+
+/**
+ * Search files and directories using glob patterns
+ */
+export const searchFiles = async (
+  query: string,
+  options?: {
+    maxResults?: number;
+    workingDirectory?: string;
+  },
+): Promise<FileItem[]> => {
+  const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
+
+  try {
+    const globOptions: import("glob").GlobOptionsWithFileTypesTrue = {
+      ignore: getGlobIgnorePatterns(workingDirectory),
+      maxDepth: 10,
+      nocase: true, // Case insensitive
+      dot: true, // Include hidden files and directories
+      cwd: workingDirectory, // Specify search root directory
+      withFileTypes: true, // Get Path objects instead of strings
+    };
+
+    // Build glob patterns based on query
+    let patterns: string[] = [];
+
+    if (!query.trim()) {
+      // When query is empty, show some common file types and directories
+      patterns = [
+        "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
+        "*/", // First level directories
+      ];
+    } else {
+      // Build multiple glob patterns to support more flexible search
+      patterns = [
+        // Match files with filenames containing query
+        `**/*${query}*`,
+        // Match files with query in path (match directory names)
+        `**/${query}*/**/*`,
+        // Match directory names containing query
+        `**/*${query}*/`,
+        // Match directories containing query in path
+        `**/${query}*/`,
+      ];
+    }
+
+    // Collect results until we reach maxResults
+    const collectedPaths: Path[] = [];
+    const seenPaths = new Set<string>();
+
+    // Process each pattern sequentially
+    for (const pattern of patterns) {
+      if (collectedPaths.length >= maxResults) {
+        break;
+      }
+
+      // Use globIterate to get results one by one
+      const iterator = globIterate(pattern, globOptions) as AsyncGenerator<
+        Path,
+        void,
+        void
+      >;
+
+      for await (const pathObj of iterator) {
+        if (collectedPaths.length >= maxResults) {
+          // Stop the iterator when we have enough results
+          break;
+        }
+
+        const relativePath = pathObj.relative();
+        if (!seenPaths.has(relativePath)) {
+          seenPaths.add(relativePath);
+          collectedPaths.push(pathObj);
+        }
+      }
+    }
+
+    // Sort collected paths: directories first, then files
+    collectedPaths.sort((a, b) => {
+      const aIsDir = a.isDirectory();
+      const bIsDir = b.isDirectory();
+      if (aIsDir && !bIsDir) return -1;
+      if (!aIsDir && bIsDir) return 1;
+      return a.relative().localeCompare(b.relative());
+    });
+
+    // Convert to FileItems
+    const fileItems = convertPathsToFileItems(collectedPaths);
+    return fileItems;
+  } catch (error) {
+    console.error("Glob search error:", error);
+    return [];
+  }
+};