@sammorrowdrums/mcpi-ext 0.2.0 → 1.0.0

package/src/skills/skill-registry.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { SkillRegistry, type McpSkillMetadata } from "./skill-registry.js";
-
-function makeSkill(overrides: Partial<McpSkillMetadata> = {}): McpSkillMetadata {
-  return {
-    name: "test-skill",
-    description: "A test skill",
-    uri: "skill://test/SKILL.md",
-    serverName: "test-server",
-    allowedTools: ["tool_a"],
-    ...overrides,
-  };
-}
-
-describe("SkillRegistry", () => {
-  it("registers and retrieves a skill", () => {
-    const reg = new SkillRegistry();
-    const skill = makeSkill();
-    reg.register(skill);
-
-    expect(reg.get("test-skill")).toEqual(skill);
-    expect(reg.size).toBe(1);
-  });
-
-  it("getAll returns all registered skills", () => {
-    const reg = new SkillRegistry();
-    reg.register(makeSkill({ name: "a" }));
-    reg.register(makeSkill({ name: "b" }));
-
-    expect(reg.getAll()).toHaveLength(2);
-  });
-
-  it("overwrites on duplicate name", () => {
-    const reg = new SkillRegistry();
-    reg.register(makeSkill({ description: "first" }));
-    reg.register(makeSkill({ description: "second" }));
-
-    expect(reg.size).toBe(1);
-    expect(reg.get("test-skill")?.description).toBe("second");
-  });
-
-  it("unregister removes by name", () => {
-    const reg = new SkillRegistry();
-    reg.register(makeSkill());
-
-    expect(reg.unregister("test-skill")).toBe(true);
-    expect(reg.get("test-skill")).toBeUndefined();
-    expect(reg.unregister("test-skill")).toBe(false);
-  });
-
-  it("unregisterByServer removes all skills from a server", () => {
-    const reg = new SkillRegistry();
-    reg.register(makeSkill({ name: "a", serverName: "srv1" }));
-    reg.register(makeSkill({ name: "b", serverName: "srv1" }));
-    reg.register(makeSkill({ name: "c", serverName: "srv2" }));
-
-    reg.unregisterByServer("srv1");
-
-    expect(reg.size).toBe(1);
-    expect(reg.get("c")).toBeDefined();
-  });
-
-  it("registerAll registers multiple skills", () => {
-    const reg = new SkillRegistry();
-    reg.registerAll([makeSkill({ name: "x" }), makeSkill({ name: "y" })]);
-
-    expect(reg.size).toBe(2);
-  });
-
-  it("clear removes everything", () => {
-    const reg = new SkillRegistry();
-    reg.registerAll([makeSkill({ name: "a" }), makeSkill({ name: "b" })]);
-
-    reg.clear();
-    expect(reg.size).toBe(0);
-    expect(reg.getAll()).toEqual([]);
-  });
-
-  it("get returns undefined for unknown name", () => {
-    const reg = new SkillRegistry();
-    expect(reg.get("nonexistent")).toBeUndefined();
-  });
-});

package/src/skills/skill-registry.ts

@@ -1,69 +0,0 @@
-/** Metadata for a skill discovered from an MCP server. */
-export interface McpSkillMetadata {
-  /** Skill name from SKILL.md frontmatter. */
-  name: string;
-  /** Short description from SKILL.md frontmatter. */
-  description: string;
-  /** The skill:// URI for the SKILL.md resource. */
-  uri: string;
-  /** Which MCP server this skill came from. */
-  serverName: string;
-  /** Tool names this skill gates via allowed-tools frontmatter. */
-  allowedTools: string[];
-}
-
-/**
- * Registry for MCP-discovered skills.
- *
- * Holds skill metadata discovered from MCP servers. Skills are registered
- * during MCP connection and looked up when the model invokes load_skill.
- */
-export class SkillRegistry {
-  private skills = new Map<string, McpSkillMetadata>();
-
-  /** Register a skill. Overwrites any existing skill with the same name. */
-  register(skill: McpSkillMetadata): void {
-    this.skills.set(skill.name, skill);
-  }
-
-  /** Register multiple skills at once. */
-  registerAll(skills: McpSkillMetadata[]): void {
-    for (const skill of skills) {
-      this.register(skill);
-    }
-  }
-
-  /** Get a skill by name. */
-  get(name: string): McpSkillMetadata | undefined {
-    return this.skills.get(name);
-  }
-
-  /** Get all registered skills. */
-  getAll(): McpSkillMetadata[] {
-    return [...this.skills.values()];
-  }
-
-  /** Remove a skill by name. */
-  unregister(name: string): boolean {
-    return this.skills.delete(name);
-  }
-
-  /** Remove all skills from a specific MCP server. */
-  unregisterByServer(serverName: string): void {
-    for (const [name, skill] of this.skills) {
-      if (skill.serverName === serverName) {
-        this.skills.delete(name);
-      }
-    }
-  }
-
-  /** Remove all skills. */
-  clear(): void {
-    this.skills.clear();
-  }
-
-  /** Number of registered skills. */
-  get size(): number {
-    return this.skills.size;
-  }
-}

