devtoolkit-mcp 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # devtoolkit-mcp
 
-25+ developer utilities as an MCP server for AI-assisted workflows. JSON repair, SQL formatting, hashing, encoding, UUID generation, regex testing, CSV transforms, subnet calculation, and more.
+26 developer utilities as an MCP server for AI-assisted workflows. JSON repair, SQL formatting, hashing, encoding, UUID generation, regex testing, CSV transforms, subnet calculation, diagram generation, and more.
 
 **No API keys. No network requests. Everything runs locally.**
 
@@ -91,7 +91,7 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 }
 ```
 
-## Available Tools (25)
+## Available Tools (26)
 
 ### Data Transform
 | Tool | Description |
@@ -104,6 +104,7 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 | `csv_transform` | Parse, filter, sort, aggregate, convert CSV data |
 | `yaml_json` | Convert between YAML and JSON |
 | `json_to_types` | Convert JSON to TypeScript interfaces, Zod schemas, or JSON Schema |
+| `generate_diagram` | Generate Mermaid flowcharts and sequence diagrams from plain English descriptions |
 
 ### Decode & Parse
 | Tool | Description |
@@ -182,6 +183,10 @@ Convert this JSON to TypeScript: {"id": 1, "name": "John", "tags": ["admin"]}
 Generate 20 mock users with id, name, email, salary as CSV, then filter salary > 60000
 ```
 
+```
+Draw diagram: User sends request to API Gateway, forwards to Auth Service, queries Postgres
+```
+
 ## Why MCP Tools vs Native AI?
 
 These tools provide capabilities that AI models **cannot do natively**:
@@ -196,6 +201,7 @@ These tools provide capabilities that AI models **cannot do natively**:
 | Date arithmetic | Often wrong | Millisecond exact |
 | CSV parsing (quoted fields) | Approximates | RFC-compliant |
 | Line-by-line diff | Misses changes | LCS algorithm |
+| Diagram generation | Approximates syntax | Valid Mermaid output |
 
 ## Requirements
 

package/dist/index.js

