wave-agent-sdk 0.10.1 → 0.10.2

package/src/services/fileWatcher.ts

@@ -95,7 +95,7 @@ export class FileWatcherService extends EventEmitter {
       await this.initializeWatcher(entry);
     } catch (error) {
       this.logger?.error(
-        `Live Config: Failed to watch file ${path}: ${(error as Error).message}`,
+        `FileWatcher: Failed to watch file ${path}: ${(error as Error).message}`,
       );
       throw error;
     }
@@ -117,7 +117,7 @@ export class FileWatcherService extends EventEmitter {
       this.watchers.delete(path);
     } catch (error) {
       this.logger?.warn(
-        `Live Config: Error unwatching file ${path}: ${(error as Error).message}`,
+        `FileWatcher: Error unwatching file ${path}: ${(error as Error).message}`,
       );
     }
   }
@@ -204,7 +204,7 @@ export class FileWatcherService extends EventEmitter {
       entry.lastError = (error as Error).message;
 
       this.logger?.error(
-        `Live Config: Failed to initialize watcher for ${entry.path}: ${(error as Error).message}`,
+        `FileWatcher: Failed to initialize watcher for ${entry.path}: ${(error as Error).message}`,
       );
 
       // Try fallback polling if not already using it
@@ -241,9 +241,17 @@ export class FileWatcherService extends EventEmitter {
       this.handleFileEvent("delete", filePath);
     });
 
+    this.globalWatcher.on("addDir", (dirPath: string) => {
+      this.handleFileEvent("create", dirPath);
+    });
+
+    this.globalWatcher.on("unlinkDir", (dirPath: string) => {
+      this.handleFileEvent("delete", dirPath);
+    });
+
     this.globalWatcher.on("error", (err: unknown) => {
       const error = err instanceof Error ? err : new Error(String(err));
-      this.logger?.error(`Live Config: File watcher error: ${error.message}`);
+      this.logger?.error(`FileWatcher: File watcher error: ${error.message}`);
       this.emit("watcherError", error);
     });
   }
