mindgraph-mcp 0.14.8 → 0.15.0

package/dist/index.js

@@ -28,6 +28,38 @@ var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_mindgraph2 = require("mindgraph");
 
+// src/hook-env.ts
+var import_node_crypto = __toESM(require("crypto"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+function stableAgentId() {
+  let user = "user";
+  try {
+    user = import_node_os.default.userInfo().username || "user";
+  } catch {
+  }
+  const digest = import_node_crypto.default.createHash("sha256").update(`${user}@${import_node_os.default.hostname()}`).digest("hex").slice(0, 12);
+  return `u-${digest}`;
+}
+function hookEnvPath(dir) {
+  return import_node_path.default.join(dir || import_node_path.default.join(import_node_os.default.homedir(), ".mindgraph"), "hooks.json");
+}
+function loadHookEnv(dir) {
+  try {
+    const raw = import_node_fs.default.readFileSync(hookEnvPath(dir), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : void 0,
+      apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : void 0,
+      agentId: typeof parsed.agentId === "string" ? parsed.agentId : void 0,
+      orgId: typeof parsed.orgId === "string" ? parsed.orgId : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+
 // src/error-detail.ts
 var import_mindgraph = require("mindgraph");
 function errorDetail(e) {
@@ -37,14 +69,31 @@ function errorDetail(e) {
   }
   return e instanceof Error ? e.message : String(e);
 }
+var CONFLICT_STATE_KEYS = [
+  "current_version",
+  "current_epoch",
+  "lease_expires_at",
+  "lease_owner_agent_id"
+];
+function conflictState(e) {
+  if (!(e instanceof import_mindgraph.MindGraphError) || !e.body || typeof e.body !== "object") {
+    return {};
+  }
+  const body = e.body;
+  const lifted = {};
+  for (const key of CONFLICT_STATE_KEYS) {
+    if (body[key] !== void 0) lifted[key] = body[key];
+  }
+  return lifted;
+}
 
 // src/codegraph.ts
 var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_os = require("os");
-var import_node_path = require("path");
-var import_node_crypto = require("crypto");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var import_node_crypto2 = require("crypto");
 function unavailabilityCaveats(reason, message) {
   const caveats = [message || "codegraph status failed"];
   if (reason === "absent") {
@@ -57,14 +106,14 @@ function unavailabilityCaveats(reason, message) {
 var DEFAULT_TIMEOUT_MS = 5e3;
 var DEFAULT_STATUS_TTL_MS = 6e4;
 var MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
-function normalizePath(path2) {
-  return path2.replaceAll("\\", "/").replace(/^\.\//, "");
+function normalizePath(path3) {
+  return path3.replaceAll("\\", "/").replace(/^\.\//, "");
 }
 function normalizeSignature(signature) {
   return signature.replace(/\s+/g, " ").trim();
 }
-function languageFromPath(path2) {
-  const extension = (0, import_node_path.extname)(path2).toLowerCase();
+function languageFromPath(path3) {
+  const extension = (0, import_node_path2.extname)(path3).toLowerCase();
   return {
     ".c": "c",
     ".cc": "cpp",
@@ -113,30 +162,30 @@ function normalizeRemote(remote) {
   }
 }
 function pathContains(root, candidate) {
-  const child = (0, import_node_path.relative)(root, candidate);
-  return child === "" || child !== ".." && !child.startsWith(`..${import_node_path.sep}`) && !(0, import_node_path.isAbsolute)(child);
+  const child = (0, import_node_path2.relative)(root, candidate);
+  return child === "" || child !== ".." && !child.startsWith(`..${import_node_path2.sep}`) && !(0, import_node_path2.isAbsolute)(child);
 }
 function nearestExistingDirectory(candidate) {
-  let current = (0, import_node_path.resolve)(candidate);
+  let current = (0, import_node_path2.resolve)(candidate);
   for (; ; ) {
-    if ((0, import_node_fs.existsSync)(current)) {
+    if ((0, import_node_fs2.existsSync)(current)) {
       try {
-        return (0, import_node_fs.statSync)(current).isDirectory() ? current : (0, import_node_path.dirname)(current);
+        return (0, import_node_fs2.statSync)(current).isDirectory() ? current : (0, import_node_path2.dirname)(current);
       } catch {
       }
     }
-    const parent = (0, import_node_path.dirname)(current);
+    const parent = (0, import_node_path2.dirname)(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 function findWorkspaceFile(start, explicit) {
-  if (explicit) return (0, import_node_path.resolve)(start, explicit);
-  let current = (0, import_node_path.resolve)(start);
+  if (explicit) return (0, import_node_path2.resolve)(start, explicit);
+  let current = (0, import_node_path2.resolve)(start);
   for (; ; ) {
-    const candidate = (0, import_node_path.join)(current, ".mindgraph", "workspace.json");
-    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
-    const parent = (0, import_node_path.dirname)(current);
+    const candidate = (0, import_node_path2.join)(current, ".mindgraph", "workspace.json");
+    if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path2.dirname)(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -223,7 +272,7 @@ var CodegraphAdapter = class {
   async resolveRepository(repo, fallbackSpaceUid) {
     const configured = await this.resolveRepositories(fallbackSpaceUid);
     const selected = repo && configured.find((candidate) => candidate.repoId === repo) || repo && configured.find(
-      (candidate) => candidate.repoRoot === repo || (0, import_node_path.basename)(candidate.repoRoot) === repo
+      (candidate) => candidate.repoRoot === repo || (0, import_node_path2.basename)(candidate.repoRoot) === repo
     ) || (!repo ? [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, this.cwd)) : void 0) || (!repo && configured.length === 1 ? configured[0] : void 0);
     if (selected) {
       return !repo && this.env.MINDGRAPH_REPO_ID ? this.resolveRepositoryIdentity(
@@ -233,8 +282,8 @@ var CodegraphAdapter = class {
       ) : selected;
     }
     const requestedRoot = repo || this.env.MINDGRAPH_REPO_ROOT || this.cwd;
-    const requestedPath = await (0, import_promises.realpath)((0, import_node_path.resolve)(this.cwd, requestedRoot)).catch(
-      () => (0, import_node_path.resolve)(this.cwd, requestedRoot)
+    const requestedPath = await (0, import_promises.realpath)((0, import_node_path2.resolve)(this.cwd, requestedRoot)).catch(
+      () => (0, import_node_path2.resolve)(this.cwd, requestedRoot)
     );
     const repoRoot = await this.gitRoot(requestedPath) ?? requestedPath;
     return this.resolveRepositoryIdentity(
@@ -255,7 +304,7 @@ var CodegraphAdapter = class {
     );
   }
   async resolveRepositoryIdentity(root, explicitRepoId, spaceUid) {
-    const repoRoot = await (0, import_promises.realpath)(root).catch(() => (0, import_node_path.resolve)(root));
+    const repoRoot = await (0, import_promises.realpath)(root).catch(() => (0, import_node_path2.resolve)(root));
     const cacheKey = `${repoRoot}\0${explicitRepoId ?? ""}\0${spaceUid ?? ""}`;
     const cached = this.identityCache.get(cacheKey);
     if (cached) return cached;
@@ -285,20 +334,20 @@ var CodegraphAdapter = class {
       this.env
     ).catch(() => "");
     if (!rawCommonDir.trim()) {
-      return `local:${(0, import_node_path.basename)(repoRoot)}`;
+      return `local:${(0, import_node_path2.basename)(repoRoot)}`;
     }
-    const commonDir = (0, import_node_path.resolve)(repoRoot, rawCommonDir.trim());
-    const identityDir = (0, import_node_path.join)(commonDir, "mindgraph");
-    const identityFile = (0, import_node_path.join)(identityDir, "repository-id");
+    const commonDir = (0, import_node_path2.resolve)(repoRoot, rawCommonDir.trim());
+    const identityDir = (0, import_node_path2.join)(commonDir, "mindgraph");
+    const identityFile = (0, import_node_path2.join)(identityDir, "repository-id");
     try {
-      const existing = (0, import_node_fs.readFileSync)(identityFile, "utf8").trim();
+      const existing = (0, import_node_fs2.readFileSync)(identityFile, "utf8").trim();
       if (existing) return existing;
     } catch {
     }
-    (0, import_node_fs.mkdirSync)(identityDir, { recursive: true, mode: 448 });
-    const generated = (0, import_node_crypto.randomUUID)();
+    (0, import_node_fs2.mkdirSync)(identityDir, { recursive: true, mode: 448 });
+    const generated = (0, import_node_crypto2.randomUUID)();
     try {
-      (0, import_node_fs.writeFileSync)(identityFile, `${generated}
+      (0, import_node_fs2.writeFileSync)(identityFile, `${generated}
 `, {
         encoding: "utf8",
         flag: "wx",
@@ -307,7 +356,7 @@ var CodegraphAdapter = class {
       return generated;
     } catch (cause) {
       if (cause.code !== "EEXIST") throw cause;
-      const winner = (0, import_node_fs.readFileSync)(identityFile, "utf8").trim();
+      const winner = (0, import_node_fs2.readFileSync)(identityFile, "utf8").trim();
       if (!winner) throw new Error(`empty repository identity file: ${identityFile}`);
       return winner;
     }
@@ -320,7 +369,7 @@ var CodegraphAdapter = class {
       Math.min(this.timeoutMs, 2e3),
       this.env
     ).catch(() => "");
-    return raw.trim() ? (0, import_node_path.resolve)(start, raw.trim()) : void 0;
+    return raw.trim() ? (0, import_node_path2.resolve)(start, raw.trim()) : void 0;
   }
   async availability(repository) {
     const cached = this.statusCache.get(repository.repoRoot);
@@ -437,7 +486,7 @@ var CodegraphAdapter = class {
       return this.resolveRepository(ref.repo || defaultRepo, fallbackSpaceUid);
     }
     if (ref.path) {
-      const requested = (0, import_node_path.isAbsolute)(ref.path) ? (0, import_node_path.resolve)(ref.path) : (0, import_node_path.resolve)(this.cwd, ref.path);
+      const requested = (0, import_node_path2.isAbsolute)(ref.path) ? (0, import_node_path2.resolve)(ref.path) : (0, import_node_path2.resolve)(this.cwd, ref.path);
       const absolute = await (0, import_promises.realpath)(requested).catch(() => requested);
       const configured = await this.resolveRepositories(fallbackSpaceUid);
       const defining = [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, absolute));
@@ -514,19 +563,19 @@ var CodegraphAdapter = class {
   }
   configuredRepositories() {
     const configured = [];
-    if (this.workspaceFile && (0, import_node_fs.existsSync)(this.workspaceFile)) {
+    if (this.workspaceFile && (0, import_node_fs2.existsSync)(this.workspaceFile)) {
       try {
         const parsed = JSON.parse(
-          (0, import_node_fs.readFileSync)(this.workspaceFile, "utf8")
+          (0, import_node_fs2.readFileSync)(this.workspaceFile, "utf8")
         );
         if (parsed.v === 1 && Array.isArray(parsed.repositories)) {
-          const configDirectory = (0, import_node_path.dirname)(this.workspaceFile);
-          const base = (0, import_node_path.basename)(configDirectory) === ".mindgraph" ? (0, import_node_path.dirname)(configDirectory) : configDirectory;
+          const configDirectory = (0, import_node_path2.dirname)(this.workspaceFile);
+          const base = (0, import_node_path2.basename)(configDirectory) === ".mindgraph" ? (0, import_node_path2.dirname)(configDirectory) : configDirectory;
           for (const repository of parsed.repositories) {
             if (!repository || typeof repository.root !== "string") continue;
             configured.push({
               repoId: typeof repository.repo_id === "string" ? repository.repo_id : void 0,
-              repoRoot: (0, import_node_path.resolve)(base, repository.root),
+              repoRoot: (0, import_node_path2.resolve)(base, repository.root),
               spaceUid: typeof repository.space_uid === "string" ? repository.space_uid : void 0
             });
           }
@@ -541,7 +590,7 @@ var CodegraphAdapter = class {
         for (const [repoId, config] of Object.entries(parsed)) {
           configured.push({
             repoId,
-            repoRoot: (0, import_node_path.resolve)(
+            repoRoot: (0, import_node_path2.resolve)(
               this.cwd,
               typeof config === "string" ? config : config.root
             ),
@@ -569,9 +618,9 @@ var CodegraphAdapter = class {
       const hits = await this.runJson(args);
       let candidates = hits.map(asNode).map(toCandidate).filter((item) => item !== null);
       if (ref.path) {
-        const absolutePath = (0, import_node_path.isAbsolute)(ref.path) ? await (0, import_promises.realpath)(ref.path).catch(() => ref.path) : void 0;
+        const absolutePath = (0, import_node_path2.isAbsolute)(ref.path) ? await (0, import_promises.realpath)(ref.path).catch(() => ref.path) : void 0;
         const wanted = normalizePath(
-          absolutePath ? (0, import_node_path.relative)(repository.repoRoot, absolutePath) : ref.path
+          absolutePath ? (0, import_node_path2.relative)(repository.repoRoot, absolutePath) : ref.path
         );
         candidates = candidates.filter((candidate) => candidate.path === wanted);
       }
@@ -672,7 +721,7 @@ var CodegraphAdapter = class {
     const candidates = [
       this.env.MINDGRAPH_CODEGRAPH_BIN,
       "codegraph",
-      (0, import_node_path.resolve)((0, import_node_os.homedir)(), ".local", "bin", "codegraph")
+      (0, import_node_path2.resolve)((0, import_node_os2.homedir)(), ".local", "bin", "codegraph")
     ].filter((candidate, index, all) => {
       return Boolean(candidate) && all.indexOf(candidate) === index;
     });
@@ -1219,9 +1268,9 @@ function primaryUids(value) {
 }
 
 // src/sync-tool.ts
-var import_node_crypto2 = __toESM(require("crypto"));
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_crypto3 = __toESM(require("crypto"));
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
 var ok2 = (data) => ({
   content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
 });
@@ -1298,25 +1347,25 @@ var SYNC_TOOL = {
   }
 };
 function safePath(root, candidate) {
-  const absolute = import_node_path2.default.resolve(root, candidate);
-  const relative2 = import_node_path2.default.relative(root, absolute);
-  if (relative2.startsWith("..") || import_node_path2.default.isAbsolute(relative2)) {
+  const absolute = import_node_path3.default.resolve(root, candidate);
+  const relative2 = import_node_path3.default.relative(root, absolute);
+  if (relative2.startsWith("..") || import_node_path3.default.isAbsolute(relative2)) {
     throw new Error(`path escapes repository root: ${candidate}`);
   }
   return absolute;
 }
 function markdownFiles(target) {
-  if (!import_node_fs2.default.existsSync(target)) return [];
-  const stat = import_node_fs2.default.statSync(target);
+  if (!import_node_fs3.default.existsSync(target)) return [];
+  const stat = import_node_fs3.default.statSync(target);
   if (stat.isFile()) return target.endsWith(".md") ? [target] : [];
   if (!stat.isDirectory()) return [];
-  return import_node_fs2.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path2.default.join(target, entry.name)));
+  return import_node_fs3.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path3.default.join(target, entry.name)));
 }
 function fileDescriptor(root, absolute) {
-  const content = import_node_fs2.default.readFileSync(absolute, "utf8");
+  const content = import_node_fs3.default.readFileSync(absolute, "utf8");
   return {
-    logical_path: import_node_path2.default.relative(root, absolute).split(import_node_path2.default.sep).join("/"),
-    content_hash: import_node_crypto2.default.createHash("sha256").update(content).digest("hex"),
+    logical_path: import_node_path3.default.relative(root, absolute).split(import_node_path3.default.sep).join("/"),
+    content_hash: import_node_crypto3.default.createHash("sha256").update(content).digest("hex"),
     bytes: Buffer.byteLength(content),
     content
   };
@@ -1381,7 +1430,7 @@ async function handleSyncTool(client2, args) {
     }
     if (action === "status" && request.logical_path && request.file_present !== false) {
       const absolute = safePath(root, String(request.logical_path));
-      request.file_present = import_node_fs2.default.existsSync(absolute);
+      request.file_present = import_node_fs3.default.existsSync(absolute);
       if (request.file_present && !request.content_hash) {
         request.content_hash = fileDescriptor(root, absolute).content_hash;
       }
@@ -1889,7 +1938,7 @@ var TOOLS = [
         scope_uids: {
           type: "array",
           items: { type: "string" },
-          description: "Ordinary target UIDs that bound deterministic resume selection"
+          description: "Required target UIDs for create_task and ordinary target UIDs that bound deterministic resume selection"
         },
         limit: {
           type: "number",
@@ -2441,6 +2490,18 @@ async function handleTool(client2, name, args) {
     ].includes(action);
     return attach ? await attachCodeRefsToToolResult(client2, result, args) : result;
   } catch (e) {
+    const lifted = conflictState(e);
+    if (Object.keys(lifted).length > 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: errorDetail(e), ...lifted })
+          }
+        ],
+        isError: true
+      };
+    }
     return err3(errorDetail(e));
   }
 }
@@ -2687,6 +2748,38 @@ async function handleCommit(client2, args) {
       return err3(`Unknown commit action: ${action}`);
   }
 }
+async function repositoryScopeUidsForTask(client2, options) {
+  const scopeUids = [...new Set(options.scopeUids ?? [])];
+  const cwd = options.invocationContext?.cwd;
+  const repoId = options.invocationContext?.repoId;
+  if (!options.repo && !cwd && !repoId) {
+    return options.scopeUids;
+  }
+  const agentId = options.agentId ?? process.env.MINDGRAPH_AGENT_ID ?? "mcp";
+  const fallbackSpaceUid = options.repoSpaceUid ?? `space:agent:${agentId}`;
+  const env = { ...process.env };
+  if (!options.repo && repoId) {
+    env.MINDGRAPH_REPO_ID = repoId;
+  }
+  const adapter = new CodegraphAdapter({
+    cwd: cwd ?? process.cwd(),
+    env
+  });
+  const repository = await adapter.resolveRepository(options.repo, fallbackSpaceUid);
+  const anchored = await anchorRepository(
+    client2,
+    repository,
+    repository.spaceUid ?? fallbackSpaceUid,
+    agentId
+  );
+  if (!anchored.uid) {
+    throw new Error(
+      `repository scope ${repository.repoId} could not be materialized (${anchored.status ?? "missing uid"})`
+    );
+  }
+  scopeUids.push(anchored.uid);
+  return [...new Set(scopeUids)];
+}
 async function handlePlan(client2, args) {
   const {
     action,
@@ -2717,6 +2810,9 @@ async function handlePlan(client2, args) {
     release_lease,
     override_reason,
     scope_uids,
+    repo,
+    repo_space_uid,
+    invocation_context,
     limit,
     confidence,
     salience,
@@ -2746,7 +2842,14 @@ async function handlePlan(client2, args) {
     case "checkpoint_iteration":
     case "block_task":
     case "complete_task":
-    case "abandon_iteration":
+    case "abandon_iteration": {
+      const resolvedScopeUids = action === "create_task" ? await repositoryScopeUidsForTask(client2, {
+        scopeUids: scope_uids,
+        repo,
+        repoSpaceUid: repo_space_uid,
+        invocationContext: invocation_context,
+        agentId: agent_id
+      }) : scope_uids;
       return ok3(
         await client2.plan({
           action,
@@ -2774,7 +2877,7 @@ async function handlePlan(client2, args) {
           allow_takeover,
           release_lease,
           override_reason,
-          scope_uids,
+          scope_uids: resolvedScopeUids,
           limit,
           input_snapshot,
           output_snapshot,
@@ -2789,6 +2892,7 @@ async function handlePlan(client2, args) {
           agent_id
         })
       );
+    }
     // Execution tracking
     case "start_execution":
       return ok3(
@@ -3833,7 +3937,7 @@ async function readGovernedResource(client2, uri, governanceConfig) {
 // src/index.ts
 var API_KEY = process.env.MINDGRAPH_API_KEY;
 var BASE_URL = process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud";
-var AGENT_ID = process.env.MINDGRAPH_AGENT_ID || "mcp";
+var AGENT_ID = process.env.MINDGRAPH_AGENT_ID || loadHookEnv().agentId || stableAgentId();
 var ORG_ID = process.env.MINDGRAPH_ORG_ID;
 var PROFILE = process.env.MINDGRAPH_PROFILE || "general";
 var HARNESS = process.env.MINDGRAPH_HARNESS || "generic";
@@ -3955,7 +4059,7 @@ if (PROFILE === "coding") {
 var server = new import_server.Server(
   {
     name: "mindgraph",
-    version: "0.14.8"
+    version: "0.15.0"
   },
   {
     capabilities: {
@@ -4169,7 +4273,7 @@ async function main() {
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `MindGraph MCP server v0.7.1 running on stdio (${BASE_URL})`
+    `MindGraph MCP server v${"0.15.0"} running on stdio (${BASE_URL})`
   );
 }
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindgraph-mcp",
-  "version": "0.14.8",
+  "version": "0.15.0",
   "description": "MCP server for MindGraph — connect Claude Desktop, Claude Code, and any MCP client to your knowledge graph",
   "repository": {
     "type": "git",