wave-agent-sdk 0.12.6 → 0.12.8

package/src/services/autoMemoryService.ts

@@ -0,0 +1,178 @@
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { Container } from "../utils/container.js";
+import { MessageManager } from "../managers/messageManager.js";
+import { SubagentManager } from "../managers/subagentManager.js";
+import { MemoryService } from "./memory.js";
+import { ConfigurationService } from "./configurationService.js";
+import { logger } from "../utils/globalLogger.js";
+import { isPathInside } from "../utils/pathSafety.js";
+import { buildAutoMemoryExtractionPrompt } from "../prompts/autoMemoryExtraction.js";
+import type { Message } from "../types/index.js";
+
+/**
+ * Service responsible for managing the auto-memory background agent lifecycle.
+ * Extracts and updates persistent project-level memory from conversation history.
+ */
+export class AutoMemoryService {
+  private lastMemoryMessageId: string | null = null;
+  private turnsSinceLastExtraction: number = 0;
+
+  constructor(private container: Container) {}
+
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
+  }
+
+  private get subagentManager(): SubagentManager {
+    return this.container.get<SubagentManager>("SubagentManager")!;
+  }
+
+  private get memoryService(): MemoryService {
+    return this.container.get<MemoryService>("MemoryService")!;
+  }
+
+  private get configurationService(): ConfigurationService {
+    return this.container.get<ConfigurationService>("ConfigurationService")!;
+  }
+
+  /**
+   * Called at the end of each conversation turn to trigger auto-memory extraction if needed.
+   */
+  async onTurnEnd(workdir: string): Promise<void> {
+    if (!this.configurationService.resolveAutoMemoryEnabled()) {
+      return;
+    }
+
+    this.turnsSinceLastExtraction++;
+
+    const messages = this.messageManager.getMessages();
+    if (messages.length === 0) return;
+
+    // 1. Check if we should run based on throttling
+    const frequency = this.configurationService.resolveAutoMemoryFrequency();
+    if (this.turnsSinceLastExtraction < frequency) {
+      return;
+    }
+
+    // 2. Check for mutual exclusion: skip if main agent manually updated memory in this turn
+    const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
+
+    // Find messages since last extraction
+    let startIndex = 0;
+    if (this.lastMemoryMessageId) {
+      startIndex =
+        messages.findIndex((m) => m.id === this.lastMemoryMessageId) + 1;
+      if (startIndex <= 0) startIndex = 0;
+    }
+
+    const recentMessages = messages.slice(startIndex);
+    const hasManualMemoryWrite = recentMessages.some(
+      (m) =>
+        m.role === "assistant" &&
+        m.blocks.some((b) => {
+          if (b.type === "tool" && (b.name === "Write" || b.name === "Edit")) {
+            try {
+              const params = b.parameters ? JSON.parse(b.parameters) : null;
+              const filePath = params?.file_path || params?.path;
+              if (filePath) {
+                const absolutePath = path.isAbsolute(filePath)
+                  ? filePath
+                  : path.resolve(workdir, filePath);
+                return isPathInside(absolutePath, memoryDir);
+              }
+            } catch {
+              return false;
+            }
+          }
+          return false;
+        }),
+    );
+
+    if (hasManualMemoryWrite) {
+      logger.debug(
+        "Skipping auto-memory extraction: manual memory write detected in this turn.",
+      );
+      this.lastMemoryMessageId = messages[messages.length - 1].id || null;
+      this.turnsSinceLastExtraction = 0;
+      return;
+    }
+
+    // 3. Trigger background extraction using a forked subagent
+    try {
+      await this.runExtraction(workdir, messages);
+      this.lastMemoryMessageId = messages[messages.length - 1].id || null;
+      this.turnsSinceLastExtraction = 0;
+    } catch (error) {
+      logger.error("Auto-memory extraction failed to trigger:", error);
+    }
+  }
+
+  /**
+   * Initialize and execute the background extraction subagent.
+   */
+  private async runExtraction(
+    workdir: string,
+    messages: Message[],
+  ): Promise<void> {
+    const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
+
+    // Ensure memory directory exists before starting
+    await this.memoryService.ensureAutoMemoryDirectory(workdir);
+
+    // Prepare manifest of existing memory files
+    let existingMemoriesManifest = "";
+    try {
+      const files = await fs.readdir(memoryDir);
+      existingMemoriesManifest = files
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => `- ${f}`)
+        .join("\n");
+    } catch {
+      // Ignore if directory doesn't exist yet
+    }
+
+    // Calculate how many new messages to analyze
+    let newMessageCount = messages.length;
+    if (this.lastMemoryMessageId) {
+      const lastIndex = messages.findIndex(
+        (m) => m.id === this.lastMemoryMessageId,
+      );
+      if (lastIndex !== -1) {
+        newMessageCount = messages.length - 1 - lastIndex;
+      }
+    }
+
+    // Fork the general-purpose agent with restricted tool access
+    const instance = await this.subagentManager.forkAgent(
+      "general-purpose",
+      messages,
+      {
+        description: "Auto-memory extraction background agent",
+        allowedTools: [
+          "Read",
+          "Glob",
+          "Grep",
+          `Write(${memoryDir}/**/*)`,
+          `Edit(${memoryDir}/**/*)`,
+        ],
+        model: "fastModel", // Use fast model for background tasks to reduce latency and cost
+      },
+    );
+
+    const prompt = buildAutoMemoryExtractionPrompt(
+      newMessageCount,
+      existingMemoriesManifest,
+    );
+
+    // Execute in background so it doesn't block the main conversation flow
+    await this.subagentManager.executeAgent(
+      instance,
+      `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
+      undefined,
+      true, // runInBackground
+    );
+
+    logger.debug("Auto-memory extraction started in background.");
+  }
+}

package/src/services/configurationService.ts

@@ -275,6 +275,18 @@ export class ConfigurationService {
       result.errors.push("autoMemoryEnabled configuration must be a boolean");
     }
 
+    // Validate autoMemoryFrequency if present
+    if (
+      config.autoMemoryFrequency !== undefined &&
+      (typeof config.autoMemoryFrequency !== "number" ||
+        config.autoMemoryFrequency <= 0)
+    ) {
+      result.isValid = false;
+      result.errors.push(
+        "autoMemoryFrequency configuration must be a positive number",
+      );
+    }
+
     // Validate models if present
     if (config.models !== undefined) {
       if (typeof config.models !== "object" || config.models === null) {
@@ -595,6 +607,32 @@ export class ConfigurationService {
     return true;
   }
 
+  /**
+   * Resolves auto-memory extraction frequency with fallbacks
+   * Resolution priority: settings.json > WAVE_AUTO_MEMORY_FREQUENCY > default (1)
+   * @returns Resolved auto-memory extraction frequency (turns)
+   */
+  resolveAutoMemoryFrequency(): number {
+    // 1. settings.json (merged)
+    if (this.currentConfiguration?.autoMemoryFrequency !== undefined) {
+      return this.currentConfiguration.autoMemoryFrequency;
+    }
+
+    // 2. WAVE_AUTO_MEMORY_FREQUENCY environment variable
+    const envFrequency =
+      this.env.WAVE_AUTO_MEMORY_FREQUENCY ||
+      process.env.WAVE_AUTO_MEMORY_FREQUENCY;
+    if (envFrequency) {
+      const parsed = parseInt(envFrequency, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        return parsed;
+      }
+    }
+
+    // 3. Default (1)
+    return 1;
+  }
+
   /**
    * Resolves max output tokens with fallbacks
    * Resolution priority: override > options > env (from settings.json) > process.env > default
@@ -1081,6 +1119,11 @@ export function loadMergedWaveConfig(
       mergedConfig.autoMemoryEnabled = config.autoMemoryEnabled;
     }
 
+    // Merge autoMemoryFrequency (last one wins)
+    if (config.autoMemoryFrequency !== undefined) {
+      mergedConfig.autoMemoryFrequency = config.autoMemoryFrequency;
+    }
+
     // Merge models
     if (config.models) {
       if (!mergedConfig.models) mergedConfig.models = {};

package/src/types/configuration.ts

@@ -35,6 +35,8 @@ export interface WaveConfiguration {
   language?: string;
   /** Whether auto-memory is enabled */
   autoMemoryEnabled?: boolean;
+  /** Frequency of auto-memory extraction turns */
+  autoMemoryFrequency?: number;
   /** Model-specific configuration overrides */
   models?: Record<string, Partial<ModelConfig>>;
 }

package/src/types/mcp.ts

@@ -4,9 +4,11 @@
  */
 
 export interface McpServerConfig {
-  command: string;
+  command?: string;
   args?: string[];
   env?: Record<string, string>;
+  url?: string;
+  headers?: Record<string, string>;
 }
 
 export interface McpConfig {

package/src/utils/containerSetup.ts

@@ -22,6 +22,7 @@ import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { ReversionService } from "../services/reversionService.js";
 import { MemoryService } from "../services/memory.js";
+import { AutoMemoryService } from "../services/autoMemoryService.js";
 import { getGitMainRepoRoot } from "./gitUtils.js";
 import type { AgentOptions } from "../types/index.js";
 import type {
@@ -85,6 +86,9 @@ export function setupAgentContainer(
   const memoryService = new MemoryService(container);
   container.register("MemoryService", memoryService);
 
+  const autoMemoryService = new AutoMemoryService(container);
+  container.register("AutoMemoryService", autoMemoryService);
+
   const memoryRuleManager = new MemoryRuleManager(container, { workdir });
   container.register("MemoryRuleManager", memoryRuleManager);