package/src/test-servers/weather-server.ts

@@ -1,171 +0,0 @@
-/**
- * Test MCP weather server — exposes a weather skill with gated tools.
- *
- * Registers:
- * - skill://weather/SKILL.md — a skill resource with frontmatter
- * - check_weather_for_city — current weather (gated by skill)
- * - check_weekly_forecast_for_city — 7-day forecast (gated by skill)
- * - echo — ungated baseline tool
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-const SKILL_CONTENT = `---
-name: weather
-description: Check current weather and weekly forecasts for any city
-allowed-tools:
-  - check_weather_for_city
-  - check_weekly_forecast_for_city
----
-
-# Weather Forecasting Skill
-
-Use the weather tools to look up conditions for any city.
-
-- **check_weather_for_city** — returns current temperature, conditions, and humidity
-- **check_weekly_forecast_for_city** — returns a 7-day forecast summary
-
-Always confirm the city name with the user before calling.
-`;
-
-const WEATHER_DATA: Record<string, { temp: number; conditions: string; humidity: number }> = {
-  london: { temp: 14, conditions: "Cloudy", humidity: 78 },
-  tokyo: { temp: 26, conditions: "Sunny", humidity: 55 },
-  "new york": { temp: 22, conditions: "Partly cloudy", humidity: 62 },
-  sydney: { temp: 19, conditions: "Clear", humidity: 45 },
-};
-
-const FORECAST_DATA: Record<string, string> = {
-  london:
-    "Mon 13°C Rain | Tue 14°C Cloudy | Wed 15°C Cloudy | Thu 12°C Rain | Fri 14°C Sunny | Sat 16°C Sunny | Sun 15°C Cloudy",
-  tokyo:
-    "Mon 27°C Sunny | Tue 28°C Sunny | Wed 25°C Rain | Thu 24°C Cloudy | Fri 26°C Sunny | Sat 27°C Sunny | Sun 26°C Partly cloudy",
-  "new york":
-    "Mon 23°C Sunny | Tue 24°C Sunny | Wed 20°C Thunderstorms | Thu 18°C Cloudy | Fri 21°C Sunny | Sat 22°C Sunny | Sun 23°C Clear",
-  sydney:
-    "Mon 18°C Clear | Tue 20°C Sunny | Wed 19°C Cloudy | Thu 17°C Rain | Fri 18°C Cloudy | Sat 21°C Sunny | Sun 20°C Clear",
-};
-
-export function createWeatherServer(): McpServer {
-  const server = new McpServer(
-    { name: "test-weather-server", version: "0.1.0" },
-    { capabilities: { resources: {} } },
-  );
-
-  // Skill resource
-  server.registerResource(
-    "weather-skill",
-    "skill://weather/SKILL.md",
-    {
-      description: "Weather forecasting skill instructions",
-      mimeType: "text/markdown",
-    },
-    async () => ({
-      contents: [
-        {
-          uri: "skill://weather/SKILL.md",
-          text: SKILL_CONTENT,
-          mimeType: "text/markdown",
-        },
-      ],
-    }),
-  );
-
-  // Tool: current weather (gated by skill)
-  server.registerTool(
-    "check_weather_for_city",
-    {
-      description: "Get current weather conditions for a city",
-      inputSchema: { city: z.string().describe("City name, e.g. 'London'") },
-      outputSchema: {
-        temperature: z.number().describe("Temperature in Celsius"),
-        conditions: z.string().describe("Weather conditions description"),
-        humidity: z.number().describe("Humidity percentage"),
-        city: z.string().describe("City name"),
-      },
-      annotations: { readOnlyHint: true },
-    },
-    async ({ city }) => {
-      const data = WEATHER_DATA[city.toLowerCase()];
-      if (!data) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `No weather data available for "${city}". Try: London, Tokyo, New York, or Sydney.`,
-            },
-          ],
-        };
-      }
-      const structuredContent = {
-        temperature: data.temp,
-        conditions: data.conditions,
-        humidity: data.humidity,
-        city,
-      };
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Weather in ${city}: ${data.conditions}, ${data.temp}°C, humidity ${data.humidity}%`,
-          },
-        ],
-        structuredContent,
-      };
-    },
-  );
-
-  // Tool: weekly forecast (gated by skill)
-  server.registerTool(
-    "check_weekly_forecast_for_city",
-    {
-      description: "Get a 7-day weather forecast for a city",
-      inputSchema: { city: z.string().describe("City name, e.g. 'Tokyo'") },
-      outputSchema: {
-        city: z.string().describe("City name"),
-        forecast: z.string().describe("7-day forecast summary"),
-      },
-      annotations: { readOnlyHint: true },
-    },
-    async ({ city }) => {
-      const forecast = FORECAST_DATA[city.toLowerCase()];
-      if (!forecast) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `No forecast data available for "${city}". Try: London, Tokyo, New York, or Sydney.`,
-            },
-          ],
-        };
-      }
-      const structuredContent = { city, forecast };
-      return {
-        content: [{ type: "text" as const, text: `Forecast for ${city}: ${forecast}` }],
-        structuredContent,
-      };
-    },
-  );
-
-  // Ungated tool (always available, not behind a skill)
-  server.registerTool(
-    "echo",
-    {
-      description: "Echoes back the input message",
-      inputSchema: { message: z.string() },
-      outputSchema: {
-        echo: z.string().describe("The echoed message"),
-      },
-      annotations: { readOnlyHint: true },
-    },
-    async ({ message }) => {
-      const structuredContent = { echo: message };
-      return {
-        content: [{ type: "text" as const, text: `Echo: ${message}` }],
-        structuredContent,
-      };
-    },
-  );
-
-  return server;
-}

package/src/test-servers/weather-stdio.ts

@@ -1,11 +0,0 @@
-/**
- * stdio entrypoint for the test weather server.
- * Run with: node dist/test-servers/weather-stdio.js
- */
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createWeatherServer } from "./weather-server.js";
-
-const server = createWeatherServer();
-const transport = new StdioServerTransport();
-await server.connect(transport);
-console.error("Test weather server running on stdio");

