@modudraft/mcp 0.1.1 → 0.2.0

package/dist/index.js

@@ -14599,7 +14599,11 @@ var archetypes_default = {
         suggestions: ["10GB", "100GB", "1TB", "10TB"]
       },
       { key: "indexes", label: "Indexes", type: "text" },
-      { key: "connection-pool", label: "Connection Pool", type: "number" }
+      { key: "connection-pool", label: "Connection Pool", type: "number" },
+      { key: "database-name", label: "Database Name", type: "text" },
+      { key: "host", label: "Host", type: "text" },
+      { key: "port", label: "Port", type: "number" },
+      { key: "schema", label: "Schema", type: "text" }
     ]
   },
   queue: {
@@ -14675,7 +14679,14 @@ var archetypes_default = {
         label: "CPU",
         type: "text",
         suggestions: ["0.25 vCPU", "1 vCPU", "4 vCPU", "16 vCPU"]
-      }
+      },
+      {
+        key: "region",
+        label: "Region",
+        type: "text",
+        suggestions: ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"]
+      },
+      { key: "hostname", label: "Hostname", type: "text" }
     ]
   },
   cache: {
@@ -14713,7 +14724,9 @@ var archetypes_default = {
         label: "Size",
         type: "text",
         suggestions: ["512MB", "2GB", "8GB", "64GB"]
-      }
+      },
+      { key: "host", label: "Host", type: "text" },
+      { key: "port", label: "Port", type: "number" }
     ]
   },
   gateway: {
@@ -14798,6 +14811,13 @@ var archetypes_default = {
         label: "Region Replication",
         type: "enum",
         options: ["single-region", "multi-region"]
+      },
+      { key: "bucket-name", label: "Bucket Name", type: "text" },
+      {
+        key: "region",
+        label: "Region",
+        type: "text",
+        suggestions: ["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"]
       }
     ]
   },
@@ -16187,6 +16207,18 @@ var tools_default = {
     iconSlug: "fluentbit",
     brandColor: "#49BDA5"
   },
