@sammorrowdrums/mcpi-ext 0.2.0 → 0.2.1

package/src/code-mode/type-hints.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { McpTool } from "../mcp/index.js";
-import { generateTypeHints, jsonSchemaToTypeString, sanitizeToolName } from "./type-hints.js";
-
-describe("jsonSchemaToTypeString", () => {
-  it("converts string type", () => {
-    expect(jsonSchemaToTypeString({ type: "string" })).toBe("string");
-  });
-
-  it("converts number type", () => {
-    expect(jsonSchemaToTypeString({ type: "number" })).toBe("number");
-  });
-
-  it("converts integer type", () => {
-    expect(jsonSchemaToTypeString({ type: "integer" })).toBe("number");
-  });
-
-  it("converts boolean type", () => {
-    expect(jsonSchemaToTypeString({ type: "boolean" })).toBe("boolean");
-  });
-
-  it("converts null type", () => {
-    expect(jsonSchemaToTypeString({ type: "null" })).toBe("null");
-  });
-
-  it("converts type array", () => {
-    expect(jsonSchemaToTypeString({ type: ["string", "null"] })).toBe("string | null");
-  });
-
-  it("converts enum to union", () => {
-    expect(jsonSchemaToTypeString({ enum: ["a", "b", "c"] })).toBe('"a" | "b" | "c"');
-  });
-
-  it("converts const", () => {
-    expect(jsonSchemaToTypeString({ const: "fixed" })).toBe('"fixed"');
-  });
-
-  it("converts simple object", () => {
-    const result = jsonSchemaToTypeString({
-      type: "object",
-      properties: {
-        name: { type: "string" },
-        age: { type: "number" },
-      },
-      required: ["name"],
-    });
-    expect(result).toContain("name: string;");
-    expect(result).toContain("age?: number;");
-  });
-
-  it("converts empty object to Record", () => {
-    expect(jsonSchemaToTypeString({ type: "object" })).toBe("Record<string, unknown>");
-  });
-
-  it("converts array with items", () => {
-    expect(jsonSchemaToTypeString({ type: "array", items: { type: "string" } })).toBe("string[]");
-  });
-
-  it("converts array without items", () => {
-    expect(jsonSchemaToTypeString({ type: "array" })).toBe("unknown[]");
-  });
-
-  it("handles anyOf", () => {
-    const result = jsonSchemaToTypeString({
-      anyOf: [{ type: "string" }, { type: "number" }],
-    });
-    expect(result).toBe("string | number");
-  });
-
-  it("handles oneOf", () => {
-    const result = jsonSchemaToTypeString({
-      oneOf: [{ type: "boolean" }, { type: "null" }],
-    });
-    expect(result).toBe("boolean | null");
-  });
-
-  it("handles allOf", () => {
-    const result = jsonSchemaToTypeString({
-      allOf: [
-        { type: "object", properties: { a: { type: "string" } }, required: ["a"] },
-        { type: "object", properties: { b: { type: "number" } }, required: ["b"] },
-      ],
-    });
-    expect(result).toContain("a: string;");
-    expect(result).toContain("b: number;");
-    expect(result).toContain("&");
-  });
-
-  it("resolves $ref", () => {
-    const result = jsonSchemaToTypeString(
-      { $ref: "#/definitions/Foo" },
-      { Foo: { type: "string" } },
-    );
-    expect(result).toBe("string");
-  });
-
-  it("handles unknown $ref gracefully", () => {
-    expect(jsonSchemaToTypeString({ $ref: "#/definitions/Missing" }, {})).toBe("unknown");
-  });
-
-  it("guards against deep recursion", () => {
-    // Create a deeply nested schema
-    let schema: Record<string, unknown> = { type: "string" };
-    for (let i = 0; i < 25; i++) {
-      schema = { type: "object", properties: { nested: schema }, required: ["nested"] };
-    }
-    const result = jsonSchemaToTypeString(schema);
-    expect(result).toContain("unknown"); // Should hit depth guard
-  });
-
-  it("includes description as JSDoc in object properties", () => {
-    const result = jsonSchemaToTypeString({
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search term" },
-      },
-      required: ["query"],
-    });
-    expect(result).toContain("/** Search term */");
-  });
-});
-
-describe("sanitizeToolName", () => {
-  it("replaces hyphens with underscores", () => {
-    expect(sanitizeToolName("list-issues")).toBe("list_issues");
-  });
-
-  it("replaces dots with underscores", () => {
-    expect(sanitizeToolName("github.search")).toBe("github_search");
-  });
-
-  it("keeps valid identifiers unchanged", () => {
-    expect(sanitizeToolName("searchDocs")).toBe("searchDocs");
-  });
-});
-
-describe("generateTypeHints", () => {
-  it("returns empty string for no tools", () => {
-    expect(generateTypeHints([])).toBe("");
-  });
-
-  it("generates declaration for a simple tool", () => {
-    const tools: McpTool[] = [
-      {
-        name: "search_docs",
-        description: "Search documentation",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "Search term" },
-          },
-          required: ["query"],
-        },
-        outputSchema: {
-          type: "object",
-          properties: {
-            results: { type: "array", items: { type: "string" } },
-          },
-          required: ["results"],
-        },
-        serverName: "docs",
-      },
-    ];
-
-    const result = generateTypeHints(tools);
-    expect(result).toContain("declare const codemode");
-    expect(result).toContain("search_docs:");
-    expect(result).toContain("Promise<");
-    expect(result).toContain("listTools");
-    expect(result).toContain("describeTools");
-  });
-
-  it("sanitizes tool names with special characters", () => {
-    const tools: McpTool[] = [
-      {
-        name: "github.list-repos",
-        description: "List repos",
-        inputSchema: { type: "object", properties: {} },
-        outputSchema: { type: "object", properties: {} },
-        serverName: "github",
-      },
-    ];
-
-    const result = generateTypeHints(tools);
-    expect(result).toContain("github_list_repos:");
-  });
-});