@@ -21025,24 +21025,24 @@ var McpServer = class {
       }
     });
     this.server.setRequestHandler(ListToolsRequestSchema, () => ({
-      tools: Object.entries(this._registeredTools).filter(([, tool26]) => tool26.enabled).map(([name, tool26]) => {
+      tools: Object.entries(this._registeredTools).filter(([, tool27]) => tool27.enabled).map(([name, tool27]) => {
         const toolDefinition = {
           name,
-          title: tool26.title,
-          description: tool26.description,
+          title: tool27.title,
+          description: tool27.description,
           inputSchema: (() => {
-            const obj = normalizeObjectSchema(tool26.inputSchema);
+            const obj = normalizeObjectSchema(tool27.inputSchema);
             return obj ? toJsonSchemaCompat(obj, {
               strictUnions: true,
               pipeStrategy: "input"
             }) : EMPTY_OBJECT_JSON_SCHEMA;
           })(),
-          annotations: tool26.annotations,
-          execution: tool26.execution,
-          _meta: tool26._meta
+          annotations: tool27.annotations,
+          execution: tool27.execution,
+          _meta: tool27._meta
         };
-        if (tool26.outputSchema) {
-          const obj = normalizeObjectSchema(tool26.outputSchema);
+        if (tool27.outputSchema) {
+          const obj = normalizeObjectSchema(tool27.outputSchema);
           if (obj) {
             toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
               strictUnions: true,
@@ -21055,16 +21055,16 @@ var McpServer = class {
     }));
     this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
       try {
-        const tool26 = this._registeredTools[request.params.name];
-        if (!tool26) {
+        const tool27 = this._registeredTools[request.params.name];
+        if (!tool27) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
         }
-        if (!tool26.enabled) {
+        if (!tool27.enabled) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
         }
         const isTaskRequest = !!request.params.task;
-        const taskSupport = tool26.execution?.taskSupport;
-        const isTaskHandler = "createTask" in tool26.handler;
+        const taskSupport = tool27.execution?.taskSupport;
+        const isTaskHandler = "createTask" in tool27.handler;
         if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
           throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
         }
@@ -21072,14 +21072,14 @@ var McpServer = class {
           throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
         }
         if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
-          return await this.handleAutomaticTaskPolling(tool26, request, extra);
+          return await this.handleAutomaticTaskPolling(tool27, request, extra);
         }
-        const args = await this.validateToolInput(tool26, request.params.arguments, request.params.name);
-        const result = await this.executeToolHandler(tool26, args, extra);
+        const args = await this.validateToolInput(tool27, request.params.arguments, request.params.name);
+        const result = await this.executeToolHandler(tool27, args, extra);
         if (isTaskRequest) {
           return result;
         }
-        await this.validateToolOutput(tool26, result, request.params.name);
+        await this.validateToolOutput(tool27, result, request.params.name);
         return result;
       } catch (error2) {
         if (error2 instanceof McpError) {
@@ -21112,12 +21112,12 @@ var McpServer = class {
   /**
    * Validates tool input arguments against the tool's input schema.
    */
-  async validateToolInput(tool26, args, toolName) {
-    if (!tool26.inputSchema) {
+  async validateToolInput(tool27, args, toolName) {
+    if (!tool27.inputSchema) {
       return void 0;
     }
-    const inputObj = normalizeObjectSchema(tool26.inputSchema);
-    const schemaToParse = inputObj ?? tool26.inputSchema;
+    const inputObj = normalizeObjectSchema(tool27.inputSchema);
+    const schemaToParse = inputObj ?? tool27.inputSchema;
     const parseResult = await safeParseAsync2(schemaToParse, args);
     if (!parseResult.success) {
       const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
@@ -21129,8 +21129,8 @@ var McpServer = class {
   /**
    * Validates tool output against the tool's output schema.
    */
-  async validateToolOutput(tool26, result, toolName) {
-    if (!tool26.outputSchema) {
+  async validateToolOutput(tool27, result, toolName) {
+    if (!tool27.outputSchema) {
       return;
     }
     if (!("content" in result)) {
@@ -21142,7 +21142,7 @@ var McpServer = class {
     if (!result.structuredContent) {
       throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
     }
-    const outputObj = normalizeObjectSchema(tool26.outputSchema);
+    const outputObj = normalizeObjectSchema(tool27.outputSchema);
     const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
@@ -21153,15 +21153,15 @@ var McpServer = class {
   /**
    * Executes a tool handler (either regular or task-based).
    */
-  async executeToolHandler(tool26, args, extra) {
-    const handler = tool26.handler;
+  async executeToolHandler(tool27, args, extra) {
+    const handler = tool27.handler;
     const isTaskHandler = "createTask" in handler;
     if (isTaskHandler) {
       if (!extra.taskStore) {
         throw new Error("No task store provided.");
       }
       const taskExtra = { ...extra, taskStore: extra.taskStore };
-      if (tool26.inputSchema) {
+      if (tool27.inputSchema) {
         const typedHandler = handler;
         return await Promise.resolve(typedHandler.createTask(args, taskExtra));
       } else {
@@ -21169,7 +21169,7 @@ var McpServer = class {
         return await Promise.resolve(typedHandler.createTask(taskExtra));
       }
     }
-    if (tool26.inputSchema) {
+    if (tool27.inputSchema) {
       const typedHandler = handler;
       return await Promise.resolve(typedHandler(args, extra));
     } else {
@@ -21180,12 +21180,12 @@ var McpServer = class {
   /**
    * Handles automatic task polling for tools with taskSupport 'optional'.
    */
-  async handleAutomaticTaskPolling(tool26, request, extra) {
+  async handleAutomaticTaskPolling(tool27, request, extra) {
     if (!extra.taskStore) {
       throw new Error("No task store provided for task-capable tool.");
     }
-    const args = await this.validateToolInput(tool26, request.params.arguments, request.params.name);
-    const handler = tool26.handler;
+    const args = await this.validateToolInput(tool27, request.params.arguments, request.params.name);
+    const handler = tool27.handler;
     const taskExtra = { ...extra, taskStore: extra.taskStore };
     const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : (
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -67522,10 +67522,10 @@ var DETECTORS = [
 function detectAll(input) {
   if (!input.trim()) return [];
   const results = [];
-  for (const { tool: tool26, label, detect } of DETECTORS) {
+  for (const { tool: tool27, label, detect } of DETECTORS) {
     const confidence = detect(input);
     if (confidence > 0) {
-      results.push({ tool: tool26, confidence, label });
+      results.push({ tool: tool27, confidence, label });
     }
   }
   results.sort((a2, b2) => b2.confidence - a2.confidence);
@@ -70401,6 +70401,319 @@ ${output}`
   }
 };
 
+// ../utils/diagramParser.ts
+var NODE_KEYWORDS = {
+  user: "user",
+  client: "client",
+  mobile: "client",
+  browser: "client",
+  app: "client",
+  frontend: "client",
+  api: "service",
+  server: "service",
+  service: "service",
+  worker: "service",
+  gateway: "service",
+  lambda: "service",
+  function: "service",
+  microservice: "service",
+  postgres: "database",
+  postgresql: "database",
+  mysql: "database",
+  mongo: "database",
+  mongodb: "database",
+  redis: "database",
+  database: "database",
+  db: "database",
+  dynamodb: "database",
+  sqs: "queue",
+  rabbitmq: "queue",
+  kafka: "queue",
+  queue: "queue",
+  pubsub: "queue",
+  sns: "queue",
+  s3: "storage",
+  storage: "storage",
+  bucket: "storage",
+  blob: "storage",
+  cdn: "external",
+  stripe: "external",
+  twilio: "external",
+  email: "external",
+  webhook: "external",
+  external: "external"
+};
+function inferNodeType(name) {
+  const lower = name.toLowerCase();
+  for (const [keyword, type] of Object.entries(NODE_KEYWORDS)) {
+    if (lower.includes(keyword)) return type;
+  }
+  return "service";
+}
+function toId(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+}
+function parseSentences(input) {
+  return input.split(/[.!?\n]+/).map((s2) => s2.trim()).filter((s2) => s2.length > 0);
+}
+function extractEntitiesAndActions(input) {
+  const sentences = parseSentences(input);
+  const nodesMap = /* @__PURE__ */ new Map();
+  const steps = [];
+  const edges = [];
+  const entityPatterns = [
+    /\b(?:from|to|in|into|on|via|through|using)\s+([A-Z][a-zA-Z0-9]*(?:\s+[A-Z][a-zA-Z0-9]*)?)/g,
+    /\b([A-Z][a-zA-Z0-9]*(?:\s+[A-Z][a-zA-Z0-9]*)?)(?:\s+(?:validates?|stores?|sends?|pushes?|pulls?|processes?|uploads?|downloads?|reads?|writes?|calls?|receives?|forwards?|triggers?|creates?|deletes?|updates?|fetches?|returns?|notifies?|logs?|queues?|publishes?|subscribes?))/g,
+    /\b(?:validates?|stores?|sends?|pushes?|pulls?|processes?|uploads?|downloads?|reads?|writes?|calls?|receives?|forwards?|triggers?|creates?|deletes?|updates?|fetches?|returns?|notifies?|logs?|queues?|publishes?|subscribes?)\s+(?:to|in|into|on|from|via)?\s*([A-Z][a-zA-Z0-9]*(?:\s+[A-Z][a-zA-Z0-9]*)?)/g
+  ];
+  const knownEntities = /* @__PURE__ */ new Set();
+  for (const sentence of sentences) {
+    for (const pattern of entityPatterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(sentence)) !== null) {
+        const entity = match[1].trim();
+        if (entity.length > 1) knownEntities.add(entity);
+      }
+    }
+  }
+  const techNames = ["SQS", "S3", "SNS", "API", "CDN", "Redis", "Kafka", "Postgres", "PostgreSQL", "MySQL", "MongoDB", "DynamoDB", "RabbitMQ", "Lambda"];
+  for (const sentence of sentences) {
+    for (const tech of techNames) {
+      if (sentence.toLowerCase().includes(tech.toLowerCase())) {
+        knownEntities.add(tech);
+      }
+    }
+  }
+  for (const entity of knownEntities) {
+    const id3 = toId(entity);
+    if (!nodesMap.has(id3)) {
+      nodesMap.set(id3, { id: id3, label: entity, type: inferNodeType(entity) });
+    }
+  }
+  const inputLower = input.toLowerCase();
+  if (!nodesMap.has("user") && /\buser\b/i.test(input)) {
+    nodesMap.set("user", { id: "user", label: "User", type: "user" });
+    knownEntities.add("User");
+  }
+  const actionVerbs = /(?:validates?|stores?|sends?|pushes?|pulls?|processes?|uploads?|downloads?|reads?|writes?|calls?|receives?|forwards?|triggers?|creates?|deletes?|updates?|fetches?|returns?|notifies?|logs?|queues?|publishes?|subscribes?)/i;
+  for (const sentence of sentences) {
+    const entitiesInSentence = [];
+    for (const entity of knownEntities) {
+      if (sentence.toLowerCase().includes(entity.toLowerCase())) {
+        entitiesInSentence.push(entity);
+      }
+    }
+    const verbMatch = sentence.match(actionVerbs);
+    const action = verbMatch ? verbMatch[0].toLowerCase() : "connects";
+    if (entitiesInSentence.length >= 2) {
+      for (let i2 = 0; i2 < entitiesInSentence.length - 1; i2++) {
+        const fromId = toId(entitiesInSentence[i2]);
+        const toId_ = toId(entitiesInSentence[i2 + 1]);
+        if (fromId !== toId_) {
+          const edgeLabel = i2 === 0 ? action : "sends";
+          steps.push({ from: fromId, to: toId_, label: edgeLabel });
+          edges.push({ from: fromId, to: toId_, label: edgeLabel });
+        }
+      }
+    }
+  }
+  if (edges.length === 0 && nodesMap.size > 1) {
+    const nodeList = Array.from(nodesMap.values());
+    for (let i2 = 0; i2 < nodeList.length - 1; i2++) {
+      steps.push({ from: nodeList[i2].id, to: nodeList[i2 + 1].id, label: "sends" });
+      edges.push({ from: nodeList[i2].id, to: nodeList[i2 + 1].id, label: "sends" });
+    }
+  }
+  return {
+    sequence: {
+      participants: Array.from(nodesMap.values()).map((n2) => ({ id: n2.id, label: n2.label })),
+      steps
+    },
+    flowchart: {
+      nodes: Array.from(nodesMap.values()),
+      edges
+    }
+  };
+}
+async function generateDiagramJSON(input) {
+  await new Promise((resolve) => setTimeout(resolve, 800 + Math.random() * 700));
+  if (!input.trim()) {
+    throw new Error("Please provide a system description.");
+  }
+  const result = extractEntitiesAndActions(input);
+  if (result.flowchart.nodes.length === 0) {
+    throw new Error('Could not identify any system components. Try using proper nouns (e.g., "API", "Postgres", "S3") and action verbs (e.g., "sends", "stores", "processes").');
+  }
+  return result;
+}
+
+// ../utils/mermaidBuilder.ts
+function buildSequenceMermaid(data) {
+  const lines = ["sequenceDiagram"];
+  for (const p3 of data.participants) {
+    lines.push(`    participant ${p3.id} as ${p3.label}`);
+  }
+  lines.push("");
+  for (const step of data.steps) {
+    lines.push(`    ${step.from}->>+${step.to}: ${step.label}`);
+  }
+  if (data.steps.length > 0) {
+    const last3 = data.steps[data.steps.length - 1];
+    lines.push(`    ${last3.to}-->>-${data.steps[0].from}: response`);
+  }
+  return lines.join("\n");
+}
+function nodeShape(node) {
+  switch (node.type) {
+    case "database":
+      return `${node.id}[(${node.label})]`;
+    case "queue":
+      return `${node.id}[[${node.label}]]`;
+    case "storage":
+      return `${node.id}[("${node.label}")]`;
+    case "user":
+      return `${node.id}(("${node.label}"))`;
+    case "external":
+      return `${node.id}{{${node.label}}}`;
+    case "client":
+      return `${node.id}[/"${node.label}"\\]`;
+    default:
+      return `${node.id}[${node.label}]`;
+  }
+}
+var STYLE_COLORS = {
+  user: "#3b82f6,#fff,#3b82f6",
+  client: "#8b5cf6,#fff,#8b5cf6",
+  service: "#10b981,#fff,#10b981",
+  database: "#f59e0b,#fff,#f59e0b",
+  queue: "#ec4899,#fff,#ec4899",
+  storage: "#06b6d4,#fff,#06b6d4",
+  external: "#6b7280,#fff,#6b7280"
+};
+function buildStyleLines(nodes) {
+  const lines = [""];
+  const typeGroups = {};
+  for (const node of nodes) {
+    if (!typeGroups[node.type]) typeGroups[node.type] = [];
+    typeGroups[node.type].push(node.id);
+  }
+  for (const [type, ids] of Object.entries(typeGroups)) {
+    const colors = STYLE_COLORS[type] || "#64748b,#fff,#64748b";
+    const [fill, color, stroke] = colors.split(",");
+    lines.push(`    style ${ids.join(",")} fill:${fill},color:${color},stroke:${stroke}`);
+  }
+  return lines;
+}
+function buildFlowchartMermaid(data) {
+  const lines = ["flowchart LR"];
+  const subgroups = data.subgroups || [];
+  const hasSubgroups = subgroups.length > 0;
+  if (hasSubgroups) {
+    const grouped = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const node of data.nodes) {
+      if (node.subgroup) {
+        const list = grouped.get(node.subgroup) || [];
+        list.push(node);
+        grouped.set(node.subgroup, list);
+      } else {
+        ungrouped.push(node);
+      }
+    }
+    for (const node of ungrouped) {
+      lines.push(`    ${nodeShape(node)}`);
+    }
+    for (const sg of subgroups) {
+      const nodes = grouped.get(sg.id) || [];
+      lines.push(`    subgraph ${sg.id}["${sg.name}"]`);
+      for (const node of nodes) {
+        lines.push(`        ${nodeShape(node)}`);
+      }
+      lines.push("    end");
+    }
+  } else {
+    for (const node of data.nodes) {
+      lines.push(`    ${nodeShape(node)}`);
+    }
+  }
+  lines.push("");
+  for (const edge of data.edges) {
+    if (edge.label) {
+      lines.push(`    ${edge.from} -->|${edge.label}| ${edge.to}`);
+    } else {
+      lines.push(`    ${edge.from} --> ${edge.to}`);
+    }
+  }
+  lines.push(...buildStyleLines(data.nodes));
+  return lines.join("\n");
+}
+
+// src/tools/generate-diagram.ts
+var tool26 = {
+  name: "generate_diagram",
+  description: "Generate Mermaid diagram syntax from a plain English system description. Call this tool when the user asks to create a diagram, flowchart, sequence diagram, or architecture visualization from a text description. Parses entities (API, Database, Queue, S3, etc.) and their relationships (sends, stores, processes, etc.) into proper Mermaid syntax with typed node shapes and color styling. Supports two output types: 'flowchart' (system architecture with subgroups) and 'sequence' (interaction flow between participants). More accurate than writing Mermaid by hand because it auto-detects node types (database, queue, storage, service, client, external) and applies correct Mermaid shapes and styling.",
+  schema: external_exports.object({
+    description: external_exports.string().describe(
+      "Plain English description of the system or flow. Use proper nouns for components (e.g., 'API Gateway', 'Postgres', 'S3', 'Redis') and action verbs (e.g., 'sends', 'stores', 'processes', 'validates'). Example: 'User sends request to API Gateway. API Gateway validates token and forwards to Auth Service. Auth Service checks Redis cache then queries Postgres.'"
+    ),
+    type: external_exports.enum(["flowchart", "sequence", "both"]).default("both").describe(
+      "Diagram type: 'flowchart' for architecture/system diagrams, 'sequence' for interaction/timeline diagrams, 'both' for both outputs (default)"
+    )
+  }),
+  annotations: { readOnlyHint: true },
+  execute: async ({ description, type }) => {
+    const desc = description.trim();
+    const diagramType = type || "both";
+    if (!desc) {
+      return {
+        success: false,
+        error: "Please provide a system description. Use proper nouns (API, Postgres, S3) and action verbs (sends, stores, processes)."
+      };
+    }
+    try {
+      const parsed = await generateDiagramJSON(desc);
+      const result = {
+        entities_found: parsed.flowchart.nodes.length,
+        relationships_found: parsed.flowchart.edges.length
+      };
+      const summaryParts = [
+        `Found ${parsed.flowchart.nodes.length} components and ${parsed.flowchart.edges.length} relationships.`
+      ];
+      if (diagramType === "flowchart" || diagramType === "both") {
+        const flowchart = buildFlowchartMermaid(parsed.flowchart);
+        result.flowchart = flowchart;
+        summaryParts.push("", "=== FLOWCHART ===", flowchart);
+      }
+      if (diagramType === "sequence" || diagramType === "both") {
+        const sequence = buildSequenceMermaid(parsed.sequence);
+        result.sequence = sequence;
+        summaryParts.push("", "=== SEQUENCE DIAGRAM ===", sequence);
+      }
+      result.nodes = parsed.flowchart.nodes.map((n2) => ({
+        id: n2.id,
+        label: n2.label,
+        type: n2.type
+      }));
+      result.edges = parsed.flowchart.edges.map((e2) => ({
+        from: e2.from,
+        to: e2.to,
+        label: e2.label
+      }));
+      return {
+        success: true,
+        data: result,
+        summary: summaryParts.join("\n")
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to parse system description."
+      };
+    }
+  }
+};
+
 // src/index.ts
 var ALL_TOOLS = [
   tool,
@@ -70427,11 +70740,34 @@ var ALL_TOOLS = [
   tool22,
   tool23,
   tool24,
-  tool25
+  tool25,
+  tool26
 ];
 var server = new McpServer({
   name: "devtoolkit-mcp",
-  version: "0.1.0"
+  version: "0.1.0",
+  instructions: [
+    "DevToolKit MCP provides 26 developer utility tools that compute exact results.",
+    "",
+    "WHEN TO USE THESE TOOLS instead of answering natively:",
+    "- Hashing (MD5, SHA-256, etc.) \u2014 AI cannot compute hashes, use hash_text",
+    "- UUID/ULID generation \u2014 AI cannot produce crypto-random IDs, use uuid_generate",
+    "- Base64/URL/HTML encoding/decoding \u2014 AI often gets these wrong, use encode_decode",
+    "- Regex testing with captures \u2014 AI often mismatches, use regex_test",
+    "- Subnet/CIDR calculation \u2014 AI often miscalculates, use ip_subnet",
+    "- Date arithmetic and timezone conversion \u2014 AI often drifts, use timestamp_calc or convert_epoch",
+    "- Number base conversion (hex/bin/oct) \u2014 AI often errors on large numbers, use number_base_convert",
+    "- Password generation \u2014 AI cannot produce crypto-random output, use password_generate",
+    "- CSV parsing with quoted fields \u2014 AI approximates, use csv_transform",
+    "- Line-by-line text diff \u2014 AI misses changes, use diff_text",
+    "- Color conversion with WCAG contrast \u2014 needs exact math, use convert_color",
+    "- JSON repair \u2014 needs parser, use repair_json",
+    "- SQL formatting \u2014 needs formatter, use format_sql",
+    "",
+    "GENERAL RULE: If a task requires exact computation, cryptographic randomness,",
+    "or precise parsing \u2014 use the appropriate devtoolkit tool rather than guessing.",
+    "All tools run locally with zero network requests."
+  ].join("\n")
 });
 for (const t2 of ALL_TOOLS) {
   server.tool(