+  "elastic-apm": {
+    archetype: "observability",
+    label: "Elastic APM",
+    iconSlug: "elasticstack",
+    brandColor: "#005571"
+  },
+  logstash: {
+    archetype: "observability",
+    label: "Logstash",
+    iconSlug: "logstash",
+    brandColor: "#005571"
+  },
   digitalocean: {
     archetype: "compute",
     label: "DigitalOcean",
@@ -18354,9 +18386,114 @@ function importDiagram(json2) {
 }
 
 // src/tools.ts
+var DESCRIPTOR_WORDS = /* @__PURE__ */ new Set([
+  "bucket",
+  "cluster",
+  "database",
+  "db",
+  "server",
+  "service",
+  "cache",
+  "queue",
+  "store",
+  "storage",
+  "topic",
+  "stream",
+  "instance",
+  "container",
+  "pod",
+  "node",
+  "system",
+  "platform",
+  "layer",
+  "tier",
+  "component",
+  "infrastructure",
+  "provider",
+  "engine"
+]);
+var ALIASES = {
+  postgres: "postgresql",
+  pg: "postgresql",
+  mongo: "mongodb",
+  k8s: "kubernetes",
+  kube: "kubernetes",
+  rabbit: "rabbitmq",
+  otel: "opentelemetry",
+  elasticapm: "elastic-apm",
+  "elastic-apm": "elastic-apm",
+  elk: "kibana",
+  mssql: "sqlserver",
+  "sql-server": "sqlserver",
+  "sql server": "sqlserver",
+  aurora: "aurora",
+  "cloud sql": "cloudsql",
+  "big table": "bigtable",
+  cosmos: "cosmosdb",
+  "cosmos db": "cosmosdb",
+  dynamo: "dynamodb",
+  "dynamo db": "dynamodb",
+  redis: "redis",
+  "aws s3": "s3",
+  "s3 bucket": "s3",
+  "google cloud storage": "gcs",
+  "gcs bucket": "gcs",
+  "azure blob": "azureblob",
+  "azure blob storage": "azureblob",
+  lambda: "lambda",
+  "cloud functions": "cloudfunctions",
+  "cloud run": "cloudrun",
+  "github actions": "githubactions",
+  "google gemini": "googlegemini",
+  "open ai": "openai",
+  "hugging face": "huggingface"
+};
+function tryResolveByName(name) {
+  const slug = name.replace(/[^a-z0-9]/g, "");
+  const aliasKey = ALIASES[slug] ?? ALIASES[name];
+  if (aliasKey && tools[aliasKey]) {
+    return { archetype: tools[aliasKey].archetype, toolKey: aliasKey };
+  }
+  if (tools[slug]) return { archetype: tools[slug].archetype, toolKey: slug };
+  for (const [key, tool] of Object.entries(tools)) {
+    if (tool.label.toLowerCase() === name) return { archetype: tool.archetype, toolKey: key };
+  }
+  return null;
+}
+function resolveEntity(rawName) {
+  const lower = rawName.toLowerCase().trim();
+  const direct = tryResolveByName(lower);
+  if (direct) return direct;
+  const stripped = lower.split(/\s+/).filter((w2) => !DESCRIPTOR_WORDS.has(w2)).join(" ").trim();
+  if (stripped && stripped !== lower) {
+    const fromStripped = tryResolveByName(stripped);
+    if (fromStripped) return fromStripped;
+  }
+  for (const word of lower.split(/\s+/)) {
+    if (word.length < 2) continue;
+    const m = tryResolveByName(word);
+    if (m) return m;
+  }
+  for (const [key, tool] of Object.entries(tools)) {
+    const tLabel = tool.label.toLowerCase();
+    if (tLabel.length > 3 && lower.includes(tLabel)) {
+      return { archetype: tool.archetype, toolKey: key };
+    }
+  }
+  const archSlug = lower.replace(/[^a-z0-9]/g, "");
+  if (archetypes[archSlug]) {
+    return { archetype: archSlug, toolKey: archetypes[archSlug].defaultTool };
+  }
+  for (const [key, arch] of Object.entries(archetypes)) {
+    if (arch.label.toLowerCase() === lower) {
+      return { archetype: key, toolKey: arch.defaultTool };
+    }
+  }
+  return null;
+}
 var getDiagram = {
   name: "get_diagram",
-  description: "Return the current diagram state: all nodes and edges with their properties.",
+  description: "Return the current diagram state: all nodes and edges with their properties, including any metadata.",
   inputSchema: { type: "object", properties: {} },
   handler: () => {
     const { nodes, edges, title } = getState();
@@ -18364,12 +18501,14 @@ var getDiagram = {
       title,
       nodeCount: nodes.length,
       edgeCount: edges.length,
-      nodes: nodes.map((n) => ({
-        id: n.id,
-        type: n.type,
-        position: n.position,
-        data: n.data
-      })),
+      nodes: nodes.map((n) => {
+        const base = { id: n.id, type: n.type, position: n.position, data: n.data };
+        if (n.type === "sysNode") {
+          const d = n.data;
+          return { ...base, metadata: d.customProperties ?? {} };
+        }
+        return base;
+      }),
       edges: edges.map((e) => ({
         id: e.id,
         source: e.source,
@@ -18381,14 +18520,17 @@ var getDiagram = {
 };
 var addNodeTool = {
   name: "add_node",
-  description: "Add a system component node to the diagram. Use list_archetypes to see valid archetypes, list_tools to see valid tools.",
+  description: "Add a system component node to the diagram. Prefer passing 'name' (e.g. 'Sentry', 'GCS bucket', 'Elastic APM', 'PostgreSQL') \u2014 the server will automatically resolve the correct archetype and tool. Use list_archetypes / list_tools if you need explicit control. Pass 'metadata' for structured properties like schema, port, host, region, etc. Use list_archetypes to see well-known attribute keys per archetype.",
   inputSchema: {
     type: "object",
-    required: ["archetype"],
     properties: {
+      name: {
+        type: "string",
+        description: "Natural name of the technology (e.g. 'Sentry', 'GCS bucket', 'Elastic APM', 'Redis cache', 'PostgreSQL'). Auto-resolves to the correct archetype and tool. Takes precedence over 'archetype'/'tool' when provided."
+      },
       archetype: {
         type: "string",
-        description: "Archetype key e.g. 'database', 'queue', 'compute'"
+        description: "Archetype key e.g. 'database', 'queue', 'compute'. Required if 'name' is not given."
       },
       tool: {
         type: "string",
@@ -18396,28 +18538,59 @@ var addNodeTool = {
       },
       label: {
         type: "string",
-        description: "Display label for the node. Defaults to the tool or archetype label."
+        description: "Display label. Defaults to the resolved tool's proper name (e.g. 'Google Cloud Storage')."
+      },
+      metadata: {
+        type: "object",
+        description: "Structured key-value metadata for this node. Use list_archetypes to see well-known keys (e.g. 'schema', 'host', 'port', 'database-name' for databases; 'region', 'hostname' for compute; 'bucket-name', 'region' for storage). Any string key is accepted.",
+        additionalProperties: { type: "string" }
       },
       x: { type: "number", description: "Canvas X position (default 0)" },
       y: { type: "number", description: "Canvas Y position (default 0)" }
     }
   },
   handler: (args) => {
-    const archetypeKey = String(args.archetype);
+    let archetypeKey;
+    let toolKey;
+    if (args.name) {
+      const resolved = resolveEntity(String(args.name));
+      if (!resolved) {
+        throw new Error(
+          `Could not resolve "${args.name}" to a known technology. Call list_tools or list_archetypes to browse available options, then pass 'archetype' and 'tool' explicitly.`
+        );
+      }
+      archetypeKey = resolved.archetype;
+      toolKey = args.tool ? String(args.tool) : resolved.toolKey;
+    } else if (args.archetype) {
+      archetypeKey = String(args.archetype);
+      const arch2 = getArchetype(archetypeKey);
+      if (!arch2) {
+        throw new Error(`Unknown archetype "${archetypeKey}". Call list_archetypes to see valid values.`);
+      }
+      toolKey = args.tool ? String(args.tool) : arch2.defaultTool;
+    } else {
+      throw new Error("Provide either 'name' (e.g. 'Sentry') or 'archetype'.");
+    }
     const arch = getArchetype(archetypeKey);
-    if (!arch) throw new Error(`Unknown archetype "${archetypeKey}". Call list_archetypes to see valid values.`);
-    const toolKey = args.tool ? String(args.tool) : arch.defaultTool;
+    if (!arch) throw new Error(`Unknown archetype "${archetypeKey}".`);
     const toolDef = getTool(toolKey);
     if (!toolDef) throw new Error(`Unknown tool "${toolKey}". Call list_tools to see valid values.`);
     const label = args.label ? String(args.label) : toolDef.label ?? arch.label;
+    const customProperties = args.metadata ? args.metadata : void 0;
     const node = {
       id: genId("node"),
       type: "sysNode",
       position: { x: Number(args.x ?? 0), y: Number(args.y ?? 0) },
-      data: { archetype: archetypeKey, concreteTool: toolKey, label }
+      data: { archetype: archetypeKey, concreteTool: toolKey, label, customProperties }
     };
     addNode(node);
-    return { id: node.id, type: node.type, data: node.data, position: node.position };
+    return {
+      id: node.id,
+      type: node.type,
+      data: node.data,
+      position: node.position,
+      metadata: customProperties ?? {}
+    };
   }
 };
 var addNoteTool = {
@@ -18487,7 +18660,7 @@ var addBoundaryTool = {
 };
 var updateNodeTool = {
   name: "update_node",
-  description: "Update a node's label, tool, or position.",
+  description: "Update a node's label, tool, position, or metadata.",
   inputSchema: {
     type: "object",
     required: ["id"],
@@ -18496,7 +18669,12 @@ var updateNodeTool = {
       label: { type: "string" },
       tool: { type: "string", description: "New tool key (sysNode only)" },
       x: { type: "number" },
-      y: { type: "number" }
+      y: { type: "number" },
+      metadata: {
+        type: "object",
+        description: "Metadata key-value pairs to merge into this node's properties. Pass an empty string value to delete a key. Existing keys not mentioned are preserved.",
+        additionalProperties: { type: "string" }
+      }
     }
   },
   handler: (args) => {
@@ -18517,12 +18695,64 @@ var updateNodeTool = {
         if (!getTool(String(args.tool))) throw new Error(`Unknown tool "${args.tool}"`);
         dataPatch.concreteTool = String(args.tool);
       }
+      if (args.metadata !== void 0) {
+        const existing = node.data.customProperties ?? {};
+        const incoming = args.metadata;
+        const merged = { ...existing };
+        for (const [k2, v2] of Object.entries(incoming)) {
+          if (v2 === "" || v2 === null) delete merged[k2];
+          else merged[k2] = String(v2);
+        }
+        dataPatch.customProperties = Object.keys(merged).length ? merged : void 0;
+      }
       if (Object.keys(dataPatch).length) patch.data = { ...node.data, ...dataPatch };
     } else if (args.label !== void 0) {
       patch.data = { ...node.data, text: String(args.label) };
     }
     const updated = updateNode(id, patch);
-    return { id: updated.id, data: updated.data, position: updated.position };
+    const updatedData = updated.data;
+    return {
+      id: updated.id,
+      data: updated.data,
+      position: updated.position,
+      metadata: updatedData.customProperties ?? {}
+    };
+  }
+};
+var setNodeMetadataTool = {
+  name: "set_node_metadata",
+  description: "Set, update, or delete individual metadata fields on a sysNode. Merges into existing metadata \u2014 unmentioned keys are preserved. Pass an empty string to delete a key. Use list_archetypes to see well-known attribute keys for each archetype (e.g. 'schema', 'host', 'port', 'database-name' for databases).",
+  inputSchema: {
+    type: "object",
+    required: ["id", "metadata"],
+    properties: {
+      id: { type: "string", description: "Node ID" },
+      metadata: {
+        type: "object",
+        description: "Key-value pairs to set. Empty string removes the key. Well-known keys per archetype: database \u2192 schema, host, port, database-name, replication, consistency; cache \u2192 host, port, eviction, ttl; compute \u2192 region, hostname, replicas, language; storage \u2192 bucket-name, region, class; observability \u2192 signal, retention, sampling.",
+        additionalProperties: { type: "string" }
+      }
+    }
+  },
+  handler: (args) => {
+    const id = String(args.id);
+    const node = getNode(id);
+    if (!node) throw new Error(`Node "${id}" not found`);
+    if (node.type !== "sysNode") {
+      throw new Error(`Metadata is only supported on sysNode nodes (type is "${node.type}")`);
+    }
+    const existing = node.data.customProperties ?? {};
+    const incoming = args.metadata;
+    const merged = { ...existing };
+    for (const [k2, v2] of Object.entries(incoming)) {
+      if (v2 === "" || v2 === null) delete merged[k2];
+      else merged[k2] = String(v2);
+    }
+    const customProperties = Object.keys(merged).length ? merged : void 0;
+    const updated = updateNode(id, {
+      data: { ...node.data, customProperties }
+    });
+    return { id: updated.id, metadata: updated.data.customProperties ?? {} };
   }
 };
 var deleteNodeTool = {
@@ -18654,12 +18884,19 @@ var layoutDiagramTool = {
 };
 var listArchetypes = {
   name: "list_archetypes",
-  description: "List all available node archetypes (database, queue, compute, etc.) with their default tools.",
+  description: "List all available node archetypes with their default tools and well-known metadata attributes. Use attribute keys with add_node/set_node_metadata to attach structured metadata.",
   inputSchema: { type: "object", properties: {} },
   handler: () => Object.entries(archetypes).map(([key, a]) => ({
     key,
     label: a.label,
-    defaultTool: a.defaultTool
+    defaultTool: a.defaultTool,
+    attributes: (a.attributes ?? []).map((attr) => ({
+      key: attr.key,
+      label: attr.label,
+      type: attr.type,
+      ...attr.type === "enum" ? { options: attr.options } : {},
+      ..."suggestions" in attr && attr.suggestions ? { suggestions: attr.suggestions } : {}
+    }))
   }))
 };
 var listTools = {
@@ -18670,7 +18907,7 @@ var listTools = {
     properties: {
       archetype: {
         type: "string",
-        description: "Filter by archetype key. Omit to list all 190+ tools."
+        description: "Filter by archetype key. Omit to list all tools."
       }
     }
   },
@@ -18692,6 +18929,7 @@ var ALL_TOOLS = [
   addNoteTool,
   addBoundaryTool,
   updateNodeTool,
+  setNodeMetadataTool,
   deleteNodeTool,
   addEdgeTool,
   deleteEdgeTool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modudraft/mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server for Modudraft — create and edit system-design diagrams via AI",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "devDependencies": {
-    "@modudraft/core": ">=0.1.5",
+    "@modudraft/core": ">=0.1.6",
     "@types/node": "^22.0.0",
     "tsup": "^8.5.0",
     "typescript": "~5.8.0"