wave-agent-sdk 0.2.1 → 0.5.0

package/src/services/configurationService.ts

@@ -13,6 +13,7 @@ import type {
   ValidationResult,
   ConfigurationPaths,
   WaveConfiguration,
+  Scope,
 } from "../types/configuration.js";
 import {
   getAllConfigPaths,
@@ -492,6 +493,26 @@ export class ConfigurationService {
     return DEFAULT_WAVE_MAX_INPUT_TOKENS;
   }
 
+  /**
+   * Resolves preferred language with fallbacks
+   * Resolution priority: options > settings.json > undefined
+   * @param constructorLanguage - Language from constructor (optional)
+   * @returns Resolved language or undefined
+   */
+  resolveLanguage(constructorLanguage?: string): string | undefined {
+    // 1. Constructor options (highest priority)
+    if (constructorLanguage !== undefined) {
+      return constructorLanguage;
+    }
+
+    // 2. settings.json (merged)
+    if (this.currentConfiguration?.language) {
+      return this.currentConfiguration.language;
+    }
+
+    return undefined;
+  }
+
   /**
    * Resolves max output tokens with fallbacks
    * Resolution priority: options > env (from settings.json) > process.env > default
@@ -577,7 +598,7 @@ export class ConfigurationService {
    */
   async updateEnabledPlugin(
     workdir: string,
-    scope: "user" | "project" | "local",
+    scope: Scope,
     pluginId: string,
     enabled: boolean,
   ): Promise<void> {
@@ -619,6 +640,48 @@ export class ConfigurationService {
     await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 
+  /**
+   * Remove a plugin from the enabled plugins in the specified scope
+   */
+  async removeEnabledPlugin(
+    workdir: string,
+    scope: Scope,
+    pluginId: string,
+  ): Promise<void> {
+    if (scope !== "user" && !existsSync(workdir)) {
+      throw new Error(`Working directory does not exist: ${workdir}`);
+    }
+
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[1]; // settings.json
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1]; // settings.json
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0]; // settings.local.json
+    }
+
+    if (!existsSync(configPath)) {
+      return; // Nothing to remove
+    }
+
+    try {
+      const content = await fs.readFile(configPath, "utf-8");
+      const config: WaveConfiguration = JSON.parse(content);
+
+      if (config.enabledPlugins && pluginId in config.enabledPlugins) {
+        delete config.enabledPlugins[pluginId];
+        await fs.writeFile(
+          configPath,
+          JSON.stringify(config, null, 2),
+          "utf-8",
+        );
+      }
+    } catch {
+      // Ignore errors for corrupted or non-existent files
+    }
+  }
+
   /**
    * Get merged enabled plugins from all scopes
    */
@@ -626,6 +689,14 @@ export class ConfigurationService {
     const mergedConfig = loadMergedWaveConfig(workdir);
     return mergedConfig?.enabledPlugins || {};
   }
+
+  /**
+   * Load Wave configuration from a JSON file
+   * Supports both hooks and environment variables with proper validation
+   */
+  loadWaveConfigFromFile(filePath: string): WaveConfiguration | null {
+    return loadWaveConfigFromFile(filePath);
+  }
 }
 // =============================================================================
 // Extracted Configuration Functions
@@ -781,6 +852,7 @@ export function loadWaveConfigFromFile(
       env: config.env || undefined,
       permissions: config.permissions || undefined,
       enabledPlugins: config.enabledPlugins || undefined,
+      language: config.language || undefined,
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -932,6 +1004,11 @@ export function loadMergedWaveConfig(
       if (!mergedConfig.enabledPlugins) mergedConfig.enabledPlugins = {};
       Object.assign(mergedConfig.enabledPlugins, config.enabledPlugins);
     }
+
+    // Merge language (last one wins)
+    if (config.language !== undefined) {
+      mergedConfig.language = config.language;
+    }
   }
 
   return {
@@ -953,5 +1030,6 @@ export function loadMergedWaveConfig(
       Object.keys(mergedConfig.enabledPlugins).length > 0
         ? mergedConfig.enabledPlugins
         : undefined,
+    language: mergedConfig.language,
   };
 }

package/src/services/fileWatcher.ts

@@ -163,19 +163,6 @@ export class FileWatcherService extends EventEmitter {
       .filter((status): status is FileWatcherStatus => status !== null);
   }
 
-  /**
-   * Configure watcher behavior
-   * Runtime configuration updates
-   */
-  updateConfig(config: Partial<FileWatcherConfig>): void {
-    this.defaultConfig = { ...this.defaultConfig, ...config };
-
-    // Update existing watchers with new config
-    for (const entry of this.watchers.values()) {
-      entry.config = { ...entry.config, ...config };
-    }
-  }
-
   /**
    * Cleanup all watchers
    */

package/src/services/memory.ts

@@ -142,7 +142,7 @@ export const readMemoryFile = async (workdir: string): Promise<string> => {
       return "";
     }
     logger.error("Failed to read memory file", { memoryFilePath, error });
-    throw error;
+    return "";
   }
 };
 

