@sammorrowdrums/mcpi-ext 0.1.0 → 0.2.1

package/eslint.config.js

@@ -1,27 +0,0 @@
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
-import eslintConfigPrettier from "eslint-config-prettier";
-
-export default tseslint.config(
-  eslint.configs.recommended,
-  ...tseslint.configs.strict,
-  ...tseslint.configs.stylistic,
-  eslintConfigPrettier,
-  {
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-    rules: {
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
-      ],
-    },
-  },
-  {
-    ignores: ["dist/", "node_modules/", "*.js", "scripts/"],
-  },
-);

package/mise.toml

@@ -1,65 +0,0 @@
-[tools]
-node = "22"
-
-[tasks.build]
-description = "Build TypeScript"
-run = [
-  "npx tsc",
-  "chmod +x dist/tool-cli/cli.js",
-]
-
-[tasks."install:tool-cli"]
-description = "Symlink tool-cli binary for local use"
-depends = ["build"]
-run = [
-  "ln -sf ../../dist/tool-cli/cli.js node_modules/.bin/tool-cli",
-  "mkdir -p ~/.local/bin",
-  "ln -sf $PWD/dist/tool-cli/cli.js ~/.local/bin/tool-cli",
-]
-
-[tasks.dev]
-description = "Watch mode"
-run = "npx tsc --watch"
-
-[tasks.test]
-description = "Run tests"
-run = "npx vitest --run"
-
-[tasks.check]
-description = "Type-check without emitting"
-run = "npx tsc --noEmit"
-
-[tasks.lint]
-description = "Lint TypeScript files"
-run = "npx eslint ."
-
-[tasks.format]
-description = "Format code with Prettier"
-run = "npx prettier --write ."
-
-[tasks."format:check"]
-description = "Check code formatting"
-run = "npx prettier --check ."
-
-[tasks.start]
-description = "Run the built project"
-run = "node dist/index.js"
-
-[tasks.docker-build]
-description = "Build the Docker e2e image"
-run = "docker build -t mcpi-ext-e2e ."
-
-[tasks."test:integration"]
-description = "Run MCP integration smoke test"
-depends = ["build"]
-run = "node scripts/test-mcp-integration.mjs"
-
-[tasks."test:tool-cli"]
-description = "Run tool-cli smoke test (requires build)"
-depends = ["build"]
-run = "node scripts/test-tool-cli-smoke.mjs"
-
-[tasks."test:skill-integration"]
-description = "Run skill discovery integration test (requires build)"
-depends = ["build"]
-run = "npx vitest run src/skills/skill-integration.test.ts"

