@teddysc/mcp-codemode 1.0.0

package/src/types.ts

@@ -0,0 +1,216 @@
+/**
+ * Type generation for MCP tool schemas.
+ * Converts MCP JSON Schema tool descriptors into TypeScript type strings
+ * that the LLM can understand (the "codemode" system prompt injection).
+ *
+ * Adapted from @cloudflare/codemode/src/types.ts — JSON Schema path only,
+ * since Playwright MCP uses JSON Schema (not Zod).
+ */
+
+export type JSONSchema = {
+  type?: string | string[];
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  description?: string;
+  enum?: unknown[];
+  const?: unknown;
+  items?: JSONSchema;
+  prefixItems?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  allOf?: JSONSchema[];
+  $ref?: string;
+  format?: string;
+  nullable?: boolean; // OpenAPI 3.0
+};
+
+export type ToolDescriptor = {
+  description?: string;
+  inputSchema?: JSONSchema;
+  execute?: (...args: unknown[]) => Promise<unknown>;
+};
+
+const JS_RESERVED_WORDS = new Set([
+  "break", "case", "catch", "continue", "debugger", "default", "delete",
+  "do", "else", "finally", "for", "function", "if", "in", "instanceof",
+  "new", "return", "switch", "this", "throw", "try", "typeof", "var",
+  "void", "while", "with", "class", "const", "enum", "export", "extends",
+  "import", "super", "implements", "interface", "let", "package", "private",
+  "protected", "public", "static", "yield", "null", "true", "false"
+]);
+
+/**
+ * Converts an MCP tool name (which may contain hyphens, dots, etc.) into
+ * a valid JavaScript identifier. Matches codemode's sanitizeToolName exactly.
+ */
+export function sanitizeToolName(name: string): string {
+  let result = name.replace(/[-.\s]/g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+  if (!result) return "_";
+  if (/^[0-9]/.test(result)) result = "_" + result;
+  if (JS_RESERVED_WORDS.has(result)) result = result + "_";
+  return result;
+}
+
+/** Converts a sanitized tool name to a PascalCase type name. */
+function toTypeName(sanitized: string): string {
+  return sanitized
+    .split("_")
+    .filter(Boolean)
+    .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+    .join("");
+}
+
+/** Ensures a property name is a valid identifier; otherwise quotes it. */
+function safePropertyName(key: string): string {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+const MAX_DEPTH = 15;
+
+/**
+ * Recursively converts a JSON Schema to a TypeScript type string.
+ */
+export function jsonSchemaToTypeString(
+  schema: JSONSchema,
+  indent = "",
+  depth = 0
+): string {
+  if (depth > MAX_DEPTH) return "unknown";
+  if (!schema || typeof schema !== "object") return "unknown";
+
+  // anyOf / oneOf → union
+  if (schema.anyOf || schema.oneOf) {
+    const variants = (schema.anyOf ?? schema.oneOf)!;
+    const parts = variants.map(v => jsonSchemaToTypeString(v, indent, depth + 1));
+    return parts.join(" | ");
+  }
+
+  // allOf → intersection
+  if (schema.allOf) {
+    const parts = schema.allOf.map(v =>
+      jsonSchemaToTypeString(v, indent, depth + 1)
+    );
+    return parts.join(" & ");
+  }
+
+  // const → literal
+  if ("const" in schema && schema.const !== undefined) {
+    return JSON.stringify(schema.const);
+  }
+
+  // enum → literal union
+  if (schema.enum !== undefined) {
+    return schema.enum.map(v => JSON.stringify(v)).join(" | ");
+  }
+
+  const rawType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  const nullable = schema.nullable === true ||
+    (Array.isArray(schema.type) && schema.type.includes("null"));
+
+  let typeStr: string;
+
+  switch (rawType) {
+    case "string":
+      typeStr = "string";
+      break;
+    case "number":
+    case "integer":
+      typeStr = "number";
+      break;
+    case "boolean":
+      typeStr = "boolean";
+      break;
+    case "null":
+      return "null";
+    case "array": {
+      if (schema.prefixItems) {
+        // Tuple
+        const items = schema.prefixItems.map(s =>
+          jsonSchemaToTypeString(s, indent + "  ", depth + 1)
+        );
+        typeStr = `[${items.join(", ")}]`;
+      } else {
+        let itemType = schema.items
+          ? jsonSchemaToTypeString(schema.items, indent, depth + 1)
+          : "unknown";
+        // Wrap union/intersection items in parens so `(A | B)[]` is valid
+        if (itemType.includes(" | ") || itemType.includes(" & ")) {
+          itemType = `(${itemType})`;
+        }
+        typeStr = `${itemType}[]`;
+      }
+      break;
+    }
+    case "object": {
+      if (!schema.properties || Object.keys(schema.properties).length === 0) {
+        typeStr = "Record<string, unknown>";
+        break;
+      }
+      const required = new Set(schema.required ?? []);
+      const innerIndent = indent + "  ";
+      const props = Object.entries(schema.properties).map(([key, val]) => {
+        const optional = required.has(key) ? "" : "?";
+        const desc = val.description
+          ? `${innerIndent}/** ${val.description.replace(/\*\//g, "* /")} */\n`
+          : "";
+        const propType = jsonSchemaToTypeString(val, innerIndent, depth + 1);
+        return `${desc}${innerIndent}${safePropertyName(key)}${optional}: ${propType}`;
+      });
+      typeStr = `{\n${props.join(";\n")};\n${indent}}`;
+      break;
+    }
+    default:
+      typeStr = "unknown";
+  }
+
+  return nullable ? `${typeStr} | null` : typeStr;
+}
+
+/**
+ * Generates TypeScript type definitions for all tools, producing the
+ * "codemode" declaration block that gets injected into the LLM system prompt.
+ *
+ * Example output:
+ *   type BrowserNavigateInput = { url: string; timeout?: number };
+ *   declare const codemode: {
+ *     browser_navigate: (input: BrowserNavigateInput) => Promise<unknown>;
+ *   };
+ */
+export function generateTypes(tools: Record<string, ToolDescriptor>): string {
+  const typeLines: string[] = [];
+  const codemodeProps: string[] = [];
+
+  for (const [rawName, tool] of Object.entries(tools)) {
+    const sanitized = sanitizeToolName(rawName);
+    const typeName = toTypeName(sanitized) + "Input";
+
+    try {
+      const schema = tool.inputSchema;
+      if (schema && Object.keys(schema).length > 0) {
+        const typeStr = jsonSchemaToTypeString(schema, "");
+        typeLines.push(`type ${typeName} = ${typeStr};`);
+      } else {
+        typeLines.push(`type ${typeName} = Record<string, unknown>;`);
+      }
+
+      const descComment = tool.description
+        ? `  /** ${tool.description.replace(/\*\//g, "* /")} */\n`
+        : "";
+      codemodeProps.push(
+        `${descComment}  ${sanitized}: (input: ${typeName}) => Promise<unknown>`
+      );
+    } catch {
+      // Don't let one bad tool break the rest
+      typeLines.push(`type ${typeName} = unknown;`);
+      codemodeProps.push(`  ${sanitized}: (input: ${typeName}) => Promise<unknown>`);
+    }
+  }
+
+  return [
+    ...typeLines,
+    "",
+    "declare const codemode: {",
+    codemodeProps.join(";\n"),
+    "};",
+  ].join("\n");
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}