@astramindapp/mcp-server 0.1.0 → 0.3.0

package/src/server.ts

@@ -1,457 +0,0 @@
-/**
- * MIND MCP Server
- *
- * Exposes the MIND knowledge graph as MCP tools that any LLM agent can use.
- * This is the universal AI memory layer.
- *
- * Tools:
- *   mind_query     — Semantic search across the knowledge graph
- *   mind_remember  — Store content to the graph (auto-categorized)
- *   mind_context   — Get structured always-loaded context (soul/user/rules)
- *   mind_life      — Read/write goals, projects, tasks
- *   mind_crm       — Read/write contacts and interactions
- *   mind_graph     — Get graph statistics and health
- */
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { MindClient } from "./mind-client.js";
-
-export function createMindMcpServer(client: MindClient): McpServer {
-  const server = new McpServer({
-    name: "mind",
-    version: "0.1.0",
-  });
-
-  // ─── mind_query ─────────────────────────────────────────
-  // Semantic search across the user's knowledge graph.
-  // Replaces flat MEMORY.md — returns only relevant memories.
-
-  server.tool(
-    "mind_query",
-    "Search your MIND knowledge graph. Returns AI-synthesized answer from your stored documents, entries, and thoughts. Use this BEFORE making decisions — MIND is your memory.",
-    {
-      query: z.string().describe("What to search for in your knowledge graph"),
-      mode: z
-        .enum(["mix", "graph", "vector"])
-        .optional()
-        .default("mix")
-        .describe("Search mode: mix (default, best results), graph (entity relationships), vector (semantic similarity)"),
-    },
-    async ({ query, mode }) => {
-      try {
-        const result = await client.query({ query, mode });
-        const text = [
-          result.response,
-          "",
-          `--- Sources: ${result.sources?.length ?? 0} | Credits used: ${result.credits_used} | Remaining: ${result.credits_remaining} ---`,
-        ];
-
-        if (result.sources?.length) {
-          text.push("");
-          for (const s of result.sources.slice(0, 5)) {
-            text.push(
-              `• ${s.title ?? "Untitled"} (score: ${s.relevance_score?.toFixed(2) ?? "N/A"})`
-            );
-          }
-        }
-
-        return { content: [{ type: "text" as const, text: text.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error querying MIND: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  // ─── mind_remember ──────────────────────────────────────
-  // Store content to the knowledge graph. Auto-categorized by type.
-  // Replaces manual memory file writes.
-
-  server.tool(
-    "mind_remember",
-    "Store something in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks.",
-    {
-      content: z.string().describe("What to remember — the actual content to store"),
-      type: z
-        .enum(["document", "entry", "thought"])
-        .optional()
-        .default("entry")
-        .describe(
-          "Storage type: document (long-form, structured — research, specs, strategies), entry (medium — observations, findings, action logs), thought (quick — fleeting ideas, one-liners)"
-        ),
-      title: z
-        .string()
-        .optional()
-        .describe("Title for documents and entries (auto-generated if omitted for thoughts)"),
-      tags: z
-        .array(z.string())
-        .optional()
-        .describe("Tags for categorization (e.g. ['strategy', 'competitor', 'learning'])"),
-      source: z
-        .string()
-        .optional()
-        .default("mcp-agent")
-        .describe("Source identifier (e.g. 'claude-code', 'openclaw', 'cursor')"),
-    },
-    async ({ content, type, title, tags, source }) => {
-      try {
-        let result: { id?: string; entry_id?: string; thought_id?: string; item_id?: string };
-        let storedAs: string;
-
-        switch (type) {
-          case "document":
-            result = await client.createDocument({
-              title: title ?? `Agent Document — ${new Date().toISOString().slice(0, 10)}`,
-              content,
-              source: source ?? "mcp-agent",
-              tags,
-            });
-            storedAs = "document";
-            break;
-
-          case "thought":
-            result = await client.createThought({ content });
-            storedAs = "thought";
-            break;
-
-          case "entry":
-          default:
-            result = await client.createEntry({
-              title,
-              content,
-              entry_type: "text",
-              tags,
-            });
-            storedAs = "entry";
-            break;
-        }
-
-        const id = result.id ?? result.entry_id ?? result.thought_id ?? "unknown";
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `✅ Stored to MIND as ${storedAs} (id: ${id})${title ? ` — "${title}"` : ""}`,
-            },
-          ],
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error storing to MIND: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  // ─── mind_context ───────────────────────────────────────
-  // Get structured always-loaded context.
-  // Equivalent to OpenClaw's SOUL.md + USER.md + AGENTS.md bootstrap injection,
-  // but backed by the knowledge graph.
-
-  server.tool(
-    "mind_context",
-    "Get your persistent context from MIND — identity, preferences, rules, and recent activity. Call this at the start of every session to know who you are, who the user is, and what matters right now.",
-    {
-      sections: z
-        .array(z.enum(["soul", "user", "rules", "priorities", "recent"]))
-        .optional()
-        .default(["soul", "user", "rules", "priorities", "recent"])
-        .describe(
-          "Which context sections to load: soul (identity/personality), user (who the user is), rules (operating constraints), priorities (current goals/tasks), recent (latest activity)"
-        ),
-    },
-    async ({ sections }) => {
-      try {
-        const results: string[] = [];
-
-        for (const section of sections) {
-          let query: string;
-          switch (section) {
-            case "soul":
-              query = "my identity, mission, personality, who I am, my role and purpose";
-              break;
-            case "user":
-              query = "user profile, preferences, timezone, communication style, who is the user";
-              break;
-            case "rules":
-              query = "operating rules, constraints, hard limits, things I must never do, safety rules";
-              break;
-            case "priorities":
-              query = "current priorities, active goals, top tasks, what to focus on right now";
-              break;
-            case "recent":
-              query = "most recent activity, what happened today, latest outcomes and decisions";
-              break;
-          }
-
-          const result = await client.query({ query, mode: "mix" });
-          results.push(`## ${section.toUpperCase()}\n\n${result.response}`);
-        }
-
-        return {
-          content: [{ type: "text" as const, text: results.join("\n\n---\n\n") }],
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error loading context from MIND: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  // ─── mind_life ──────────────────────────────────────────
-  // Read/write goals, projects, and tasks.
-
-  server.tool(
-    "mind_life",
-    "Manage goals, projects, and tasks in MIND Life. Use for tracking work, creating action items, updating progress, and completing tasks.",
-    {
-      action: z
-        .enum(["list", "create", "update", "complete", "delete"])
-        .describe("What to do: list (view items), create (new item), update (modify), complete (mark done), delete (remove)"),
-      title: z.string().optional().describe("Title for new items"),
-      description: z.string().optional().describe("Description for new items"),
-      status: z
-        .string()
-        .optional()
-        .describe("Status filter for list, or new status for update (e.g. action, someday, waiting, completed)"),
-      priority: z
-        .string()
-        .optional()
-        .describe("Priority: low, medium, high, urgent"),
-      due_date: z.string().optional().describe("Due date in YYYY-MM-DD format"),
-      item_id: z.string().optional().describe("Item ID for update/complete/delete actions"),
-    },
-    async ({ action, title, description, status, priority, due_date, item_id }) => {
-      try {
-        switch (action) {
-          case "list": {
-            const result = await client.listLifeItems(status);
-            const items = result.items ?? [];
-            if (items.length === 0) {
-              return { content: [{ type: "text" as const, text: "No life items found." }] };
-            }
-            const lines = items.map(
-              (i) =>
-                `• [${i.priority ?? "—"}] ${i.title} (status: ${i.status ?? "—"}${i.due_date ? `, due: ${i.due_date}` : ""}) — id: ${i.item_id}`
-            );
-            return { content: [{ type: "text" as const, text: lines.join("\n") }] };
-          }
-
-          case "create": {
-            if (!title) {
-              return {
-                content: [{ type: "text" as const, text: "Error: title is required to create a life item" }],
-                isError: true,
-              };
-            }
-            const result = await client.createLifeItem({
-              title,
-              description,
-              status: status ?? "action",
-              priority: priority ?? "medium",
-              due_date,
-            });
-            return {
-              content: [
-                {
-                  type: "text" as const,
-                  text: `✅ Created life item: "${result.title}" (id: ${result.item_id}, priority: ${result.priority}, due: ${result.due_date ?? "none"})`,
-                },
-              ],
-            };
-          }
-
-          case "update": {
-            if (!item_id) {
-              return {
-                content: [{ type: "text" as const, text: "Error: item_id is required for update" }],
-                isError: true,
-              };
-            }
-            const patch: Record<string, unknown> = {};
-            if (title) patch.title = title;
-            if (description) patch.description = description;
-            if (status) patch.status = status;
-            if (priority) patch.priority = priority;
-            if (due_date) patch.due_date = due_date;
-            const result = await client.updateLifeItem(item_id, patch);
-            return {
-              content: [{ type: "text" as const, text: `✅ Updated: "${result.title}" (status: ${result.status})` }],
-            };
-          }
-
-          case "complete": {
-            if (!item_id) {
-              return {
-                content: [{ type: "text" as const, text: "Error: item_id is required for complete" }],
-                isError: true,
-              };
-            }
-            const result = await client.updateLifeItem(item_id, { status: "completed" });
-            return {
-              content: [{ type: "text" as const, text: `✅ Completed: "${result.title}"` }],
-            };
-          }
-
-          case "delete": {
-            if (!item_id) {
-              return {
-                content: [{ type: "text" as const, text: "Error: item_id is required for delete" }],
-                isError: true,
-              };
-            }
-            await client.deleteLifeItem(item_id);
-            return {
-              content: [{ type: "text" as const, text: `✅ Deleted life item ${item_id}` }],
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error in mind_life: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  // ─── mind_crm ───────────────────────────────────────────
-  // Read/write contacts and interactions.
-
-  server.tool(
-    "mind_crm",
-    "Manage contacts and relationships in MIND CRM. Use for tracking people, companies, leads, and interaction history.",
-    {
-      action: z
-        .enum(["list", "create", "update"])
-        .describe("What to do: list contacts, create new contact, update existing"),
-      name: z.string().optional().describe("Contact name (required for create)"),
-      email: z.string().optional().describe("Contact email"),
-      company: z.string().optional().describe("Company/organization"),
-      type: z.string().optional().describe("Contact type: lead, prospect, partner, customer, personal"),
-      stage: z.string().optional().describe("Pipeline stage: new, qualified, proposal, closed, lost"),
-      source: z.string().optional().describe("How you found them"),
-      notes: z.string().optional().describe("Notes about this contact"),
-      contact_id: z.string().optional().describe("Contact ID for updates"),
-    },
-    async ({ action, name, email, company, type, stage, source, notes, contact_id }) => {
-      try {
-        switch (action) {
-          case "list": {
-            const result = await client.listContacts();
-            const contacts = result.contacts ?? [];
-            if (contacts.length === 0) {
-              return { content: [{ type: "text" as const, text: "No contacts found." }] };
-            }
-            const lines = contacts.map(
-              (c) =>
-                `• ${c.name}${c.company ? ` @ ${c.company}` : ""}${c.email ? ` (${c.email})` : ""} — ${c.type ?? "—"} / ${c.stage ?? "—"} — id: ${c.id ?? c.contact_id}`
-            );
-            return { content: [{ type: "text" as const, text: lines.join("\n") }] };
-          }
-
-          case "create": {
-            if (!name) {
-              return {
-                content: [{ type: "text" as const, text: "Error: name is required to create a contact" }],
-                isError: true,
-              };
-            }
-            const result = await client.createContact({
-              name,
-              email,
-              company,
-              type,
-              stage,
-              source,
-              notes,
-            });
-            return {
-              content: [
-                {
-                  type: "text" as const,
-                  text: `✅ Created contact: "${result.name}" (id: ${result.id ?? result.contact_id})`,
-                },
-              ],
-            };
-          }
-
-          case "update": {
-            if (!contact_id) {
-              return {
-                content: [{ type: "text" as const, text: "Error: contact_id is required for update" }],
-                isError: true,
-              };
-            }
-            const patch: Record<string, unknown> = {};
-            if (name) patch.name = name;
-            if (email) patch.email = email;
-            if (company) patch.company = company;
-            if (type) patch.type = type;
-            if (stage) patch.stage = stage;
-            if (notes) patch.notes = notes;
-            const result = await client.updateContact(contact_id, patch);
-            return {
-              content: [{ type: "text" as const, text: `✅ Updated contact: "${result.name}"` }],
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error in mind_crm: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  // ─── mind_graph ─────────────────────────────────────────
-  // Get graph statistics and health.
-
-  server.tool(
-    "mind_graph",
-    "Get MIND knowledge graph statistics — how many entities, relationships, documents, and entries exist. Use to check graph health and growth.",
-    {},
-    async () => {
-      try {
-        const [graph, profile] = await Promise.all([
-          client.graphInfo(),
-          client.credits().catch(() => null),
-        ]);
-
-        const lines = [
-          "📊 MIND Graph Status",
-          `• Entities: ${graph.total_entities}`,
-          `• Relationships: ${graph.total_relationships}`,
-          `• Storage: ${graph.storage_status?.status ?? "unknown"}`,
-        ];
-
-        if (graph.popular_labels?.length) {
-          const docCount = graph.popular_labels.reduce((sum, l) => sum + l.count, 0);
-          lines.push(`• Items in graph: ${docCount}`);
-        }
-
-        if (profile) {
-          lines.push(`• Credits: ${profile.credits_balance}/${profile.credits_limit}`);
-          lines.push(`• Tier: ${profile.tier}`);
-          lines.push(`• Documents: ${profile.documents_used}/${profile.documents_limit}`);
-        }
-
-        return { content: [{ type: "text" as const, text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text" as const, text: `Error getting graph info: ${err}` }],
-          isError: true,
-        };
-      }
-    }
-  );
-
-  return server;
-}