wave-agent-sdk 0.14.1 → 0.14.3

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

package/src/services/pluginLoader.ts

@@ -1,5 +1,4 @@
 import * as fs from "fs/promises";
-import * as fsSync from "fs";
 import * as path from "path";
 import {
   PluginManifest,
@@ -11,82 +10,29 @@ import {
 } from "../types/index.js";
 import { scanCommandsDirectory } from "../utils/customCommands.js";
 import { parseSkillFile } from "../utils/skillParser.js";
+import {
+  parseAgentFile,
+  type SubagentConfiguration,
+} from "../utils/subagentParser.js";
 import { resolveMcpConfig } from "../managers/mcpManager.js";
+import { logger } from "../utils/globalLogger.js";
 
 export class PluginLoader {
-  /**
-   * Finds the first existing plugin manifest path.
-   * Prefers .wave-plugin/ for backward compatibility, falls back to .claude-plugin/.
-   * Returns null if neither exists.
-   */
-  private static findPluginManifestPath(pluginPath: string): string | null {
-    const waveManifestPath = path.join(
-      pluginPath,
-      ".wave-plugin",
-      "plugin.json",
-    );
-    const claudeManifestPath = path.join(
-      pluginPath,
-      ".claude-plugin",
-      "plugin.json",
-    );
-
-    // Check .wave-plugin first for backward compatibility
-    try {
-      const waveStat = fsSync.statSync(waveManifestPath);
-      if (waveStat.isFile()) {
-        return waveManifestPath;
-      }
-    } catch {
-      // .wave-plugin/plugin.json doesn't exist
-    }
-
-    try {
-      const claudeStat = fsSync.statSync(claudeManifestPath);
-      if (claudeStat.isFile()) {
-        return claudeManifestPath;
-      }
-    } catch {
-      // .claude-plugin/plugin.json doesn't exist
-    }
-
-    return null;
-  }
-
   /**
    * Load and validate a plugin manifest from a directory
    * @param pluginPath Absolute path to the plugin directory
    */
   static async loadManifest(pluginPath: string): Promise<PluginManifest> {
-    const manifestPath = this.findPluginManifestPath(pluginPath);
-    if (!manifestPath) {
-      throw new Error(
-        `Plugin manifest not found at ${pluginPath}. Neither .wave-plugin/plugin.json nor .claude-plugin/plugin.json exists.`,
-      );
-    }
+    const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
+    const manifestPath = path.join(dotWavePluginPath, "plugin.json");
 
-    // Determine which directory is being used for validation
-    const pluginDirName = manifestPath.includes(".claude-plugin")
-      ? ".claude-plugin"
-      : ".wave-plugin";
-    const pluginDirPath = path.join(pluginPath, pluginDirName);
-
-    // T018: Ensure plugin.json is the only file in the manifest directory
-    // For .claude-plugin/, marketplace.json is also allowed (Claude Code convention)
+    // T018: Ensure plugin.json is the only file in .wave-plugin/
     try {
-      const entries = await fs.readdir(pluginDirPath);
-      const allowedFiles = ["plugin.json"];
-      if (pluginDirName === ".claude-plugin") {
-        allowedFiles.push("marketplace.json");
-      }
-      const misplaced = entries.filter((e) => !allowedFiles.includes(e));
+      const entries = await fs.readdir(dotWavePluginPath);
+      const misplaced = entries.filter((e) => e !== "plugin.json");
       if (misplaced.length > 0) {
-        const allowedMsg =
-          pluginDirName === ".claude-plugin"
-            ? "Only plugin.json and marketplace.json should be in this directory."
-            : "Only plugin.json should be in this directory.";
         throw new Error(
-          `Misplaced files/directories in ${pluginDirName}/: ${misplaced.join(", ")}. ${allowedMsg}`,
+          `Misplaced files/directories in .wave-plugin/: ${misplaced.join(", ")}. Only plugin.json should be in this directory.`,
         );
       }
     } catch (error) {
@@ -95,7 +41,7 @@ export class PluginLoader {
         (error as { code?: string }).code === "ENOENT"
       ) {
         throw new Error(
-          `Plugin manifest directory not found at ${pluginDirPath}`,
+          `Plugin manifest directory not found at ${dotWavePluginPath}`,
         );
       }
       throw error;
@@ -212,12 +158,50 @@ export class PluginLoader {
     const hooksPath = path.join(pluginPath, "hooks", "hooks.json");
     try {
       const content = await fs.readFile(hooksPath, "utf-8");
-      return JSON.parse(content) as PartialHookConfiguration;
+      const parsed = JSON.parse(content);
+      // Claude Code wrapper format: { "hooks": { "SessionStart": [...] } }
+      // (optional "description" sibling key)
+      if (parsed && typeof parsed === "object" && "hooks" in parsed) {
+        return parsed.hooks as PartialHookConfiguration;
+      }
+      return undefined;
     } catch {
       return undefined;
     }
   }
 
+  /**
+   * Load agent configurations from a plugin's agents directory
+   */
+  static async loadAgents(
+    pluginPath: string,
+  ): Promise<SubagentConfiguration[]> {
+    const agentsPath = path.join(pluginPath, "agents");
+    const agents: SubagentConfiguration[] = [];
+
+    try {
+      const entries = await fs.readdir(agentsPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const agentFilePath = path.join(agentsPath, entry.name);
+          try {
+            const config = parseAgentFile(agentFilePath, "plugin", pluginPath);
+            agents.push(config);
+          } catch (parseError) {
+            // Log error but continue with other files
+            logger?.warn(
+              `Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+            );
+          }
+        }
+      }
+    } catch {
+      // agents directory might not exist
+    }
+
+    return agents;
+  }
+
   /**
    * Validate the plugin manifest structure
    */

package/src/services/session.ts

@@ -816,7 +816,7 @@ export async function sessionExistsInJsonl(
 /**
  * Get the content of the first message in a session
  * For user role: get text block content
- * For assistant role: get compress block content
+ * For assistant role: get compact block content
  * @param sessionId - Session ID to get first message from
  * @param workdir - Working directory for session operations
  * @returns Promise that resolves to the first message content or null if not found
@@ -996,18 +996,18 @@ export async function loadFullMessageThread(
 
     sessionIds.unshift(currentId);
     // Add messages from this session to the beginning of the list
-    // But skip the "compress" block if it's not the first session in our traversal (which is the latest)
+    // But skip the "compact" block if it's not the first session in our traversal (which is the latest)
     // Actually, we should probably keep all messages and let the UI/logic handle it.
-    // But wait, if we are concatenating, the "compress" block in session N summarizes session N-1.
-    // So if we have session N-1 and session N, we should probably skip the compress block in session N.
+    // But wait, if we are concatenating, the "compact" block in session N summarizes session N-1.
+    // So if we have session N-1 and session N, we should probably skip the compact block in session N.
 
     const messages = sessionData.messages;
     if (allMessages.length > 0) {
       // If we already have messages (from "later" sessions),
       // we are now adding messages from an "earlier" session.
-      // The later session's first message might be a "compress" block.
-      if (allMessages[0].blocks.some((b) => b.type === "compress")) {
-        // Remove the compress block from the later session's messages
+      // The later session's first message might be a "compact" block.
+      if (allMessages[0].blocks.some((b) => b.type === "compact")) {
+        // Remove the compact block from the later session's messages
         // because we are now providing the actual messages it summarized.
         allMessages.shift();
       }

package/src/services/taskManager.ts

@@ -30,7 +30,7 @@ export class TaskManager extends EventEmitter {
 
   /**
    * Syncs the task list ID with the current session's root session ID.
-   * This is typically called when the session is cleared or compressed.
+   * This is typically called when the session is cleared or compacted.
    */
   public async syncWithSession(): Promise<void> {
     const messageManager = this.container.get<MessageManager>("MessageManager");

package/src/types/core.ts

@@ -25,7 +25,7 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compress"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact"; // Type of operation that generated usage
 
   // Cache-related tokens (Claude models only)
   cache_read_input_tokens?: number; // Tokens read from cache

package/src/types/hooks.ts

@@ -21,7 +21,9 @@ export type HookEvent =
   | "SubagentStop"
   | "PermissionRequest"
   | "WorktreeCreate"
-  | "CwdChanged";
+  | "CwdChanged"
+  | "SessionStart"
+  | "SessionEnd";
 
 // Individual hook command configuration
 export interface HookCommand {
@@ -94,6 +96,10 @@ export class HookConfigurationError extends Error {
   }
 }
 
+export type SessionStartSource = "startup" | "resume" | "compact";
+
+export type SessionEndSource = "exit" | "stop" | "compact";
+
 // Type guards for runtime validation
 export function isValidHookEvent(event: string): event is HookEvent {
   return [
@@ -105,6 +111,8 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "PermissionRequest",
     "WorktreeCreate",
     "CwdChanged",
+    "SessionStart",
+    "SessionEnd",
   ].includes(event);
 }
 
@@ -161,7 +169,7 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "CwdChanged"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "CwdChanged" | "SessionStart"
 
   // Optional fields based on event type
   tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
@@ -172,6 +180,9 @@ export interface HookJsonInput {
   name?: string; // Present for WorktreeCreate events
   old_cwd?: string; // Present for CwdChanged events
   new_cwd?: string; // Present for CwdChanged events
+  source?: SessionStartSource; // Present for SessionStart events
+  agent_type?: string; // Present for SessionStart events
+  end_source?: SessionEndSource; // Present for SessionEnd events
 }
 
 // Extended context interface for passing additional data to hook executor
@@ -187,6 +198,9 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   worktreeName?: string; // Worktree name (WorktreeCreate only)
   oldCwd?: string; // Previous working directory (CwdChanged only)
   newCwd?: string; // New working directory (CwdChanged only)
+  source?: SessionStartSource; // Session start source (SessionStart only)
+  agentType?: string; // Agent type identifier (SessionStart only)
+  endSource?: SessionEndSource; // Session end source (SessionEnd only)
 }
 
 // Environment variables injected into hook processes