@@ -253,9 +261,6 @@ export class FileWatcherService extends EventEmitter {
     filePath: string,
     stats?: { size?: number },
   ): void {
-    const entry = this.watchers.get(filePath);
-    if (!entry) return;
-
     const event: FileWatchEvent = {
       type,
       path: filePath,
@@ -263,16 +268,27 @@ export class FileWatcherService extends EventEmitter {
       size: stats?.size,
     };
 
-    entry.lastEvent = event.timestamp;
-
-    // Notify all callbacks for this file
-    for (const callback of entry.callbacks) {
-      try {
-        callback(event);
-      } catch (error) {
-        this.logger?.error(
-          `Live Config: Error in file watch callback for ${filePath}: ${(error as Error).message}`,
-        );
+    // Notify all watchers that match the path or are parents of the path
+    for (const [watchedPath, entry] of this.watchers.entries()) {
+      if (
+        filePath === watchedPath ||
+        filePath.startsWith(watchedPath + "/") ||
+        // Handle cases where the watched path might be a file and we get an event for it
+        // (already covered by filePath === watchedPath)
+        false
+      ) {
+        entry.lastEvent = event.timestamp;
+
+        // Notify all callbacks for this watcher
+        for (const callback of entry.callbacks) {
+          try {
+            callback(event);
+          } catch (error) {
+            this.logger?.error(
+              `FileWatcher: Error in file watch callback for ${watchedPath} (event on ${filePath}): ${(error as Error).message}`,
+            );
+          }
+        }
       }
     }
   }

package/src/services/session.ts

@@ -423,11 +423,17 @@ export async function listSessionsFromJsonl(
 
     // Try to read from index first
     const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
+    const sevenDaysAgo = new Date();
+    sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+
     try {
       const indexContent = await fs.readFile(indexPath, "utf8");
       const index = JSON.parse(indexContent) as SessionIndex;
       const sessions: SessionMetadata[] = Object.entries(index.sessions)
-        .filter(([, meta]) => meta.sessionType === "main")
+        .filter(([, meta]) => {
+          const lastActiveAt = new Date(meta.lastActiveAt);
+          return meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo;
+        })
         .map(([id, meta]) => ({
           id,
           ...meta,
@@ -492,6 +498,10 @@ export async function listSessionsFromJsonl(
           lastActiveAt = stats.mtime;
         }
 
+        if (lastActiveAt < sevenDaysAgo) {
+          continue;
+        }
+
         // Return inline object for performance (no interface instantiation overhead)
         const sessionMeta: SessionMetadata = {
           id: sessionId,
@@ -550,6 +560,68 @@ export async function listSessionsFromJsonl(
   }
 }
 
+/**
+ * List all sessions across all project directories
+ *
+ * @returns Promise that resolves to array of session metadata objects
+ */
+export async function listAllSessions(): Promise<SessionMetadata[]> {
+  try {
+    const baseDir = SESSION_DIR;
+    let projectDirs: string[];
+    try {
+      projectDirs = await fs.readdir(baseDir);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+
+    const allSessions: SessionMetadata[] = [];
+    const sevenDaysAgo = new Date();
+    sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+
+    for (const projectDirName of projectDirs) {
+      const projectPath = join(baseDir, projectDirName);
+      try {
+        const stat = await fs.stat(projectPath);
+        if (!stat.isDirectory()) {
+          continue;
+        }
+
+        // Try to read from index first
+        const indexPath = join(projectPath, SESSION_INDEX_FILENAME);
+        try {
+          const indexContent = await fs.readFile(indexPath, "utf8");
+          const index = JSON.parse(indexContent) as SessionIndex;
+          for (const [id, meta] of Object.entries(index.sessions)) {
+            const lastActiveAt = new Date(meta.lastActiveAt);
+            if (meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo) {
+              allSessions.push({
+                id,
+                ...meta,
+                lastActiveAt,
+              });
+            }
+          }
+        } catch {
+          // If index fails, we skip this project directory
+          // In the future, we could scan for .jsonl files here
+        }
+      } catch {
+        // Skip if stat fails
+      }
+    }
+
+    return allSessions.sort(
+      (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
+    );
+  } catch (error) {
+    throw new Error(`Failed to list all sessions: ${error}`);
+  }
+}
+
 /**
  * Clean up expired sessions older than 14 days based on file modification time
  *
@@ -840,19 +912,23 @@ export async function deleteSession(
 }
 
 /**
- * Truncate content to a maximum length, adding ellipsis if truncated
+ * Truncate content to a maximum length, adding ellipsis if truncated.
+ * Also replaces real newlines with the literal string "\n".
  * @param content - The content to truncate
- * @param maxLength - Maximum length before truncation (default: 30)
+ * @param maxLength - Maximum length before truncation (default: 100)
  * @returns Truncated content with ellipsis if needed
  */
 export function truncateContent(
   content: string,
-  maxLength: number = 30,
+  maxLength: number = 100,
 ): string {
-  if (content.length <= maxLength) {
-    return content;
+  // Replace real newlines with literal "\n"
+  const singleLineContent = content.replace(/\n/g, "\\n");
+
+  if (singleLineContent.length <= maxLength) {
+    return singleLineContent;
   }
-  return content.substring(0, maxLength) + "...";
+  return singleLineContent.substring(0, maxLength) + "...";
 }
 
 /**

package/src/tools/bashTool.ts

@@ -77,10 +77,10 @@ Usage notes:
   - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
   - If the output exceeds ${MAX_OUTPUT_LENGTH} characters, output will be truncated before being returned to you.
   - You can use the \`run_in_background\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the ${BASH_TOOL_NAME} tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.
-  - Avoid using ${BASH_TOOL_NAME} with the \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
+  - Avoid using ${BASH_TOOL_NAME} with the \`find\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
     - File search: Use ${GLOB_TOOL_NAME} (NOT find or ls)
-    - Content search: Use ${GREP_TOOL_NAME} (NOT grep or rg)
-    - Read files: Use ${READ_TOOL_NAME} (NOT cat/head/tail)
+    - Content search: Use ${GREP_TOOL_NAME}
+    - Read files: Use ${READ_TOOL_NAME}
     - Edit files: Use ${EDIT_TOOL_NAME} (NOT sed/awk)
     - Write files: Use ${WRITE_TOOL_NAME} (NOT echo >/cat <<EOF)
     - Communication: Output text directly (NOT echo/printf)

package/src/tools/exitPlanMode.ts

@@ -85,7 +85,9 @@ Ensure your plan is complete and unambiguous:
         EXIT_PLAN_MODE_TOOL_NAME,
         context.permissionMode || "plan",
         context.canUseToolCallback,
-        { plan_content: planContent },
+        {
+          plan_content: planContent,
+        },
         context.toolCallId,
       );
 

package/src/tools/grepTool.ts

@@ -212,7 +212,8 @@ export const grepTool: ToolPlugin = {
       if (!output) {
         return {
           success: true,
-          content: "No matches found",
+          content:
+            "No matches found. Suggestion: specify the 'path' field to search in ignored or other directories (e.g., 'node_modules'), as the default search path is the current working directory and respects .gitignore.",
           shortResult: "No matches found",
         };
       }

package/src/tools/lspTool.ts

@@ -1,5 +1,6 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { relative } from "path";
+import { relative, join, isAbsolute } from "path";
+import * as fs from "fs";
 import { logger } from "../utils/globalLogger.js";
 import { getDisplayPath } from "../utils/path.js";
 import { LSP_TOOL_NAME } from "../constants/tools.js";
@@ -50,6 +51,43 @@ function formatUri(uri: string, workdir?: string): string {
   return path;
 }
 
+/**
+ * Formats an error message when no results are found, including context from the file
+ */
+function formatNoResultError(
+  message: string,
+  filePath: string,
+  line: number,
+  character: number,
+  workdir?: string,
+): string {
+  let absolutePath = filePath;
+  if (!isAbsolute(filePath) && workdir) {
+    absolutePath = join(workdir, filePath);
+  }
+
+  let lineContent = "";
+  try {
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    if (line > 0 && line <= lines.length) {
+      lineContent = lines[line - 1];
+    }
+  } catch {
+    // Ignore file read errors
+  }
+
+  const displayPath = getDisplayPath(filePath, workdir || "");
+  const baseMessage = `${message}\n\nPlease check if the character offset is correct and points to a valid symbol.`;
+
+  if (lineContent) {
+    const pointer = " ".repeat(Math.max(0, character - 1)) + "^";
+    return `${message}\n\nContext at ${displayPath}:${line}:${character}:\n${lineContent}\n${pointer}\n\nPlease check if the character offset is correct and points to a valid symbol.`;
+  }
+
+  return baseMessage;
+}
+
 /**
  * Groups items by their URI
  */
@@ -109,10 +147,19 @@ function isLocationLink(loc: Location | LocationLink): loc is LocationLink {
  */
 function formatGoToDefinitionResult(
   result: Location | Location[] | LocationLink | LocationLink[] | null,
+  filePath: string,
+  line: number,
+  character: number,
+  operation: string,
   workdir?: string,
 ): string {
+  const message =
+    operation === "goToImplementation"
+      ? "No implementation found. This may occur if the cursor is not on a symbol, or if the implementation is in an external library not indexed by the LSP server."
+      : "No definition found. This may occur if the cursor is not on a symbol, or if the definition is in an external library not indexed by the LSP server.";
+
   if (!result) {
-    return "No definition found. This may occur if the cursor is not on a symbol, or if the definition is in an external library not indexed by the LSP server.";
+    return formatNoResultError(message, filePath, line, character, workdir);
   }
 
   if (Array.isArray(result)) {
@@ -122,7 +169,7 @@ function formatGoToDefinitionResult(
     const validLocations = locations.filter((loc) => loc && loc.uri);
 
     if (validLocations.length === 0) {
-      return "No definition found. This may occur if the cursor is not on a symbol, or if the definition is in an external library not indexed by the LSP server.";
+      return formatNoResultError(message, filePath, line, character, workdir);
     }
 
     if (validLocations.length === 1) {
@@ -150,15 +197,21 @@ function formatGoToDefinitionResult(
  */
 function formatFindReferencesResult(
   result: Location[] | null,
+  filePath: string,
+  line: number,
+  character: number,
   workdir?: string,
 ): string {
+  const message =
+    "No references found. This may occur if the symbol has no usages, or if the LSP server has not fully indexed the workspace.";
+
   if (!result || result.length === 0) {
-    return "No references found. This may occur if the symbol has no usages, or if the LSP server has not fully indexed the workspace.";
+    return formatNoResultError(message, filePath, line, character, workdir);
   }
 
   const validLocations = result.filter((loc) => loc && loc.uri);
   if (validLocations.length === 0) {
-    return "No references found. This may occur if the symbol has no usages, or if the LSP server has not fully indexed the workspace.";
+    return formatNoResultError(message, filePath, line, character, workdir);
   }
 
   if (validLocations.length === 1) {
@@ -224,9 +277,21 @@ function formatHoverContents(contents: Hover["contents"]): string {
 /**
  * Formats the result of a hover operation
  */
-function formatHoverResult(result: Hover | null): string {
+function formatHoverResult(
+  result: Hover | null,
+  filePath: string,
+  line: number,
+  character: number,
+  workdir?: string,
+): string {
   if (!result) {
-    return "No hover information available. This may occur if the cursor is not on a symbol, or if the LSP server has not fully indexed the file.";
+    return formatNoResultError(
+      "No hover information available. This may occur if the cursor is not on a symbol, or if the LSP server has not fully indexed the file.",
+      filePath,
+      line,
+      character,
+      workdir,
+    );
   }
 
   const contents = formatHoverContents(result.contents);
@@ -428,10 +493,19 @@ function formatCallHierarchyItem(
  */
 function formatPrepareCallHierarchyResult(
   result: CallHierarchyItem[] | null,
+  filePath: string,
+  line: number,
+  character: number,
   workdir?: string,
 ): string {
   if (!result || result.length === 0) {
-    return "No call hierarchy item found at this position";
+    return formatNoResultError(
+      "No call hierarchy item found at this position",
+      filePath,
+      line,
+      character,
+      workdir,
+    );
   }
 
   if (result.length === 1) {
@@ -719,17 +793,30 @@ Note: LSP servers must be configured for the file type. If no server is availabl
               | LocationLink
               | LocationLink[]
               | null,
+            filePath,
+            line,
+            character,
+            operation,
             context.workdir,
           );
           break;
         case "findReferences":
           formattedContent = formatFindReferencesResult(
             rawResult as Location[] | null,
+            filePath,
+            line,
+            character,
             context.workdir,
           );
           break;
         case "hover":
-          formattedContent = formatHoverResult(rawResult as Hover | null);
+          formattedContent = formatHoverResult(
+            rawResult as Hover | null,
+            filePath,
+            line,
+            character,
+            context.workdir,
+          );
           break;
         case "documentSymbol":
           formattedContent = formatDocumentSymbolResult(
@@ -746,6 +833,9 @@ Note: LSP servers must be configured for the file type. If no server is availabl
         case "prepareCallHierarchy":
           formattedContent = formatPrepareCallHierarchyResult(
             rawResult as CallHierarchyItem[] | null,
+            filePath,
+            line,
+            character,
             context.workdir,
           );
           break;

package/src/tools/taskOutputTool.ts

@@ -82,16 +82,35 @@ export const taskOutputTool: ToolPlugin = {
       }
 
       const finalContent = content || "No output available";
-      const processedContent =
-        finalContent.length > MAX_OUTPUT_LENGTH
-          ? finalContent.substring(0, MAX_OUTPUT_LENGTH) +
-            "\n\n... (output truncated)"
-          : finalContent;
+      let processedContent = finalContent;
+      let isTruncated = false;
+
+      if (finalContent.length > MAX_OUTPUT_LENGTH) {
+        processedContent =
+          finalContent.substring(0, MAX_OUTPUT_LENGTH) +
+          "\n\n... (output truncated)";
+        isTruncated = true;
+      }
+
+      if (isTruncated && output.outputPath) {
+        processedContent += `\n\nFull output available at: ${output.outputPath}`;
+      }
+
+      let shortResult = `${taskId}: ${output.status}`;
+      if (output.status === "failed" && output.exitCode !== undefined) {
+        shortResult += ` (exit code: ${output.exitCode})`;
+      }
 
       return {
         success: true,
         content: processedContent,
-        shortResult: `${taskId}: ${output.status}`,
+        shortResult,
+        metadata: {
+          outputPath: output.outputPath,
+          status: output.status,
+          type: output.type,
+          exitCode: output.exitCode,
+        },
       };
     };
 

package/src/tools/types.ts

@@ -49,6 +49,8 @@ export interface ToolResult {
   }>;
   // Whether the tool was manually backgrounded by the user (e.g. via Ctrl-B)
   isManuallyBackgrounded?: boolean;
+  // Optional metadata for the tool result
+  metadata?: Record<string, unknown>;
 }
 
 export interface ToolContext {

package/src/types/agent.ts

@@ -65,6 +65,8 @@ export interface AgentOptions {
   worktreeName?: string;
   /**Whether this is a newly created worktree */
   isNewWorktree?: boolean;
+  /**Whether to watch for skill changes - defaults to true */
+  watchSkills?: boolean;
 }
 
 export interface AgentCallbacks

package/src/types/configuration.ts

@@ -91,6 +91,8 @@ export interface ConfigurationPaths {
   userPaths: string[];
   /** Project-specific configuration file paths in priority order */
   projectPaths: string[];
+  /** Builtin configuration file paths */
+  builtinPaths: string[];
   /** All configuration paths combined */
   allPaths: string[];
   /** Only the paths that actually exist on the filesystem */

package/src/types/skills.ts

@@ -6,7 +6,7 @@
 export interface SkillMetadata {
   name: string;
   description: string;
-  type: "personal" | "project";
+  type: "personal" | "project" | "builtin";
   skillPath: string;
   allowedTools?: string[];
   context?: "fork";
@@ -37,7 +37,7 @@ export interface SkillFrontmatter {
 }
 
 export interface SkillCollection {
-  type: "personal" | "project";
+  type: "personal" | "project" | "builtin";
   basePath: string;
   skills: Map<string, SkillMetadata>;
   errors: SkillError[];
@@ -57,6 +57,7 @@ export interface SkillValidationResult {
 export interface SkillDiscoveryResult {
   personalSkills: Map<string, SkillMetadata>;
   projectSkills: Map<string, SkillMetadata>;
+  builtinSkills: Map<string, SkillMetadata>;
   errors: SkillError[];
 }
 
@@ -73,6 +74,7 @@ export interface SkillManagerOptions {
   personalSkillsPath?: string;
   scanTimeout?: number;
   workdir?: string;
+  watch?: boolean;
 }
 
 export interface ParsedSkillFile {

package/src/utils/configPaths.ts

@@ -10,9 +10,29 @@
  * - Project configs override user configs (existing behavior)
  */
 
-import { join } from "path";
+import { join, dirname } from "path";
 import { homedir } from "os";
 import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Get the builtin skills directory path
+ */
+export function getBuiltinSkillsDir(): string {
+  // In development, it's in src/builtin-skills
+  // In production (dist), it should be in dist/builtin-skills
+  // We'll look for it relative to this file
+  const devPath = join(__dirname, "..", "builtin-skills");
+  const prodPath = join(__dirname, "builtin-skills");
+
+  if (existsSync(devPath)) {
+    return devPath;
+  }
+  return prodPath;
+}
 
 /**
  * Get the user-specific configuration file path (legacy function)
@@ -62,15 +82,18 @@ export function getProjectConfigPaths(workdir: string): string[] {
 export function getAllConfigPaths(workdir: string): {
   userPaths: string[];
   projectPaths: string[];
+  builtinPaths: string[];
   allPaths: string[];
 } {
   const userPaths = getUserConfigPaths();
   const projectPaths = getProjectConfigPaths(workdir);
+  const builtinPaths = [join(getBuiltinSkillsDir(), "settings", "SKILL.md")];
 
   return {
     userPaths,
     projectPaths,
-    allPaths: [...userPaths, ...projectPaths],
+    builtinPaths,
+    allPaths: [...userPaths, ...projectPaths, ...builtinPaths],
   };
 }
 
@@ -81,17 +104,20 @@ export function getAllConfigPaths(workdir: string): {
 export function getExistingConfigPaths(workdir: string): {
   userPaths: string[];
   projectPaths: string[];
+  builtinPaths: string[];
   existingPaths: string[];
 } {
   const allPaths = getAllConfigPaths(workdir);
 
   const existingUserPaths = allPaths.userPaths.filter(existsSync);
   const existingProjectPaths = allPaths.projectPaths.filter(existsSync);
+  const existingBuiltinPaths = allPaths.builtinPaths.filter(existsSync);
   const allExistingPaths = allPaths.allPaths.filter(existsSync);
 
   return {
     userPaths: existingUserPaths,
     projectPaths: existingProjectPaths,
+    builtinPaths: existingBuiltinPaths,
     existingPaths: allExistingPaths,
   };
 }

package/src/utils/containerSetup.ts

@@ -147,7 +147,10 @@ export function setupAgentContainer(
   const hookManager = new HookManager(container, workdir);
   container.register("HookManager", hookManager);
 
-  const skillManager = new SkillManager(container, { workdir });
+  const skillManager = new SkillManager(container, {
+    workdir,
+    watch: options.watchSkills ?? true,
+  });
   container.register("SkillManager", skillManager);
 
   container.register(

package/src/utils/gitUtils.ts

@@ -59,6 +59,28 @@ export function getGitCommonDir(cwd: string): string {
   }
 }
 
+/**
+ * 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 = execSync("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);
+  }
+}
+
 /**
  * Get the default remote branch (e.g., origin/main)
  * @param cwd Working directory