@stackmemoryai/stackmemory 1.10.4 → 1.12.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/integrations/mcp/handlers/cord-handlers.js

@@ -1,397 +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 { randomUUID } from "crypto";
-import { logger } from "../../../core/monitoring/logger.js";
-class CordHandlers {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  MAX_DEPTH = 10;
-  MAX_TASKS = 50;
-  /**
-   * cord_spawn — create a child task with clean context (only blocker results visible)
-   */
-  async handleCordSpawn(args) {
-    return this.createTask(args, "spawn");
-  }
-  /**
-   * cord_fork — create a child task with full sibling context
-   */
-  async handleCordFork(args) {
-    return this.createTask(args, "fork");
-  }
-  /**
-   * cord_complete — mark a task as completed and unblock dependents
-   */
-  async handleCordComplete(args) {
-    try {
-      const { task_id, result } = args;
-      if (!task_id) throw new Error("task_id is required");
-      if (result === void 0 || result === null) {
-        throw new Error("result is required");
-      }
-      const db = this.deps.dbAdapter.getRawDatabase();
-      if (!db) throw new Error("Database not available");
-      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(task_id);
-      if (!task) throw new Error(`Task not found: ${task_id}`);
-      if (task.status === "completed") {
-        throw new Error(`Task already completed: ${task_id}`);
-      }
-      const now = Math.floor(Date.now() / 1e3);
-      db.prepare(
-        "UPDATE cord_tasks SET status = ?, result = ?, completed_at = ? WHERE task_id = ?"
-      ).run("completed", String(result), now, task_id);
-      const unblocked = this.checkAndUnblockDependents(db, task_id);
-      logger.info("Cord task completed", { task_id, unblocked });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Task ${task_id} completed.${unblocked.length > 0 ? ` Unblocked: ${unblocked.join(", ")}` : ""}`
-          }
-        ],
-        metadata: { task_id, status: "completed", unblocked }
-      };
-    } catch (error) {
-      logger.error(
-        "Error completing cord task",
-        error instanceof Error ? error : new Error(String(error))
-      );
-      throw error;
-    }
-  }
-  /**
-   * cord_ask — create an "ask" task (question with optional options)
-   */
-  async handleCordAsk(args) {
-    try {
-      const { question, options, parent_id } = args;
-      if (!question) throw new Error("question is required");
-      const db = this.deps.dbAdapter.getRawDatabase();
-      if (!db) throw new Error("Database not available");
-      const projectId = this.getProjectId();
-      const runId = this.getRunId();
-      const taskId = randomUUID();
-      this.checkTaskLimit(db, projectId);
-      let depth = 0;
-      if (parent_id) {
-        depth = this.computeDepth(db, parent_id);
-      }
-      const prompt = options ? JSON.stringify({ question, options }) : JSON.stringify({ question });
-      db.prepare(
-        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, depth)
-         VALUES (?, ?, ?, ?, ?, ?, 'asked', 'ask', ?)`
-      ).run(
-        taskId,
-        parent_id || null,
-        projectId,
-        runId,
-        question,
-        prompt,
-        depth
-      );
-      logger.info("Cord ask created", { task_id: taskId });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Ask created: ${taskId} \u2014 "${question}"`
-          }
-        ],
-        metadata: {
-          task_id: taskId,
-          status: "asked",
-          context_mode: "ask",
-          question,
-          options: options || null
-        }
-      };
-    } catch (error) {
-      logger.error(
-        "Error creating cord ask",
-        error instanceof Error ? error : new Error(String(error))
-      );
-      throw error;
-    }
-  }
-  /**
-   * cord_tree — view the task tree with context scoping
-   */
-  async handleCordTree(args) {
-    try {
-      const { task_id, include_results = false } = args;
-      const db = this.deps.dbAdapter.getRawDatabase();
-      if (!db) throw new Error("Database not available");
-      const projectId = this.getProjectId();
-      let tasks;
-      if (task_id) {
-        tasks = this.getSubtree(db, task_id);
-      } else {
-        tasks = db.prepare(
-          "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
-        ).all(projectId);
-      }
-      if (tasks.length === 0) {
-        return {
-          content: [{ type: "text", text: "No cord tasks found." }],
-          metadata: { tasks: [] }
-        };
-      }
-      const taskMap = /* @__PURE__ */ new Map();
-      for (const t of tasks) taskMap.set(t.task_id, t);
-      const allTasks = db.prepare(
-        "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
-      ).all(projectId);
-      const allTaskMap = /* @__PURE__ */ new Map();
-      for (const t of allTasks) allTaskMap.set(t.task_id, t);
-      const treeNodes = tasks.map((t) => {
-        const blockedBy = JSON.parse(t.blocked_by);
-        const node = {
-          task_id: t.task_id,
-          goal: t.goal,
-          status: t.status,
-          context_mode: t.context_mode,
-          depth: t.depth,
-          blocked_by: blockedBy,
-          parent_id: t.parent_id
-        };
-        if (include_results && t.result !== null) {
-          node.result = t.result;
-        }
-        node.visible_context = this.computeVisibleContext(
-          t,
-          allTaskMap,
-          include_results
-        );
-        return node;
-      });
-      const summary = tasks.map(
-        (t) => `${"  ".repeat(t.depth)}[${t.status}] ${t.goal}${t.context_mode === "ask" ? " (ask)" : ""}`
-      ).join("\n");
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Cord Tree (${tasks.length} tasks):
-${summary}`
-          }
-        ],
-        metadata: { tasks: treeNodes }
-      };
-    } catch (error) {
-      logger.error(
-        "Error getting cord tree",
-        error instanceof Error ? error : new Error(String(error))
-      );
-      throw error;
-    }
-  }
-  // --- Private helpers ---
-  async createTask(args, contextMode) {
-    try {
-      const { goal, prompt = "", blocked_by = [], parent_id } = args;
-      if (!goal) throw new Error("goal is required");
-      const db = this.deps.dbAdapter.getRawDatabase();
-      if (!db) throw new Error("Database not available");
-      const projectId = this.getProjectId();
-      const runId = this.getRunId();
-      const taskId = randomUUID();
-      this.checkTaskLimit(db, projectId);
-      let depth = 0;
-      if (parent_id) {
-        depth = this.computeDepth(db, parent_id);
-      }
-      const blockerIds = Array.isArray(blocked_by) ? blocked_by : [];
-      if (blockerIds.length > 0) {
-        this.validateBlockers(db, blockerIds);
-        this.detectCircularDeps(db, taskId, blockerIds);
-      }
-      const status = this.initialStatus(db, blockerIds);
-      db.prepare(
-        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, blocked_by, depth)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      ).run(
-        taskId,
-        parent_id || null,
-        projectId,
-        runId,
-        goal,
-        prompt,
-        status,
-        contextMode,
-        JSON.stringify(blockerIds),
-        depth
-      );
-      logger.info("Cord task created", {
-        task_id: taskId,
-        context_mode: contextMode,
-        status
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Task ${taskId} created (${contextMode}, ${status}): ${goal}`
-          }
-        ],
-        metadata: {
-          task_id: taskId,
-          status,
-          context_mode: contextMode,
-          depth,
-          blocked_by: blockerIds
-        }
-      };
-    } catch (error) {
-      logger.error(
-        "Error creating cord task",
-        error instanceof Error ? error : new Error(String(error))
-      );
-      throw error;
-    }
-  }
-  checkTaskLimit(db, projectId) {
-    const row = db.prepare("SELECT COUNT(*) as count FROM cord_tasks WHERE project_id = ?").get(projectId);
-    if (row.count >= this.MAX_TASKS) {
-      throw new Error(
-        `Task limit reached: ${this.MAX_TASKS} tasks per project`
-      );
-    }
-  }
-  computeDepth(db, parentId) {
-    const parent = db.prepare("SELECT depth FROM cord_tasks WHERE task_id = ?").get(parentId);
-    if (!parent) throw new Error(`Parent task not found: ${parentId}`);
-    const depth = parent.depth + 1;
-    if (depth >= this.MAX_DEPTH) {
-      throw new Error(`Max depth exceeded: ${this.MAX_DEPTH}`);
-    }
-    return depth;
-  }
-  validateBlockers(db, blockerIds) {
-    for (const id of blockerIds) {
-      const exists = db.prepare("SELECT 1 FROM cord_tasks WHERE task_id = ?").get(id);
-      if (!exists) throw new Error(`Blocker task not found: ${id}`);
-    }
-  }
-  detectCircularDeps(db, newTaskId, blockerIds) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [...blockerIds];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current === newTaskId) {
-        throw new Error("Circular dependency detected");
-      }
-      if (visited.has(current)) continue;
-      visited.add(current);
-      const task = db.prepare("SELECT blocked_by FROM cord_tasks WHERE task_id = ?").get(current);
-      if (task) {
-        const deps = JSON.parse(task.blocked_by);
-        for (const dep of deps) {
-          if (!visited.has(dep)) queue.push(dep);
-        }
-      }
-    }
-  }
-  initialStatus(db, blockerIds) {
-    if (blockerIds.length === 0) return "active";
-    for (const id of blockerIds) {
-      const task = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(id);
-      if (!task || task.status !== "completed") return "blocked";
-    }
-    return "active";
-  }
-  checkAndUnblockDependents(db, completedTaskId) {
-    const allBlocked = db.prepare("SELECT * FROM cord_tasks WHERE status = 'blocked'").all();
-    const unblocked = [];
-    for (const task of allBlocked) {
-      const blockers = JSON.parse(task.blocked_by);
-      if (!blockers.includes(completedTaskId)) continue;
-      const allDone = blockers.every((bid) => {
-        if (bid === completedTaskId) return true;
-        const blocker = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(bid);
-        return blocker?.status === "completed";
-      });
-      if (allDone) {
-        db.prepare(
-          "UPDATE cord_tasks SET status = 'active' WHERE task_id = ?"
-        ).run(task.task_id);
-        unblocked.push(task.task_id);
-      }
-    }
-    return unblocked;
-  }
-  getSubtree(db, rootId) {
-    const result = [];
-    const queue = [rootId];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(current);
-      if (task) {
-        result.push(task);
-        const children = db.prepare(
-          "SELECT task_id FROM cord_tasks WHERE parent_id = ? ORDER BY created_at ASC"
-        ).all(current);
-        for (const c of children) queue.push(c.task_id);
-      }
-    }
-    return result;
-  }
-  computeVisibleContext(task, allTaskMap, includeResults) {
-    const ctx = { prompt: task.prompt };
-    if (task.context_mode === "ask") {
-      try {
-        const parsed = JSON.parse(task.prompt);
-        ctx.question = parsed.question;
-        ctx.options = parsed.options || null;
-      } catch {
-        ctx.question = task.goal;
-      }
-      if (task.status === "completed" && task.result !== null) {
-        ctx.answer = task.result;
-      }
-      return ctx;
-    }
-    const blockerIds = JSON.parse(task.blocked_by);
-    const blockerResults = [];
-    for (const bid of blockerIds) {
-      const blocker = allTaskMap.get(bid);
-      if (blocker?.status === "completed" && blocker.result !== null) {
-        blockerResults.push({
-          task_id: bid,
-          goal: blocker.goal,
-          result: includeResults ? blocker.result : "[completed]"
-        });
-      }
-    }
-    if (blockerResults.length > 0) {
-      ctx.blocker_results = blockerResults;
-    }
-    if (task.context_mode === "fork" && task.parent_id) {
-      const siblingResults = [];
-      for (const [, t] of allTaskMap) {
-        if (t.parent_id === task.parent_id && t.task_id !== task.task_id && t.status === "completed" && t.result !== null) {
-          siblingResults.push({
-            task_id: t.task_id,
-            goal: t.goal,
-            result: includeResults ? t.result : "[completed]"
-          });
-        }
-      }
-      if (siblingResults.length > 0) {
-        ctx.sibling_results = siblingResults;
-      }
-    }
-    return ctx;
-  }
-  getProjectId() {
-    return this.deps.dbAdapter.projectId;
-  }
-  getRunId() {
-    return this.deps.frameManager.currentRunId;
-  }
-}
-export {
-  CordHandlers
-};