wave-agent-sdk 0.14.1 → 0.14.2

package/src/managers/messageManager.ts

@@ -47,8 +47,8 @@ export interface MessageManagerCallbacks {
   onAssistantReasoningUpdated?: (chunk: string, accumulated: string) => void;
   onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
   onErrorBlockAdded?: (error: string) => void;
-  onCompressBlockAdded?: (content: string) => void;
-  onCompressionStateChange?: (isCompressing: boolean) => void;
+  onCompactBlockAdded?: (content: string) => void;
+  onCompactionStateChange?: (isCompacting: boolean) => void;
   // Bang callback
   onAddBangMessage?: (command: string) => void;
   onUpdateBangMessage?: (command: string, output: string) => void;
@@ -92,6 +92,8 @@ export class MessageManager {
   private filesInContext: Set<string> = new Set(); // Track files mentioned in the conversation
   private recentFileReads: Map<string, { content: string; timestamp: number }> =
     new Map(); // Track file read contents
+  private invokedSkills: Map<string, { skillName: string; timestamp: number }> =
+    new Map(); // Track invoked skill names
   private sessionType: "main" | "subagent";
   private subagentType?: string;
   private _usages: Usage[] = [];
@@ -270,12 +272,14 @@ export class MessageManager {
     for (const message of newMessages) {
       this.addPathsFromMessage(message);
       this.extractFileReadsFromMessage(message);
+      this.extractSkillInvocationsFromMessage(message);
     }
 
     // Also check if the last message was updated (common for tool blocks)
     if (messages.length > 0 && messages.length === oldLength) {
       this.addPathsFromMessage(messages[messages.length - 1]);
       this.extractFileReadsFromMessage(messages[messages.length - 1]);
+      this.extractSkillInvocationsFromMessage(messages[messages.length - 1]);
     }
 
     this.callbacks.onMessagesChange?.([...messages]);
@@ -494,31 +498,31 @@ export class MessageManager {
   }
 
   /**
-   * Compress messages and update session, delete compressed messages, only keep compressed messages and last 3 messages
+   * Compact messages and update session, delete compacted messages, only keep compacted messages and last 3 messages
    */
-  public compressMessagesAndUpdateSession(
-    compressedContent: string,
+  public compactMessagesAndUpdateSession(
+    compactedContent: string,
     usage?: Usage,
   ): void {
     // Get last 2 API rounds to preserve (structurally safe boundary)
     const lastThreeMessages = getLastApiRounds(this.messages, 2);
 
-    // Create compressed message
-    const compressMessage: Message = {
+    // Create compacted message
+    const compactMessage: Message = {
       id: generateMessageId(),
       role: "assistant",
       blocks: [
         {
-          type: "compress",
-          content: compressedContent,
+          type: "compact",
+          content: compactedContent,
           sessionId: this.sessionId,
         },
       ],
       ...(usage && { usage }),
     };
 
-    // Build new message array: keep the compressed message and last 3 messages
-    const newMessages: Message[] = [compressMessage, ...lastThreeMessages];
+    // Build new message array: keep the compacted message and last 3 messages
+    const newMessages: Message[] = [compactMessage, ...lastThreeMessages];
 
     // Update sessionId and parentSessionId
     const oldSessionId = this.sessionId;
@@ -539,15 +543,15 @@ export class MessageManager {
       this.addPathsFromMessage(message);
     }
 
-    // Scan compressedContent for file mentions
+    // Scan compactedContent for file mentions
     const fileMentionRegex = /(?:^|\s)@([\w.\-/]+)/g;
     let match;
-    while ((match = fileMentionRegex.exec(compressedContent)) !== null) {
+    while ((match = fileMentionRegex.exec(compactedContent)) !== null) {
       this.touchFile(match[1]);
     }
 
-    // Trigger compression callback
-    this.callbacks.onCompressBlockAdded?.(compressedContent);
+    // Trigger compaction callback
+    this.callbacks.onCompactBlockAdded?.(compactedContent);
   }
 
   public addFileHistoryBlock(
@@ -861,7 +865,7 @@ export class MessageManager {
     let targetSessionId = this.sessionId;
     let targetIndexInSession = index;
 
-    // We need to be careful here because loadFullMessageThread might have removed "compress" blocks
+    // We need to be careful here because loadFullMessageThread might have removed "compact" blocks
     // Let's re-calculate based on the actual messages returned.
     // Actually, it's easier to just load sessions one by one again or keep track of counts.
 
@@ -883,19 +887,19 @@ export class MessageManager {
       if (!sessionData) continue;
 
       const sessionMessages = sessionData.messages;
-      // If this is not the first session in the thread, it might have a compress block at the start
+      // If this is not the first session in the thread, it might have a compact block at the start
       // that was removed in getFullMessageThread.
-      const hasCompressBlock = sessionMessages[0]?.blocks.some(
-        (b) => b.type === "compress",
+      const hasCompactBlock = sessionMessages[0]?.blocks.some(
+        (b) => b.type === "compact",
       );
       const effectiveMessages =
-        hasCompressBlock && sid !== sessionIds[0]
+        hasCompactBlock && sid !== sessionIds[0]
           ? sessionMessages.slice(1)
           : sessionMessages;
 
       if (remainingIndex < effectiveMessages.length) {
         targetSessionId = sid;
-        targetIndexInSession = hasCompressBlock
+        targetIndexInSession = hasCompactBlock
           ? remainingIndex + 1
           : remainingIndex;
         break;
@@ -938,7 +942,7 @@ export class MessageManager {
 
     // Update in-memory messages to the truncated session messages
     // We do NOT include ancestor messages here to avoid exceeding context limits.
-    // The 'compress' block at the start of the session (if any) already summarizes them.
+    // The 'compact' block at the start of the session (if any) already summarizes them.
     this.setMessages(newMessagesInSession);
 
     // Update saved message count
@@ -1056,4 +1060,54 @@ export class MessageManager {
     }
     return result;
   }
+
+  /**
+   * Extract skill invocations from tool blocks in a message.
+   */
+  private extractSkillInvocationsFromMessage(message: Message): void {
+    for (const block of message.blocks) {
+      if (
+        block.type === "tool" &&
+        block.name === "Skill" &&
+        block.stage === "end" &&
+        block.parameters
+      ) {
+        try {
+          const params = JSON.parse(block.parameters) as Record<
+            string,
+            unknown
+          >;
+          const skillName = params.skill_name as string | undefined;
+          if (skillName) {
+            this.invokedSkills.set(skillName, {
+              skillName,
+              timestamp: Date.now(),
+            });
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+    }
+  }
+
+  /**
+   * Get recently invoked skill names, sorted by timestamp (newest first).
+   * @param maxSkills - Maximum number of skills to return
+   * @returns Array of skill names sorted by recency
+   */
+  public getInvokedSkillNames(maxSkills = 10): string[] {
+    const sorted = Array.from(this.invokedSkills.entries())
+      .sort(([, a], [, b]) => b.timestamp - a.timestamp)
+      .slice(0, maxSkills);
+
+    return sorted.map(([, { skillName }]) => skillName);
+  }
+
+  /**
+   * Clear all invoked skills (e.g., after compaction).
+   */
+  public clearInvokedSkills(): void {
+    this.invokedSkills.clear();
+  }
 }

package/src/prompts/index.ts

@@ -179,7 +179,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
 
-export const COMPRESS_MESSAGES_SYSTEM_PROMPT = `You are continuing work on a software engineering task. Write a detailed continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary.
+export const COMPACT_MESSAGES_SYSTEM_PROMPT = `You are continuing work on a software engineering task. Write a detailed continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary.
 
 First, write your analysis in <analysis> tags as a thinking scratchpad:
 - Chronologically review the conversation

package/src/services/MarketplaceService.ts

@@ -8,12 +8,12 @@ import {
   InstalledPlugin,
   InstalledPluginsRegistry,
   MarketplaceManifest,
-  MarketplacePluginEntry,
   MarketplaceSource,
 } from "../types/marketplace.js";
 import { GitService } from "./GitService.js";
 import { ConfigurationService } from "./configurationService.js";
 import type { MarketplaceConfig, Scope } from "../types/configuration.js";
+import { logger } from "../utils/globalLogger.js";
 
 /**
  * Marketplace Service
@@ -320,42 +320,19 @@ export class MarketplaceService {
     await fs.rename(tmpPath, this.installedPluginsPath);
   }
 
-  /**
-   * Finds the first existing marketplace manifest path.
-   * Prefers .wave-plugin/ for backward compatibility, falls back to .claude-plugin/.
-   * Returns null if neither exists.
-   */
-  private async findMarketplaceManifestPath(
-    dir: string,
-  ): Promise<string | null> {
-    const waveManifestPath = path.join(dir, ".wave-plugin", "marketplace.json");
-    const claudeManifestPath = path.join(
-      dir,
-      ".claude-plugin",
-      "marketplace.json",
-    );
-
-    if (existsSync(waveManifestPath)) {
-      return waveManifestPath;
-    }
-    if (existsSync(claudeManifestPath)) {
-      return claudeManifestPath;
-    }
-    return null;
-  }
-
   /**
    * Loads a marketplace manifest from a local path
    */
   async loadMarketplaceManifest(
     marketplacePath: string,
   ): Promise<MarketplaceManifest> {
-    const manifestPath =
-      await this.findMarketplaceManifestPath(marketplacePath);
-    if (!manifestPath) {
-      throw new Error(
-        `Marketplace manifest not found at ${marketplacePath}. Neither .wave-plugin/marketplace.json nor .claude-plugin/marketplace.json exists.`,
-      );
+    const manifestPath = path.join(
+      marketplacePath,
+      ".wave-plugin",
+      "marketplace.json",
+    );
+    if (!existsSync(manifestPath)) {
+      throw new Error(`Marketplace manifest not found at ${manifestPath}`);
     }
     const content = await fs.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(content);
@@ -665,7 +642,7 @@ export class MarketplaceService {
                 (p) => p.name === plugin.name,
               );
               if (!pluginEntry) {
-                console.warn(
+                logger.warn(
                   `Plugin "${plugin.name}" no longer found in marketplace "${marketplace.name}". Uninstalling...`,
                 );
                 try {
@@ -767,74 +744,6 @@ export class MarketplaceService {
     });
   }
 
-  /**
-   * Resolves a plugin source into a consistent format for installation.
-   * Handles both string sources (local paths or git URLs) and object-style MarketplaceSource.
-   */
-  private resolvePluginSource(
-    pluginEntry: MarketplacePluginEntry,
-    marketplacePath: string,
-  ): { isGit: boolean; url?: string; ref?: string; localPath: string } {
-    const { source } = pluginEntry;
-
-    if (typeof source === "string") {
-      // String source: could be a git URL or a relative local path
-      const isGitUrl =
-        source.startsWith("http://") ||
-        source.startsWith("https://") ||
-        source.startsWith("git@") ||
-        source.startsWith("ssh://");
-
-      if (isGitUrl) {
-        let url = source;
-        let ref: string | undefined;
-        if (url.includes("#")) {
-          [url, ref] = url.split("#");
-        }
-        return { isGit: true, url, ref, localPath: "" };
-      }
-
-      // Relative local path
-      return { isGit: false, localPath: path.resolve(marketplacePath, source) };
-    }
-
-    // Object-style source
-    if (source.source === "git") {
-      return { isGit: true, url: source.url, ref: source.ref, localPath: "" };
-    }
-
-    if (source.source === "github") {
-      return {
-        isGit: true,
-        url: `https://github.com/${source.repo}.git`,
-        ref: source.ref,
-        localPath: "",
-      };
-    }
-
-    if (source.source === "url") {
-      let url = source.url;
-      let ref = source.ref;
-      if (url.includes("#")) {
-        [url, ref] = url.split("#");
-      }
-      return { isGit: true, url, ref, localPath: "" };
-    }
-
-    if (source.source === "directory") {
-      return {
-        isGit: false,
-        localPath: path.resolve(marketplacePath, source.path),
-      };
-    }
-
-    // Exhaustiveness: this should be unreachable given the union type
-    const _exhaustive: never = source;
-    throw new Error(
-      `Unsupported plugin source type: ${(_exhaustive as { source: string }).source}`,
-    );
-  }
-
   /**
    * Installs a plugin from a marketplace
    */
@@ -863,46 +772,36 @@ export class MarketplaceService {
         );
       }
 
-      const resolved = this.resolvePluginSource(pluginEntry, marketplacePath);
+      const isGitSource =
+        pluginEntry.source.startsWith("http://") ||
+        pluginEntry.source.startsWith("https://") ||
+        pluginEntry.source.startsWith("git@") ||
+        pluginEntry.source.startsWith("ssh://");
 
       let pluginSrcPath: string;
       let tempCloneDir: string | undefined;
 
       try {
-        if (resolved.isGit) {
+        if (isGitSource) {
           tempCloneDir = path.join(this.tmpDir, `clone-${Date.now()}`);
-          await this.gitService.clone(
-            resolved.url!,
-            tempCloneDir,
-            resolved.ref,
-          );
+          let url = pluginEntry.source;
+          let ref: string | undefined;
+          if (url.includes("#")) {
+            [url, ref] = url.split("#");
+          }
+          await this.gitService.clone(url, tempCloneDir, ref);
           pluginSrcPath = tempCloneDir;
         } else {
-          pluginSrcPath = resolved.localPath;
+          pluginSrcPath = path.resolve(marketplacePath, pluginEntry.source);
         }
 
-        let pluginManifestPath: string | undefined;
-        const wavePluginPath = path.join(
+        const pluginManifestPath = path.join(
           pluginSrcPath,
           ".wave-plugin",
           "plugin.json",
         );
-        const claudePluginPath = path.join(
-          pluginSrcPath,
-          ".claude-plugin",
-          "plugin.json",
-        );
-
-        if (existsSync(wavePluginPath)) {
-          pluginManifestPath = wavePluginPath;
-        } else if (existsSync(claudePluginPath)) {
-          pluginManifestPath = claudePluginPath;
-        }
-
-        if (!pluginManifestPath) {
-          throw new Error(
-            `Plugin manifest not found at ${pluginSrcPath}. Neither .wave-plugin/plugin.json nor .claude-plugin/plugin.json exists.`,
-          );
+        if (!existsSync(pluginManifestPath)) {
+          throw new Error(`Plugin manifest not found at ${pluginManifestPath}`);
         }
 
         const pluginManifestContent = await fs.readFile(
@@ -917,7 +816,7 @@ export class MarketplaceService {
           `${pluginName}-${Date.now()}`,
         );
         try {
-          if (resolved.isGit) {
+          if (isGitSource) {
             await fs.rename(pluginSrcPath, tmpPluginDir);
             tempCloneDir = undefined;
           } else {

package/src/services/aiService.ts

@@ -23,7 +23,7 @@ import * as fs from "fs";
 import * as path from "path";
 
 import {
-  COMPRESS_MESSAGES_SYSTEM_PROMPT,
+  COMPACT_MESSAGES_SYSTEM_PROMPT,
   WEB_CONTENT_SYSTEM_PROMPT,
   BTW_SYSTEM_PROMPT,
 } from "../prompts/index.js";
@@ -751,7 +751,7 @@ async function processStreamingResponse(
   return result;
 }
 
-export interface CompressMessagesOptions {
+export interface CompactMessagesOptions {
   // Resolved configuration
   gatewayConfig: GatewayConfig;
   modelConfig: ModelConfig;
@@ -762,7 +762,7 @@ export interface CompressMessagesOptions {
   model?: string;
 }
 
-export interface CompressMessagesResult {
+export interface CompactMessagesResult {
   content: string;
   usage?: {
     prompt_tokens: number;
@@ -771,9 +771,9 @@ export interface CompressMessagesResult {
   };
 }
 
-export async function compressMessages(
-  options: CompressMessagesOptions,
-): Promise<CompressMessagesResult> {
+export async function compactMessages(
+  options: CompactMessagesOptions,
+): Promise<CompactMessagesResult> {
   const { gatewayConfig, modelConfig, messages, abortSignal } = options;
 
   // Apply global 1 QPS rate limit
@@ -832,7 +832,7 @@ export async function compressMessages(
         messages: [
           {
             role: "system",
-            content: COMPRESS_MESSAGES_SYSTEM_PROMPT,
+            content: COMPACT_MESSAGES_SYSTEM_PROMPT,
           },
           ...cleanedMessages,
           {
@@ -849,7 +849,7 @@ export async function compressMessages(
     const content = response.choices[0]?.message?.content?.trim();
     if (!content) {
       throw new Error(
-        "Failed to compress conversation history: Empty response from AI",
+        "Failed to compact conversation history: Empty response from AI",
       );
     }
     const usage = response.usage
@@ -866,10 +866,10 @@ export async function compressMessages(
     };
   } catch (error) {
     if ((error as Error).name === "AbortError") {
-      logger.info("Compression request was aborted");
-      throw new Error("Compression request was aborted");
+      logger.info("Compaction request was aborted");
+      throw new Error("Compaction request was aborted");
     }
-    logger.error("Failed to compress messages:", error);
+    logger.error("Failed to compact messages:", error);
     throw error;
   }
 }

package/src/services/hook.ts

@@ -84,6 +84,23 @@ async function buildHookJsonInput(
     }
   }
 
+  // Add SessionStart-specific fields
+  if (context.event === "SessionStart") {
+    if (context.source !== undefined) {
+      jsonInput.source = context.source;
+    }
+    if (context.agentType !== undefined) {
+      jsonInput.agent_type = context.agentType;
+    }
+  }
+
+  // Add SessionEnd-specific fields
+  if (context.event === "SessionEnd") {
+    if (context.endSource !== undefined) {
+      jsonInput.end_source = context.endSource;
+    }
+  }
+
   return jsonInput;
 }
 

package/src/services/initializationService.ts

@@ -178,6 +178,38 @@ export class InitializationService {
       // Don't throw error to prevent app startup failure
     }
 
+    // Execute SessionStart hooks
+    try {
+      const phaseStart = performance.now();
+      const sessionStartResult = await hookManager.executeSessionStartHooks(
+        "startup",
+        messageManager.getSessionId(),
+        messageManager.getTranscriptPath(),
+      );
+
+      // Inject additionalContext as a meta user message (matches Claude Code)
+      if (sessionStartResult.additionalContext) {
+        messageManager.addUserMessage({
+          content: `<system-reminder>\nSessionStart hook additional context: ${sessionStartResult.additionalContext}\n</system-reminder>`,
+          isMeta: true,
+        });
+      }
+
+      // Inject initialUserMessage as a meta user message
+      if (sessionStartResult.initialUserMessage) {
+        messageManager.addUserMessage({
+          content: sessionStartResult.initialUserMessage,
+          isMeta: true,
+        });
+      }
+
+      logger?.debug(
+        `Initialization Phase [SessionStart Hooks] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
+    } catch (error) {
+      logger?.warn("SessionStart hooks execution failed:", error);
+    }
+
     // Trigger WorktreeCreate hook if this is a new worktree
     if (agentOptions.isNewWorktree && hookManager) {
       try {
@@ -318,7 +350,7 @@ export class InitializationService {
       if (sessionToRestore) {
         messageManager.initializeFromSession(sessionToRestore);
 
-        // Update task manager with the root session ID to ensure continuity across compressions
+        // Update task manager with the root session ID to ensure continuity across compactions
         taskManager.setTaskListId(
           sessionToRestore.rootSessionId || sessionToRestore.id,
         );

package/src/services/interactionService.ts

@@ -183,7 +183,7 @@ export class InteractionService {
     // 6. Initialize session state last
     messageManager.initializeFromSession(sessionData);
 
-    // Update task manager with the root session ID to ensure continuity across compressions
+    // Update task manager with the root session ID to ensure continuity across compactions
     taskManager.setTaskListId(sessionData.rootSessionId || sessionData.id);
 
     // 7. Load tasks for the restored session