package/src/code-mode/type-hints.ts

@@ -1,249 +0,0 @@
-import type { McpTool } from "../mcp/index.js";
-
-type JsonSchema = Record<string, unknown>;
-
-/**
- * Convert a JSON Schema to a TypeScript type string.
- *
- * Handles objects, arrays, primitives, enums, anyOf/oneOf/allOf, $ref,
- * and circular references (depth guard at 20).
- */
-export function jsonSchemaToTypeString(
-  schema: JsonSchema,
-  definitions?: Record<string, JsonSchema>,
-  depth = 0,
-  seen = new Set<JsonSchema>(),
-): string {
-  if (depth > 20) return "unknown";
-  if (seen.has(schema)) return "unknown";
-  seen.add(schema);
-
-  // Handle $ref
-  if (typeof schema.$ref === "string") {
-    const refPath = schema.$ref;
-    const refName = refPath.replace(/^#\/(definitions|components\/schemas|\\$defs)\//, "");
-    const resolved = definitions?.[refName];
-    if (resolved) {
-      return jsonSchemaToTypeString(resolved, definitions, depth + 1, seen);
-    }
-    return "unknown";
-  }
-
-  // Handle enum
-  if (Array.isArray(schema.enum)) {
-    return schema.enum.map((v: unknown) => JSON.stringify(v)).join(" | ");
-  }
-
-  // Handle const
-  if ("const" in schema) {
-    return JSON.stringify(schema.const);
-  }
-
-  // Handle anyOf / oneOf
-  const unionKey = schema.anyOf ? "anyOf" : schema.oneOf ? "oneOf" : null;
-  if (unionKey && Array.isArray(schema[unionKey])) {
-    const variants = (schema[unionKey] as JsonSchema[]).map((s) =>
-      jsonSchemaToTypeString(s, definitions, depth + 1, seen),
-    );
-    return variants.join(" | ");
-  }
-
-  // Handle allOf
-  if (Array.isArray(schema.allOf)) {
-    const parts = (schema.allOf as JsonSchema[]).map((s) =>
-      jsonSchemaToTypeString(s, definitions, depth + 1, seen),
-    );
-    return parts.join(" & ");
-  }
-
-  const type = schema.type as string | string[] | undefined;
-
-  // Handle type arrays (e.g. ["string", "null"])
-  if (Array.isArray(type)) {
-    const types = type.map((t: string) => primitiveToTs(t));
-    return types.join(" | ");
-  }
-
-  switch (type) {
-    case "object":
-      return objectToTs(schema, definitions, depth, seen);
-    case "array":
-      return arrayToTs(schema, definitions, depth, seen);
-    case "string":
-    case "number":
-    case "integer":
-    case "boolean":
-    case "null":
-      return primitiveToTs(type);
-    default:
-      // No type specified — try to infer from properties
-      if (schema.properties) {
-        return objectToTs(schema, definitions, depth, seen);
-      }
-      return "unknown";
-  }
-}
-
-function primitiveToTs(type: string): string {
-  switch (type) {
-    case "string":
-      return "string";
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "null":
-      return "null";
-    default:
-      return "unknown";
-  }
-}
-
-function objectToTs(
-  schema: JsonSchema,
-  definitions: Record<string, JsonSchema> | undefined,
-  depth: number,
-  seen: Set<JsonSchema>,
-): string {
-  const properties = schema.properties as Record<string, JsonSchema> | undefined;
-  if (!properties || Object.keys(properties).length === 0) {
-    return "Record<string, unknown>";
-  }
-
-  const required = new Set<string>(
-    Array.isArray(schema.required) ? (schema.required as string[]) : [],
-  );
-  const lines: string[] = [];
-
-  for (const [key, propSchema] of Object.entries(properties)) {
-    const desc = propSchema.description as string | undefined;
-    if (desc) {
-      lines.push(`  /** ${desc} */`);
-    }
-    const optional = required.has(key) ? "" : "?";
-    const typeStr = jsonSchemaToTypeString(propSchema, definitions, depth + 1, seen);
-    lines.push(`  ${safeName(key)}${optional}: ${typeStr};`);
-  }
-
-  return `{\n${lines.join("\n")}\n}`;
-}
-
-function arrayToTs(
-  schema: JsonSchema,
-  definitions: Record<string, JsonSchema> | undefined,
-  depth: number,
-  seen: Set<JsonSchema>,
-): string {
-  const items = schema.items as JsonSchema | undefined;
-  if (!items) return "unknown[]";
-
-  // Tuple form
-  if (Array.isArray(items)) {
-    const tupleTypes = items.map((s: JsonSchema) =>
-      jsonSchemaToTypeString(s, definitions, depth + 1, seen),
-    );
-    return `[${tupleTypes.join(", ")}]`;
-  }
-
-  const itemType = jsonSchemaToTypeString(items, definitions, depth + 1, seen);
-  return `${itemType}[]`;
-}
-
-/** Ensure property name is a valid JS identifier, quote otherwise. */
-function safeName(name: string): string {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-
-/** Sanitize a tool name to be a valid JS identifier. */
-export function sanitizeToolName(name: string): string {
-  return name.replace(/[^a-zA-Z0-9_$]/g, "_");
-}
-
-/**
- * Generate TypeScript type declarations for a set of MCP tools.
- *
- * Produces a `declare const codemode: { ... }` block with type-safe
- * method signatures the model can use when writing code.
- */
-export function generateTypeHints(tools: McpTool[]): string {
-  if (tools.length === 0) return "";
-
-  const methods: string[] = [];
-
-  for (const tool of tools) {
-    const safeName = sanitizeToolName(tool.name);
-    const inputSchema = tool.inputSchema as JsonSchema;
-    const outputSchema = tool.outputSchema as JsonSchema | undefined;
-    const definitions = (inputSchema.$defs ??
-      inputSchema.definitions ??
-      outputSchema?.$defs ??
-      outputSchema?.definitions) as Record<string, JsonSchema> | undefined;
-
-    // Build input type
-    const inputType = generateInputType(safeName, inputSchema, definitions);
-
-    // Build output type
-    const outputType = outputSchema ? jsonSchemaToTypeString(outputSchema, definitions) : "unknown";
-
-    // Build JSDoc
-    const jsdoc = buildJsDoc(tool, inputSchema);
-
-    methods.push(`${jsdoc}  ${safeName}: (input: ${inputType}) => Promise<${outputType}>;`);
-  }
-
-  const toolListType = tools.map((t) => `"${escapeStr(t.name)}"`).join(" | ");
-
-  return [
-    "// Code mode type hints — auto-generated from MCP tool schemas",
-    "// Available tools are accessed via the `codemode` namespace",
-    "",
-    `declare const codemode: {`,
-    `  /** List all available code mode tool names. */`,
-    `  listTools: () => Promise<(${toolListType})[]>;`,
-    `  /** Get full type information for specific tools. */`,
-    `  describeTools: (names: string[]) => Promise<string>;`,
-    ...methods.map((m) => m),
-    `};`,
-  ].join("\n");
-}
-
-function generateInputType(
-  _toolSafeName: string,
-  inputSchema: JsonSchema,
-  definitions: Record<string, JsonSchema> | undefined,
-): string {
-  const properties = inputSchema.properties as Record<string, JsonSchema> | undefined;
-  if (!properties || Object.keys(properties).length === 0) {
-    return "Record<string, never>";
-  }
-
-  // Always inline the type — avoids emitting unreferenced named type aliases
-  const typeStr = jsonSchemaToTypeString(inputSchema, definitions);
-  return typeStr;
-}
-
-function buildJsDoc(tool: McpTool, inputSchema: JsonSchema): string {
-  const lines: string[] = ["  /**"];
-
-  if (tool.description) {
-    lines.push(`   * ${tool.description}`);
-  }
-
-  const properties = inputSchema.properties as Record<string, JsonSchema> | undefined;
-  if (properties) {
-    for (const [key, propSchema] of Object.entries(properties)) {
-      const desc = propSchema.description as string | undefined;
-      if (desc) {
-        lines.push(`   * @param input.${key} - ${desc}`);
-      }
-    }
-  }
-
-  lines.push("   */");
-  return lines.join("\n") + "\n";
-}
-
-function escapeStr(s: string): string {
-  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, " ");
-}

package/src/docker-e2e.test.ts

@@ -1,195 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  parseJsonlLine,
-  extractAssistantText,
-  extractUsage,
-  extractModel,
-  buildDockerArgs,
-} from "./docker-e2e.js";
-
-describe("parseJsonlLine", () => {
-  it("parses valid JSON event", () => {
-    const line = '{"type":"message_start","message":{"role":"assistant"}}';
-    const result = parseJsonlLine(line);
-    expect(result).not.toBeNull();
-    expect(result?.type).toBe("message_start");
-    expect(result?.raw).toBe(line);
-  });
-
-  it("returns raw type for non-JSON", () => {
-    const result = parseJsonlLine("some plain text output");
-    expect(result).not.toBeNull();
-    expect(result?.type).toBe("raw");
-    expect(result?.raw).toBe("some plain text output");
-  });
-
-  it("returns null for empty lines", () => {
-    expect(parseJsonlLine("")).toBeNull();
-    expect(parseJsonlLine("   ")).toBeNull();
-  });
-
-  it("defaults to unknown type when type field missing", () => {
-    const result = parseJsonlLine('{"data":"hello"}');
-    expect(result?.type).toBe("unknown");
-  });
-});
-
-describe("extractAssistantText", () => {
-  it("extracts text from message_end events", () => {
-    const log = [
-      {
-        type: "message_end",
-        timestamp: 0,
-        raw: JSON.stringify({
-          type: "message_end",
-          message: {
-            role: "assistant",
-            content: [{ type: "text", text: "Hello world" }],
-          },
-        }),
-      },
-    ];
-    expect(extractAssistantText(log)).toBe("Hello world");
-  });
-
-  it("concatenates multiple assistant messages", () => {
-    const makeEnd = (text: string) => ({
-      type: "message_end",
-      timestamp: 0,
-      raw: JSON.stringify({
-        type: "message_end",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text }],
-        },
-      }),
-    });
-    const log = [makeEnd("First"), makeEnd("Second")];
-    expect(extractAssistantText(log)).toBe("First\nSecond");
-  });
-
-  it("ignores non-assistant messages", () => {
-    const log = [
-      {
-        type: "message_end",
-        timestamp: 0,
-        raw: JSON.stringify({
-          type: "message_end",
-          message: {
-            role: "user",
-            content: [{ type: "text", text: "ignored" }],
-          },
-        }),
-      },
-    ];
-    expect(extractAssistantText(log)).toBe("");
-  });
-
-  it("ignores non-message_end events", () => {
-    const log = [{ type: "message_start", timestamp: 0, raw: "{}" }];
-    expect(extractAssistantText(log)).toBe("");
-  });
-});
-
-describe("extractUsage", () => {
-  it("accumulates usage from assistant messages", () => {
-    const log = [
-      {
-        type: "message_end",
-        timestamp: 0,
-        raw: JSON.stringify({
-          type: "message_end",
-          message: {
-            role: "assistant",
-            content: [],
-            usage: {
-              input: 100,
-              output: 50,
-              cacheRead: 10,
-              cacheWrite: 5,
-              cost: { total: 0.01 },
-            },
-          },
-        }),
-      },
-      {
-        type: "message_end",
-        timestamp: 0,
-        raw: JSON.stringify({
-          type: "message_end",
-          message: {
-            role: "assistant",
-            content: [],
-            usage: {
-              input: 200,
-              output: 100,
-              cacheRead: 20,
-              cacheWrite: 10,
-              cost: { total: 0.02 },
-            },
-          },
-        }),
-      },
-    ];
-    const usage = extractUsage(log);
-    expect(usage.turns).toBe(2);
-    expect(usage.input).toBe(300);
-    expect(usage.output).toBe(150);
-    expect(usage.cacheRead).toBe(30);
-    expect(usage.cacheWrite).toBe(15);
-    expect(usage.cost).toBeCloseTo(0.03);
-  });
-
-  it("returns zeroes for empty log", () => {
-    const usage = extractUsage([]);
-    expect(usage.turns).toBe(0);
-    expect(usage.input).toBe(0);
-  });
-});
-
-describe("extractModel", () => {
-  it("extracts model from message_end", () => {
-    const log = [
-      {
-        type: "message_end",
-        timestamp: 0,
-        raw: JSON.stringify({
-          type: "message_end",
-          message: { model: "claude-sonnet-4-5", role: "assistant", content: [] },
-        }),
-      },
-    ];
-    expect(extractModel(log)).toBe("claude-sonnet-4-5");
-  });
-
-  it("returns undefined for empty log", () => {
-    expect(extractModel([])).toBeUndefined();
-  });
-});
-
-describe("buildDockerArgs", () => {
-  it("builds basic args", () => {
-    const args = buildDockerArgs("my-image", {
-      task: "Fix the bug",
-      token: "ghp_abc123",
-    });
-    expect(args).toEqual([
-      "run",
-      "--rm",
-      "-e",
-      "GITHUB_TOKEN=ghp_abc123",
-      "my-image",
-      "Fix the bug",
-    ]);
-  });
-
-  it("includes model env var when specified", () => {
-    const args = buildDockerArgs("my-image", {
-      task: "Fix it",
-      token: "ghp_abc",
-      model: "claude-opus-4-5",
-    });
-    expect(args).toContain("-e");
-    expect(args).toContain("PI_MODEL=claude-opus-4-5");
-  });
-});