@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/core/merge/unified-merge-resolver.js

@@ -1,302 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { v4 as uuidv4 } from "uuid";
-import { ConflictDetector } from "./conflict-detector.js";
-import { StackDiffVisualizer } from "./stack-diff.js";
-import { ResolutionEngine } from "./resolution-engine.js";
-import { logger } from "../monitoring/logger.js";
-class UnifiedMergeResolver {
-  conflictDetector;
-  diffVisualizer;
-  resolutionEngine;
-  activeSessions = /* @__PURE__ */ new Map();
-  rollbackSnapshots = /* @__PURE__ */ new Map();
-  statistics = {
-    totalConflicts: 0,
-    resolvedConflicts: 0,
-    averageResolutionTime: 0,
-    successRate: 0,
-    rollbackCount: 0
-  };
-  constructor() {
-    this.conflictDetector = new ConflictDetector();
-    this.diffVisualizer = new StackDiffVisualizer();
-    this.resolutionEngine = new ResolutionEngine();
-    logger.debug("UnifiedMergeResolver initialized");
-  }
-  /**
-   * Start a new merge session with automatic conflict detection
-   */
-  async startMergeSession(stack1, stack2, options) {
-    const sessionId = `unified-merge-${Date.now()}-${uuidv4().substring(0, 8)}`;
-    const conflicts = this.conflictDetector.detectConflicts(stack1, stack2);
-    let rollbackPoint;
-    if (options?.preserveRollback !== false) {
-      rollbackPoint = this.createRollbackSnapshot(sessionId, stack1, stack2);
-    }
-    const session = {
-      sessionId,
-      stack1,
-      stack2,
-      conflicts,
-      status: "analyzing",
-      rollbackPoint,
-      startedAt: Date.now(),
-      metadata: {
-        totalFrames: stack1.frames.length + stack2.frames.length,
-        conflictCount: conflicts.length,
-        resolvedCount: 0
-      }
-    };
-    this.activeSessions.set(sessionId, session);
-    this.statistics.totalConflicts += conflicts.length;
-    logger.info(`Merge session started: ${sessionId}`, {
-      stack1Id: stack1.id,
-      stack2Id: stack2.id,
-      conflictCount: conflicts.length
-    });
-    if (options?.autoResolve && conflicts.length > 0 && options.context) {
-      const defaultStrategy = options.strategy || "ai_suggest";
-      await this.resolveConflicts(sessionId, defaultStrategy, options.context);
-    }
-    return sessionId;
-  }
-  /**
-   * Generate a preview of the merge result
-   */
-  async generatePreview(sessionId, strategy) {
-    const session = this.activeSessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const preview = this.diffVisualizer.generateMergePreview(
-      session.stack1,
-      session.stack2,
-      strategy
-    );
-    session.preview = preview;
-    session.status = "preview";
-    session.metadata.strategyUsed = strategy;
-    this.activeSessions.set(sessionId, session);
-    logger.info(`Preview generated for session: ${sessionId}`, {
-      mergedFrameCount: preview.mergedFrames.length,
-      estimatedSuccess: preview.estimatedSuccess
-    });
-    return preview;
-  }
-  /**
-   * Resolve conflicts using the specified strategy
-   */
-  async resolveConflicts(sessionId, strategy, context) {
-    const session = this.activeSessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    session.status = "resolving";
-    try {
-      const result = await this.resolutionEngine.resolveConflicts(
-        session.stack1,
-        session.stack2,
-        strategy,
-        context
-      );
-      session.resolution = result.resolution;
-      session.status = result.success ? "completed" : "failed";
-      session.completedAt = Date.now();
-      session.metadata.resolvedCount = session.conflicts.filter(
-        (c) => c.resolution !== void 0
-      ).length;
-      session.metadata.strategyUsed = strategy;
-      this.activeSessions.set(sessionId, session);
-      if (result.success) {
-        this.statistics.resolvedConflicts += session.metadata.resolvedCount;
-        this.updateSuccessRate();
-        this.updateAverageResolutionTime(session);
-      }
-      logger.info(`Conflicts resolved for session: ${sessionId}`, {
-        success: result.success,
-        strategy,
-        resolvedCount: session.metadata.resolvedCount
-      });
-      return result;
-    } catch (error) {
-      session.status = "failed";
-      this.activeSessions.set(sessionId, session);
-      logger.error(
-        `Failed to resolve conflicts for session: ${sessionId}`,
-        error
-      );
-      throw error;
-    }
-  }
-  /**
-   * Rollback a merge to its original state
-   */
-  async rollback(sessionId) {
-    const session = this.activeSessions.get(sessionId);
-    if (!session || !session.rollbackPoint) {
-      logger.warn(`Cannot rollback session: ${sessionId} - no rollback point`);
-      return false;
-    }
-    const snapshot = this.rollbackSnapshots.get(session.rollbackPoint);
-    if (!snapshot) {
-      logger.error(`Rollback snapshot not found: ${session.rollbackPoint}`);
-      return false;
-    }
-    session.stack1 = snapshot.stack1;
-    session.stack2 = snapshot.stack2;
-    session.status = "rolled_back";
-    session.resolution = void 0;
-    session.conflicts = this.conflictDetector.detectConflicts(
-      snapshot.stack1,
-      snapshot.stack2
-    );
-    session.metadata.resolvedCount = 0;
-    this.activeSessions.set(sessionId, session);
-    this.statistics.rollbackCount++;
-    logger.info(`Session rolled back: ${sessionId}`);
-    return true;
-  }
-  /**
-   * Get merge session details
-   */
-  getSession(sessionId) {
-    return this.activeSessions.get(sessionId);
-  }
-  /**
-   * List all active merge sessions
-   */
-  listActiveSessions() {
-    return Array.from(this.activeSessions.values()).filter(
-      (s) => s.status !== "completed" && s.status !== "rolled_back" && s.status !== "failed"
-    );
-  }
-  /**
-   * Get merge statistics
-   */
-  getStatistics() {
-    return { ...this.statistics };
-  }
-  /**
-   * Analyze parallel solutions across stacks
-   */
-  analyzeParallelSolutions(frames) {
-    const solutions = this.conflictDetector.analyzeParallelSolutions(frames);
-    const recommendations = [];
-    if (solutions.length > 1) {
-      const grouped = /* @__PURE__ */ new Map();
-      for (const sol of solutions) {
-        const key = sol.approach.toLowerCase();
-        if (!grouped.has(key)) {
-          grouped.set(key, []);
-        }
-        grouped.get(key).push(sol);
-      }
-      for (const [approach, group] of grouped) {
-        if (group.length > 1) {
-          const avgEffectiveness = group.reduce((sum, s) => sum + (s.effectiveness || 0), 0) / group.length;
-          recommendations.push(
-            `${group.length} parallel solutions using "${approach}" approach (avg effectiveness: ${(avgEffectiveness * 100).toFixed(1)}%)`
-          );
-        }
-      }
-      const best = solutions.reduce(
-        (a, b) => (a.effectiveness || 0) > (b.effectiveness || 0) ? a : b,
-        solutions[0]
-      );
-      if (best && best.effectiveness && best.effectiveness > 0.7) {
-        recommendations.push(
-          `Recommended: Use solution from frame "${best.frameId}" (${(best.effectiveness * 100).toFixed(1)}% effectiveness)`
-        );
-      }
-    }
-    return {
-      solutions: solutions.map((s) => ({
-        frameId: s.frameId,
-        approach: s.approach,
-        effectiveness: s.effectiveness || 0
-      })),
-      recommendations
-    };
-  }
-  /**
-   * Create a visual diff between two stacks
-   */
-  createVisualDiff(baseFrame, stack1, stack2) {
-    const diff = this.diffVisualizer.visualizeDivergence(
-      baseFrame,
-      stack1,
-      stack2
-    );
-    const conflicts = this.conflictDetector.detectConflicts(stack1, stack2);
-    return {
-      nodes: diff.nodes.map((n) => ({
-        id: n.id,
-        type: n.type,
-        depth: n.frame?.depth
-      })),
-      edges: diff.edges.map((e) => ({
-        source: e.source,
-        target: e.target,
-        type: e.type
-      })),
-      conflicts: conflicts.map((c) => ({
-        frameId1: c.frameId1,
-        frameId2: c.frameId2,
-        severity: c.severity
-      }))
-    };
-  }
-  /**
-   * Close a merge session and clean up resources
-   */
-  closeSession(sessionId) {
-    const session = this.activeSessions.get(sessionId);
-    if (session) {
-      if (session.rollbackPoint) {
-        this.rollbackSnapshots.delete(session.rollbackPoint);
-      }
-      this.activeSessions.delete(sessionId);
-      logger.debug(`Session closed: ${sessionId}`);
-    }
-  }
-  // Private helpers
-  createRollbackSnapshot(sessionId, stack1, stack2) {
-    const snapshotId = `rollback-${sessionId}`;
-    this.rollbackSnapshots.set(snapshotId, {
-      stack1: this.deepCloneStack(stack1),
-      stack2: this.deepCloneStack(stack2)
-    });
-    return snapshotId;
-  }
-  deepCloneStack(stack) {
-    return {
-      ...stack,
-      frames: stack.frames.map((f) => ({ ...f })),
-      events: stack.events.map((e) => ({ ...e }))
-    };
-  }
-  updateSuccessRate() {
-    if (this.statistics.totalConflicts > 0) {
-      this.statistics.successRate = this.statistics.resolvedConflicts / this.statistics.totalConflicts;
-    }
-  }
-  updateAverageResolutionTime(session) {
-    if (session.completedAt && session.startedAt) {
-      const duration = session.completedAt - session.startedAt;
-      const completedSessions = Array.from(this.activeSessions.values()).filter(
-        (s) => s.completedAt
-      ).length;
-      if (completedSessions === 1) {
-        this.statistics.averageResolutionTime = duration;
-      } else {
-        this.statistics.averageResolutionTime = (this.statistics.averageResolutionTime * (completedSessions - 1) + duration) / completedSessions;
-      }
-    }
-  }
-}
-export {
-  UnifiedMergeResolver
-};

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

@@ -1,376 +0,0 @@
-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
-};