@stackmemoryai/stackmemory 0.5.61 → 0.5.62

package/dist/src/hooks/diffmem-hooks.js

@@ -0,0 +1,377 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../core/monitoring/logger.js";
+const DEFAULT_CONFIG = {
+  enabled: !!process.env.DIFFMEM_ENDPOINT,
+  endpoint: process.env.DIFFMEM_ENDPOINT || "http://localhost:3100",
+  autoFetchCategories: ["preference", "expertise", "pattern"],
+  autoLearnEnabled: true,
+  learningConfidenceThreshold: 0.7,
+  maxMemoriesPerSession: 50
+};
+class DiffMemHooks {
+  config;
+  fetchedMemories = [];
+  learningBuffer = [];
+  isConnected = false;
+  frameManager;
+  sessionStartTime = 0;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Register session hooks with the event emitter
+   */
+  register(emitter, frameManager) {
+    this.frameManager = frameManager;
+    if (!this.config.enabled) {
+      logger.debug("DiffMem hooks disabled - skipping registration");
+      return;
+    }
+    emitter.registerHandler("session_start", this.onSessionStart.bind(this));
+    emitter.registerHandler("session_end", this.onSessionEnd.bind(this));
+    logger.info("DiffMem hooks registered", {
+      endpoint: this.config.endpoint,
+      autoFetchCategories: this.config.autoFetchCategories,
+      autoLearnEnabled: this.config.autoLearnEnabled
+    });
+  }
+  /**
+   * Handle session start - fetch user knowledge
+   */
+  async onSessionStart(event) {
+    const sessionEvent = event;
+    this.sessionStartTime = Date.now();
+    try {
+      const status = await this.checkStatus();
+      this.isConnected = status.connected;
+      if (!this.isConnected) {
+        logger.debug("DiffMem not available - skipping memory fetch");
+        return;
+      }
+      const query = {
+        categories: this.config.autoFetchCategories,
+        limit: this.config.maxMemoriesPerSession,
+        minConfidence: this.config.learningConfidenceThreshold
+      };
+      this.fetchedMemories = await this.fetchMemories(query);
+      if (this.frameManager && this.fetchedMemories.length > 0) {
+        await this.injectAsAnchors(sessionEvent.data.sessionId);
+      }
+      logger.info("DiffMem session start completed", {
+        memoriesFetched: this.fetchedMemories.length,
+        sessionId: sessionEvent.data.sessionId
+      });
+    } catch (error) {
+      logger.warn("DiffMem session start failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.isConnected = false;
+    }
+  }
+  /**
+   * Handle session end - sync buffered learnings
+   */
+  async onSessionEnd(event) {
+    const sessionEvent = event;
+    if (!this.config.autoLearnEnabled || this.learningBuffer.length === 0) {
+      logger.debug("No learnings to sync on session end");
+      return;
+    }
+    if (!this.isConnected) {
+      const status = await this.checkStatus();
+      if (!status.connected) {
+        logger.warn("DiffMem not available - learnings not synced", {
+          bufferedCount: this.learningBuffer.length
+        });
+        return;
+      }
+      this.isConnected = true;
+    }
+    try {
+      await this.syncLearnings();
+      const sessionDuration = Date.now() - this.sessionStartTime;
+      logger.info("DiffMem session end completed", {
+        learningSynced: this.learningBuffer.length,
+        sessionId: sessionEvent.data.sessionId,
+        sessionDurationMs: sessionDuration
+      });
+      this.learningBuffer = [];
+    } catch (error) {
+      logger.warn("DiffMem session end sync failed", {
+        error: error instanceof Error ? error.message : String(error),
+        bufferedCount: this.learningBuffer.length
+      });
+    }
+  }
+  /**
+   * Record a learning during session
+   */
+  recordLearning(insight) {
+    if (!this.config.autoLearnEnabled) {
+      return;
+    }
+    if (insight.confidence < this.config.learningConfidenceThreshold) {
+      logger.debug("Learning below confidence threshold", {
+        confidence: insight.confidence,
+        threshold: this.config.learningConfidenceThreshold
+      });
+      return;
+    }
+    const learning = {
+      ...insight,
+      timestamp: Date.now()
+    };
+    this.learningBuffer.push(learning);
+    logger.debug("Learning recorded", {
+      category: learning.category,
+      confidence: learning.confidence,
+      bufferSize: this.learningBuffer.length
+    });
+  }
+  /**
+   * Get fetched memories
+   */
+  getUserKnowledge() {
+    return [...this.fetchedMemories];
+  }
+  /**
+   * Format memories for LLM context with token budget
+   */
+  formatForContext(maxTokens = 2e3) {
+    if (this.fetchedMemories.length === 0) {
+      return "";
+    }
+    const sortedMemories = [...this.fetchedMemories].sort((a, b) => {
+      if (b.confidence !== a.confidence) {
+        return b.confidence - a.confidence;
+      }
+      return b.timestamp - a.timestamp;
+    });
+    const sections = /* @__PURE__ */ new Map();
+    for (const memory of sortedMemories) {
+      const category = memory.category;
+      if (!sections.has(category)) {
+        sections.set(category, []);
+      }
+      const categoryMemories = sections.get(category);
+      if (categoryMemories) {
+        categoryMemories.push(memory.content);
+      }
+    }
+    const lines = ["## User Knowledge"];
+    let estimatedTokens = 5;
+    const categoryLabels = {
+      preference: "Preferences",
+      expertise: "Expertise",
+      project_knowledge: "Project Knowledge",
+      pattern: "Patterns",
+      correction: "Corrections"
+    };
+    for (const [category, contents] of sections) {
+      const label = categoryLabels[category] || category;
+      const categoryHeader = `
+### ${label}`;
+      const headerTokens = Math.ceil(categoryHeader.length / 4);
+      if (estimatedTokens + headerTokens > maxTokens) {
+        break;
+      }
+      lines.push(categoryHeader);
+      estimatedTokens += headerTokens;
+      for (const content of contents) {
+        const contentLine = `- ${content}`;
+        const contentTokens = Math.ceil(contentLine.length / 4);
+        if (estimatedTokens + contentTokens > maxTokens) {
+          lines.push("- (additional items truncated for token budget)");
+          break;
+        }
+        lines.push(contentLine);
+        estimatedTokens += contentTokens;
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return {
+      connected: this.isConnected,
+      memoriesLoaded: this.fetchedMemories.length,
+      learningsBuffered: this.learningBuffer.length
+    };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    logger.debug("DiffMem config updated", { config: this.config });
+  }
+  // Private methods
+  /**
+   * Check DiffMem service status
+   */
+  async checkStatus() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(`${this.config.endpoint}/status`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return { connected: false, memoryCount: 0, lastSync: null };
+      }
+      const status = await response.json();
+      return {
+        connected: true,
+        memoryCount: status.memoryCount || 0,
+        lastSync: status.lastSync || null,
+        version: status.version
+      };
+    } catch {
+      return { connected: false, memoryCount: 0, lastSync: null };
+    }
+  }
+  /**
+   * Fetch memories from DiffMem
+   */
+  async fetchMemories(query) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.config.endpoint}/memories/query`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(query),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        logger.warn("DiffMem query failed", { status: response.status });
+        return [];
+      }
+      const data = await response.json();
+      return data.memories || [];
+    } catch (error) {
+      logger.debug("DiffMem fetch failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  /**
+   * Sync buffered learnings to DiffMem
+   */
+  async syncLearnings() {
+    if (this.learningBuffer.length === 0) {
+      return;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const response = await fetch(`${this.config.endpoint}/memories/learn`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ insights: this.learningBuffer }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`Sync failed with status ${response.status}`);
+      }
+      logger.info("Learnings synced to DiffMem", {
+        count: this.learningBuffer.length
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Inject fetched memories as frame anchors
+   */
+  async injectAsAnchors(sessionId) {
+    if (!this.frameManager || this.fetchedMemories.length === 0) {
+      return;
+    }
+    try {
+      const byCategory = /* @__PURE__ */ new Map();
+      for (const memory of this.fetchedMemories) {
+        if (!byCategory.has(memory.category)) {
+          byCategory.set(memory.category, []);
+        }
+        const categoryList = byCategory.get(memory.category);
+        if (categoryList) {
+          categoryList.push(memory);
+        }
+      }
+      for (const [category, memories] of byCategory) {
+        const highConfidence = memories.filter((m) => m.confidence >= 0.8);
+        for (const memory of highConfidence.slice(0, 5)) {
+          const anchorType = this.categoryToAnchorType(category);
+          const priority = Math.round(memory.confidence * 10);
+          this.frameManager.addAnchor(anchorType, memory.content, priority, {
+            source: "diffmem",
+            category: memory.category,
+            memoryId: memory.id,
+            confidence: memory.confidence,
+            sessionId
+          });
+        }
+      }
+      logger.debug("Memories injected as anchors", {
+        totalMemories: this.fetchedMemories.length,
+        anchorsCreated: Math.min(
+          this.fetchedMemories.filter((m) => m.confidence >= 0.8).length,
+          25
+        )
+      });
+    } catch (error) {
+      logger.warn("Failed to inject memories as anchors", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Map memory category to anchor type
+   */
+  categoryToAnchorType(category) {
+    switch (category) {
+      case "preference":
+        return "CONSTRAINT";
+      case "expertise":
+        return "FACT";
+      case "project_knowledge":
+        return "FACT";
+      case "pattern":
+        return "INTERFACE_CONTRACT";
+      case "correction":
+        return "DECISION";
+      default:
+        return "FACT";
+    }
+  }
+}
+let instance = null;
+function getDiffMemHooks(config) {
+  if (!instance) {
+    instance = new DiffMemHooks(config);
+  } else if (config) {
+    instance.updateConfig(config);
+  }
+  return instance;
+}
+function resetDiffMemHooks() {
+  instance = null;
+}
+export {
+  DiffMemHooks,
+  getDiffMemHooks,
+  resetDiffMemHooks
+};
+//# sourceMappingURL=diffmem-hooks.js.map

package/dist/src/hooks/diffmem-hooks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/diffmem-hooks.ts"],
+  "sourcesContent": ["/**\n * DiffMem Session Hooks\n * Integrates DiffMem user memory with StackMemory session lifecycle\n */\n\nimport { logger } from '../core/monitoring/logger.js';\nimport type { HookEventEmitter, HookEventData } from './events.js';\nimport type { RefactoredFrameManager } from '../core/context/refactored-frame-manager.js';\nimport type {\n  UserMemory,\n  MemoryQuery,\n  LearnedInsight,\n  DiffMemStatus,\n} from '../integrations/diffmem/types.js';\n\nexport interface DiffMemHookConfig {\n  enabled: boolean;\n  endpoint: string;\n  autoFetchCategories: string[];\n  autoLearnEnabled: boolean;\n  learningConfidenceThreshold: number;\n  maxMemoriesPerSession: number;\n}\n\ninterface SessionStartEvent extends HookEventData {\n  type: 'session_start';\n  data: {\n    sessionId?: string;\n    projectId?: string;\n    context?: Record<string, unknown>;\n  };\n}\n\ninterface SessionEndEvent extends HookEventData {\n  type: 'session_end';\n  data: {\n    sessionId?: string;\n    duration?: number;\n    exitCode?: number | null;\n  };\n}\n\nconst DEFAULT_CONFIG: DiffMemHookConfig = {\n  enabled: !!process.env.DIFFMEM_ENDPOINT,\n  endpoint: process.env.DIFFMEM_ENDPOINT || 'http://localhost:3100',\n  autoFetchCategories: ['preference', 'expertise', 'pattern'],\n  autoLearnEnabled: true,\n  learningConfidenceThreshold: 0.7,\n  maxMemoriesPerSession: 50,\n};\n\n/**\n * DiffMem Session Hooks\n * Manages user memory fetch on session start and sync on session end\n */\nexport class DiffMemHooks {\n  private config: DiffMemHookConfig;\n  private fetchedMemories: UserMemory[] = [];\n  private learningBuffer: LearnedInsight[] = [];\n  private isConnected: boolean = false;\n  private frameManager?: RefactoredFrameManager;\n  private sessionStartTime: number = 0;\n\n  constructor(config: Partial<DiffMemHookConfig> = {}) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n  }\n\n  /**\n   * Register session hooks with the event emitter\n   */\n  register(\n    emitter: HookEventEmitter,\n    frameManager?: RefactoredFrameManager\n  ): void {\n    this.frameManager = frameManager;\n\n    if (!this.config.enabled) {\n      logger.debug('DiffMem hooks disabled - skipping registration');\n      return;\n    }\n\n    emitter.registerHandler('session_start', this.onSessionStart.bind(this));\n    emitter.registerHandler('session_end', this.onSessionEnd.bind(this));\n\n    logger.info('DiffMem hooks registered', {\n      endpoint: this.config.endpoint,\n      autoFetchCategories: this.config.autoFetchCategories,\n      autoLearnEnabled: this.config.autoLearnEnabled,\n    });\n  }\n\n  /**\n   * Handle session start - fetch user knowledge\n   */\n  async onSessionStart(event: HookEventData): Promise<void> {\n    const sessionEvent = event as SessionStartEvent;\n    this.sessionStartTime = Date.now();\n\n    try {\n      // Check DiffMem connectivity\n      const status = await this.checkStatus();\n      this.isConnected = status.connected;\n\n      if (!this.isConnected) {\n        logger.debug('DiffMem not available - skipping memory fetch');\n        return;\n      }\n\n      // Fetch user memories for configured categories\n      const query: MemoryQuery = {\n        categories: this.config.autoFetchCategories,\n        limit: this.config.maxMemoriesPerSession,\n        minConfidence: this.config.learningConfidenceThreshold,\n      };\n\n      this.fetchedMemories = await this.fetchMemories(query);\n\n      // Inject as frame anchors if frame manager available\n      if (this.frameManager && this.fetchedMemories.length > 0) {\n        await this.injectAsAnchors(sessionEvent.data.sessionId);\n      }\n\n      logger.info('DiffMem session start completed', {\n        memoriesFetched: this.fetchedMemories.length,\n        sessionId: sessionEvent.data.sessionId,\n      });\n    } catch (error) {\n      // Graceful degradation - log and continue\n      logger.warn('DiffMem session start failed', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      this.isConnected = false;\n    }\n  }\n\n  /**\n   * Handle session end - sync buffered learnings\n   */\n  async onSessionEnd(event: HookEventData): Promise<void> {\n    const sessionEvent = event as SessionEndEvent;\n\n    if (!this.config.autoLearnEnabled || this.learningBuffer.length === 0) {\n      logger.debug('No learnings to sync on session end');\n      return;\n    }\n\n    if (!this.isConnected) {\n      // Try to reconnect before giving up\n      const status = await this.checkStatus();\n      if (!status.connected) {\n        logger.warn('DiffMem not available - learnings not synced', {\n          bufferedCount: this.learningBuffer.length,\n        });\n        return;\n      }\n      this.isConnected = true;\n    }\n\n    try {\n      await this.syncLearnings();\n\n      const sessionDuration = Date.now() - this.sessionStartTime;\n      logger.info('DiffMem session end completed', {\n        learningSynced: this.learningBuffer.length,\n        sessionId: sessionEvent.data.sessionId,\n        sessionDurationMs: sessionDuration,\n      });\n\n      // Clear buffer after successful sync\n      this.learningBuffer = [];\n    } catch (error) {\n      logger.warn('DiffMem session end sync failed', {\n        error: error instanceof Error ? error.message : String(error),\n        bufferedCount: this.learningBuffer.length,\n      });\n    }\n  }\n\n  /**\n   * Record a learning during session\n   */\n  recordLearning(insight: Omit<LearnedInsight, 'timestamp'>): void {\n    if (!this.config.autoLearnEnabled) {\n      return;\n    }\n\n    // Filter by confidence threshold\n    if (insight.confidence < this.config.learningConfidenceThreshold) {\n      logger.debug('Learning below confidence threshold', {\n        confidence: insight.confidence,\n        threshold: this.config.learningConfidenceThreshold,\n      });\n      return;\n    }\n\n    const learning: LearnedInsight = {\n      ...insight,\n      timestamp: Date.now(),\n    };\n\n    this.learningBuffer.push(learning);\n\n    logger.debug('Learning recorded', {\n      category: learning.category,\n      confidence: learning.confidence,\n      bufferSize: this.learningBuffer.length,\n    });\n  }\n\n  /**\n   * Get fetched memories\n   */\n  getUserKnowledge(): UserMemory[] {\n    return [...this.fetchedMemories];\n  }\n\n  /**\n   * Format memories for LLM context with token budget\n   */\n  formatForContext(maxTokens: number = 2000): string {\n    if (this.fetchedMemories.length === 0) {\n      return '';\n    }\n\n    // Sort by confidence (highest first) then by timestamp (newest first)\n    const sortedMemories = [...this.fetchedMemories].sort((a, b) => {\n      if (b.confidence !== a.confidence) {\n        return b.confidence - a.confidence;\n      }\n      return b.timestamp - a.timestamp;\n    });\n\n    const sections: Map<string, string[]> = new Map();\n\n    // Group by category\n    for (const memory of sortedMemories) {\n      const category = memory.category;\n      if (!sections.has(category)) {\n        sections.set(category, []);\n      }\n      const categoryMemories = sections.get(category);\n      if (categoryMemories) {\n        categoryMemories.push(memory.content);\n      }\n    }\n\n    // Build output with token estimation (~4 chars per token)\n    const lines: string[] = ['## User Knowledge'];\n    let estimatedTokens = 5; // Header\n\n    const categoryLabels: Record<string, string> = {\n      preference: 'Preferences',\n      expertise: 'Expertise',\n      project_knowledge: 'Project Knowledge',\n      pattern: 'Patterns',\n      correction: 'Corrections',\n    };\n\n    for (const [category, contents] of sections) {\n      const label = categoryLabels[category] || category;\n      const categoryHeader = `\\n### ${label}`;\n      const headerTokens = Math.ceil(categoryHeader.length / 4);\n\n      if (estimatedTokens + headerTokens > maxTokens) {\n        break;\n      }\n\n      lines.push(categoryHeader);\n      estimatedTokens += headerTokens;\n\n      for (const content of contents) {\n        const contentLine = `- ${content}`;\n        const contentTokens = Math.ceil(contentLine.length / 4);\n\n        if (estimatedTokens + contentTokens > maxTokens) {\n          lines.push('- (additional items truncated for token budget)');\n          break;\n        }\n\n        lines.push(contentLine);\n        estimatedTokens += contentTokens;\n      }\n    }\n\n    return lines.join('\\n');\n  }\n\n  /**\n   * Get current connection status\n   */\n  getStatus(): {\n    connected: boolean;\n    memoriesLoaded: number;\n    learningsBuffered: number;\n  } {\n    return {\n      connected: this.isConnected,\n      memoriesLoaded: this.fetchedMemories.length,\n      learningsBuffered: this.learningBuffer.length,\n    };\n  }\n\n  /**\n   * Update configuration\n   */\n  updateConfig(config: Partial<DiffMemHookConfig>): void {\n    this.config = { ...this.config, ...config };\n    logger.debug('DiffMem config updated', { config: this.config });\n  }\n\n  // Private methods\n\n  /**\n   * Check DiffMem service status\n   */\n  private async checkStatus(): Promise<DiffMemStatus> {\n    try {\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 3000);\n\n      const response = await fetch(`${this.config.endpoint}/status`, {\n        method: 'GET',\n        signal: controller.signal,\n      });\n\n      clearTimeout(timeoutId);\n\n      if (!response.ok) {\n        return { connected: false, memoryCount: 0, lastSync: null };\n      }\n\n      const status = await response.json();\n      return {\n        connected: true,\n        memoryCount: status.memoryCount || 0,\n        lastSync: status.lastSync || null,\n        version: status.version,\n      };\n    } catch {\n      return { connected: false, memoryCount: 0, lastSync: null };\n    }\n  }\n\n  /**\n   * Fetch memories from DiffMem\n   */\n  private async fetchMemories(query: MemoryQuery): Promise<UserMemory[]> {\n    try {\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 5000);\n\n      const response = await fetch(`${this.config.endpoint}/memories/query`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(query),\n        signal: controller.signal,\n      });\n\n      clearTimeout(timeoutId);\n\n      if (!response.ok) {\n        logger.warn('DiffMem query failed', { status: response.status });\n        return [];\n      }\n\n      const data = await response.json();\n      return data.memories || [];\n    } catch (error) {\n      logger.debug('DiffMem fetch failed', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      return [];\n    }\n  }\n\n  /**\n   * Sync buffered learnings to DiffMem\n   */\n  private async syncLearnings(): Promise<void> {\n    if (this.learningBuffer.length === 0) {\n      return;\n    }\n\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => controller.abort(), 10000);\n\n    try {\n      const response = await fetch(`${this.config.endpoint}/memories/learn`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ insights: this.learningBuffer }),\n        signal: controller.signal,\n      });\n\n      clearTimeout(timeoutId);\n\n      if (!response.ok) {\n        throw new Error(`Sync failed with status ${response.status}`);\n      }\n\n      logger.info('Learnings synced to DiffMem', {\n        count: this.learningBuffer.length,\n      });\n    } catch (error) {\n      clearTimeout(timeoutId);\n      throw error;\n    }\n  }\n\n  /**\n   * Inject fetched memories as frame anchors\n   */\n  private async injectAsAnchors(sessionId?: string): Promise<void> {\n    if (!this.frameManager || this.fetchedMemories.length === 0) {\n      return;\n    }\n\n    try {\n      // Group by category for efficient anchor creation\n      const byCategory = new Map<string, UserMemory[]>();\n      for (const memory of this.fetchedMemories) {\n        if (!byCategory.has(memory.category)) {\n          byCategory.set(memory.category, []);\n        }\n        const categoryList = byCategory.get(memory.category);\n        if (categoryList) {\n          categoryList.push(memory);\n        }\n      }\n\n      // Create anchors for high-confidence memories\n      for (const [category, memories] of byCategory) {\n        const highConfidence = memories.filter((m) => m.confidence >= 0.8);\n\n        for (const memory of highConfidence.slice(0, 5)) {\n          const anchorType = this.categoryToAnchorType(category);\n          const priority = Math.round(memory.confidence * 10);\n\n          this.frameManager.addAnchor(anchorType, memory.content, priority, {\n            source: 'diffmem',\n            category: memory.category,\n            memoryId: memory.id,\n            confidence: memory.confidence,\n            sessionId,\n          });\n        }\n      }\n\n      logger.debug('Memories injected as anchors', {\n        totalMemories: this.fetchedMemories.length,\n        anchorsCreated: Math.min(\n          this.fetchedMemories.filter((m) => m.confidence >= 0.8).length,\n          25\n        ),\n      });\n    } catch (error) {\n      logger.warn('Failed to inject memories as anchors', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  /**\n   * Map memory category to anchor type\n   */\n  private categoryToAnchorType(\n    category: string\n  ):\n    | 'FACT'\n    | 'DECISION'\n    | 'CONSTRAINT'\n    | 'INTERFACE_CONTRACT'\n    | 'TODO'\n    | 'RISK' {\n    switch (category) {\n      case 'preference':\n        return 'CONSTRAINT';\n      case 'expertise':\n        return 'FACT';\n      case 'project_knowledge':\n        return 'FACT';\n      case 'pattern':\n        return 'INTERFACE_CONTRACT';\n      case 'correction':\n        return 'DECISION';\n      default:\n        return 'FACT';\n    }\n  }\n}\n\n// Singleton instance\nlet instance: DiffMemHooks | null = null;\n\n/**\n * Get the singleton DiffMemHooks instance\n */\nexport function getDiffMemHooks(\n  config?: Partial<DiffMemHookConfig>\n): DiffMemHooks {\n  if (!instance) {\n    instance = new DiffMemHooks(config);\n  } else if (config) {\n    instance.updateConfig(config);\n  }\n  return instance;\n}\n\n/**\n * Reset the singleton (for testing)\n */\nexport function resetDiffMemHooks(): void {\n  instance = null;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/integrations/diffmem/client.js

@@ -0,0 +1,209 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { DEFAULT_DIFFMEM_CONFIG } from "./config.js";
+class DiffMemClientError extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "DiffMemClientError";
+  }
+}
+class DiffMemClient {
+  endpoint;
+  userId;
+  timeout;
+  maxRetries;
+  constructor(config = {}) {
+    const mergedConfig = { ...DEFAULT_DIFFMEM_CONFIG, ...config };
+    this.endpoint = mergedConfig.endpoint.replace(/\/$/, "");
+    this.userId = mergedConfig.userId;
+    this.timeout = mergedConfig.timeout;
+    this.maxRetries = mergedConfig.maxRetries;
+  }
+  async request(path, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await fetch(`${this.endpoint}${path}`, {
+          ...options,
+          signal: controller.signal,
+          headers: {
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          throw new DiffMemClientError(
+            `Request failed: ${response.statusText}`,
+            "HTTP_ERROR",
+            response.status
+          );
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof DiffMemClientError) {
+          throw error;
+        }
+        if (error.name === "AbortError") {
+          throw new DiffMemClientError("Request timeout", "TIMEOUT");
+        }
+        if (attempt < this.maxRetries) {
+          await new Promise(
+            (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 100)
+          );
+          continue;
+        }
+      }
+    }
+    clearTimeout(timeoutId);
+    throw new DiffMemClientError(
+      lastError?.message || "Request failed after retries",
+      "NETWORK_ERROR"
+    );
+  }
+  /**
+   * Get user context/memories from DiffMem
+   * Maps to POST /memory/{user_id}/context
+   */
+  async getMemories(query = {}) {
+    try {
+      const conversation = query.query ? [{ role: "user", content: query.query }] : [{ role: "user", content: "What do you know about me?" }];
+      const response = await this.request(`/memory/${this.userId}/context`, {
+        method: "POST",
+        body: JSON.stringify({
+          conversation,
+          depth: "wide"
+        })
+      });
+      if (response.entities) {
+        return response.entities.slice(0, query.limit || 10).map((entity) => ({
+          id: entity.id,
+          content: entity.content,
+          category: "project_knowledge",
+          confidence: entity.score || 0.7,
+          timestamp: Date.now()
+        }));
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Store an insight/learning in DiffMem
+   * Maps to POST /memory/{user_id}/process-and-commit
+   */
+  async storeInsight(insight) {
+    const response = await this.request(`/memory/${this.userId}/process-and-commit`, {
+      method: "POST",
+      body: JSON.stringify({
+        memory_input: `[${insight.category}] ${insight.content}`,
+        session_id: `sm-${Date.now()}`,
+        session_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      })
+    });
+    return { id: response.session_id || `insight-${Date.now()}` };
+  }
+  /**
+   * Search memories in DiffMem
+   * Maps to POST /memory/{user_id}/search
+   */
+  async search(query) {
+    try {
+      const response = await this.request(`/memory/${this.userId}/search`, {
+        method: "POST",
+        body: JSON.stringify({
+          query: query.query || "",
+          k: query.limit || 10
+        })
+      });
+      if (response.results) {
+        return response.results.map((result) => ({
+          id: result.snippet.id,
+          content: result.snippet.content,
+          category: "project_knowledge",
+          confidence: result.score,
+          timestamp: Date.now(),
+          metadata: { filePath: result.snippet.file_path }
+        }));
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get DiffMem server status
+   * Maps to GET /health
+   */
+  async getStatus() {
+    try {
+      const health = await this.request("/health", { method: "GET" });
+      return {
+        connected: health.status === "healthy",
+        memoryCount: health.active_contexts || 0,
+        lastSync: Date.now(),
+        version: health.version
+      };
+    } catch {
+      return {
+        connected: false,
+        memoryCount: 0,
+        lastSync: null
+      };
+    }
+  }
+  /**
+   * Batch sync multiple insights
+   * Processes each insight individually since DiffMem doesn't have batch API
+   */
+  async batchSync(insights) {
+    if (insights.length === 0) {
+      return { synced: 0, failed: 0 };
+    }
+    let synced = 0;
+    let failed = 0;
+    for (const insight of insights) {
+      try {
+        await this.storeInsight(insight);
+        synced++;
+      } catch {
+        failed++;
+      }
+    }
+    return { synced, failed };
+  }
+  /**
+   * Onboard a new user in DiffMem
+   */
+  async onboardUser(userInfo) {
+    try {
+      const response = await this.request(
+        `/memory/${this.userId}/onboard`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            user_info: userInfo,
+            session_id: `onboard-${Date.now()}`
+          })
+        }
+      );
+      return { success: response.status === "success" };
+    } catch {
+      return { success: false };
+    }
+  }
+}
+export {
+  DiffMemClient,
+  DiffMemClientError
+};
+//# sourceMappingURL=client.js.map

package/dist/src/integrations/diffmem/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/integrations/diffmem/client.ts"],
+  "sourcesContent": ["/**\n * DiffMem API Client\n * Handles communication with the DiffMem memory service\n */\n\nimport type {\n  UserMemory,\n  MemoryQuery,\n  LearnedInsight,\n  DiffMemStatus,\n} from './types.js';\nimport type { DiffMemIntegrationConfig } from './config.js';\nimport { DEFAULT_DIFFMEM_CONFIG } from './config.js';\n\nexport class DiffMemClientError extends Error {\n  constructor(\n    message: string,\n    public readonly code?: string,\n    public readonly statusCode?: number\n  ) {\n    super(message);\n    this.name = 'DiffMemClientError';\n  }\n}\n\nexport class DiffMemClient {\n  private readonly endpoint: string;\n  private readonly userId: string;\n  private readonly timeout: number;\n  private readonly maxRetries: number;\n\n  constructor(config: Partial<DiffMemIntegrationConfig> = {}) {\n    const mergedConfig = { ...DEFAULT_DIFFMEM_CONFIG, ...config };\n    this.endpoint = mergedConfig.endpoint.replace(/\\/$/, '');\n    this.userId = mergedConfig.userId;\n    this.timeout = mergedConfig.timeout;\n    this.maxRetries = mergedConfig.maxRetries;\n  }\n\n  private async request<T>(\n    path: string,\n    options: RequestInit = {}\n  ): Promise<T> {\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => controller.abort(), this.timeout);\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {\n      try {\n        const response = await fetch(`${this.endpoint}${path}`, {\n          ...options,\n          signal: controller.signal,\n          headers: {\n            'Content-Type': 'application/json',\n            ...options.headers,\n          },\n        });\n\n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          const errorBody = await response.text().catch(() => '');\n          throw new DiffMemClientError(\n            `Request failed: ${response.statusText}`,\n            'HTTP_ERROR',\n            response.status\n          );\n        }\n\n        return (await response.json()) as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (error instanceof DiffMemClientError) {\n          throw error;\n        }\n\n        if ((error as Error).name === 'AbortError') {\n          throw new DiffMemClientError('Request timeout', 'TIMEOUT');\n        }\n\n        // Retry on network errors\n        if (attempt < this.maxRetries) {\n          await new Promise((resolve) =>\n            setTimeout(resolve, Math.pow(2, attempt) * 100)\n          );\n          continue;\n        }\n      }\n    }\n\n    clearTimeout(timeoutId);\n    throw new DiffMemClientError(\n      lastError?.message || 'Request failed after retries',\n      'NETWORK_ERROR'\n    );\n  }\n\n  /**\n   * Get user context/memories from DiffMem\n   * Maps to POST /memory/{user_id}/context\n   */\n  async getMemories(query: MemoryQuery = {}): Promise<UserMemory[]> {\n    try {\n      // DiffMem uses conversation-based context retrieval\n      const conversation = query.query\n        ? [{ role: 'user', content: query.query }]\n        : [{ role: 'user', content: 'What do you know about me?' }];\n\n      const response = await this.request<{\n        status: string;\n        context?: string;\n        entities?: Array<{ id: string; content: string; score?: number }>;\n      }>(`/memory/${this.userId}/context`, {\n        method: 'POST',\n        body: JSON.stringify({\n          conversation,\n          depth: 'wide',\n        }),\n      });\n\n      // Transform DiffMem response to UserMemory format\n      if (response.entities) {\n        return response.entities.slice(0, query.limit || 10).map((entity) => ({\n          id: entity.id,\n          content: entity.content,\n          category: 'project_knowledge' as const,\n          confidence: entity.score || 0.7,\n          timestamp: Date.now(),\n        }));\n      }\n\n      return [];\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Store an insight/learning in DiffMem\n   * Maps to POST /memory/{user_id}/process-and-commit\n   */\n  async storeInsight(insight: LearnedInsight): Promise<{ id: string }> {\n    const response = await this.request<{\n      status: string;\n      session_id?: string;\n    }>(`/memory/${this.userId}/process-and-commit`, {\n      method: 'POST',\n      body: JSON.stringify({\n        memory_input: `[${insight.category}] ${insight.content}`,\n        session_id: `sm-${Date.now()}`,\n        session_date: new Date().toISOString().split('T')[0],\n      }),\n    });\n\n    return { id: response.session_id || `insight-${Date.now()}` };\n  }\n\n  /**\n   * Search memories in DiffMem\n   * Maps to POST /memory/{user_id}/search\n   */\n  async search(query: MemoryQuery): Promise<UserMemory[]> {\n    try {\n      const response = await this.request<{\n        status: string;\n        results?: Array<{\n          score: number;\n          snippet: { id: string; content: string; file_path?: string };\n        }>;\n      }>(`/memory/${this.userId}/search`, {\n        method: 'POST',\n        body: JSON.stringify({\n          query: query.query || '',\n          k: query.limit || 10,\n        }),\n      });\n\n      if (response.results) {\n        return response.results.map((result) => ({\n          id: result.snippet.id,\n          content: result.snippet.content,\n          category: 'project_knowledge' as const,\n          confidence: result.score,\n          timestamp: Date.now(),\n          metadata: { filePath: result.snippet.file_path },\n        }));\n      }\n\n      return [];\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Get DiffMem server status\n   * Maps to GET /health\n   */\n  async getStatus(): Promise<DiffMemStatus> {\n    try {\n      const health = await this.request<{\n        status: string;\n        active_contexts?: number;\n        version?: string;\n      }>('/health', { method: 'GET' });\n\n      return {\n        connected: health.status === 'healthy',\n        memoryCount: health.active_contexts || 0,\n        lastSync: Date.now(),\n        version: health.version,\n      };\n    } catch {\n      return {\n        connected: false,\n        memoryCount: 0,\n        lastSync: null,\n      };\n    }\n  }\n\n  /**\n   * Batch sync multiple insights\n   * Processes each insight individually since DiffMem doesn't have batch API\n   */\n  async batchSync(\n    insights: LearnedInsight[]\n  ): Promise<{ synced: number; failed: number }> {\n    if (insights.length === 0) {\n      return { synced: 0, failed: 0 };\n    }\n\n    let synced = 0;\n    let failed = 0;\n\n    for (const insight of insights) {\n      try {\n        await this.storeInsight(insight);\n        synced++;\n      } catch {\n        failed++;\n      }\n    }\n\n    return { synced, failed };\n  }\n\n  /**\n   * Onboard a new user in DiffMem\n   */\n  async onboardUser(userInfo: string): Promise<{ success: boolean }> {\n    try {\n      const response = await this.request<{ status: string }>(\n        `/memory/${this.userId}/onboard`,\n        {\n          method: 'POST',\n          body: JSON.stringify({\n            user_info: userInfo,\n            session_id: `onboard-${Date.now()}`,\n          }),\n        }\n      );\n\n      return { success: response.status === 'success' };\n    } catch {\n      return { success: false };\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/integrations/diffmem/config.js

@@ -0,0 +1,15 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const DEFAULT_DIFFMEM_CONFIG = {
+  endpoint: process.env.DIFFMEM_ENDPOINT || "http://localhost:8000",
+  userId: process.env.DIFFMEM_USER_ID || "default",
+  timeout: 5e3,
+  maxRetries: 3,
+  enabled: process.env.DIFFMEM_ENABLED === "true" || !!process.env.DIFFMEM_ENDPOINT
+};
+export {
+  DEFAULT_DIFFMEM_CONFIG
+};
+//# sourceMappingURL=config.js.map