@stackmemoryai/stackmemory 1.8.1 → 1.10.2

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

@@ -627,6 +627,72 @@ class LinearClient {
       };
     }
   }
+  // --- Comment CRUD ---
+  async createComment(issueId, body) {
+    const mutation = `
+      mutation CreateComment($input: CommentCreateInput!) {
+        commentCreate(input: $input) {
+          success
+          comment {
+            id
+            body
+            createdAt
+            user { id name }
+          }
+        }
+      }
+    `;
+    const result = await this.graphql(mutation, { input: { issueId, body } });
+    if (!result.commentCreate.success) {
+      throw new IntegrationError(
+        "Failed to create comment",
+        ErrorCode.LINEAR_API_ERROR,
+        { issueId }
+      );
+    }
+    return result.commentCreate.comment;
+  }
+  async updateComment(commentId, body) {
+    const mutation = `
+      mutation UpdateComment($id: String!, $input: CommentUpdateInput!) {
+        commentUpdate(id: $id, input: $input) {
+          success
+          comment {
+            id
+            body
+            updatedAt
+          }
+        }
+      }
+    `;
+    const result = await this.graphql(mutation, { id: commentId, input: { body } });
+    if (!result.commentUpdate.success) {
+      throw new IntegrationError(
+        "Failed to update comment",
+        ErrorCode.LINEAR_API_ERROR,
+        { commentId }
+      );
+    }
+    return result.commentUpdate.comment;
+  }
+  async getComments(issueId) {
+    const query = `
+      query GetComments($issueId: String!) {
+        issue(id: $issueId) {
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              createdAt
+              user { name }
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.graphql(query, { issueId });
+    return result.issue.comments.nodes;
+  }
 }
 export {
   LinearClient

package/dist/src/integrations/mcp/handlers/index.js

@@ -20,6 +20,9 @@ import {
 } from "./provider-handlers.js";
 import { TeamHandlers } from "./team-handlers.js";
 import { CordHandlers } from "./cord-handlers.js";
+import {
+  ProvenantHandlers
+} from "./provenant-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -31,6 +34,7 @@ import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
 import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
 import { TeamHandlers as TeamHandlers2 } from "./team-handlers.js";
 import { CordHandlers as CordHandlers2 } from "./cord-handlers.js";
+import { ProvenantHandlers as ProvenantHandlers2 } from "./provenant-handlers.js";
 class MCPHandlerFactory {
   contextHandlers;
   taskHandlers;
@@ -39,6 +43,7 @@ class MCPHandlerFactory {
   providerHandlers;
   teamHandlers;
   cordHandlers;
+  provenantHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -67,6 +72,11 @@ class MCPHandlerFactory {
         dbAdapter: deps.dbAdapter
       });
     }
+    if (deps.projectDir) {
+      this.provenantHandlers = new ProvenantHandlers2({
+        projectDir: deps.projectDir
+      });
+    }
   }
   /**
    * Get handler for a specific tool
@@ -166,6 +176,31 @@ class MCPHandlerFactory {
       case "cord_tree":
         if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
         return this.cordHandlers.handleCordTree.bind(this.cordHandlers);
+      // Provenant decision graph handlers
+      case "provenant_search":
+        if (!this.provenantHandlers)
+          throw new Error("Provenant tools require projectDir");
+        return this.provenantHandlers.handleSearch.bind(this.provenantHandlers);
+      case "provenant_log":
+        if (!this.provenantHandlers)
+          throw new Error("Provenant tools require projectDir");
+        return this.provenantHandlers.handleLog.bind(this.provenantHandlers);
+      case "provenant_status":
+        if (!this.provenantHandlers)
+          throw new Error("Provenant tools require projectDir");
+        return this.provenantHandlers.handleStatus.bind(this.provenantHandlers);
+      case "provenant_contradictions":
+        if (!this.provenantHandlers)
+          throw new Error("Provenant tools require projectDir");
+        return this.provenantHandlers.handleContradictions.bind(
+          this.provenantHandlers
+        );
+      case "provenant_resolve":
+        if (!this.provenantHandlers)
+          throw new Error("Provenant tools require projectDir");
+        return this.provenantHandlers.handleResolve.bind(
+          this.provenantHandlers
+        );
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -211,7 +246,13 @@ class MCPHandlerFactory {
       "cord_fork",
       "cord_complete",
       "cord_ask",
-      "cord_tree"
+      "cord_tree",
+      // Provenant decision graph tools
+      "provenant_search",
+      "provenant_log",
+      "provenant_status",
+      "provenant_contradictions",
+      "provenant_resolve"
     ];
   }
   /**
@@ -227,6 +268,7 @@ export {
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
+  ProvenantHandlers,
   ProviderHandlers,
   TaskHandlers,
   TeamHandlers,

package/dist/src/integrations/mcp/handlers/linear-handlers.js

@@ -218,6 +218,108 @@ ${issueLines.join("\n")}` : "No issues found matching filters.";
       };
     }
   }