package/src/tool-cli/format.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatToolCliForPrompt } from "./format.js";
-
-describe("formatToolCliForPrompt", () => {
-  it("returns empty string when no servers connected", () => {
-    expect(formatToolCliForPrompt(0)).toBe("");
-  });
-
-  it("includes tool-cli usage instructions when servers are connected", () => {
-    const result = formatToolCliForPrompt(2);
-    expect(result).toContain("tool-cli");
-    expect(result).toContain("<tool_cli>");
-    expect(result).toContain("</tool_cli>");
-    expect(result).toContain("--help");
-    expect(result).toContain("<server>");
-    expect(result).toContain("<tool>");
-    expect(result).toContain("2 MCP server(s) currently connected");
-  });
-
-  it("advises preferring skills over tool-cli", () => {
-    const result = formatToolCliForPrompt(1);
-    expect(result).toContain("prefer the skill");
-  });
-
-  it("includes shell chaining and piping examples", () => {
-    const result = formatToolCliForPrompt(1);
-    expect(result).toContain("grep");
-    expect(result).toContain("|");
-    expect(result).toContain("jq");
-    expect(result).toContain("xargs");
-    expect(result).toContain("Prefer piping and chaining");
-  });
-});

package/src/tool-cli/format.ts

@@ -1,56 +0,0 @@
-/**
- * Format system prompt section advising the agent when and how to use tool-cli.
- *
- * Only included when MCP servers are connected. Tells the agent about
- * progressive discovery via tool-cli as an alternative to skill-based access.
- */
-export function formatToolCliForPrompt(serverCount: number): string {
-  if (serverCount === 0) return "";
-
-  return `
-
-<tool_cli>
-You have access to \`tool-cli\`, a CLI for discovering and calling MCP server tools progressively.
-
-Use tool-cli when:
-- No skill covers the task you need to do
-- You want to explore what tools are available on a server
-- You need ad-hoc access to an MCP tool without loading a full skill
-
-If a skill exists for the task, prefer the skill — it provides workflow instructions and curated tool access.
-
-Discovery (progressive — only fetch what you need):
-  tool-cli --help                            # List MCP servers with tool counts
-  tool-cli <server>                          # List all tools on a server
-  tool-cli <server> <tool>                   # Show full schema for a tool
-
-Calling tools:
-  tool-cli <server> <tool> '{"key":"value"}' # Call a tool with JSON arguments
-  tool-cli <server> <tool> '{}' --out /tmp/result.json  # Save large output to file
-
-tool-cli outputs plain text or JSON. When a tool provides structured output (typed JSON),
-tool-cli returns it directly as JSON — use \`jq\` to query fields.
-Chain calls, filter, and transform results using pipes and bash idioms:
-
-  # Search across tool results
-  tool-cli myserver search_docs '{"query":"auth"}' | grep -i "token"
-
-  # Query structured JSON output with jq
-  tool-cli myserver list_issues '{"repo":"owner/repo"}' | jq '.[].title'
-
-  # Chain tool calls — feed one result into another
-  tool-cli myserver list_items '{}' | jq -r '.[0].id' | xargs -I{} tool-cli myserver get_item '{"id":"{}"}'
-
-  # Process multiple items
-  for city in London Tokyo Paris; do
-    echo "=== $city ==="; tool-cli weather check_weather '{"city":"'$city'"}';
-  done
-
-  # Combine with standard tools
-  tool-cli myserver export_csv '{"table":"users"}' | sort -t, -k2 | head -20
-
-Prefer piping and chaining over multiple separate tool calls when processing collections or filtering results.
-Errors go to stderr with exit code 1 — use \`&&\` or \`set -e\` for safe chaining.
-${serverCount} MCP server(s) currently connected.
-</tool_cli>`;
-}

package/src/tool-cli/index.ts

@@ -1,3 +0,0 @@
-export { ToolCliServer } from "@sammorrowdrums/tool-cli/server";
-export type { ToolProvider } from "@sammorrowdrums/tool-cli/server";
-export { formatToolCliForPrompt } from "./format.js";

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "lib": ["ES2022"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "types": ["node"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}