mindgraph-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,1549 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/tools.ts
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function err(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+async function handleTool(client2, name, args) {
+  try {
+    switch (name) {
+      case "mindgraph_session":
+        return await handleSession(client2, args);
+      case "mindgraph_journal":
+        return await handleJournal(client2, args);
+      case "mindgraph_capture":
+        return await handleCapture(client2, args);
+      case "mindgraph_argue":
+        return await handleArgue(client2, args);
+      case "mindgraph_inquire":
+        return await handleInquire(client2, args);
+      case "mindgraph_commit":
+        return await handleCommit(client2, args);
+      case "mindgraph_decide":
+        return await handleDecide(client2, args);
+      case "mindgraph_action":
+        return await handleAction(client2, args);
+      case "mindgraph_plan":
+        return await handlePlan(client2, args);
+      case "mindgraph_retrieve":
+        return await handleRetrieve(client2, args);
+      case "mindgraph_ingest":
+        return await handleIngest(client2, args);
+      default:
+        return err(`Unknown tool: ${name}`);
+    }
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return err(message);
+  }
+}
+async function handleSession(client2, args) {
+  const { action, label, session_uid, summary, props, agent_id } = args;
+  switch (action) {
+    case "open": {
+      if (!label) return err("label is required for open");
+      const result = await client2.session({
+        action: "open",
+        label,
+        summary,
+        props,
+        agent_id
+      });
+      return ok(result);
+    }
+    case "trace": {
+      if (!session_uid) return err("session_uid is required for trace");
+      if (!label) return err("label is required for trace");
+      const result = await client2.session({
+        action: "trace",
+        label,
+        session_uid,
+        props,
+        agent_id
+      });
+      return ok(result);
+    }
+    case "close": {
+      if (!session_uid) return err("session_uid is required for close");
+      const result = await client2.session({
+        action: "close",
+        session_uid,
+        summary,
+        agent_id
+      });
+      return ok(result);
+    }
+    default:
+      return err(`Unknown session action: ${action}`);
+  }
+}
+async function handleJournal(client2, args) {
+  const { label, content, mood, tags, session_uid, agent_id } = args;
+  const props = { content };
+  if (mood) props.mood = mood;
+  if (tags) props.tags = tags;
+  const result = await client2.journal(
+    label,
+    props,
+    { session_uid, agent_id }
+  );
+  return ok(result);
+}
+async function handleCapture(client2, args) {
+  const {
+    action,
+    label,
+    summary,
+    entity_type,
+    source_uid,
+    confidence,
+    salience,
+    props,
+    agent_id
+  } = args;
+  switch (action) {
+    case "entity": {
+      const type = entity_type || "concept";
+      const entityProps = { ...props };
+      if (summary) entityProps.description = summary;
+      switch (type) {
+        case "person":
+          return ok(await client2.findOrCreatePerson(label, entityProps, agent_id));
+        case "organization":
+          return ok(await client2.findOrCreateOrganization(label, entityProps, agent_id));
+        case "nation":
+          return ok(await client2.findOrCreateNation(label, entityProps, agent_id));
+        case "event":
+          return ok(await client2.findOrCreateEvent(label, entityProps, agent_id));
+        case "place":
+          return ok(await client2.findOrCreatePlace(label, entityProps, agent_id));
+        case "concept":
+        default:
+          return ok(await client2.findOrCreateConcept(label, entityProps, agent_id));
+      }
+    }
+    case "observation":
+      return ok(
+        await client2.capture({
+          action: "observation",
+          label,
+          summary,
+          confidence,
+          salience,
+          props,
+          agent_id
+        })
+      );
+    case "source":
+      return ok(
+        await client2.capture({
+          action: "source",
+          label,
+          summary,
+          confidence,
+          salience,
+          props,
+          agent_id
+        })
+      );
+    case "snippet":
+      return ok(
+        await client2.capture({
+          action: "snippet",
+          label,
+          summary,
+          source_uid,
+          confidence,
+          salience,
+          props,
+          agent_id
+        })
+      );
+    case "concept":
+      return ok(
+        await client2.structure({
+          action: "concept",
+          label,
+          summary,
+          confidence,
+          salience,
+          props,
+          agent_id
+        })
+      );
+    default:
+      return err(`Unknown capture action: ${action}`);
+  }
+}
+async function handleArgue(client2, args) {
+  const { claim, evidence, warrant, argument, agent_id } = args;
+  const result = await client2.argue({
+    claim,
+    evidence,
+    warrant,
+    argument,
+    agent_id
+  });
+  return ok(result);
+}
+async function handleInquire(client2, args) {
+  const { action, label, summary, confidence, salience, props, agent_id } = args;
+  const result = await client2.inquire({
+    action,
+    label,
+    summary,
+    confidence,
+    salience,
+    props,
+    agent_id
+  });
+  return ok(result);
+}
+async function handleCommit(client2, args) {
+  const { action, label, summary, parent_uid, confidence, salience, props, agent_id } = args;
+  const result = await client2.commit({
+    action,
+    label,
+    summary,
+    parent_uid,
+    confidence,
+    salience,
+    props,
+    agent_id
+  });
+  return ok(result);
+}
+async function handleDecide(client2, args) {
+  const { action, label, summary, decision_uid, chosen_option_uid, props, agent_id } = args;
+  switch (action) {
+    case "open_decision":
+      if (!label) return err("label is required for open_decision");
+      return ok(await client2.openDecision(label, { summary, props, agent_id }));
+    case "add_option":
+      if (!decision_uid) return err("decision_uid is required");
+      if (!label) return err("label is required for add_option");
+      return ok(
+        await client2.addOption(decision_uid, label, { summary, props, agent_id })
+      );
+    case "add_constraint":
+      if (!decision_uid) return err("decision_uid is required");
+      return ok(
+        await client2.deliberate({
+          action: "add_constraint",
+          label,
+          decision_uid,
+          summary,
+          props,
+          agent_id
+        })
+      );
+    case "resolve":
+      if (!decision_uid) return err("decision_uid is required");
+      if (!chosen_option_uid) return err("chosen_option_uid is required");
+      return ok(
+        await client2.resolveDecision(decision_uid, chosen_option_uid, {
+          summary,
+          agent_id
+        })
+      );
+    case "get_open":
+      return ok(await client2.getOpenDecisions());
+    default:
+      return err(`Unknown decide action: ${action}`);
+  }
+}
+async function handleAction(client2, args) {
+  const { action, label, summary, target_uid, props, agent_id } = args;
+  switch (action) {
+    case "create_flow":
+    case "add_step":
+    case "add_affordance":
+    case "add_control":
+      return ok(
+        await client2.procedure({
+          action,
+          label,
+          summary,
+          target_uid,
+          props,
+          agent_id
+        })
+      );
+    case "assess_risk":
+      return ok(
+        await client2.risk({
+          action: "assess",
+          label,
+          summary,
+          target_uid,
+          props,
+          agent_id
+        })
+      );
+    case "get_assessments":
+      return ok(
+        await client2.risk({
+          action: "get_assessments",
+          target_uid,
+          agent_id
+        })
+      );
+    default:
+      return err(`Unknown action: ${action}`);
+  }
+}
+async function handlePlan(client2, args) {
+  const { action, label, summary, plan_uid, task_uid, status, props, agent_id } = args;
+  switch (action) {
+    case "create_task":
+    case "create_plan":
+    case "add_step":
+    case "update_status":
+    case "get_plan":
+      return ok(
+        await client2.plan({
+          action,
+          label,
+          summary,
+          plan_uid,
+          task_uid,
+          status,
+          props,
+          agent_id
+        })
+      );
+    case "start_execution":
+      return ok(
+        await client2.execution({
+          action: "start",
+          task_uid,
+          agent_id
+        })
+      );
+    case "complete_execution":
+      return ok(
+        await client2.execution({
+          action: "complete",
+          task_uid,
+          agent_id
+        })
+      );
+    case "fail_execution":
+      return ok(
+        await client2.execution({
+          action: "fail",
+          task_uid,
+          agent_id
+        })
+      );
+    case "create_policy":
+      return ok(
+        await client2.governance({
+          action: "create_policy",
+          label,
+          summary,
+          props,
+          agent_id
+        })
+      );
+    case "request_approval":
+      return ok(
+        await client2.governance({
+          action: "request_approval",
+          label,
+          summary,
+          props,
+          agent_id
+        })
+      );
+    case "resolve_approval":
+      return ok(
+        await client2.governance({
+          action: "resolve_approval",
+          task_uid,
+          props,
+          agent_id
+        })
+      );
+    case "get_pending":
+      return ok(
+        await client2.governance({
+          action: "get_pending",
+          agent_id
+        })
+      );
+    default:
+      return err(`Unknown plan action: ${action}`);
+  }
+}
+async function handleRetrieve(client2, args) {
+  const { action, query, layer, limit, node_type, agent_id } = args;
+  switch (action) {
+    case "context":
+      if (!query) return err("query is required for context retrieval");
+      return ok(await client2.retrieveContext({ query, k: limit }));
+    case "hybrid":
+      if (!query) return err("query is required for hybrid search");
+      return ok(
+        await client2.hybridSearch(query, {
+          k: limit,
+          node_types: node_type ? [node_type] : void 0
+        })
+      );
+    case "semantic":
+      if (!query) return err("query is required for semantic search");
+      return ok(
+        await client2.retrieve({
+          action: "semantic",
+          query,
+          limit,
+          node_type,
+          agent_id
+        })
+      );
+    case "text":
+      if (!query) return err("query is required for text search");
+      return ok(await client2.search(query, { limit, node_type }));
+    case "active_goals":
+      return ok(await client2.getGoals());
+    case "open_questions":
+      return ok(await client2.getOpenQuestions());
+    case "weak_claims":
+      return ok(await client2.getWeakClaims());
+    case "pending_approvals":
+      return ok(await client2.getPendingApprovals());
+    case "unresolved_contradictions":
+      return ok(await client2.getContradictions());
+    case "layer":
+      if (!layer) return err("layer is required for layer retrieval");
+      return ok(
+        await client2.retrieve({
+          action: "layer",
+          layer,
+          limit,
+          agent_id
+        })
+      );
+    case "recent":
+      return ok(
+        await client2.retrieve({
+          action: "recent",
+          limit,
+          node_type,
+          agent_id
+        })
+      );
+    default:
+      return err(`Unknown retrieve action: ${action}`);
+  }
+}
+async function handleIngest(client2, args) {
+  const { action, content, title, source, layers, chunk_size, chunk_overlap, job_id, agent_id } = args;
+  switch (action) {
+    case "chunk":
+      if (!content) return err("content is required for chunk ingestion");
+      return ok(
+        await client2.ingestChunk({
+          content,
+          title,
+          source,
+          layers,
+          agent_id
+        })
+      );
+    case "document":
+      if (!content) return err("content is required for document ingestion");
+      return ok(
+        await client2.ingestDocument({
+          content,
+          title,
+          source,
+          layers,
+          chunk_size,
+          chunk_overlap,
+          agent_id
+        })
+      );
+    case "session":
+      if (!content) return err("content is required for session ingestion");
+      return ok(
+        await client2.ingestSession({
+          content,
+          title,
+          source,
+          layers,
+          agent_id
+        })
+      );
+    case "job_status":
+      if (job_id) {
+        return ok(await client2.getJob(job_id));
+      }
+      return ok(await client2.listJobs());
+    default:
+      return err(`Unknown ingest action: ${action}`);
+  }
+}
+var TOOLS;
+var init_tools = __esm({
+  "src/tools.ts"() {
+    "use strict";
+    TOOLS = [
+      {
+        name: "mindgraph_session",
+        description: "Open, trace, or close a memory session. Sessions group related interactions and enable context continuity. Open a session at the start of a conversation, trace key moments during it, and close it at the end to trigger distillation.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["open", "trace", "close"],
+              description: "Session lifecycle action"
+            },
+            label: {
+              type: "string",
+              description: "Session or trace label (required for open/trace)"
+            },
+            session_uid: {
+              type: "string",
+              description: "Session UID (required for trace/close)"
+            },
+            summary: {
+              type: "string",
+              description: "Session summary (used on close)"
+            },
+            props: {
+              type: "object",
+              description: "Additional properties"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity for multi-agent systems"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      {
+        name: "mindgraph_journal",
+        description: "Low-friction capture of observations, notes, preferences, and reflections. Creates a Journal node in the Memory layer. Use this for quick thoughts, user preferences, mood tracking, and daily notes that don't fit a formal structure.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            label: {
+              type: "string",
+              description: "Brief title for the journal entry"
+            },
+            content: {
+              type: "string",
+              description: "The journal content/body text"
+            },
+            mood: {
+              type: "string",
+              description: "Emotional tone or mood tag"
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Categorization tags"
+            },
+            session_uid: {
+              type: "string",
+              description: "Link to an active session"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["label", "content"]
+        }
+      },
+      {
+        name: "mindgraph_capture",
+        description: "Capture entities, observations, concepts, sources, and snippets into the Reality layer with automatic deduplication. Use 'entity' for people, organizations, places, events, nations, or abstract concepts. Use 'observation' for factual observations. Use 'source' for documents or references. Use 'snippet' for direct quotes linked to a source.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["entity", "observation", "source", "snippet", "concept"],
+              description: "Type of reality to capture"
+            },
+            label: {
+              type: "string",
+              description: "Name or title"
+            },
+            summary: {
+              type: "string",
+              description: "Description or summary text"
+            },
+            entity_type: {
+              type: "string",
+              enum: [
+                "person",
+                "organization",
+                "place",
+                "event",
+                "nation",
+                "concept"
+              ],
+              description: "Entity subtype (only for action=entity)"
+            },
+            source_uid: {
+              type: "string",
+              description: "Source node UID (for snippets)"
+            },
+            confidence: {
+              type: "number",
+              minimum: 0,
+              maximum: 1,
+              description: "Confidence score (0-1)"
+            },
+            salience: {
+              type: "number",
+              minimum: 0,
+              maximum: 1,
+              description: "Importance/salience score (0-1)"
+            },
+            props: {
+              type: "object",
+              description: "Type-specific properties (e.g. birth_date for person, coordinates for place)"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action", "label"]
+        }
+      },
+      {
+        name: "mindgraph_argue",
+        description: "Construct a structured argument with claims, evidence, warrants, and rebuttals. Creates interconnected Epistemic layer nodes. Use this when you need to record or evaluate a reasoned position with supporting evidence and logical connections.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            claim: {
+              type: "object",
+              properties: {
+                label: { type: "string", description: "Claim statement" },
+                content: { type: "string", description: "Detailed claim content" },
+                confidence: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 1,
+                  description: "How likely this claim is true (0-1)"
+                }
+              },
+              required: ["label"],
+              description: "The central claim being argued"
+            },
+            evidence: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: { type: "string" },
+                  description: { type: "string" }
+                },
+                required: ["label"]
+              },
+              description: "Supporting evidence items"
+            },
+            warrant: {
+              type: "object",
+              properties: {
+                label: { type: "string" },
+                content: { type: "string" }
+              },
+              description: "Logical warrant connecting evidence to claim"
+            },
+            argument: {
+              type: "object",
+              properties: {
+                label: { type: "string" }
+              },
+              description: "Top-level argument container"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["claim"]
+        }
+      },
+      {
+        name: "mindgraph_inquire",
+        description: "Record questions, hypotheses, theories, anomalies, assumptions, and paradigms in the Epistemic layer. Use this to track open questions worth investigating, form testable hypotheses, flag anomalies that challenge existing understanding, or articulate theoretical frameworks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "question",
+                "open_question",
+                "hypothesis",
+                "theory",
+                "paradigm",
+                "anomaly",
+                "assumption"
+              ],
+              description: "Type of epistemic inquiry"
+            },
+            label: {
+              type: "string",
+              description: "The question, hypothesis, or theory statement"
+            },
+            summary: {
+              type: "string",
+              description: "Expanded description or context"
+            },
+            confidence: {
+              type: "number",
+              minimum: 0,
+              maximum: 1,
+              description: "Confidence level (0-1)"
+            },
+            salience: {
+              type: "number",
+              minimum: 0,
+              maximum: 1,
+              description: "Importance score (0-1)"
+            },
+            props: {
+              type: "object",
+              description: "Type-specific properties"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action", "label"]
+        }
+      },
+      {
+        name: "mindgraph_commit",
+        description: "Create goals, projects, and milestones in the Intent layer. Use 'goal' for desired outcomes, 'project' for organized efforts toward goals, and 'milestone' for measurable checkpoints within projects.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["goal", "project", "milestone"],
+              description: "Type of commitment"
+            },
+            label: {
+              type: "string",
+              description: "Name of the goal, project, or milestone"
+            },
+            summary: {
+              type: "string",
+              description: "Description and success criteria"
+            },
+            parent_uid: {
+              type: "string",
+              description: "Parent goal/project UID to link under"
+            },
+            confidence: {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            salience: {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            props: {
+              type: "object",
+              description: "Type-specific properties (e.g. status, priority, deadline, horizon for goals)"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action", "label"]
+        }
+      },
+      {
+        name: "mindgraph_decide",
+        description: "Manage decisions through their full lifecycle: open a decision, add options and constraints, then resolve by choosing an option. Use 'get_open' to list all unresolved decisions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["open_decision", "add_option", "add_constraint", "resolve", "get_open"],
+              description: "Decision lifecycle action"
+            },
+            label: {
+              type: "string",
+              description: "Decision, option, or constraint label"
+            },
+            summary: {
+              type: "string",
+              description: "Description or rationale"
+            },
+            decision_uid: {
+              type: "string",
+              description: "Decision UID (for add_option, add_constraint, resolve)"
+            },
+            chosen_option_uid: {
+              type: "string",
+              description: "UID of the chosen option (for resolve)"
+            },
+            props: {
+              type: "object",
+              description: "Additional properties"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      {
+        name: "mindgraph_action",
+        description: "Record procedural knowledge (workflows, steps, affordances, controls) and risk assessments in the Action layer. Use this for SOPs, runbooks, capability mappings, and risk analysis.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "create_flow",
+                "add_step",
+                "add_affordance",
+                "add_control",
+                "assess_risk",
+                "get_assessments"
+              ],
+              description: "Action layer operation"
+            },
+            label: {
+              type: "string",
+              description: "Flow, step, affordance, control, or risk label"
+            },
+            summary: {
+              type: "string",
+              description: "Description"
+            },
+            target_uid: {
+              type: "string",
+              description: "Parent flow/step UID or target node for risk assessment"
+            },
+            props: {
+              type: "object",
+              description: "Type-specific properties (e.g. likelihood, impact, mitigation for risks)"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      {
+        name: "mindgraph_plan",
+        description: "Create and manage plans, tasks, execution tracking, and governance policies in the Agent layer. Supports full task lifecycle from creation through completion, plan hierarchies, and approval workflows.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "create_task",
+                "create_plan",
+                "add_step",
+                "update_status",
+                "get_plan",
+                "start_execution",
+                "complete_execution",
+                "fail_execution",
+                "create_policy",
+                "request_approval",
+                "resolve_approval",
+                "get_pending"
+              ],
+              description: "Agent layer operation"
+            },
+            label: {
+              type: "string",
+              description: "Task, plan, step, or policy label"
+            },
+            summary: {
+              type: "string",
+              description: "Description"
+            },
+            plan_uid: {
+              type: "string",
+              description: "Plan UID (for add_step, get_plan)"
+            },
+            task_uid: {
+              type: "string",
+              description: "Task/step UID (for update_status, execution actions)"
+            },
+            status: {
+              type: "string",
+              description: "New status value (for update_status)"
+            },
+            props: {
+              type: "object",
+              description: "Additional properties"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      {
+        name: "mindgraph_retrieve",
+        description: "Search and query the knowledge graph. Supports hybrid (text + semantic) search, active goals, open questions, weak claims, pending approvals, contradictions, layer-filtered retrieval, and rich context retrieval that follows graph edges from matching chunks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: [
+                "hybrid",
+                "semantic",
+                "text",
+                "context",
+                "active_goals",
+                "open_questions",
+                "weak_claims",
+                "pending_approvals",
+                "unresolved_contradictions",
+                "layer",
+                "recent"
+              ],
+              description: "Retrieval strategy"
+            },
+            query: {
+              type: "string",
+              description: "Search query (for hybrid, semantic, text, context)"
+            },
+            layer: {
+              type: "string",
+              enum: [
+                "reality",
+                "epistemic",
+                "intent",
+                "action",
+                "memory",
+                "agent"
+              ],
+              description: "Layer filter (for layer action)"
+            },
+            limit: {
+              type: "number",
+              description: "Max results to return (default: 10)"
+            },
+            node_type: {
+              type: "string",
+              description: "Filter by node type"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      {
+        name: "mindgraph_ingest",
+        description: "Ingest long-form content into the knowledge graph. Supports single chunks (synchronous), full documents (async with job tracking), and session transcripts. The ingestion pipeline automatically extracts entities, claims, relationships, and structures across cognitive layers.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["chunk", "document", "session", "job_status"],
+              description: "Ingestion action"
+            },
+            content: {
+              type: "string",
+              description: "Text content to ingest (for chunk/document/session)"
+            },
+            title: {
+              type: "string",
+              description: "Document or session title"
+            },
+            source: {
+              type: "string",
+              description: "Source URL or reference"
+            },
+            layers: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "reality",
+                  "epistemic",
+                  "intent",
+                  "action",
+                  "memory",
+                  "agent"
+                ]
+              },
+              description: "Cognitive layers to extract (defaults vary by action)"
+            },
+            chunk_size: {
+              type: "number",
+              description: "Characters per chunk for document ingestion (default: 4000)"
+            },
+            chunk_overlap: {
+              type: "number",
+              description: "Overlap between chunks (default: 200)"
+            },
+            job_id: {
+              type: "string",
+              description: "Job ID to check status (for job_status action)"
+            },
+            agent_id: {
+              type: "string",
+              description: "Agent identity"
+            }
+          },
+          required: ["action"]
+        }
+      }
+    ];
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("MindGraph MCP server running on stdio");
+}
+var import_server, import_stdio, import_types, import_mindgraph, API_KEY, BASE_URL, AGENT_ID, client, server;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_server = require("@modelcontextprotocol/sdk/server/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    import_mindgraph = require("mindgraph");
+    init_tools();
+    API_KEY = process.env.MINDGRAPH_API_KEY;
+    BASE_URL = process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud";
+    AGENT_ID = process.env.MINDGRAPH_AGENT_ID || "mcp";
+    if (!API_KEY) {
+      console.error(
+        "Error: MINDGRAPH_API_KEY environment variable is required.\nGet your API key at https://mindgraph.cloud/dashboard/keys"
+      );
+      process.exit(1);
+    }
+    client = new import_mindgraph.MindGraph({
+      baseUrl: BASE_URL,
+      apiKey: API_KEY
+    });
+    server = new import_server.Server(
+      {
+        name: "mindgraph",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      return { tools: TOOLS };
+    });
+    server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const toolArgs = { ...args || {} };
+      if (!toolArgs.agent_id) {
+        toolArgs.agent_id = AGENT_ID;
+      }
+      return handleTool(client, name, toolArgs);
+    });
+    server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+      return {
+        resources: [
+          {
+            uri: "mindgraph://stats",
+            name: "Graph Statistics",
+            description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
+            mimeType: "application/json"
+          },
+          {
+            uri: "mindgraph://goals",
+            name: "Active Goals",
+            description: "All active goals in the knowledge graph",
+            mimeType: "application/json"
+          },
+          {
+            uri: "mindgraph://questions",
+            name: "Open Questions",
+            description: "All open questions in the knowledge graph",
+            mimeType: "application/json"
+          }
+        ]
+      };
+    });
+    server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      switch (uri) {
+        case "mindgraph://stats": {
+          const stats = await client.stats();
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(stats, null, 2)
+              }
+            ]
+          };
+        }
+        case "mindgraph://goals": {
+          const goals = await client.getGoals();
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(goals, null, 2)
+              }
+            ]
+          };
+        }
+        case "mindgraph://questions": {
+          const questions = await client.getOpenQuestions();
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(questions, null, 2)
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`Unknown resource: ${uri}`);
+      }
+    });
+    main().catch((error) => {
+      console.error("Fatal error:", error);
+      process.exit(1);
+    });
+  }
+});
+
+// src/cli.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var crypto = __toESM(require("crypto"));
+var import_child_process = require("child_process");
+function getClaudeDesktopConfigPath() {
+  switch (process.platform) {
+    case "darwin":
+      return path.join(
+        os.homedir(),
+        "Library",
+        "Application Support",
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    case "win32":
+      return path.join(
+        process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"),
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    case "linux":
+      return path.join(
+        os.homedir(),
+        ".config",
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  const content = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function writeJsonFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function getMcpServerEntry(apiKey, baseUrl) {
+  const env = { MINDGRAPH_API_KEY: apiKey };
+  if (baseUrl) env.MINDGRAPH_BASE_URL = baseUrl;
+  return {
+    command: "npx",
+    args: ["-y", "mindgraph-mcp"],
+    env
+  };
+}
+function installClaudeDesktop(apiKey, baseUrl) {
+  const configPath = getClaudeDesktopConfigPath();
+  console.log(`Claude Desktop config: ${configPath}`);
+  const config = readJsonFile(configPath);
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  const servers = config.mcpServers;
+  const isUpdate = "mindgraph" in servers;
+  servers.mindgraph = getMcpServerEntry(apiKey, baseUrl);
+  writeJsonFile(configPath, config);
+  if (isUpdate) {
+    console.log("Updated MindGraph MCP server in Claude Desktop config.");
+  } else {
+    console.log("Added MindGraph MCP server to Claude Desktop config.");
+  }
+  console.log("Restart Claude Desktop to activate.");
+}
+function installClaudeCode(apiKey, baseUrl) {
+  const envArgs = [`--env`, `MINDGRAPH_API_KEY=${apiKey}`];
+  if (baseUrl) {
+    envArgs.push("--env", `MINDGRAPH_BASE_URL=${baseUrl}`);
+  }
+  try {
+    (0, import_child_process.execSync)(
+      [
+        "claude",
+        "mcp",
+        "add",
+        "mindgraph",
+        ...envArgs,
+        "--",
+        "npx",
+        "-y",
+        "mindgraph-mcp"
+      ].join(" "),
+      { stdio: "inherit" }
+    );
+    console.log("Added MindGraph MCP server to Claude Code.");
+  } catch {
+    console.error(
+      "Failed to run 'claude mcp add'. Is Claude Code CLI installed?"
+    );
+    console.error("Install it from: https://claude.ai/code");
+    process.exit(1);
+  }
+}
+function uninstallClaudeDesktop() {
+  const configPath = getClaudeDesktopConfigPath();
+  if (!fs.existsSync(configPath)) {
+    console.log("Claude Desktop config not found. Nothing to remove.");
+    return;
+  }
+  const config = readJsonFile(configPath);
+  const servers = config.mcpServers;
+  if (!servers || !("mindgraph" in servers)) {
+    console.log("MindGraph not found in Claude Desktop config.");
+    return;
+  }
+  delete servers.mindgraph;
+  writeJsonFile(configPath, config);
+  console.log("Removed MindGraph from Claude Desktop config.");
+  console.log("Restart Claude Desktop to apply.");
+}
+function uninstallClaudeCode() {
+  try {
+    (0, import_child_process.execSync)("claude mcp remove mindgraph", { stdio: "inherit" });
+    console.log("Removed MindGraph MCP server from Claude Code.");
+  } catch {
+    console.error("Failed to run 'claude mcp remove'.");
+  }
+}
+function printStatus() {
+  const desktopPath = getClaudeDesktopConfigPath();
+  if (fs.existsSync(desktopPath)) {
+    const config = readJsonFile(desktopPath);
+    const servers = config.mcpServers;
+    if (servers && "mindgraph" in servers) {
+      console.log("Claude Desktop: installed");
+    } else {
+      console.log("Claude Desktop: not installed");
+    }
+  } else {
+    console.log("Claude Desktop: config not found");
+  }
+  console.log(
+    `MINDGRAPH_API_KEY: ${process.env.MINDGRAPH_API_KEY ? "set" : "not set"}`
+  );
+  console.log(
+    `MINDGRAPH_BASE_URL: ${process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud (default)"}`
+  );
+}
+function printUsage() {
+  console.log(`
+mindgraph-mcp \u2014 MCP server for MindGraph knowledge graphs
+
+USAGE:
+  mindgraph-mcp                  Start the MCP server (stdio transport)
+  mindgraph-mcp init             Interactive setup for Claude Desktop
+  mindgraph-mcp install          Install into Claude Desktop config
+  mindgraph-mcp install-code     Install into Claude Code
+  mindgraph-mcp uninstall        Remove from Claude Desktop config
+  mindgraph-mcp uninstall-code   Remove from Claude Code
+  mindgraph-mcp status           Show installation status
+
+OPTIONS:
+  --api-key <key>     MindGraph API key (or set MINDGRAPH_API_KEY env var)
+  --base-url <url>    Custom API base URL (default: https://api.mindgraph.cloud)
+  --help, -h          Show this help message
+
+EXAMPLES:
+  # Interactive setup
+  npx mindgraph-mcp init
+
+  # Install with API key
+  npx mindgraph-mcp install --api-key mg_your_key_here
+
+  # Install into Claude Code
+  npx mindgraph-mcp install-code --api-key mg_your_key_here
+
+Get your API key at: https://mindgraph.cloud/dashboard/keys
+`);
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let command = "serve";
+  let apiKey = process.env.MINDGRAPH_API_KEY;
+  let baseUrl = process.env.MINDGRAPH_BASE_URL;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--api-key":
+        apiKey = args[++i];
+        break;
+      case "--base-url":
+        baseUrl = args[++i];
+        break;
+      case "--help":
+      case "-h":
+        command = "help";
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          command = arg;
+        }
+        break;
+    }
+  }
+  return { command, apiKey, baseUrl };
+}
+var DASHBOARD_URL = process.env.MINDGRAPH_DASHBOARD_URL || "https://mindgraph.cloud";
+var POLL_INTERVAL = 2e3;
+var POLL_TIMEOUT = 10 * 60 * 1e3;
+function generateCode() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function openBrowser(url) {
+  try {
+    switch (process.platform) {
+      case "darwin":
+        (0, import_child_process.execSync)(`open "${url}"`);
+        break;
+      case "win32":
+        (0, import_child_process.execSync)(`start "" "${url}"`);
+        break;
+      case "linux":
+        (0, import_child_process.execSync)(`xdg-open "${url}"`);
+        break;
+    }
+  } catch {
+  }
+}
+async function pollForKey(code) {
+  const pollUrl = `${DASHBOARD_URL}/api/connect?code=${code}`;
+  const deadline = Date.now() + POLL_TIMEOUT;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(pollUrl);
+      const data = await res.json();
+      if (data.status === "authorized" && data.api_key) {
+        return data.api_key;
+      }
+      if (data.status === "expired") {
+        throw new Error("Session expired. Please try again.");
+      }
+      if (data.status === "claimed") {
+        throw new Error("Session already used. Please try again.");
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("Session")) throw e;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+  }
+  throw new Error("Timed out waiting for authorization.");
+}
+async function interactiveInit(baseUrl) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+  console.log("\nMindGraph MCP Server Setup\n");
+  console.log("  1. Sign in via browser (recommended)");
+  console.log("  2. Enter API key manually");
+  console.log("");
+  const method = await ask("Choice (1/2): ");
+  let apiKey;
+  if (method.trim() === "2") {
+    apiKey = await ask(
+      "\nEnter your MindGraph API key (from mindgraph.cloud/dashboard/keys): "
+    );
+    if (!apiKey || !apiKey.startsWith("mg_")) {
+      console.error('Invalid API key. Keys start with "mg_".');
+      rl.close();
+      process.exit(1);
+    }
+  } else {
+    const code = generateCode();
+    const authUrl = `${DASHBOARD_URL}/dashboard/connect?code=${code}`;
+    console.log("\nOpening browser to authorize...\n");
+    console.log(`  ${authUrl}
+`);
+    console.log("If the browser didn't open, copy the URL above and paste it in your browser.");
+    console.log("Waiting for authorization...\n");
+    openBrowser(authUrl);
+    try {
+      apiKey = await pollForKey(code);
+      console.log("Authorization received!\n");
+    } catch (e) {
+      console.error(e instanceof Error ? e.message : "Authorization failed.");
+      rl.close();
+      process.exit(1);
+    }
+  }
+  console.log("Where do you want to install?\n");
+  console.log("  1. Claude Desktop");
+  console.log("  2. Claude Code");
+  console.log("  3. Both");
+  console.log("");
+  const choice = await ask("Choice (1/2/3): ");
+  rl.close();
+  switch (choice.trim()) {
+    case "1":
+      installClaudeDesktop(apiKey, baseUrl);
+      break;
+    case "2":
+      installClaudeCode(apiKey, baseUrl);
+      break;
+    case "3":
+      installClaudeDesktop(apiKey, baseUrl);
+      installClaudeCode(apiKey, baseUrl);
+      break;
+    default:
+      console.error("Invalid choice.");
+      process.exit(1);
+  }
+  console.log("\nDone! Your knowledge graph is now connected.");
+}
+async function main2() {
+  const { command, apiKey, baseUrl } = parseArgs(process.argv);
+  switch (command) {
+    case "help":
+      printUsage();
+      break;
+    case "init":
+      await interactiveInit(baseUrl);
+      break;
+    case "install":
+      if (!apiKey) {
+        console.error(
+          "API key required. Use --api-key or set MINDGRAPH_API_KEY."
+        );
+        process.exit(1);
+      }
+      installClaudeDesktop(apiKey, baseUrl);
+      break;
+    case "install-code":
+      if (!apiKey) {
+        console.error(
+          "API key required. Use --api-key or set MINDGRAPH_API_KEY."
+        );
+        process.exit(1);
+      }
+      installClaudeCode(apiKey, baseUrl);
+      break;
+    case "uninstall":
+      uninstallClaudeDesktop();
+      break;
+    case "uninstall-code":
+      uninstallClaudeCode();
+      break;
+    case "status":
+      printStatus();
+      break;
+    case "serve": {
+      await Promise.resolve().then(() => (init_src(), src_exports));
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+}
+main2().catch((error) => {
+  console.error("Error:", error.message || error);
+  process.exit(1);
+});