mcpill 1.3.0 → 1.5.0

package/src/__tests__/loaders/prompts.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadPrompts } from "../../loaders/prompts.js";
-
-describe("loadPrompts", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-prompts-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writePrompts(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "prompts.json"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("parses valid JSON correctly", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "summarize",
-          description: "Summarize text",
-          args: { text: { type: "string" }, count: { type: "number" } },
-          messages: [{ role: "user", content: "Summarize: {{text}}" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    expect(prompts).toHaveLength(1);
-    expect(prompts[0]!.name).toBe("summarize");
-    expect(Object.keys(prompts[0]!.argsShape)).toEqual(["text", "count"]);
-  });
-
-  it("throws on invalid JSON", async () => {
-    const dir = mkTmp();
-    writePrompts(dir, `{ not valid json`);
-    await expect(loadPrompts(dir)).rejects.toThrow("prompts.json is not valid JSON:");
-  });
-
-  it("throws when file is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadPrompts(dir)).rejects.toThrow("prompts.json is not valid JSON:");
-  });
-
-  it("throws on unsupported arg type", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "greet",
-          args: { user: { type: "object" } },
-          messages: [],
-        },
-      ])
-    );
-    await expect(loadPrompts(dir)).rejects.toThrow(
-      "Prompt 'greet': arg 'user' uses unsupported type 'object'. Supported: string, number, boolean"
-    );
-  });
-
-  it("interpolates {{placeholder}} in message content", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "greet",
-          args: { name: { type: "string" } },
-          messages: [{ role: "user", content: "Hello, {{name}}!" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    const { messages } = prompts[0]!;
-
-    // Replicate the interpolation logic from run.ts
-    const args: Record<string, unknown> = { name: "world" };
-    const result = messages.map((m) => ({
-      role: m.role,
-      content: m.content.replace(
-        /\{\{(\w+)\}\}/g,
-        (_, k: string) => String(args[k] ?? "")
-      ),
-    }));
-
-    expect(result[0]!.content).toBe("Hello, world!");
-  });
-
-  it("handles prompts with no args", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "hello",
-          args: {},
-          messages: [{ role: "user", content: "Hello!" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    expect(prompts[0]!.argsShape).toEqual({});
-  });
-});

package/src/__tests__/loaders/resources.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadResources } from "../../loaders/resources.js";
-
-describe("loadResources", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-resources-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writeResources(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "resources.md"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("parses a single resource block", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      "uri: config://app\nname: App Config\n---\nThis is the config resource."
-    );
-    const resources = await loadResources(dir);
-    expect(resources).toHaveLength(1);
-    expect(resources[0]!.uri).toBe("config://app");
-    expect(resources[0]!.name).toBe("App Config");
-    expect(resources[0]!.content).toBe("This is the config resource.");
-  });
-
-  it("parses multiple resource blocks", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      [
-        "uri: config://app\nname: App Config",
-        "Config content here.",
-        "uri: data://schema\nname: Schema",
-        "Schema content here.",
-      ].join("\n---\n")
-    );
-    const resources = await loadResources(dir);
-    expect(resources).toHaveLength(2);
-    expect(resources[0]!.uri).toBe("config://app");
-    expect(resources[1]!.uri).toBe("data://schema");
-    expect(resources[1]!.content).toBe("Schema content here.");
-  });
-
-  it("throws when a block is missing uri", async () => {
-    const dir = mkTmp();
-    writeResources(dir, "name: App Config\n---\nSome content.");
-    await expect(loadResources(dir)).rejects.toThrow(
-      "resources.md block 1 is missing required frontmatter field: uri"
-    );
-  });
-
-  it("handles empty body gracefully", async () => {
-    const dir = mkTmp();
-    writeResources(dir, "uri: config://app\n---\n");
-    const resources = await loadResources(dir);
-    expect(resources[0]!.content).toBe("");
-  });
-
-  it("throws when resources.md is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadResources(dir)).rejects.toThrow();
-  });
-
-  it("parses optional mimeType from frontmatter", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      "uri: config://app\nmimeType: application/json\n---\n{}"
-    );
-    const resources = await loadResources(dir);
-    expect(resources[0]!.mimeType).toBe("application/json");
-  });
-});