package/src/services/pluginLoader.ts

@@ -67,7 +67,13 @@ export class PluginLoader {
    */
   static loadCommands(pluginPath: string): CustomSlashCommand[] {
     const commandsPath = path.join(pluginPath, "commands");
-    return scanCommandsDirectory(commandsPath);
+    const commands = scanCommandsDirectory(commandsPath);
+
+    // Attach plugin path to each command for WAVE_PLUGIN_ROOT support
+    return commands.map((command) => ({
+      ...command,
+      pluginPath,
+    }));
   }
 
   /**

package/src/services/reversionService.ts

@@ -0,0 +1,94 @@
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+import { FileSnapshot } from "../types/reversion.js";
+
+export class ReversionService {
+  private historyBaseDir: string;
+  private sessionId: string;
+
+  constructor(sessionId: string) {
+    this.sessionId = sessionId;
+    this.historyBaseDir = join(homedir(), ".wave", "file-history", sessionId);
+  }
+
+  private getFilePathHash(filePath: string): string {
+    return createHash("md5").update(filePath).digest("hex");
+  }
+
+  private async getNextVersion(fileHashDir: string): Promise<number> {
+    try {
+      const files = await readFile(join(fileHashDir, "versions"), "utf-8");
+      const versions = files
+        .split("\n")
+        .map((v) => parseInt(v, 10))
+        .filter((v) => !isNaN(v));
+      return versions.length > 0 ? Math.max(...versions) + 1 : 1;
+    } catch {
+      return 1;
+    }
+  }
+
+  private async updateVersionsFile(
+    fileHashDir: string,
+    version: number,
+  ): Promise<void> {
+    await appendFile(join(fileHashDir, "versions"), `${version}\n`, "utf-8");
+  }
+
+  /**
+   * Saves a single snapshot to the file history directory.
+   * Returns the snapshot path.
+   */
+  async saveSnapshot(snapshot: FileSnapshot): Promise<string> {
+    const fileHash = this.getFilePathHash(snapshot.filePath);
+    const fileHashDir = join(this.historyBaseDir, fileHash);
+    await this.ensureDirectory(fileHashDir);
+
+    const version = await this.getNextVersion(fileHashDir);
+    const snapshotPath = join(fileHashDir, `v${version}`);
+
+    const snapshotWithContent = snapshot as FileSnapshot & {
+      content: string | null;
+    };
+    if (snapshotWithContent.content !== null) {
+      await writeFile(snapshotPath, snapshotWithContent.content, "utf-8");
+    } else {
+      // For 'create' operation, the file didn't exist, so we don't write a content file.
+      // The absence of the file at snapshotPath will indicate it should be deleted on reversion.
+      return ""; // Return empty string to indicate no snapshot file
+    }
+
+    await this.updateVersionsFile(fileHashDir, version);
+    return snapshotPath;
+  }
+
+  /**
+   * Reads snapshot content from the given path.
+   */
+  async readSnapshotContent(snapshotPath: string): Promise<string | null> {
+    try {
+      return await readFile(snapshotPath, "utf-8");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes all snapshots for this session.
+   */
+  async deleteSessionHistory(): Promise<void> {
+    await rm(this.historyBaseDir, { recursive: true, force: true });
+  }
+
+  private async ensureDirectory(dirPath: string): Promise<void> {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+
+// Helper to avoid appendFile import error if not imported
+import { appendFile } from "fs/promises";

package/src/services/session.ts

@@ -43,6 +43,15 @@ export interface SessionMetadata {
   workdir: string;
   lastActiveAt: Date;
   latestTotalTokens: number;
+  firstMessage?: string;
+}
+
+export interface SessionIndex {
+  sessions: Record<
+    string,
+    Omit<SessionMetadata, "id" | "lastActiveAt"> & { lastActiveAt: string }
+  >;
+  lastUpdated: string;
 }
 
 /**
@@ -65,6 +74,38 @@ export function generateSubagentFilename(sessionId: string): string {
 // Constants
 export const SESSION_DIR = join(homedir(), ".wave", "projects");
 const MAX_SESSION_AGE_DAYS = 14;
+const SESSION_INDEX_FILENAME = "sessions-index.json";
+
+/**
+ * Update the session index for a project directory
+ */
+async function updateSessionIndex(
+  projectDirPath: string,
+  metadata: SessionMetadata,
+): Promise<void> {
+  const indexPath = join(projectDirPath, SESSION_INDEX_FILENAME);
+  let index: SessionIndex = {
+    sessions: {},
+    lastUpdated: new Date().toISOString(),
+  };
+
+  try {
+    const content = await fs.readFile(indexPath, "utf8");
+    index = JSON.parse(content);
+  } catch {
+    // Index doesn't exist or is invalid, start fresh
+  }
+
+  const { id, ...rest } = metadata;
+  index.sessions[id] = {
+    ...rest,
+    lastActiveAt: metadata.lastActiveAt.toISOString(),
+    firstMessage: metadata.firstMessage || index.sessions[id]?.firstMessage,
+  };
+  index.lastUpdated = new Date().toISOString();
+
+  await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
+}
 
 /**
  * Ensure session directory exists
@@ -187,6 +228,38 @@ export async function appendMessages(
   await jsonlHandler.append(filePath, messagesWithTimestamp, {
     atomic: false,
   });
+
+  // Update index
+  const encoder = new PathEncoder();
+  const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
+  const lastMessage = messagesWithTimestamp[messagesWithTimestamp.length - 1];
+
+  // Get first message content if it's a new session or we don't have it
+  let firstMessage: string | undefined;
+  try {
+    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
+    const content = await fs.readFile(indexPath, "utf8");
+    const index = JSON.parse(content) as SessionIndex;
+    if (!index.sessions[sessionId]?.firstMessage) {
+      firstMessage =
+        (await getFirstMessageContent(sessionId, workdir)) || undefined;
+    }
+  } catch {
+    // If index doesn't exist, this might be the first message
+    firstMessage =
+      (await getFirstMessageContent(sessionId, workdir)) || undefined;
+  }
+
+  await updateSessionIndex(projectDir.encodedPath, {
+    id: sessionId,
+    sessionType,
+    workdir,
+    lastActiveAt: new Date(lastMessage.timestamp),
+    latestTotalTokens: lastMessage.usage
+      ? extractLatestTotalTokens([lastMessage])
+      : 0,
+    firstMessage,
+  });
 }
 
 /**
@@ -318,6 +391,27 @@ export async function listSessionsFromJsonl(
     const baseDir = SESSION_DIR;
 
     const projectDir = await encoder.getProjectDirectory(workdir, baseDir);
+
+    // Try to read from index first
+    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
+    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")
+        .map(([id, meta]) => ({
+          id,
+          ...meta,
+          lastActiveAt: new Date(meta.lastActiveAt),
+        }));
+
+      return sessions.sort(
+        (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
+      );
+    } catch {
+      // Fallback to manual listing if index fails
+    }
+
     let files: string[];
     try {
       files = await fs.readdir(projectDir.encodedPath);
@@ -370,7 +464,7 @@ export async function listSessionsFromJsonl(
         }
 
         // Return inline object for performance (no interface instantiation overhead)
-        sessions.push({
+        const sessionMeta: SessionMetadata = {
           id: sessionId,
           sessionType: "main",
           subagentType: undefined, // No longer stored in metadata
@@ -379,7 +473,19 @@ export async function listSessionsFromJsonl(
           latestTotalTokens: lastMessage?.usage
             ? extractLatestTotalTokens([lastMessage])
             : 0,
-        });
+        };
+
+        // Try to get first message content for the fallback/rebuild case
+        try {
+          const firstContent = await getFirstMessageContent(sessionId, workdir);
+          if (firstContent) {
+            sessionMeta.firstMessage = firstContent;
+          }
+        } catch {
+          // Ignore errors getting first message
+        }
+
+        sessions.push(sessionMeta);
       } catch {
         // Skip corrupted session files
         continue;
@@ -387,9 +493,29 @@ export async function listSessionsFromJsonl(
     }
 
     // Sort by last active time (most recently active first)
-    return sessions.sort(
+    const sortedSessions = sessions.sort(
       (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
     );
+
+    // Rebuild index if we had to fall back
+    try {
+      const index: SessionIndex = {
+        sessions: {},
+        lastUpdated: new Date().toISOString(),
+      };
+      for (const session of sessions) {
+        const { id, ...rest } = session;
+        index.sessions[id] = {
+          ...rest,
+          lastActiveAt: session.lastActiveAt.toISOString(),
+        };
+      }
+      await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
+    } catch (error) {
+      logger.warn(`Failed to rebuild session index for ${workdir}:`, error);
+    }
+
+    return sortedSessions;
   } catch (error) {
     throw new Error(`Failed to list sessions: ${error}`);
   }
@@ -432,6 +558,38 @@ export async function cleanupExpiredSessionsFromJsonl(
         if (fileAge > maxAge) {
           await fs.unlink(filePath);
           deletedCount++;
+
+          // Remove from index if it exists
+          try {
+            const indexPath = join(
+              projectDir.encodedPath,
+              SESSION_INDEX_FILENAME,
+            );
+            const indexContent = await fs.readFile(indexPath, "utf8");
+            const index = JSON.parse(indexContent) as SessionIndex;
+            const uuidMatch = file.match(
+              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+            );
+            const subagentMatch = file.match(
+              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+            );
+            const sessionId = uuidMatch
+              ? uuidMatch[1]
+              : subagentMatch
+                ? subagentMatch[1]
+                : null;
+
+            if (sessionId && index.sessions[sessionId]) {
+              delete index.sessions[sessionId];
+              await fs.writeFile(
+                indexPath,
+                JSON.stringify(index, null, 2),
+                "utf8",
+              );
+            }
+          } catch {
+            // Ignore index update errors during cleanup
+          }
         }
       } catch {
         // Skip failed operations and continue processing other files