wave-agent-sdk 0.14.1 → 0.14.2

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,
@@ -14,79 +13,21 @@ import { parseSkillFile } from "../utils/skillParser.js";
 import { resolveMcpConfig } from "../managers/mcpManager.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.`,
-      );
-    }
-
-    // Determine which directory is being used for validation
-    const pluginDirName = manifestPath.includes(".claude-plugin")
-      ? ".claude-plugin"
-      : ".wave-plugin";
-    const pluginDirPath = path.join(pluginPath, pluginDirName);
+    const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
+    const manifestPath = path.join(dotWavePluginPath, "plugin.json");
 
-    // 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 +36,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,7 +153,13 @@ 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;
     }

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

package/src/types/marketplace.ts

@@ -7,24 +7,8 @@ export interface MarketplaceOwner {
 
 export interface MarketplacePluginEntry {
   name: string;
-  source: string | MarketplaceSource;
+  source: string;
   description: string;
-  /** Claude Code compatibility: plugin category */
-  category?: string;
-  /** Claude Code compatibility: plugin tags */
-  tags?: string[];
-  /** Claude Code compatibility: when false, plugin.json is optional */
-  strict?: boolean;
-  /** Claude Code compatibility: inline manifest fields */
-  version?: string;
-  author?: { name: string; url?: string };
-  homepage?: string;
-  repository?: string;
-  license?: string;
-  keywords?: string[];
-  commands?: string;
-  skills?: string;
-  agents?: string;
 }
 
 export interface MarketplacePluginStatus extends MarketplacePluginEntry {
@@ -40,8 +24,6 @@ export interface MarketplaceManifest {
   name: string;
   owner: MarketplaceOwner;
   plugins: MarketplacePluginEntry[];
-  /** Claude Code compatibility: additional metadata */
-  metadata?: Record<string, unknown>;
 }
 
 export type MarketplaceSource =
@@ -58,11 +40,6 @@ export type MarketplaceSource =
       source: "git";
       url: string;
       ref?: string;
-    }
-  | {
-      source: "url";
-      url: string;
-      ref?: string;
     };
 
 export interface KnownMarketplace {

package/src/types/messaging.ts

@@ -25,7 +25,7 @@ export type MessageBlock =
   | ToolBlock
   | ImageBlock
   | BangBlock
-  | CompressBlock
+  | CompactBlock
   | ReasoningBlock
   | FileHistoryBlock
   | TaskNotificationBlock;
@@ -85,8 +85,8 @@ export interface BangBlock {
   exitCode: number | null;
 }
 
-export interface CompressBlock {
-  type: "compress";
+export interface CompactBlock {
+  type: "compact";
   content: string;
   sessionId: string;
 }

package/src/types/plugins.ts

@@ -5,7 +5,7 @@ import { McpConfig } from "./mcp.js";
 import { PartialHookConfiguration } from "./configuration.js";
 
 /**
- * Plugin manifest structure (.wave-plugin/plugin.json or .claude-plugin/plugin.json)
+ * Plugin manifest structure (.wave-plugin/plugin.json)
  */
 export interface PluginManifest {
   name: string;
@@ -14,18 +14,6 @@ export interface PluginManifest {
   author?: {
     name: string;
   };
-  /** Claude Code compatibility: plugin keywords */
-  keywords?: string[];
-  /** Claude Code compatibility: plugin homepage URL */
-  homepage?: string;
-  /** Claude Code compatibility: repository info */
-  repository?: string;
-  /** Claude Code compatibility: license info */
-  license?: string;
-  /** Claude Code compatibility: plugin dependencies */
-  dependencies?: Record<string, string>;
-  /** Claude Code compatibility: user configuration schema */
-  userConfig?: Record<string, unknown>;
 }
 
 /**

package/src/utils/convertMessagesForAPI.ts

@@ -33,7 +33,7 @@ function safeToolArguments(args: string): string {
 }
 
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Convert message format to API call format, stopping when a compacted message is encountered.
  * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
@@ -47,19 +47,19 @@ export function convertMessagesForAPI(
   for (let i = startIndex; i >= 0; i--) {
     const message = messages[i];
 
-    // Check if a compression block is encountered, if so, stop iteration
+    // Check if a compaction block is encountered, if so, stop iteration
     if (
       message.role === "assistant" &&
-      message.blocks.some((block) => block.type === "compress")
+      message.blocks.some((block) => block.type === "compact")
     ) {
-      // Add the content of the compression block as an assistant message to the history
-      const compressBlock = message.blocks.find(
-        (block) => block.type === "compress",
+      // Add the content of the compaction block as an assistant message to the history
+      const compactBlock = message.blocks.find(
+        (block) => block.type === "compact",
       );
-      if (compressBlock && compressBlock.type === "compress") {
+      if (compactBlock && compactBlock.type === "compact") {
         recentMessages.unshift({
           role: "user",
-          content: compressBlock.content,
+          content: compactBlock.content,
         });
       }
       break;

package/src/utils/groupMessagesByApiRound.ts

@@ -14,7 +14,7 @@ export interface ApiRound {
  * Boundaries:
  *  - A new `role: "user"` message starts a new round.
  *  - A new `role: "assistant"` message with a different `id` starts a new round.
- *  - A message with a `compress` block is pushed as its own round and starts a
+ *  - A message with a `compact` block is pushed as its own round and starts a
  *    new round after it.
  */
 export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
@@ -28,9 +28,9 @@ export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
     if (msg.role === "user") {
       startNewRound = true;
     } else if (msg.role === "assistant") {
-      // Compress block is always its own round
-      const hasCompress = msg.blocks.some((b) => b.type === "compress");
-      if (hasCompress) {
+      // Compact block is always its own round
+      const hasCompact = msg.blocks.some((b) => b.type === "compact");
+      if (hasCompact) {
         startNewRound = true;
       } else if (msg.id !== lastAssistantId) {
         // New assistant id starts a new round.
@@ -58,10 +58,10 @@ export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
 
     currentRound.push(msg);
 
-    // After pushing a compress message as its own round, flush immediately
+    // After pushing a compact message as its own round, flush immediately
     if (
       msg.role === "assistant" &&
-      msg.blocks.some((b) => b.type === "compress")
+      msg.blocks.some((b) => b.type === "compact")
     ) {
       rounds.push({
         messages: currentRound,

package/src/utils/messageOperations.ts

@@ -582,11 +582,9 @@ export function getMessageContent(message: Message): string {
     return `!${bangBlock.command}`;
   }
 
-  const compressBlock = message.blocks.find(
-    (block) => block.type === "compress",
-  );
-  if (compressBlock && "content" in compressBlock) {
-    return compressBlock.content;
+  const compactBlock = message.blocks.find((block) => block.type === "compact");
+  if (compactBlock && "content" in compactBlock) {
+    return compactBlock.content;
   }
 
   return "";