package/src/__tests__/loaders/tools.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadTools } from "../../loaders/tools.js";
-
-// CJS-format tools.js files work reliably in temp dirs without needing
-// a package.json with "type":"module" — Node exposes module.exports as .default
-// when imported via import().
-
-describe("loadTools", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-tools-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writeTools(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "tools.js"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("valid tools.js export passes", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [
-        { name: "read_file", description: "Read a file", schema: {}, handler: async () => ({}) }
-      ]`
-    );
-    const tools = await loadTools(dir);
-    expect(tools).toHaveLength(1);
-    expect(tools[0]!.name).toBe("read_file");
-    expect(tools[0]!.description).toBe("Read a file");
-  });
-
-  it("throws when tools.js is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadTools(dir)).rejects.toThrow("tools.js failed to load:");
-  });
-
-  it("throws when tools.js has a syntax error", async () => {
-    const dir = mkTmp();
-    writeTools(dir, `module.exports = [{ this is broken syntax`);
-    await expect(loadTools(dir)).rejects.toThrow("tools.js failed to load:");
-  });
-
-  it("throws when default export is not an array", async () => {
-    const dir = mkTmp();
-    writeTools(dir, `module.exports = { name: "not-an-array" }`);
-    await expect(loadTools(dir)).rejects.toThrow(
-      "tools.js failed to load: default export must be an array"
-    );
-  });
-
-  it("throws when name is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ description: "no name", schema: {}, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: name"
-    );
-  });
-
-  it("throws when description is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", schema: {}, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: description"
-    );
-  });
-
-  it("throws when schema is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: schema"
-    );
-  });
-
-  it("throws when handler is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", schema: {} }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: handler"
-    );
-  });
-
-  it("throws when handler is not a function", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", schema: {}, handler: "not-a-function" }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool 't': handler must be a function"
-    );
-  });
-
-  it("throws when schema field is a plain value instead of a Zod type", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "foo", description: "d", schema: { input: { type: "string" } }, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool 'foo': schema field 'input' must be a Zod type"
-    );
-  });
-});

package/src/__tests__/pack.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { runPack, SERVER_ENTRY_TEMPLATE } from "../commands/pack.js";
-
-function scaffoldPill(baseDir: string, name = "test-pill") {
-  const mcpillDir = path.join(baseDir, ".mcpill", "server");
-  fs.mkdirSync(mcpillDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(mcpillDir, "tools.js"),
-    `module.exports = [{ name: "t", description: "d", schema: {}, handler: async () => ({}) }]`
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "prompts.json"),
-    JSON.stringify([{ name: "p", args: {}, messages: [] }])
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "resources.md"),
-    "uri: config://app\n---\nContent."
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "mcpill.config.json"),
-    JSON.stringify({ name, transport: "stdio", port: 3333 })
-  );
-}
-
-describe("runPack", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-pack-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function mockExit() {
-    return vi
-      .spyOn(process, "exit")
-      .mockImplementation((_code?: number | string | null) => {
-        throw new Error("process.exit called");
-      });
-  }
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("writes bin/server.js with SERVER_ENTRY_TEMPLATE", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const serverJs = fs.readFileSync(path.join(base, "bin", "server.js"), "utf-8");
-    expect(serverJs).toBe(SERVER_ENTRY_TEMPLATE);
-  });
-
-  it("writes package.json with bin entry and mcpill-runtime dependency", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const pkg = JSON.parse(fs.readFileSync(path.join(base, "package.json"), "utf-8"));
-    expect(pkg.bin).toHaveProperty("test-pill");
-    expect(pkg.dependencies["mcpill-runtime"]).toBe("^0.1.0");
-  });
-
-  it("does not overwrite existing name/version in package.json", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    fs.writeFileSync(
-      path.join(base, "package.json"),
-      JSON.stringify({ name: "my-pill", version: "1.2.3" }, null, 2)
-    );
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const pkg = JSON.parse(fs.readFileSync(path.join(base, "package.json"), "utf-8"));
-    expect(pkg.name).toBe("my-pill");
-    expect(pkg.version).toBe("1.2.3");
-  });
-
-  it("throws when no pill directory is present", async () => {
-    const base = mkTmp();
-    mockExit();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runPack(base)).rejects.toThrow();
-  });
-});

package/src/__tests__/validate.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { runValidate } from "../commands/validate.js";
-
-// Sets up a minimal valid .<name>/ pill dir using CJS tools.js so dynamic
-// import works without a mcpill-runtime resolution in the temp tree.
-function scaffoldValid(mcpillDir: string) {
-  fs.mkdirSync(mcpillDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(mcpillDir, "tools.js"),
-    `module.exports = [{ name: "t", description: "d", schema: {}, handler: async () => ({}) }]`
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "prompts.json"),
-    JSON.stringify([{ name: "p", args: {}, messages: [] }])
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "resources.md"),
-    "uri: config://app\n---\nContent."
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "mcpill.config.json"),
-    JSON.stringify({ name: "srv", transport: "stdio", port: 3333 })
-  );
-}
-
-describe("runValidate", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-validate-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function mockExit() {
-    return vi
-      .spyOn(process, "exit")
-      .mockImplementation((_code?: number | string | null) => {
-        throw new Error("process.exit called");
-      });
-  }
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("passes on a valid scaffolded pill dir", async () => {
-    const base = mkTmp();
-    const mcpillDir = path.join(base, ".mcpill", "server");
-    scaffoldValid(mcpillDir);
-
-    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    await runValidate(base);
-    expect(logSpy).toHaveBeenCalledWith("✓ Valid: 1 tools, 1 prompts, 1 resources");
-  });
-
-  it("exits with code 1 when no pill directories found", async () => {
-    const base = mkTmp();
-    const exitSpy = mockExit();
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runValidate(base)).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errSpy).toHaveBeenCalledWith(
-      "No pill directories found — run mcpill compile first"
-    );
-  });
-
-  it("collects and prints tool error then exits 1", async () => {
-    const base = mkTmp();
-    const mcpillDir = path.join(base, ".mcpill", "server");
-    scaffoldValid(mcpillDir);
-    // Break tools.js: handler is not a function
-    fs.writeFileSync(
-      path.join(mcpillDir, "tools.js"),
-      `module.exports = [{ name: "t", description: "d", schema: {}, handler: "bad" }]`
-    );
-
-    const exitSpy = mockExit();
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runValidate(base)).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errSpy).toHaveBeenCalledWith("Tool 't': handler must be a function");
-  });
-
-  it("collects and prints prompt error then exits 1", async () => {
-    const base = mkTmp();
-    const mcpillDir = path.join(base, ".mcpill", "server");
-    scaffoldValid(mcpillDir);
-    fs.writeFileSync(path.join(mcpillDir, "prompts.json"), "not json {{{");
-
-    const exitSpy = mockExit();
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runValidate(base)).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(
-      errSpy.mock.calls.some((c) =>
-        String(c[0]).startsWith("prompts.json is not valid JSON:")
-      )
-    ).toBe(true);
-  });
-
-  it("collects and prints resource error then exits 1", async () => {
-    const base = mkTmp();
-    const mcpillDir = path.join(base, ".mcpill", "server");
-    scaffoldValid(mcpillDir);
-    // Block missing uri
-    fs.writeFileSync(
-      path.join(mcpillDir, "resources.md"),
-      "name: No Uri\n---\nContent."
-    );
-
-    const exitSpy = mockExit();
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runValidate(base)).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errSpy).toHaveBeenCalledWith(
-      "resources.md block 1 is missing required frontmatter field: uri"
-    );
-  });
-
-  it("collects errors from multiple loaders before exiting", async () => {
-    const base = mkTmp();
-    const mcpillDir = path.join(base, ".mcpill", "server");
-    scaffoldValid(mcpillDir);
-    // Break both tools and prompts
-    fs.writeFileSync(
-      path.join(mcpillDir, "tools.js"),
-      `module.exports = [{ description: "d", schema: {}, handler: async () => ({}) }]`
-    );
-    fs.writeFileSync(path.join(mcpillDir, "prompts.json"), "bad json");
-
-    const exitSpy = mockExit();
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runValidate(base)).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    // Both errors must have been printed
-    const messages = errSpy.mock.calls.map((c) => String(c[0]));
-    expect(messages.some((m) => m.includes("Tool at index 0 is missing"))).toBe(true);
-    expect(messages.some((m) => m.startsWith("prompts.json is not valid JSON:"))).toBe(true);
-  });
-});

package/src/cli.ts

@@ -1,77 +0,0 @@
-import { Command } from "commander";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import { readFileSync } from "fs";
-import { runInit } from "./commands/init.js";
-import { runServer } from "./commands/run.js";
-import { runValidate } from "./commands/validate.js";
-import { runCompile } from "./commands/compile.js";
-import { runPack } from "./commands/pack.js";
-import { runPublish } from "./commands/publish.js";
-
-const pkgDir = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(pkgDir, "../package.json"), "utf-8")
-) as { version: string };
-
-const program = new Command();
-
-program.name("mcpill").version(pkg.version);
-
-program
-  .command("init")
-  .description("Scaffold a new .mcpill/ directory")
-  .option("--dir <path>", "Target directory")
-  .action(async (opts: { dir?: string }) => {
-    await runInit(opts);
-  });
-
-program
-  .command("run")
-  .description("Start the MCP server")
-  .option("--transport <transport>", "Transport type: stdio or http")
-  .option("--port <n>", "Port number (HTTP only)", parseInt)
-  .option("--dir <path>", "Directory containing .mcpill/")
-  .action(
-    async (opts: { transport?: "stdio" | "http"; port?: number; dir?: string }) => {
-      await runServer(opts);
-    }
-  );
-
-program
-  .command("validate")
-  .description("Validate .mcpill/ configuration")
-  .option("--dir <path>", "Directory containing .mcpill/")
-  .action(async (opts: { dir?: string }) => {
-    const { resolve } = await import("path");
-    await runValidate(resolve(opts.dir ?? process.cwd()));
-  });
-
-program
-  .command("compile")
-  .description("Compile server.md ↔ .mcpill/ files")
-  .option("--dir <path>", "Directory containing server.md and .mcpill/")
-  .option("--to-md", "Reverse: generate server.md from .mcpill/ files")
-  .option("--strict", "Error on missing tool handlers instead of generating stubs")
-  .option("--no-hooks", "Skip writing the PreToolUse hook to .claude/settings.json")
-  .action(async (opts: { dir?: string; toMd?: boolean; strict?: boolean; hooks?: boolean }) => {
-    await runCompile({ ...opts, noHooks: opts.hooks === false });
-  });
-
-program
-  .command("pack")
-  .description("Prepare pill for npm distribution")
-  .option("--dir <path>", "pill project root", ".")
-  .action(({ dir }: { dir: string }) => runPack(dir));
-
-program
-  .command("publish")
-  .description("Pack and publish pill to npm")
-  .option("--dir <path>", "pill project root", ".")
-  .option("--access <level>", "npm access level", "public")
-  .action(({ dir, access }: { dir: string; access: string }) => runPublish(dir, access));
-
-program.parseAsync(process.argv).catch((err) => {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-});