graph.do 0.1.0

package/dist/chunk-SOVFPCTE.js

@@ -0,0 +1,647 @@
+// src/types.ts
+import { z } from "zod";
+var EntitySchema = z.object({
+  name: z.string().describe("Unique identifier for the entity"),
+  entityType: z.string().describe("Type classification of the entity"),
+  observations: z.array(z.string()).describe("Array of atomic facts about the entity")
+});
+var RelationSchema = z.object({
+  from: z.string().describe("Source entity name"),
+  to: z.string().describe("Target entity name"),
+  relationType: z.string().describe("Type of relationship (active voice)")
+});
+var KnowledgeGraphSchema = z.object({
+  entities: z.array(EntitySchema),
+  relations: z.array(RelationSchema)
+});
+var CreateEntitiesInputSchema = z.object({
+  entities: z.array(EntitySchema).describe("Array of entities to create")
+});
+var CreateRelationsInputSchema = z.object({
+  relations: z.array(RelationSchema).describe("Array of relations to create")
+});
+var AddObservationsInputSchema = z.object({
+  observations: z.array(
+    z.object({
+      entityName: z.string().describe("Name of the entity to add observations to"),
+      contents: z.array(z.string()).describe("Array of observations to add")
+    })
+  ).describe("Array of observation additions")
+});
+var DeleteEntitiesInputSchema = z.object({
+  entityNames: z.array(z.string()).describe("Array of entity names to delete")
+});
+var DeleteObservationsInputSchema = z.object({
+  deletions: z.array(
+    z.object({
+      entityName: z.string().describe("Name of the entity"),
+      observations: z.array(z.string()).describe("Observations to remove")
+    })
+  ).describe("Array of observation deletions")
+});
+var DeleteRelationsInputSchema = z.object({
+  relations: z.array(RelationSchema).describe("Array of relations to delete")
+});
+var SearchNodesInputSchema = z.object({
+  query: z.string().describe("Search query to match against entity names, types, and observations")
+});
+var OpenNodesInputSchema = z.object({
+  names: z.array(z.string()).describe("Array of entity names to retrieve")
+});
+
+// src/mcp/server.ts
+var McpErrorCode = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+function createGraphMcpServer(config) {
+  const { name = "graph.do", version = "0.1.0", graphManager } = config;
+  const tools = [
+    {
+      name: "create_entities",
+      description: "Create multiple new entities in the knowledge graph. Entities are nodes with a unique name, type, and observations.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          entities: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string", description: "Unique identifier for the entity" },
+                entityType: { type: "string", description: "Type classification of the entity" },
+                observations: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Array of atomic facts about the entity"
+                }
+              },
+              required: ["name", "entityType", "observations"]
+            },
+            description: "Array of entities to create"
+          }
+        },
+        required: ["entities"]
+      }
+    },
+    {
+      name: "create_relations",
+      description: "Create multiple new relations between entities. Relations are directed edges with a type.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          relations: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                from: { type: "string", description: "Source entity name" },
+                to: { type: "string", description: "Target entity name" },
+                relationType: {
+                  type: "string",
+                  description: "Type of relationship (active voice)"
+                }
+              },
+              required: ["from", "to", "relationType"]
+            },
+            description: "Array of relations to create"
+          }
+        },
+        required: ["relations"]
+      }
+    },
+    {
+      name: "add_observations",
+      description: "Add new observations to existing entities. Observations are atomic facts about an entity.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          observations: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                entityName: {
+                  type: "string",
+                  description: "Name of the entity to add observations to"
+                },
+                contents: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Array of observations to add"
+                }
+              },
+              required: ["entityName", "contents"]
+            },
+            description: "Array of observation additions"
+          }
+        },
+        required: ["observations"]
+      }
+    },
+    {
+      name: "delete_entities",
+      description: "Delete multiple entities and their relations from the knowledge graph by name.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          entityNames: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of entity names to delete"
+          }
+        },
+        required: ["entityNames"]
+      }
+    },
+    {
+      name: "delete_observations",
+      description: "Delete specific observations from entities.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          deletions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                entityName: { type: "string", description: "Name of the entity" },
+                observations: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Observations to remove"
+                }
+              },
+              required: ["entityName", "observations"]
+            },
+            description: "Array of observation deletions"
+          }
+        },
+        required: ["deletions"]
+      }
+    },
+    {
+      name: "delete_relations",
+      description: "Delete specific relations from the knowledge graph.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          relations: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                from: { type: "string", description: "Source entity name" },
+                to: { type: "string", description: "Target entity name" },
+                relationType: { type: "string", description: "Type of relationship" }
+              },
+              required: ["from", "to", "relationType"]
+            },
+            description: "Array of relations to delete"
+          }
+        },
+        required: ["relations"]
+      }
+    },
+    {
+      name: "read_graph",
+      description: "Read the entire knowledge graph including all entities and relations.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "search_nodes",
+      description: "Search for nodes in the knowledge graph by matching names, types, or observations.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query to match against entity names, types, and observations"
+          }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "open_nodes",
+      description: "Open specific nodes by name and retrieve them with their inter-relations.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          names: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of entity names to retrieve"
+          }
+        },
+        required: ["names"]
+      }
+    }
+  ];
+  const toolHandlers = {
+    create_entities: async (input) => {
+      const { entities } = CreateEntitiesInputSchema.parse(input);
+      const created = await graphManager.createEntities(entities);
+      return formatGraphResponse(created, `Created ${created.length} entities`);
+    },
+    create_relations: async (input) => {
+      const { relations } = CreateRelationsInputSchema.parse(input);
+      const created = await graphManager.createRelations(relations);
+      return formatGraphResponse(created, `Created ${created.length} relations`);
+    },
+    add_observations: async (input) => {
+      const { observations } = AddObservationsInputSchema.parse(input);
+      const results = await graphManager.addObservations(observations);
+      return formatGraphResponse(results, "Observations added");
+    },
+    delete_entities: async (input) => {
+      const { entityNames } = DeleteEntitiesInputSchema.parse(input);
+      const result = await graphManager.deleteEntities(entityNames);
+      return {
+        content: [{ type: "text", text: result.message }]
+      };
+    },
+    delete_observations: async (input) => {
+      const { deletions } = DeleteObservationsInputSchema.parse(input);
+      const result = await graphManager.deleteObservations(deletions);
+      return {
+        content: [{ type: "text", text: result.message }]
+      };
+    },
+    delete_relations: async (input) => {
+      const { relations } = DeleteRelationsInputSchema.parse(input);
+      const result = await graphManager.deleteRelations(relations);
+      return {
+        content: [{ type: "text", text: result.message }]
+      };
+    },
+    read_graph: async () => {
+      const graph = await graphManager.readGraph();
+      return formatGraphResponse(graph, `Graph contains ${graph.entities.length} entities and ${graph.relations.length} relations`);
+    },
+    search_nodes: async (input) => {
+      const { query } = SearchNodesInputSchema.parse(input);
+      const graph = await graphManager.searchNodes(query);
+      return formatGraphResponse(graph, `Found ${graph.entities.length} matching entities`);
+    },
+    open_nodes: async (input) => {
+      const { names } = OpenNodesInputSchema.parse(input);
+      const graph = await graphManager.openNodes(names);
+      return formatGraphResponse(graph, `Opened ${graph.entities.length} entities`);
+    }
+  };
+  function formatGraphResponse(data, summary) {
+    return {
+      content: [
+        { type: "text", text: summary },
+        {
+          type: "resource",
+          resource: {
+            uri: "graph://result",
+            mimeType: "application/json",
+            text: JSON.stringify(data, null, 2)
+          }
+        }
+      ]
+    };
+  }
+  async function handleRequest(request) {
+    const { id, method, params } = request;
+    try {
+      switch (method) {
+        case "initialize":
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              protocolVersion: "2024-11-05",
+              capabilities: {
+                tools: {}
+              },
+              serverInfo: {
+                name,
+                version
+              }
+            }
+          };
+        case "notifications/initialized":
+          return { jsonrpc: "2.0", id, result: {} };
+        case "tools/list":
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: { tools }
+          };
+        case "tools/call": {
+          const toolName = params?.name;
+          const toolInput = params?.arguments ?? {};
+          const handler = toolHandlers[toolName];
+          if (!handler) {
+            return {
+              jsonrpc: "2.0",
+              id,
+              error: {
+                code: McpErrorCode.METHOD_NOT_FOUND,
+                message: `Unknown tool: ${toolName}`
+              }
+            };
+          }
+          try {
+            const result = await handler(toolInput);
+            return { jsonrpc: "2.0", id, result };
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                content: [{ type: "text", text: `Error: ${error.message}` }],
+                isError: true
+              }
+            };
+          }
+        }
+        case "ping":
+          return { jsonrpc: "2.0", id, result: {} };
+        default:
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: McpErrorCode.METHOD_NOT_FOUND,
+              message: `Unknown method: ${method}`
+            }
+          };
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: McpErrorCode.INTERNAL_ERROR,
+          message: error.message
+        }
+      };
+    }
+  }
+  return {
+    name,
+    version,
+    tools,
+    handleRequest,
+    graphManager
+  };
+}
+
+// src/mcp/stdio-transport.ts
+async function runStdioTransport(server) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const stderr = process.stderr;
+  stdin.setEncoding("utf8");
+  let buffer = "";
+  stderr.write(`${server.name} v${server.version} MCP server started (stdio)
+`);
+  stdin.on("data", async (chunk) => {
+    buffer += chunk;
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) break;
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (!line) continue;
+      try {
+        const request = JSON.parse(line);
+        const response = await server.handleRequest(request);
+        stdout.write(JSON.stringify(response) + "\n");
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: -32700,
+            message: `Parse error: ${error.message}`
+          }
+        };
+        stdout.write(JSON.stringify(errorResponse) + "\n");
+      }
+    }
+  });
+  stdin.on("end", () => {
+    stderr.write("stdin closed, shutting down\n");
+    process.exit(0);
+  });
+  stdin.on("error", (err) => {
+    stderr.write(`stdin error: ${err.message}
+`);
+    process.exit(1);
+  });
+  await new Promise(() => {
+  });
+}
+function createStdioClient(server) {
+  let requestId = 0;
+  async function call(method, params) {
+    const request = {
+      jsonrpc: "2.0",
+      id: ++requestId,
+      method,
+      params
+    };
+    const response = await server.handleRequest(request);
+    if (response.error) {
+      throw new Error(`MCP Error ${response.error.code}: ${response.error.message}`);
+    }
+    return response.result;
+  }
+  return {
+    initialize: () => call("initialize"),
+    listTools: () => call("tools/list"),
+    callTool: (name, args) => call("tools/call", { name, arguments: args }),
+    ping: () => call("ping")
+  };
+}
+
+// src/mcp/http-transport.ts
+function createHttpTransport(config) {
+  const { server } = config;
+  async function handleRequest(request) {
+    const url = new URL(request.url);
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type"
+    };
+    if (request.method === "OPTIONS") {
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+    if (request.method === "GET" && (url.pathname === "/mcp" || url.pathname === "/mcp/")) {
+      const initResponse = await server.handleRequest({
+        jsonrpc: "2.0",
+        id: "info",
+        method: "initialize"
+      });
+      return new Response(JSON.stringify(initResponse.result, null, 2), {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders
+        }
+      });
+    }
+    if (request.method === "GET" && url.pathname === "/mcp/tools") {
+      const toolsResponse = await server.handleRequest({
+        jsonrpc: "2.0",
+        id: "tools",
+        method: "tools/list"
+      });
+      return new Response(JSON.stringify(toolsResponse.result, null, 2), {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders
+        }
+      });
+    }
+    if (request.method === "POST" && (url.pathname === "/mcp" || url.pathname === "/mcp/")) {
+      try {
+        const body = await request.json();
+        if (Array.isArray(body)) {
+          const responses = await Promise.all(
+            body.map((req) => server.handleRequest(req))
+          );
+          return new Response(JSON.stringify(responses), {
+            headers: {
+              "Content-Type": "application/json",
+              ...corsHeaders
+            }
+          });
+        }
+        const response = await server.handleRequest(body);
+        return new Response(JSON.stringify(response), {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders
+          }
+        });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: -32700,
+            message: `Parse error: ${error.message}`
+          }
+        };
+        return new Response(JSON.stringify(errorResponse), {
+          status: 400,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders
+          }
+        });
+      }
+    }
+    const toolMatch = url.pathname.match(/^\/mcp\/tools\/([^/]+)$/);
+    if (request.method === "POST" && toolMatch) {
+      const toolName = toolMatch[1];
+      try {
+        const args = request.headers.get("content-length") !== "0" ? await request.json() : {};
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: "tool-call",
+          method: "tools/call",
+          params: { name: toolName, arguments: args }
+        });
+        return new Response(JSON.stringify(response.result ?? response.error), {
+          status: response.error ? 400 : 200,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders
+          }
+        });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return new Response(
+          JSON.stringify({
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true
+          }),
+          {
+            status: 400,
+            headers: {
+              "Content-Type": "application/json",
+              ...corsHeaders
+            }
+          }
+        );
+      }
+    }
+    return new Response("Not Found", { status: 404, headers: corsHeaders });
+  }
+  return { handleRequest };
+}
+function createSseTransport(config) {
+  const { server } = config;
+  function handleSse(request) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify({ type: "connected", server: server.name })}
+
+`)
+        );
+        const pingInterval = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "ping" })}
+
+`));
+          } catch {
+            clearInterval(pingInterval);
+          }
+        }, 3e4);
+        request.signal.addEventListener("abort", () => {
+          clearInterval(pingInterval);
+          controller.close();
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+  return { handleSse };
+}
+
+export {
+  EntitySchema,
+  RelationSchema,
+  KnowledgeGraphSchema,
+  CreateEntitiesInputSchema,
+  CreateRelationsInputSchema,
+  AddObservationsInputSchema,
+  DeleteEntitiesInputSchema,
+  DeleteObservationsInputSchema,
+  DeleteRelationsInputSchema,
+  SearchNodesInputSchema,
+  OpenNodesInputSchema,
+  createGraphMcpServer,
+  runStdioTransport,
+  createStdioClient,
+  createHttpTransport,
+  createSseTransport
+};
+//# sourceMappingURL=chunk-SOVFPCTE.js.map