@sammorrowdrums/mcpi-ext 0.1.0

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

@@ -0,0 +1,249 @@
+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

@@ -0,0 +1,195 @@
+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");
+  });
+});

package/src/docker-e2e.ts

@@ -0,0 +1,277 @@
+import { spawn } from "node:child_process";
+import type {
+  AgentToolResult,
+  AgentToolUpdateCallback,
+  ExtensionContext,
+} from "@sammorrowdrums/mcpi";
+import { Type, type Static } from "typebox";
+
+const DOCKER_IMAGE = "mcpi-ext-e2e";
+
+const DockerE2EParams = Type.Object({
+  task: Type.String({ description: "The task/prompt to run inside the sandbox" }),
+  token: Type.String({
+    description: "GitHub token for Copilot model access",
+  }),
+  model: Type.Optional(
+    Type.String({
+      description: "Model to use (e.g. claude-sonnet-4-5). Defaults to the provider default.",
+    }),
+  ),
+  timeout: Type.Optional(
+    Type.Number({
+      description: "Timeout in seconds. Defaults to 300 (5 minutes).",
+    }),
+  ),
+});
+
+type DockerE2EInput = Static<typeof DockerE2EParams>;
+
+interface RunLogEntry {
+  type: string;
+  timestamp: number;
+  raw: string;
+}
+
+export interface DockerE2EDetails {
+  exitCode: number | null;
+  log: RunLogEntry[];
+  duration: number;
+  model?: string;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+    turns: number;
+  };
+}
+
+export function parseJsonlLine(line: string): RunLogEntry | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return { type: parsed.type ?? "unknown", timestamp: Date.now(), raw: trimmed };
+  } catch {
+    return { type: "raw", timestamp: Date.now(), raw: trimmed };
+  }
+}
+
+export function extractAssistantText(log: RunLogEntry[]): string {
+  const parts: string[] = [];
+  for (const entry of log) {
+    if (entry.type !== "message_end") continue;
+    try {
+      const event = JSON.parse(entry.raw);
+      const msg = event.message;
+      if (msg?.role !== "assistant") continue;
+      for (const part of msg.content ?? []) {
+        if (part.type === "text") parts.push(part.text);
+      }
+    } catch {
+      // skip malformed
+    }
+  }
+  return parts.join("\n");
+}
+
+export function extractUsage(log: RunLogEntry[]) {
+  const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  for (const entry of log) {
+    if (entry.type !== "message_end") continue;
+    try {
+      const event = JSON.parse(entry.raw);
+      const msg = event.message;
+      if (msg?.role !== "assistant") continue;
+      usage.turns++;
+      const u = msg.usage;
+      if (u) {
+        usage.input += u.input ?? 0;
+        usage.output += u.output ?? 0;
+        usage.cacheRead += u.cacheRead ?? 0;
+        usage.cacheWrite += u.cacheWrite ?? 0;
+        usage.cost += u.cost?.total ?? 0;
+      }
+    } catch {
+      // skip
+    }
+  }
+  return usage;
+}
+
+export function extractModel(log: RunLogEntry[]): string | undefined {
+  for (const entry of log) {
+    if (entry.type !== "message_end") continue;
+    try {
+      const event = JSON.parse(entry.raw);
+      if (event.message?.model) return event.message.model as string;
+    } catch {
+      // skip
+    }
+  }
+  return undefined;
+}
+
+export function buildDockerArgs(image: string, params: DockerE2EInput): string[] {
+  const args = ["run", "--rm", "-e", `GITHUB_TOKEN=${params.token}`];
+
+  if (params.model) {
+    args.push("-e", `PI_MODEL=${params.model}`);
+  }
+
+  args.push(image, params.task);
+  return args;
+}
+
+export const dockerE2ETool = {
+  name: "docker_e2e",
+  label: "Docker E2E",
+  description:
+    "Run a task end-to-end inside an isolated Docker container with pi and this project's extensions. Returns the full run log for evaluation.",
+  promptSnippet: "Run an isolated e2e task in Docker. Requires a GitHub token and task prompt.",
+  parameters: DockerE2EParams,
+
+  async execute(
+    _toolCallId: string,
+    params: DockerE2EInput,
+    signal: AbortSignal | undefined,
+    onUpdate: AgentToolUpdateCallback<DockerE2EDetails> | undefined,
+    _ctx: ExtensionContext,
+  ): Promise<AgentToolResult<DockerE2EDetails>> {
+    const startTime = Date.now();
+    const timeoutMs = (params.timeout ?? 300) * 1000;
+    const log: RunLogEntry[] = [];
+    let lastAssistantText = "";
+
+    const dockerArgs = buildDockerArgs(DOCKER_IMAGE, params);
+
+    const exitCode = await new Promise<number | null>((resolve) => {
+      const proc = spawn("docker", dockerArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      let buffer = "";
+      let timedOut = false;
+      let timeoutHandle: NodeJS.Timeout | undefined;
+
+      if (timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+          timedOut = true;
+          proc.kill("SIGTERM");
+          setTimeout(() => {
+            if (!proc.killed) proc.kill("SIGKILL");
+          }, 5000);
+        }, timeoutMs);
+      }
+
+      const processLine = (line: string) => {
+        const entry = parseJsonlLine(line);
+        if (!entry) return;
+        log.push(entry);
+
+        if (entry.type === "message_end") {
+          const text = extractAssistantText(log);
+          if (text) lastAssistantText = text;
+        }
+
+        onUpdate?.({
+          content: [
+            {
+              type: "text",
+              text: lastAssistantText || `(running… ${log.length} events)`,
+            },
+          ],
+          details: {
+            exitCode: null,
+            log,
+            duration: Date.now() - startTime,
+            model: extractModel(log),
+            usage: extractUsage(log),
+          },
+        });
+      };
+
+      proc.stdout.on("data", (data: Buffer) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) processLine(line);
+      });
+
+      proc.stderr.on("data", (data: Buffer) => {
+        const text = data.toString().trim();
+        if (text) {
+          log.push({ type: "stderr", timestamp: Date.now(), raw: text });
+        }
+      });
+
+      proc.on("close", (code) => {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+        if (buffer.trim()) processLine(buffer);
+        if (timedOut) {
+          log.push({
+            type: "timeout",
+            timestamp: Date.now(),
+            raw: `Timed out after ${params.timeout ?? 300}s`,
+          });
+        }
+        resolve(timedOut ? null : (code ?? 1));
+      });
+
+      proc.on("error", (err) => {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+        log.push({
+          type: "error",
+          timestamp: Date.now(),
+          raw: err.message,
+        });
+        resolve(null);
+      });
+
+      if (signal) {
+        const onAbort = () => {
+          proc.kill("SIGTERM");
+          setTimeout(() => {
+            if (!proc.killed) proc.kill("SIGKILL");
+          }, 5000);
+        };
+        if (signal.aborted) onAbort();
+        else signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+
+    const duration = Date.now() - startTime;
+    const assistantText = extractAssistantText(log);
+    const usage = extractUsage(log);
+    const model = extractModel(log);
+    const fullLog = log.map((e) => e.raw).join("\n");
+
+    const summary = [
+      `## Docker E2E Run Complete`,
+      ``,
+      `**Exit code:** ${exitCode ?? "killed"}`,
+      `**Duration:** ${(duration / 1000).toFixed(1)}s`,
+      model ? `**Model:** ${model}` : null,
+      usage.turns > 0
+        ? `**Usage:** ${usage.turns} turns, ↑${usage.input} ↓${usage.output} tokens, $${usage.cost.toFixed(4)}`
+        : null,
+      ``,
+      `### Output`,
+      assistantText || "(no assistant output)",
+      ``,
+      `### Full Log (${log.length} events)`,
+      "```",
+      fullLog,
+      "```",
+    ]
+      .filter((l) => l !== null)
+      .join("\n");
+
+    return {
+      content: [{ type: "text", text: summary }],
+      details: { exitCode, log, duration, model, usage },
+    };
+  },
+};