@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/core/merge/conflict-detector.js

@@ -0,0 +1,431 @@
+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 { logger } from "../monitoring/logger.js";
+class ConflictDetector {
+  SIMILARITY_THRESHOLD = 0.8;
+  /**
+   * Detect all types of conflicts between two frame stacks
+   */
+  detectConflicts(stack1, stack2) {
+    const conflicts = [];
+    const parallelConflicts = this.detectParallelSolutions(stack1, stack2);
+    conflicts.push(...parallelConflicts);
+    const decisionConflicts = this.detectConflictingDecisions(
+      stack1.events,
+      stack2.events
+    );
+    conflicts.push(...decisionConflicts);
+    const structuralConflicts = this.detectStructuralDivergence(
+      stack1.frames,
+      stack2.frames
+    );
+    conflicts.push(...structuralConflicts);
+    logger.info(`Detected ${conflicts.length} conflicts between stacks`, {
+      stack1Id: stack1.id,
+      stack2Id: stack2.id,
+      conflictTypes: this.summarizeConflictTypes(conflicts)
+    });
+    return conflicts;
+  }
+  /**
+   * Analyze frames to find parallel solutions to the same problem
+   */
+  analyzeParallelSolutions(frames) {
+    const solutions = [];
+    const groupedFrames = this.groupSimilarFrames(frames);
+    for (const group of groupedFrames) {
+      if (group.length > 1) {
+        group.forEach((frame) => {
+          solutions.push({
+            frameId: frame.frame_id,
+            solution: this.extractSolution(frame),
+            approach: this.analyzeApproach(frame),
+            author: frame.inputs?.author || "unknown",
+            timestamp: frame.created_at,
+            effectiveness: this.calculateEffectiveness(frame)
+          });
+        });
+      }
+    }
+    return solutions;
+  }
+  /**
+   * Identify conflicting decisions in event streams
+   */
+  identifyConflictingDecisions(events) {
+    const conflicts = [];
+    const decisions = this.extractDecisions(events);
+    for (let i = 0; i < decisions.length; i++) {
+      for (let j = i + 1; j < decisions.length; j++) {
+        if (this.decisionsConflict(decisions[i], decisions[j])) {
+          conflicts.push({
+            decision1: decisions[i].payload?.decision || "",
+            decision2: decisions[j].payload?.decision || "",
+            impact: this.assessImpact(decisions[i], decisions[j]),
+            canCoexist: this.canCoexist(decisions[i], decisions[j])
+          });
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Detect parallel solutions between two stacks
+   */
+  detectParallelSolutions(stack1, stack2) {
+    const conflicts = [];
+    for (const frame1 of stack1.frames) {
+      for (const frame2 of stack2.frames) {
+        if (this.framesAreSimilar(frame1, frame2) && !this.framesAreIdentical(frame1, frame2)) {
+          conflicts.push({
+            id: uuidv4(),
+            type: "parallel_solution",
+            frameId1: frame1.frame_id,
+            frameId2: frame2.frame_id,
+            severity: this.calculateParallelSeverity(frame1, frame2),
+            description: `Parallel solutions detected: "${frame1.name}" vs "${frame2.name}"`,
+            detectedAt: Date.now(),
+            conflictingPaths: this.extractPaths(frame1, frame2)
+          });
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Detect conflicting decisions between event streams
+   */
+  detectConflictingDecisions(events1, events2) {
+    const conflicts = [];
+    const decisions1 = this.extractDecisions(events1);
+    const decisions2 = this.extractDecisions(events2);
+    for (const d1 of decisions1) {
+      for (const d2 of decisions2) {
+        if (this.decisionsConflict(d1, d2)) {
+          conflicts.push({
+            id: uuidv4(),
+            type: "conflicting_decision",
+            frameId1: d1.frame_id,
+            frameId2: d2.frame_id,
+            severity: this.assessImpact(d1, d2),
+            description: `Conflicting decisions: "${d1.payload?.decision}" vs "${d2.payload?.decision}"`,
+            detectedAt: Date.now()
+          });
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Detect structural divergence in frame hierarchies
+   */
+  detectStructuralDivergence(frames1, frames2) {
+    const conflicts = [];
+    const tree1 = this.buildFrameTree(frames1);
+    const tree2 = this.buildFrameTree(frames2);
+    const divergences = this.findDivergences(tree1, tree2);
+    for (const divergence of divergences) {
+      conflicts.push({
+        id: uuidv4(),
+        type: "structural_divergence",
+        frameId1: divergence.node1,
+        frameId2: divergence.node2,
+        severity: this.calculateDivergenceSeverity(divergence),
+        description: `Structural divergence at depth ${divergence.depth}`,
+        detectedAt: Date.now()
+      });
+    }
+    return conflicts;
+  }
+  /**
+   * Helper: Check if two frames are similar (solving same problem)
+   */
+  framesAreSimilar(frame1, frame2) {
+    const nameSimilarity = this.calculateSimilarity(frame1.name, frame2.name);
+    if (nameSimilarity > this.SIMILARITY_THRESHOLD) return true;
+    if (frame1.type === frame2.type && frame1.parent_frame_id === frame2.parent_frame_id) {
+      return true;
+    }
+    const inputSimilarity = this.compareInputs(frame1.inputs, frame2.inputs);
+    return inputSimilarity > this.SIMILARITY_THRESHOLD;
+  }
+  /**
+   * Helper: Check if frames are identical
+   */
+  framesAreIdentical(frame1, frame2) {
+    return frame1.frame_id === frame2.frame_id;
+  }
+  /**
+   * Helper: Calculate string similarity (Levenshtein-based)
+   */
+  calculateSimilarity(str1, str2) {
+    const maxLen = Math.max(str1.length, str2.length);
+    if (maxLen === 0) return 1;
+    const distance = this.levenshteinDistance(str1, str2);
+    return 1 - distance / maxLen;
+  }
+  /**
+   * Helper: Levenshtein distance implementation
+   */
+  levenshteinDistance(str1, str2) {
+    const matrix = [];
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    return matrix[str2.length][str1.length];
+  }
+  /**
+   * Helper: Compare frame inputs
+   */
+  compareInputs(inputs1, inputs2) {
+    const keys1 = Object.keys(inputs1 || {});
+    const keys2 = Object.keys(inputs2 || {});
+    const allKeys = /* @__PURE__ */ new Set([...keys1, ...keys2]);
+    if (allKeys.size === 0) return 1;
+    let matches = 0;
+    for (const key of allKeys) {
+      if (JSON.stringify(inputs1[key]) === JSON.stringify(inputs2[key])) {
+        matches++;
+      }
+    }
+    return matches / allKeys.size;
+  }
+  /**
+   * Helper: Calculate severity for parallel solutions
+   */
+  calculateParallelSeverity(frame1, frame2) {
+    if (frame1.state === "closed" && frame2.state === "closed") {
+      const outputSimilarity = this.compareInputs(
+        frame1.outputs,
+        frame2.outputs
+      );
+      if (outputSimilarity < 0.5) return "critical";
+      if (outputSimilarity < 0.7) return "high";
+    }
+    if (frame1.parent_frame_id === frame2.parent_frame_id) {
+      return "high";
+    }
+    return "medium";
+  }
+  /**
+   * Helper: Extract decision events
+   */
+  extractDecisions(events) {
+    return events.filter(
+      (e) => e.event_type === "decision" || e.payload?.type === "decision" || e.payload?.decision !== void 0
+    );
+  }
+  /**
+   * Helper: Check if two decisions conflict
+   */
+  decisionsConflict(d1, d2) {
+    const resource1 = d1.payload?.resource || d1.payload?.path;
+    const resource2 = d2.payload?.resource || d2.payload?.path;
+    if (resource1 && resource2 && resource1 === resource2) {
+      return d1.payload?.decision !== d2.payload?.decision;
+    }
+    return this.hasLogicalConflict(d1.payload, d2.payload);
+  }
+  /**
+   * Helper: Check for logical conflicts in payloads
+   */
+  hasLogicalConflict(payload1, payload2) {
+    if (payload1?.architecture && payload2?.architecture) {
+      return payload1.architecture !== payload2.architecture;
+    }
+    if (payload1?.technology && payload2?.technology) {
+      return payload1.technology !== payload2.technology;
+    }
+    return false;
+  }
+  /**
+   * Helper: Assess impact of conflicting decisions
+   */
+  assessImpact(d1, d2) {
+    if (d1.payload?.type === "architecture" || d2.payload?.type === "architecture") {
+      return "high";
+    }
+    if (d1.payload?.scope === "implementation" || d2.payload?.scope === "implementation") {
+      return "medium";
+    }
+    return "low";
+  }
+  /**
+   * Helper: Check if decisions can coexist
+   */
+  canCoexist(d1, d2) {
+    if (d1.payload?.scope !== d2.payload?.scope) {
+      return true;
+    }
+    const resource1 = d1.payload?.resource;
+    const resource2 = d2.payload?.resource;
+    return resource1 !== resource2;
+  }
+  /**
+   * Helper: Build frame tree structure
+   */
+  buildFrameTree(frames) {
+    const tree = /* @__PURE__ */ new Map();
+    for (const frame of frames) {
+      if (frame.parent_frame_id) {
+        if (!tree.has(frame.parent_frame_id)) {
+          tree.set(frame.parent_frame_id, /* @__PURE__ */ new Set());
+        }
+        const parentSet = tree.get(frame.parent_frame_id);
+        if (parentSet) {
+          parentSet.add(frame.frame_id);
+        }
+      }
+    }
+    return tree;
+  }
+  /**
+   * Helper: Find divergence points in trees
+   */
+  findDivergences(tree1, tree2) {
+    const divergences = [];
+    for (const [node, children1] of tree1) {
+      if (tree2.has(node)) {
+        const children2 = tree2.get(node);
+        if (children2 && !this.setsEqual(children1, children2)) {
+          divergences.push({
+            node1: node,
+            node2: node,
+            depth: this.calculateDepth(node, tree1)
+          });
+        }
+      }
+    }
+    return divergences;
+  }
+  /**
+   * Helper: Check if two sets are equal
+   */
+  setsEqual(set1, set2) {
+    if (set1.size !== set2.size) return false;
+    for (const item of set1) {
+      if (!set2.has(item)) return false;
+    }
+    return true;
+  }
+  /**
+   * Helper: Calculate node depth in tree
+   */
+  calculateDepth(node, tree) {
+    let depth = 0;
+    let current = node;
+    for (const [parent, children] of tree) {
+      if (children.has(current)) {
+        depth++;
+        current = parent;
+      }
+    }
+    return depth;
+  }
+  /**
+   * Helper: Calculate divergence severity
+   */
+  calculateDivergenceSeverity(divergence) {
+    if (divergence.depth === 0) return "critical";
+    if (divergence.depth === 1) return "high";
+    if (divergence.depth === 2) return "medium";
+    return "low";
+  }
+  /**
+   * Helper: Extract paths from frames
+   */
+  extractPaths(frame1, frame2) {
+    const paths = [];
+    if (frame1.inputs?.path) paths.push(frame1.inputs.path);
+    if (frame2.inputs?.path) paths.push(frame2.inputs.path);
+    if (frame1.outputs?.files) paths.push(...frame1.outputs.files);
+    if (frame2.outputs?.files) paths.push(...frame2.outputs.files);
+    return [...new Set(paths)];
+  }
+  /**
+   * Helper: Extract solution from frame
+   */
+  extractSolution(frame) {
+    return frame.outputs?.solution || frame.digest_text || "No solution description";
+  }
+  /**
+   * Helper: Analyze approach taken
+   */
+  analyzeApproach(frame) {
+    if (frame.outputs?.approach) return frame.outputs.approach;
+    if (frame.type === "debug") return "Debug approach";
+    if (frame.type === "review") return "Review approach";
+    return "Standard approach";
+  }
+  /**
+   * Helper: Calculate solution effectiveness
+   */
+  calculateEffectiveness(frame) {
+    let score = 0.5;
+    if (frame.state === "closed") score += 0.2;
+    if (frame.outputs && Object.keys(frame.outputs).length > 0) score += 0.1;
+    if (frame.digest_text) score += 0.1;
+    if (frame.closed_at && frame.created_at) {
+      const duration = frame.closed_at - frame.created_at;
+      if (duration < 3e5) score += 0.1;
+    }
+    return Math.min(score, 1);
+  }
+  /**
+   * Helper: Group similar frames together
+   */
+  groupSimilarFrames(frames) {
+    const groups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (const frame of frames) {
+      if (processed.has(frame.frame_id)) continue;
+      const group = [frame];
+      processed.add(frame.frame_id);
+      for (const other of frames) {
+        if (!processed.has(other.frame_id) && this.framesAreSimilar(frame, other)) {
+          group.push(other);
+          processed.add(other.frame_id);
+        }
+      }
+      groups.push(group);
+    }
+    return groups;
+  }
+  /**
+   * Helper: Summarize conflict types
+   */
+  summarizeConflictTypes(conflicts) {
+    const summary = {
+      parallel_solution: 0,
+      conflicting_decision: 0,
+      structural_divergence: 0
+    };
+    for (const conflict of conflicts) {
+      summary[conflict.type]++;
+    }
+    return summary;
+  }
+}
+export {
+  ConflictDetector
+};
+//# sourceMappingURL=conflict-detector.js.map

package/dist/src/core/merge/conflict-detector.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/merge/conflict-detector.ts"],
+  "sourcesContent": ["/**\n * Conflict Detection Engine\n * Detects paradoxes in parallel frame timelines\n */\n\nimport { v4 as uuidv4 } from 'uuid';\nimport {\n  MergeConflict,\n  FrameStack,\n  ParallelSolution,\n  DecisionConflict,\n} from './types.js';\nimport { Frame, Event } from '../context/index.js';\nimport { logger } from '../monitoring/logger.js';\n\nexport class ConflictDetector {\n  private readonly SIMILARITY_THRESHOLD = 0.8;\n\n  /**\n   * Detect all types of conflicts between two frame stacks\n   */\n  detectConflicts(stack1: FrameStack, stack2: FrameStack): MergeConflict[] {\n    const conflicts: MergeConflict[] = [];\n\n    // Detect parallel solution conflicts\n    const parallelConflicts = this.detectParallelSolutions(stack1, stack2);\n    conflicts.push(...parallelConflicts);\n\n    // Detect conflicting decisions\n    const decisionConflicts = this.detectConflictingDecisions(\n      stack1.events,\n      stack2.events\n    );\n    conflicts.push(...decisionConflicts);\n\n    // Detect structural divergence\n    const structuralConflicts = this.detectStructuralDivergence(\n      stack1.frames,\n      stack2.frames\n    );\n    conflicts.push(...structuralConflicts);\n\n    logger.info(`Detected ${conflicts.length} conflicts between stacks`, {\n      stack1Id: stack1.id,\n      stack2Id: stack2.id,\n      conflictTypes: this.summarizeConflictTypes(conflicts),\n    });\n\n    return conflicts;\n  }\n\n  /**\n   * Analyze frames to find parallel solutions to the same problem\n   */\n  analyzeParallelSolutions(frames: Frame[]): ParallelSolution[] {\n    const solutions: ParallelSolution[] = [];\n\n    // Group frames by similar purpose/name\n    const groupedFrames = this.groupSimilarFrames(frames);\n\n    for (const group of groupedFrames) {\n      if (group.length > 1) {\n        // Multiple frames solving similar problems\n        group.forEach((frame) => {\n          solutions.push({\n            frameId: frame.frame_id,\n            solution: this.extractSolution(frame),\n            approach: this.analyzeApproach(frame),\n            author: frame.inputs?.author || 'unknown',\n            timestamp: frame.created_at,\n            effectiveness: this.calculateEffectiveness(frame),\n          });\n        });\n      }\n    }\n\n    return solutions;\n  }\n\n  /**\n   * Identify conflicting decisions in event streams\n   */\n  identifyConflictingDecisions(events: Event[]): DecisionConflict[] {\n    const conflicts: DecisionConflict[] = [];\n    const decisions = this.extractDecisions(events);\n\n    for (let i = 0; i < decisions.length; i++) {\n      for (let j = i + 1; j < decisions.length; j++) {\n        if (this.decisionsConflict(decisions[i], decisions[j])) {\n          conflicts.push({\n            decision1: decisions[i].payload?.decision || '',\n            decision2: decisions[j].payload?.decision || '',\n            impact: this.assessImpact(decisions[i], decisions[j]),\n            canCoexist: this.canCoexist(decisions[i], decisions[j]),\n          });\n        }\n      }\n    }\n\n    return conflicts;\n  }\n\n  /**\n   * Detect parallel solutions between two stacks\n   */\n  private detectParallelSolutions(\n    stack1: FrameStack,\n    stack2: FrameStack\n  ): MergeConflict[] {\n    const conflicts: MergeConflict[] = [];\n\n    // Find frames that appear to solve the same problem\n    for (const frame1 of stack1.frames) {\n      for (const frame2 of stack2.frames) {\n        if (\n          this.framesAreSimilar(frame1, frame2) &&\n          !this.framesAreIdentical(frame1, frame2)\n        ) {\n          conflicts.push({\n            id: uuidv4(),\n            type: 'parallel_solution',\n            frameId1: frame1.frame_id,\n            frameId2: frame2.frame_id,\n            severity: this.calculateParallelSeverity(frame1, frame2),\n            description: `Parallel solutions detected: \"${frame1.name}\" vs \"${frame2.name}\"`,\n            detectedAt: Date.now(),\n            conflictingPaths: this.extractPaths(frame1, frame2),\n          });\n        }\n      }\n    }\n\n    return conflicts;\n  }\n\n  /**\n   * Detect conflicting decisions between event streams\n   */\n  private detectConflictingDecisions(\n    events1: Event[],\n    events2: Event[]\n  ): MergeConflict[] {\n    const conflicts: MergeConflict[] = [];\n    const decisions1 = this.extractDecisions(events1);\n    const decisions2 = this.extractDecisions(events2);\n\n    for (const d1 of decisions1) {\n      for (const d2 of decisions2) {\n        if (this.decisionsConflict(d1, d2)) {\n          conflicts.push({\n            id: uuidv4(),\n            type: 'conflicting_decision',\n            frameId1: d1.frame_id,\n            frameId2: d2.frame_id,\n            severity: this.assessImpact(d1, d2) as\n              | 'low'\n              | 'medium'\n              | 'high'\n              | 'critical',\n            description: `Conflicting decisions: \"${d1.payload?.decision}\" vs \"${d2.payload?.decision}\"`,\n            detectedAt: Date.now(),\n          });\n        }\n      }\n    }\n\n    return conflicts;\n  }\n\n  /**\n   * Detect structural divergence in frame hierarchies\n   */\n  private detectStructuralDivergence(\n    frames1: Frame[],\n    frames2: Frame[]\n  ): MergeConflict[] {\n    const conflicts: MergeConflict[] = [];\n\n    // Build frame trees\n    const tree1 = this.buildFrameTree(frames1);\n    const tree2 = this.buildFrameTree(frames2);\n\n    // Find divergence points\n    const divergences = this.findDivergences(tree1, tree2);\n\n    for (const divergence of divergences) {\n      conflicts.push({\n        id: uuidv4(),\n        type: 'structural_divergence',\n        frameId1: divergence.node1,\n        frameId2: divergence.node2,\n        severity: this.calculateDivergenceSeverity(divergence),\n        description: `Structural divergence at depth ${divergence.depth}`,\n        detectedAt: Date.now(),\n      });\n    }\n\n    return conflicts;\n  }\n\n  /**\n   * Helper: Check if two frames are similar (solving same problem)\n   */\n  private framesAreSimilar(frame1: Frame, frame2: Frame): boolean {\n    // Check name similarity\n    const nameSimilarity = this.calculateSimilarity(frame1.name, frame2.name);\n    if (nameSimilarity > this.SIMILARITY_THRESHOLD) return true;\n\n    // Check type and parent\n    if (\n      frame1.type === frame2.type &&\n      frame1.parent_frame_id === frame2.parent_frame_id\n    ) {\n      return true;\n    }\n\n    // Check inputs similarity\n    const inputSimilarity = this.compareInputs(frame1.inputs, frame2.inputs);\n    return inputSimilarity > this.SIMILARITY_THRESHOLD;\n  }\n\n  /**\n   * Helper: Check if frames are identical\n   */\n  private framesAreIdentical(frame1: Frame, frame2: Frame): boolean {\n    return frame1.frame_id === frame2.frame_id;\n  }\n\n  /**\n   * Helper: Calculate string similarity (Levenshtein-based)\n   */\n  private calculateSimilarity(str1: string, str2: string): number {\n    const maxLen = Math.max(str1.length, str2.length);\n    if (maxLen === 0) return 1;\n\n    const distance = this.levenshteinDistance(str1, str2);\n    return 1 - distance / maxLen;\n  }\n\n  /**\n   * Helper: Levenshtein distance implementation\n   */\n  private levenshteinDistance(str1: string, str2: string): number {\n    const matrix: number[][] = [];\n\n    for (let i = 0; i <= str2.length; i++) {\n      matrix[i] = [i];\n    }\n\n    for (let j = 0; j <= str1.length; j++) {\n      matrix[0][j] = j;\n    }\n\n    for (let i = 1; i <= str2.length; i++) {\n      for (let j = 1; j <= str1.length; j++) {\n        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {\n          matrix[i][j] = matrix[i - 1][j - 1];\n        } else {\n          matrix[i][j] = Math.min(\n            matrix[i - 1][j - 1] + 1,\n            matrix[i][j - 1] + 1,\n            matrix[i - 1][j] + 1\n          );\n        }\n      }\n    }\n\n    return matrix[str2.length][str1.length];\n  }\n\n  /**\n   * Helper: Compare frame inputs\n   */\n  private compareInputs(\n    inputs1: Record<string, unknown>,\n    inputs2: Record<string, unknown>\n  ): number {\n    const keys1 = Object.keys(inputs1 || {});\n    const keys2 = Object.keys(inputs2 || {});\n    const allKeys = new Set([...keys1, ...keys2]);\n\n    if (allKeys.size === 0) return 1;\n\n    let matches = 0;\n    for (const key of allKeys) {\n      if (JSON.stringify(inputs1[key]) === JSON.stringify(inputs2[key])) {\n        matches++;\n      }\n    }\n\n    return matches / allKeys.size;\n  }\n\n  /**\n   * Helper: Calculate severity for parallel solutions\n   */\n  private calculateParallelSeverity(\n    frame1: Frame,\n    frame2: Frame\n  ): 'low' | 'medium' | 'high' | 'critical' {\n    // Critical if both are completed and have different outputs\n    if (frame1.state === 'closed' && frame2.state === 'closed') {\n      const outputSimilarity = this.compareInputs(\n        frame1.outputs,\n        frame2.outputs\n      );\n      if (outputSimilarity < 0.5) return 'critical';\n      if (outputSimilarity < 0.7) return 'high';\n    }\n\n    // High if different approaches to same parent task\n    if (frame1.parent_frame_id === frame2.parent_frame_id) {\n      return 'high';\n    }\n\n    return 'medium';\n  }\n\n  /**\n   * Helper: Extract decision events\n   */\n  private extractDecisions(events: Event[]): Event[] {\n    return events.filter(\n      (e) =>\n        e.event_type === 'decision' ||\n        e.payload?.type === 'decision' ||\n        e.payload?.decision !== undefined\n    );\n  }\n\n  /**\n   * Helper: Check if two decisions conflict\n   */\n  private decisionsConflict(d1: Event, d2: Event): boolean {\n    // Check if decisions affect same resource/path\n    const resource1 = d1.payload?.resource || d1.payload?.path;\n    const resource2 = d2.payload?.resource || d2.payload?.path;\n\n    if (resource1 && resource2 && resource1 === resource2) {\n      // Different decisions on same resource\n      return d1.payload?.decision !== d2.payload?.decision;\n    }\n\n    // Check for logical conflicts\n    return this.hasLogicalConflict(d1.payload, d2.payload);\n  }\n\n  /**\n   * Helper: Check for logical conflicts in payloads\n   */\n  private hasLogicalConflict(payload1: unknown, payload2: unknown): boolean {\n    // Architecture decisions\n    if (payload1?.architecture && payload2?.architecture) {\n      return payload1.architecture !== payload2.architecture;\n    }\n\n    // Technology choices\n    if (payload1?.technology && payload2?.technology) {\n      return payload1.technology !== payload2.technology;\n    }\n\n    return false;\n  }\n\n  /**\n   * Helper: Assess impact of conflicting decisions\n   */\n  private assessImpact(d1: Event, d2: Event): 'low' | 'medium' | 'high' {\n    // High impact for architecture/design decisions\n    if (\n      d1.payload?.type === 'architecture' ||\n      d2.payload?.type === 'architecture'\n    ) {\n      return 'high';\n    }\n\n    // Medium for implementation decisions\n    if (\n      d1.payload?.scope === 'implementation' ||\n      d2.payload?.scope === 'implementation'\n    ) {\n      return 'medium';\n    }\n\n    return 'low';\n  }\n\n  /**\n   * Helper: Check if decisions can coexist\n   */\n  private canCoexist(d1: Event, d2: Event): boolean {\n    // Different scopes can coexist\n    if (d1.payload?.scope !== d2.payload?.scope) {\n      return true;\n    }\n\n    // Non-conflicting resources can coexist\n    const resource1 = d1.payload?.resource;\n    const resource2 = d2.payload?.resource;\n\n    return resource1 !== resource2;\n  }\n\n  /**\n   * Helper: Build frame tree structure\n   */\n  private buildFrameTree(frames: Frame[]): Map<string, Set<string>> {\n    const tree = new Map<string, Set<string>>();\n\n    for (const frame of frames) {\n      if (frame.parent_frame_id) {\n        if (!tree.has(frame.parent_frame_id)) {\n          tree.set(frame.parent_frame_id, new Set());\n        }\n        const parentSet = tree.get(frame.parent_frame_id);\n        if (parentSet) {\n          parentSet.add(frame.frame_id);\n        }\n      }\n    }\n\n    return tree;\n  }\n\n  /**\n   * Helper: Find divergence points in trees\n   */\n  private findDivergences(\n    tree1: Map<string, Set<string>>,\n    tree2: Map<string, Set<string>>\n  ): Array<{ node1: string; node2: string; depth: number }> {\n    const divergences: Array<{ node1: string; node2: string; depth: number }> =\n      [];\n\n    // Find nodes that exist in both but have different children\n    for (const [node, children1] of tree1) {\n      if (tree2.has(node)) {\n        const children2 = tree2.get(node);\n        if (children2 && !this.setsEqual(children1, children2)) {\n          divergences.push({\n            node1: node,\n            node2: node,\n            depth: this.calculateDepth(node, tree1),\n          });\n        }\n      }\n    }\n\n    return divergences;\n  }\n\n  /**\n   * Helper: Check if two sets are equal\n   */\n  private setsEqual<T>(set1: Set<T>, set2: Set<T>): boolean {\n    if (set1.size !== set2.size) return false;\n    for (const item of set1) {\n      if (!set2.has(item)) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Helper: Calculate node depth in tree\n   */\n  private calculateDepth(node: string, tree: Map<string, Set<string>>): number {\n    let depth = 0;\n    let current = node;\n\n    // Find parent of current node\n    for (const [parent, children] of tree) {\n      if (children.has(current)) {\n        depth++;\n        current = parent;\n      }\n    }\n\n    return depth;\n  }\n\n  /**\n   * Helper: Calculate divergence severity\n   */\n  private calculateDivergenceSeverity(divergence: {\n    depth: number;\n  }): 'low' | 'medium' | 'high' | 'critical' {\n    if (divergence.depth === 0) return 'critical'; // Root divergence\n    if (divergence.depth === 1) return 'high';\n    if (divergence.depth === 2) return 'medium';\n    return 'low';\n  }\n\n  /**\n   * Helper: Extract paths from frames\n   */\n  private extractPaths(frame1: Frame, frame2: Frame): string[] {\n    const paths: string[] = [];\n\n    if (frame1.inputs?.path) paths.push(frame1.inputs.path);\n    if (frame2.inputs?.path) paths.push(frame2.inputs.path);\n    if (frame1.outputs?.files) paths.push(...frame1.outputs.files);\n    if (frame2.outputs?.files) paths.push(...frame2.outputs.files);\n\n    return [...new Set(paths)];\n  }\n\n  /**\n   * Helper: Extract solution from frame\n   */\n  private extractSolution(frame: Frame): string {\n    return (\n      frame.outputs?.solution || frame.digest_text || 'No solution description'\n    );\n  }\n\n  /**\n   * Helper: Analyze approach taken\n   */\n  private analyzeApproach(frame: Frame): string {\n    if (frame.outputs?.approach) return frame.outputs.approach;\n    if (frame.type === 'debug') return 'Debug approach';\n    if (frame.type === 'review') return 'Review approach';\n    return 'Standard approach';\n  }\n\n  /**\n   * Helper: Calculate solution effectiveness\n   */\n  private calculateEffectiveness(frame: Frame): number {\n    let score = 0.5; // Base score\n\n    // Completed frames are more effective\n    if (frame.state === 'closed') score += 0.2;\n\n    // Frames with outputs are more effective\n    if (frame.outputs && Object.keys(frame.outputs).length > 0) score += 0.1;\n\n    // Frames with digests are more effective\n    if (frame.digest_text) score += 0.1;\n\n    // Quick completion is more effective\n    if (frame.closed_at && frame.created_at) {\n      const duration = frame.closed_at - frame.created_at;\n      if (duration < 300000) score += 0.1; // Less than 5 minutes\n    }\n\n    return Math.min(score, 1);\n  }\n\n  /**\n   * Helper: Group similar frames together\n   */\n  private groupSimilarFrames(frames: Frame[]): Frame[][] {\n    const groups: Frame[][] = [];\n    const processed = new Set<string>();\n\n    for (const frame of frames) {\n      if (processed.has(frame.frame_id)) continue;\n\n      const group = [frame];\n      processed.add(frame.frame_id);\n\n      for (const other of frames) {\n        if (\n          !processed.has(other.frame_id) &&\n          this.framesAreSimilar(frame, other)\n        ) {\n          group.push(other);\n          processed.add(other.frame_id);\n        }\n      }\n\n      groups.push(group);\n    }\n\n    return groups;\n  }\n\n  /**\n   * Helper: Summarize conflict types\n   */\n  private summarizeConflictTypes(\n    conflicts: MergeConflict[]\n  ): Record<string, number> {\n    const summary: Record<string, number> = {\n      parallel_solution: 0,\n      conflicting_decision: 0,\n      structural_divergence: 0,\n    };\n\n    for (const conflict of conflicts) {\n      summary[conflict.type]++;\n    }\n\n    return summary;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/core/merge/index.js

@@ -0,0 +1,9 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+export * from "./types.js";
+export * from "./conflict-detector.js";
+export * from "./stack-diff.js";
+export * from "./resolution-engine.js";
+//# sourceMappingURL=index.js.map

package/dist/src/core/merge/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/merge/index.ts"],
+  "sourcesContent": ["/**\n * Stack Merge Conflict Resolution System\n * STA-101: Export all merge components\n */\n\nexport * from './types.js';\nexport * from './conflict-detector.js';\nexport * from './stack-diff.js';\nexport * from './resolution-engine.js';\n"],
+  "mappings": ";;;;AAKA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}