package/scripts/docker-entrypoint.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [ -z "${GITHUB_TOKEN:-}" ]; then
-  echo "ERROR: GITHUB_TOKEN environment variable is required" >&2
-  exit 1
-fi
-
-if [ $# -eq 0 ]; then
-  echo "ERROR: No task provided. Pass the task as arguments." >&2
-  echo "Usage: docker run -e GITHUB_TOKEN=... IMAGE \"your task here\"" >&2
-  exit 1
-fi
-
-TASK="$*"
-
-PI_ARGS=(
-  -e /app/dist/index.js
-  --provider github-copilot
-  --mode json
-  -p
-  --no-session
-)
-
-if [ -n "${PI_MODEL:-}" ]; then
-  PI_ARGS+=(--model "$PI_MODEL")
-fi
-
-exec npx pi "${PI_ARGS[@]}" "$TASK"

package/scripts/test-echo-server.mjs

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-/**
- * Minimal MCP server for integration testing.
- * Exposes a single "echo" tool that returns its input.
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-const server = new McpServer({
-  name: "test-echo-server",
-  version: "0.1.0",
-});
-
-server.registerTool(
-  "echo",
-  {
-    description: "Echoes back the input message",
-    inputSchema: { message: z.string() },
-    annotations: { readOnlyHint: true },
-  },
-  async ({ message }) => ({
-    content: [{ type: "text", text: message }],
-  }),
-);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/scripts/test-mcp-integration.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-/**
- * Integration smoke test: connect to the test-echo-server via stdio,
- * discover tools, call the echo tool, disconnect, exit 0.
- */
-import { McpClientManager } from "../dist/mcp/client-manager.js";
-
-const manager = new McpClientManager();
-
-try {
-  await manager.connectAll(
-    {
-      mcpServers: {
-        "test-echo": {
-          type: "stdio",
-          command: "node",
-          args: ["scripts/test-echo-server.mjs"],
-        },
-      },
-    },
-    (msg) => console.log(msg),
-  );
-
-  const servers = manager.getConnectedServers();
-  if (servers.length !== 1) {
-    throw new Error(`Expected 1 server, got ${servers.length}`);
-  }
-
-  const tools = manager.getTools();
-  console.log(`Discovered ${tools.length} tool(s): ${tools.map((t) => t.name).join(", ")}`);
-
-  const echoTool = tools.find((t) => t.name === "echo");
-  if (!echoTool) {
-    throw new Error('Expected to find "echo" tool');
-  }
-
-  // Call the tool via the client
-  const client = manager.getClient("test-echo");
-  if (!client) throw new Error("No client for test-echo");
-
-  const result = await client.callTool({
-    name: "echo",
-    arguments: { message: "hello from integration test" },
-  });
-
-  const text = result.content?.[0]?.text;
-  if (text !== "hello from integration test") {
-    throw new Error(`Unexpected echo result: ${JSON.stringify(result)}`);
-  }
-  console.log(`Echo tool returned: "${text}"`);
-
-  await manager.disconnectAll();
-  console.log("Integration test passed ✓");
-  process.exit(0);
-} catch (err) {
-  console.error("Integration test failed:", err);
-  await manager.disconnectAll().catch(() => {});
-  process.exit(1);
-}

package/scripts/test-tool-cli-smoke.mjs

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-/**
- * Smoke test: start RPC server with the weather test server,
- * exercise every tool-cli command, then shut down.
- */
-import { McpClientManager } from "../dist/mcp/client-manager.js";
-import { ToolCliRpcServer } from "../dist/tool-cli/rpc-server.js";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-const CLI = "dist/tool-cli/cli.js";
-const manager = new McpClientManager();
-let rpc;
-
-async function run(...args) {
-  const { stdout } = await execFileAsync("node", [CLI, ...args], {
-    encoding: "utf-8",
-    env: { ...process.env, TOOL_CLI_PORT: String(rpc.getPort()) },
-  });
-  console.log(`$ tool-cli ${args.join(" ")}`);
-  console.log(stdout);
-  return stdout;
-}
-
-try {
-  await manager.connectOne("weather", {
-    type: "stdio",
-    command: "node",
-    args: ["dist/test-servers/weather-stdio.js"],
-  });
-
-  rpc = new ToolCliRpcServer(manager, 0);
-  await rpc.start(console.log);
-
-  // --help: list servers
-  const help = await run("--help");
-  if (!help.includes("weather")) throw new Error("--help missing weather server");
-
-  // <server>: list tools
-  const tools = await run("weather");
-  if (!tools.includes("check_weather_for_city"))
-    throw new Error("tool list missing check_weather_for_city");
-
-  // <server> <tool>: describe
-  const desc = await run("weather", "check_weather_for_city");
-  if (!desc.includes("city")) throw new Error("describe missing city param");
-
-  // <server> <tool> <args>: call
-  const result = await run("weather", "check_weather_for_city", '{"city":"London"}');
-  if (!result.includes("London")) throw new Error("call result missing London");
-
-  await rpc.stop();
-  await manager.disconnectAll();
-  console.log("Smoke test passed ✓");
-  process.exit(0);
-} catch (err) {
-  console.error("Smoke test failed:", err);
-  await rpc?.stop().catch(() => {});
-  await manager.disconnectAll().catch(() => {});
-  process.exit(1);
-}

package/src/code-mode/code-mode-integration.test.ts

@@ -1,135 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { McpClientManager } from "../mcp/client-manager.js";
-import { CodeModeManager } from "./index.js";
-
-/**
- * Integration test: connect to the test weather server, verify code mode
- * eligibility, type hint generation, and sandboxed execution with real
- * MCP tool calls returning structuredContent.
- */
-describe("code mode integration (weather server)", () => {
-  const manager = new McpClientManager();
-  const codeMode = new CodeModeManager();
-
-  beforeAll(async () => {
-    await manager.connectAll({
-      mcpServers: {
-        "test-weather": {
-          type: "stdio",
-          command: "node",
-          args: ["dist/test-servers/weather-stdio.js"],
-        },
-      },
-    });
-
-    codeMode.initialize(manager);
-  });
-
-  afterAll(async () => {
-    await manager.disconnectAll();
-  });
-
-  it("discovers eligible tools with readOnlyHint + outputSchema", () => {
-    const eligible = codeMode.getEligibleTools();
-    expect(eligible.length).toBeGreaterThanOrEqual(2);
-    const names = eligible.map((t) => t.name).sort();
-    expect(names).toContain("check_weather_for_city");
-    expect(names).toContain("check_weekly_forecast_for_city");
-    expect(names).toContain("echo");
-  });
-
-  it("generates type hints for eligible tools", () => {
-    const hints = codeMode.getTypeHints();
-    expect(hints).toContain("declare const codemode");
-    expect(hints).toContain("check_weather_for_city");
-    expect(hints).toContain("check_weekly_forecast_for_city");
-    expect(hints).toContain("echo");
-    expect(hints).toContain("listTools");
-  });
-
-  it("reports as active", () => {
-    expect(codeMode.isActive).toBe(true);
-  });
-
-  it("generates system prompt section", () => {
-    const section = codeMode.formatSystemPromptSection();
-    expect(section).toContain("<code_mode>");
-    expect(section).toContain("code_search");
-    expect(section).toContain("code_execute");
-    expect(section).toContain("declare const codemode");
-  });
-
-  it("executes code that calls a single tool", async () => {
-    const result = await codeMode.executeCode(`
-      const weather = await codemode.check_weather_for_city({ city: "Tokyo" });
-      return weather;
-    `);
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toHaveProperty("temperature", 26);
-    expect(result.result).toHaveProperty("conditions", "Sunny");
-    expect(result.result).toHaveProperty("humidity", 55);
-  });
-
-  it("executes code that chains multiple tool calls", async () => {
-    const result = await codeMode.executeCode(`
-      const cities = ["London", "Tokyo"];
-      const results = [];
-      for (const city of cities) {
-        const w = await codemode.check_weather_for_city({ city });
-        results.push({ city, temp: w.temperature });
-      }
-      return results;
-    `);
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toEqual([
-      { city: "London", temp: 14 },
-      { city: "Tokyo", temp: 26 },
-    ]);
-  });
-
-  it("executes code that uses listTools", async () => {
-    const result = await codeMode.executeCode(`
-      const tools = await codemode.listTools();
-      return tools.sort();
-    `);
-
-    expect(result.error).toBeUndefined();
-    const names = result.result as string[];
-    expect(names).toContain("check_weather_for_city");
-    expect(names).toContain("echo");
-  });
-
-  it("executes code that calls echo tool", async () => {
-    const result = await codeMode.executeCode(`
-      const r = await codemode.echo({ message: "hello code mode" });
-      return r;
-    `);
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toEqual({ echo: "hello code mode" });
-  });
-
-  it("handles tool errors gracefully", async () => {
-    const result = await codeMode.executeCode(`
-      const w = await codemode.check_weather_for_city({ city: "Atlantis" });
-      return w;
-    `);
-
-    // Atlantis isn't in the data — server returns text-only content (no structuredContent)
-    // The executor should still return something (parsed text or raw string)
-    expect(result.error).toBeUndefined();
-    expect(result.result).toBeDefined();
-  });
-
-  it("search mode works for tool discovery", async () => {
-    const result = await codeMode.searchTools(`
-      const tools = await codemode.listTools();
-      return tools;
-    `);
-
-    expect(result.error).toBeUndefined();
-    expect(Array.isArray(result.result)).toBe(true);
-  });
-});

package/src/code-mode/eligibility.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { McpTool } from "../mcp/index.js";
-import { isEligibleForCodeMode } from "./eligibility.js";
-
-function makeTool(overrides: Partial<McpTool> = {}): McpTool {
-  return {
-    name: "test_tool",
-    description: "A test tool",
-    inputSchema: { type: "object", properties: {} },
-    serverName: "test-server",
-    ...overrides,
-  };
-}
-
-describe("isEligibleForCodeMode", () => {
-  it("returns true when readOnlyHint is true and outputSchema is defined", () => {
-    const tool = makeTool({
-      annotations: { readOnlyHint: true },
-      outputSchema: { type: "object", properties: { result: { type: "string" } } },
-    });
-    expect(isEligibleForCodeMode(tool)).toBe(true);
-  });
-
-  it("returns false when readOnlyHint is false", () => {
-    const tool = makeTool({
-      annotations: { readOnlyHint: false },
-      outputSchema: { type: "object", properties: {} },
-    });
-    expect(isEligibleForCodeMode(tool)).toBe(false);
-  });
-
-  it("returns false when readOnlyHint is missing", () => {
-    const tool = makeTool({
-      annotations: {},
-      outputSchema: { type: "object", properties: {} },
-    });
-    expect(isEligibleForCodeMode(tool)).toBe(false);
-  });
-
-  it("returns false when annotations is undefined", () => {
-    const tool = makeTool({
-      annotations: undefined,
-      outputSchema: { type: "object", properties: {} },
-    });
-    expect(isEligibleForCodeMode(tool)).toBe(false);
-  });
-
-  it("returns false when outputSchema is missing", () => {
-    const tool = makeTool({
-      annotations: { readOnlyHint: true },
-      outputSchema: undefined,
-    });
-    expect(isEligibleForCodeMode(tool)).toBe(false);
-  });
-
-  it("returns false when both readOnlyHint and outputSchema are missing", () => {
-    const tool = makeTool();
-    expect(isEligibleForCodeMode(tool)).toBe(false);
-  });
-});

package/src/code-mode/eligibility.ts

@@ -1,16 +0,0 @@
-import type { McpClientManager, McpTool } from "../mcp/index.js";
-
-/**
- * A tool is eligible for code mode when:
- * 1. annotations.readOnlyHint === true — does not modify its environment
- * 2. outputSchema is defined — results are typed and parseable
- */
-export function isEligibleForCodeMode(tool: McpTool): boolean {
-  const annotations = tool.annotations as { readOnlyHint?: boolean } | undefined;
-  return annotations?.readOnlyHint === true && tool.outputSchema != null;
-}
-
-/** Get all tools eligible for code mode across all connected MCP servers. */
-export function getEligibleTools(mcpManager: McpClientManager): McpTool[] {
-  return mcpManager.getTools().filter(isEligibleForCodeMode);
-}

package/src/code-mode/executor.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { executeInSandbox, normalizeCode } from "./executor.js";
-
-describe("normalizeCode", () => {
-  it("strips markdown code fences", () => {
-    expect(normalizeCode("```js\nconst x = 1;\n```")).toBe("const x = 1;");
-  });
-
-  it("strips typescript fences", () => {
-    expect(normalizeCode("```typescript\nconst x = 1;\n```")).toBe("const x = 1;");
-  });
-
-  it("wraps arrow function in invocation", () => {
-    expect(normalizeCode("async () => { return 42; }")).toBe(
-      "return (async () => { return 42; })();",
-    );
-  });
-
-  it("wraps function declaration in invocation", () => {
-    const code = "async function main() { return 42; }";
-    const result = normalizeCode(code);
-    expect(result).toContain("async function main()");
-    expect(result).toContain("return main();");
-  });
-
-  it("strips export default", () => {
-    const result = normalizeCode("export default async () => { return 42; }");
-    expect(result).toContain("return (async () => { return 42; })();");
-  });
-
-  it("leaves bare code as-is", () => {
-    expect(normalizeCode("const x = 1;\nreturn x;")).toBe("const x = 1;\nreturn x;");
-  });
-});
-
-describe("executeInSandbox", () => {
-  it("executes simple code and returns result", async () => {
-    const result = await executeInSandbox("return 2 + 2;", [], async () => ({}), {
-      timeoutMs: 5000,
-    });
-
-    expect(result.result).toBe(4);
-    expect(result.error).toBeUndefined();
-  });
-
-  it("captures console.log output", async () => {
-    const result = await executeInSandbox(
-      'console.log("hello", "world"); return 1;',
-      [],
-      async () => ({}),
-      { timeoutMs: 5000 },
-    );
-
-    expect(result.result).toBe(1);
-    expect(result.logs).toContain("hello world");
-  });
-
-  it("dispatches tool calls through the callback", async () => {
-    const dispatched: { name: string; args: Record<string, unknown> }[] = [];
-
-    const dispatch = async (name: string, args: Record<string, unknown>) => {
-      dispatched.push({ name, args });
-      return { results: ["doc1", "doc2"] };
-    };
-
-    const code = `
-      const result = await codemode.search_docs({ query: "test" });
-      return result;
-    `;
-
-    const result = await executeInSandbox(code, ["search_docs"], dispatch, { timeoutMs: 5000 });
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toEqual({ results: ["doc1", "doc2"] });
-    expect(dispatched).toHaveLength(1);
-    expect(dispatched[0].name).toBe("search_docs");
-    expect(dispatched[0].args).toEqual({ query: "test" });
-  });
-
-  it("handles tools with special characters in names", async () => {
-    const dispatched: string[] = [];
-
-    const dispatch = async (name: string) => {
-      dispatched.push(name);
-      return { ok: true };
-    };
-
-    const code = `
-      const result = await codemode.github_list_repos({});
-      return result;
-    `;
-
-    const result = await executeInSandbox(code, ["github.list-repos"], dispatch, {
-      timeoutMs: 5000,
-    });
-
-    expect(result.error).toBeUndefined();
-    expect(dispatched).toContain("github.list-repos");
-  });
-
-  it("returns error for invalid code", async () => {
-    const result = await executeInSandbox("throw new Error('boom');", [], async () => ({}), {
-      timeoutMs: 5000,
-    });
-
-    expect(result.error).toContain("boom");
-    expect(result.result).toBeUndefined();
-  });
-
-  it("enforces timeout", async () => {
-    const result = await executeInSandbox("while(true) {}", [], async () => ({}), {
-      timeoutMs: 100,
-    });
-
-    expect(result.error).toBeDefined();
-    expect(result.result).toBeUndefined();
-  });
-
-  it("chains multiple tool calls", async () => {
-    const calls: string[] = [];
-
-    const dispatch = async (name: string, args: Record<string, unknown>) => {
-      calls.push(name);
-      if (name === "list_items") return { items: ["a", "b", "c"] };
-      if (name === "get_details") return { detail: `info for ${args.id}` };
-      return {};
-    };
-
-    const code = `
-      const { items } = await codemode.list_items({});
-      const details = [];
-      for (const id of items) {
-        const d = await codemode.get_details({ id });
-        details.push(d.detail);
-      }
-      return details;
-    `;
-
-    const result = await executeInSandbox(code, ["list_items", "get_details"], dispatch, {
-      timeoutMs: 5000,
-    });
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toEqual(["info for a", "info for b", "info for c"]);
-    expect(calls).toEqual(["list_items", "get_details", "get_details", "get_details"]);
-  });
-
-  it("prevents imports", async () => {
-    const code = 'import("fs")';
-    const result = await executeInSandbox(code, [], async () => ({}), { timeoutMs: 5000 });
-
-    expect(result.error).toBeDefined();
-  });
-
-  it("listTools returns available tools", async () => {
-    const code = `
-      const tools = await codemode.listTools();
-      return tools;
-    `;
-
-    const result = await executeInSandbox(code, ["search", "execute"], async () => ({}), {
-      timeoutMs: 5000,
-    });
-
-    expect(result.error).toBeUndefined();
-    expect(result.result).toEqual(["search", "execute"]);
-  });
-});