+  /**
+   * Create a comment on a Linear issue
+   */
+  async handleLinearCreateComment(args) {
+    try {
+      const { issue_id, body } = args;
+      if (!issue_id || !body) {
+        throw new Error("issue_id and body are required");
+      }
+      const client = await this.getClient();
+      const comment = await client.createComment(issue_id, body);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Comment created on ${issue_id}
+ID: ${comment.id}
+Preview: ${body.slice(0, 100)}${body.length > 100 ? "..." : ""}`
+          }
+        ],
+        metadata: {
+          id: comment.id,
+          issueId: issue_id,
+          createdAt: comment.createdAt
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error creating Linear comment",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * Update an existing comment on a Linear issue
+   */
+  async handleLinearUpdateComment(args) {
+    try {
+      const { comment_id, body } = args;
+      if (!comment_id || !body) {
+        throw new Error("comment_id and body are required");
+      }
+      const client = await this.getClient();
+      const comment = await client.updateComment(comment_id, body);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Comment ${comment_id} updated
+Preview: ${body.slice(0, 100)}${body.length > 100 ? "..." : ""}`
+          }
+        ],
+        metadata: {
+          id: comment.id,
+          updatedAt: comment.updatedAt
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error updating Linear comment",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * List comments on a Linear issue
+   */
+  async handleLinearListComments(args) {
+    try {
+      const { issue_id } = args;
+      if (!issue_id) {
+        throw new Error("issue_id is required");
+      }
+      const client = await this.getClient();
+      const comments = await client.getComments(issue_id);
+      const lines = comments.map(
+        (c) => `${c.id.slice(0, 8)} | ${c.user?.name ?? "unknown"} | ${new Date(c.createdAt).toISOString().slice(0, 10)} | ${c.body.slice(0, 60).replace(/\n/g, " ")}${c.body.length > 60 ? "..." : ""}`
+      );
+      const text = comments.length > 0 ? `${comments.length} comments on ${issue_id}:
+${lines.join("\n")}` : `No comments on ${issue_id}`;
+      return {
+        content: [{ type: "text", text }],
+        metadata: {
+          count: comments.length,
+          comments: comments.map((c) => ({
+            id: c.id,
+            author: c.user?.name,
+            createdAt: c.createdAt,
+            bodyPreview: c.body.slice(0, 200)
+          }))
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error listing Linear comments",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
 }
 export {
   LinearHandlers

package/dist/src/integrations/mcp/handlers/provenant-handlers.js

@@ -0,0 +1,398 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID, createHash } from "node:crypto";
+import BetterSqlite3 from "better-sqlite3";
+import { logger } from "../../../core/monitoring/logger.js";
+const SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY, type TEXT NOT NULL, content TEXT NOT NULL,
+    embedding BLOB, actor TEXT, confidence REAL NOT NULL DEFAULT 0.0,
+    version INTEGER NOT NULL DEFAULT 1, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS edges (
+    id TEXT PRIMARY KEY, from_node TEXT NOT NULL, to_node TEXT NOT NULL,
+    rel_type TEXT NOT NULL, confidence REAL NOT NULL DEFAULT 1.0,
+    version INTEGER NOT NULL DEFAULT 1, created_at INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS sources (
+    id TEXT PRIMARY KEY, system TEXT NOT NULL, external_id TEXT NOT NULL,
+    raw_payload TEXT NOT NULL, hash TEXT NOT NULL, fetched_at INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS source_edges (
+    id TEXT PRIMARY KEY, node_id TEXT NOT NULL, source_id TEXT NOT NULL,
+    system TEXT NOT NULL, external_id TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS contradictions (
+    id TEXT PRIMARY KEY, node_a TEXT NOT NULL, node_b TEXT NOT NULL,
+    conflict_score REAL NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
+    resolved_by TEXT, resolved_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS stale_flags (
+    id TEXT PRIMARY KEY, node_id TEXT NOT NULL, triggered_by_source TEXT NOT NULL,
+    flagged_at INTEGER NOT NULL, resolved_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS rejection_log (
+    id TEXT PRIMARY KEY, suggestion_node TEXT NOT NULL, override_node TEXT,
+    reasoning TEXT, reasoning_resolved INTEGER NOT NULL DEFAULT 0,
+    actor TEXT, created_at INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS review_queue (
+    id TEXT PRIMARY KEY, source_id TEXT NOT NULL, candidate_content TEXT NOT NULL,
+    confidence REAL NOT NULL, queue_reason TEXT NOT NULL,
+    created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, resolved_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL);
+  CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+  CREATE INDEX IF NOT EXISTS idx_nodes_created ON nodes(created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_contradictions_status ON contradictions(status);
+  INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (1, unixepoch() * 1000);
+`;
+class ProvenantHandlers {
+  constructor(deps) {
+    this.deps = deps;
+    this.dbPath = join(deps.projectDir, ".provenant", "graph.db");
+  }
+  dbPath;
+  openDb() {
+    mkdirSync(dirname(this.dbPath), { recursive: true });
+    const db = new BetterSqlite3(this.dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    try {
+      db.prepare("SELECT 1 FROM schema_version").get();
+    } catch {
+      db.exec(SCHEMA_SQL);
+    }
+    return db;
+  }
+  async handleSearch(args) {
+    try {
+      const { query, actor, since, limit = 10 } = args;
+      if (!query) throw new Error("query is required");
+      const db = this.openDb();
+      try {
+        const stopwords = /* @__PURE__ */ new Set([
+          "the",
+          "a",
+          "an",
+          "is",
+          "was",
+          "were",
+          "are",
+          "we",
+          "our",
+          "this",
+          "that",
+          "it",
+          "to",
+          "of",
+          "in",
+          "for",
+          "on",
+          "with",
+          "did",
+          "do",
+          "not",
+          "why",
+          "how",
+          "what",
+          "when",
+          "and",
+          "or",
+          "but"
+        ]);
+        const keywords = query.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopwords.has(w));
+        let sql;
+        const params = [];
+        if (keywords.length === 0) {
+          sql = "SELECT * FROM nodes ORDER BY created_at DESC LIMIT ?";
+          params.push(limit);
+        } else {
+          const scoreParts = keywords.map(
+            () => "(CASE WHEN LOWER(content) LIKE ? THEN 1 ELSE 0 END)"
+          );
+          for (const kw of keywords) params.push(`%${kw}%`);
+          sql = `SELECT *, (${scoreParts.join(" + ")}) as match_score FROM nodes WHERE (${scoreParts.join(" + ")}) > 0`;
+          for (const kw of keywords) params.push(`%${kw}%`);
+          if (actor) {
+            sql += " AND actor = ?";
+            params.push(actor);
+          }
+          if (since) {
+            sql += " AND created_at >= ?";
+            params.push(new Date(since).getTime());
+          }
+          sql += " ORDER BY match_score DESC, created_at DESC LIMIT ?";
+          params.push(limit);
+        }
+        const nodes = db.prepare(sql).all(...params);
+        const results = nodes.map((n) => ({
+          id: n.id.slice(0, 8),
+          type: n.type,
+          content: n.content.slice(0, 200),
+          actor: n.actor,
+          confidence: n.confidence,
+          created: new Date(n.created_at).toISOString()
+        }));
+        logger.info("Provenant search", { query, resultCount: results.length });
+        return {
+          content: [
+            {
+              type: "text",
+              text: results.length === 0 ? `No decisions found for: "${query}"` : results.map(
+                (r) => `[${r.id}] (${r.confidence.toFixed(2)}) ${r.content}${r.actor ? ` \u2014 ${r.actor}` : ""}`
+              ).join("\n\n")
+            }
+          ],
+          metadata: { query, results }
+        };
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      logger.error(
+        "Provenant search error",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  async handleLog(args) {
+    try {
+      const { content, actor, reasoning } = args;
+      if (!content) throw new Error("content is required");
+      const db = this.openDb();
+      try {
+        const now = Date.now();
+        const hash = createHash("sha256").update(content).digest("hex");
+        const externalId = `manual-${now}`;
+        let confidence = 0.6;
+        if (reasoning) confidence += 0.15;
+        if (actor) confidence += 0.1;
+        const sourceId = randomUUID();
+        db.prepare(
+          "INSERT INTO sources (id, system, external_id, raw_payload, hash, fetched_at) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(
+          sourceId,
+          "manual",
+          externalId,
+          JSON.stringify({ content, actor, reasoning }),
+          hash,
+          now
+        );
+        const nodeId = randomUUID();
+        db.prepare(
+          "INSERT INTO nodes (id, type, content, embedding, actor, confidence, version, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        ).run(
+          nodeId,
+          "decision",
+          content,
+          null,
+          actor ?? null,
+          confidence,
+          1,
+          now,
+          now
+        );
+        db.prepare(
+          "INSERT INTO source_edges (id, node_id, source_id, system, external_id) VALUES (?, ?, ?, ?, ?)"
+        ).run(randomUUID(), nodeId, sourceId, "manual", externalId);
+        logger.info("Provenant decision logged", { nodeId, confidence });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Logged decision: ${nodeId.slice(0, 8)} (confidence: ${confidence.toFixed(2)})`
+            }
+          ],
+          metadata: { nodeId, confidence }
+        };
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      logger.error(
+        "Provenant log error",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  async handleStatus(_args) {
+    try {
+      if (!existsSync(this.dbPath)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No Provenant database found. Use provenant_log to create one."
+            }
+          ]
+        };
+      }
+      const db = this.openDb();
+      try {
+        const count = (sql) => db.prepare(sql).get().c;
+        const s = {
+          nodeCount: count("SELECT COUNT(*) as c FROM nodes"),
+          edgeCount: count("SELECT COUNT(*) as c FROM edges"),
+          pendingQueue: count(
+            "SELECT COUNT(*) as c FROM review_queue WHERE resolved_at IS NULL"
+          ),
+          unresolvedContradictions: count(
+            "SELECT COUNT(*) as c FROM contradictions WHERE status = 'pending'"
+          ),
+          unresolvedStaleFlags: count(
+            "SELECT COUNT(*) as c FROM stale_flags WHERE resolved_at IS NULL"
+          ),
+          unresolvedRejections: count(
+            "SELECT COUNT(*) as c FROM rejection_log WHERE reasoning_resolved = 0"
+          )
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Nodes: ${s.nodeCount}
+Edges: ${s.edgeCount}
+Review queue: ${s.pendingQueue}
+Contradictions: ${s.unresolvedContradictions}
+Stale flags: ${s.unresolvedStaleFlags}
+Rejections needing reasoning: ${s.unresolvedRejections}`
+            }
+          ],
+          metadata: s
+        };
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      logger.error(
+        "Provenant status error",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  async handleContradictions(_args) {
+    try {
+      if (!existsSync(this.dbPath)) {
+        return { content: [{ type: "text", text: "No Provenant database." }] };
+      }
+      const db = this.openDb();
+      try {
+        const contras = db.prepare("SELECT * FROM contradictions WHERE status = 'pending'").all();
+        if (contras.length === 0) {
+          return {
+            content: [{ type: "text", text: "No open contradictions." }]
+          };
+        }
+        const lines = contras.map((c) => {
+          const a = db.prepare("SELECT content FROM nodes WHERE id = ?").get(c.node_a);
+          const b = db.prepare("SELECT content FROM nodes WHERE id = ?").get(c.node_b);
+          return `${c.node_a.slice(0, 8)} \u2194 ${c.node_b.slice(0, 8)} (score: ${c.conflict_score.toFixed(2)})
+  A: ${a?.content?.slice(0, 100) ?? "?"}
+  B: ${b?.content?.slice(0, 100) ?? "?"}`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${contras.length} open contradictions:
+
+${lines.join("\n\n")}`
+            }
+          ],
+          metadata: { count: contras.length }
+        };
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      logger.error(
+        "Provenant contradictions error",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  async handleResolve(args) {
+    try {
+      const { node_a, node_b, winner, dismiss } = args;
+      if (!node_a || !node_b) throw new Error("node_a and node_b are required");
+      if (!winner && !dismiss) throw new Error("Specify winner or dismiss");
+      const db = this.openDb();
+      try {
+        const contras = db.prepare("SELECT * FROM contradictions WHERE status = 'pending'").all();
+        const contradiction = contras.find(
+          (c) => c.node_a.startsWith(node_a) && c.node_b.startsWith(node_b) || c.node_a.startsWith(node_b) && c.node_b.startsWith(node_a)
+        );
+        if (!contradiction) {
+          throw new Error(
+            `No pending contradiction between ${node_a} and ${node_b}`
+          );
+        }
+        if (dismiss) {
+          db.prepare(
+            "UPDATE contradictions SET status = ?, resolved_by = ?, resolved_at = ? WHERE id = ?"
+          ).run("dismissed", "human", Date.now(), contradiction.id);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Dismissed contradiction ${contradiction.id.slice(0, 8)}`
+              }
+            ]
+          };
+        }
+        const winnerNode = [contradiction.node_a, contradiction.node_b].find(
+          (id) => id.startsWith(winner)
+        );
+        if (!winnerNode) {
+          throw new Error(
+            `Winner must match one of: ${contradiction.node_a.slice(0, 8)}, ${contradiction.node_b.slice(0, 8)}`
+          );
+        }
+        const loserNode = winnerNode === contradiction.node_a ? contradiction.node_b : contradiction.node_a;
+        db.prepare(
+          "UPDATE contradictions SET status = ?, resolved_by = ?, resolved_at = ? WHERE id = ?"
+        ).run("resolved", winnerNode, Date.now(), contradiction.id);
+        db.prepare(
+          "INSERT INTO edges (id, from_node, to_node, rel_type, confidence, version, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+        ).run(
+          randomUUID(),
+          winnerNode,
+          loserNode,
+          "supersedes",
+          1,
+          1,
+          Date.now()
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Resolved: ${winnerNode.slice(0, 8)} supersedes ${loserNode.slice(0, 8)}`
+            }
+          ],
+          metadata: { winner: winnerNode, loser: loserNode }
+        };
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      logger.error(
+        "Provenant resolve error",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+}
+export {
+  ProvenantHandlers
+};