mcpill 1.1.0

package/dist/cli.js

@@ -0,0 +1,954 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import { dirname, join as join4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/commands/init.ts
+import fs from "fs";
+import path from "path";
+var TOOLS_JS = `import { z } from "mcpill-runtime";
+
+export default [
+  {
+    name: "read_file",
+    description: "Read the contents of a file",
+    schema: {
+      path: z.string().describe("Path to the file to read"),
+    },
+    handler: async ({ path: filePath }) => {
+      return { content: \`Contents of \${filePath}\` };
+    },
+  },
+];
+`;
+var PROMPTS_JSON = JSON.stringify(
+  [
+    {
+      name: "summarize",
+      description: "Summarize the given text",
+      args: {
+        text: { type: "string" }
+      },
+      messages: [
+        {
+          role: "user",
+          content: "Please summarize the following text:\n\n{{text}}"
+        }
+      ]
+    }
+  ],
+  null,
+  2
+);
+var RESOURCES_MD = `uri: config://app
+name: App Config
+---
+This resource exposes the application configuration.
+`;
+var SERVER_MD_TEMPLATE = `## Config
+name: my-server
+transport: stdio
+
+## Resources
+uri: info://status
+name: Status
+---
+The server is running.
+`;
+var ECHO_TOOL_MD = `# echo
+
+Echo a message back
+
+## Parameters
+
+- message (string): The message to echo
+
+## Handler
+
+\`\`\`js
+async ({ message }) => {
+  return { content: [{ type: "text", text: message }] };
+}
+\`\`\`
+`;
+var GREETING_PROMPT_MD = `# greeting
+
+Generate a greeting
+
+## Args
+
+- name (string): The name to greet
+
+## Message
+
+> user: Say hello to {{name}}
+`;
+async function runInit(opts) {
+  const targetDir = path.resolve(opts.dir ?? process.cwd());
+  const mcpillDir = path.join(targetDir, ".mcpill");
+  const projectName = path.basename(targetDir);
+  if (fs.existsSync(mcpillDir)) {
+    console.error(".mcpill/ already exists. Remove it manually to re-init.");
+    process.exit(1);
+  }
+  const configJson = JSON.stringify(
+    { name: projectName, transport: "stdio", port: 3333 },
+    null,
+    2
+  );
+  fs.mkdirSync(mcpillDir, { recursive: true });
+  fs.writeFileSync(path.join(mcpillDir, "tools.js"), TOOLS_JS);
+  fs.writeFileSync(path.join(mcpillDir, "prompts.json"), PROMPTS_JSON);
+  fs.writeFileSync(path.join(mcpillDir, "resources.md"), RESOURCES_MD);
+  fs.writeFileSync(path.join(mcpillDir, "mcpill.config.json"), configJson);
+  const toolsDir = path.join(targetDir, "tools");
+  const promptsDir = path.join(targetDir, "prompts");
+  fs.mkdirSync(toolsDir, { recursive: true });
+  fs.mkdirSync(promptsDir, { recursive: true });
+  fs.writeFileSync(path.join(toolsDir, "echo.md"), ECHO_TOOL_MD);
+  fs.writeFileSync(path.join(promptsDir, "greeting.md"), GREETING_PROMPT_MD);
+  const serverMd = SERVER_MD_TEMPLATE.replace(
+    "name: my-server",
+    `name: ${projectName}`
+  );
+  fs.writeFileSync(path.join(targetDir, "server.md"), serverMd);
+  const pkgJson = JSON.stringify(
+    {
+      name: projectName,
+      version: "0.1.0",
+      private: true,
+      scripts: { pack: "mcpill pack", publish: "mcpill publish" }
+    },
+    null,
+    2
+  );
+  fs.writeFileSync(path.join(targetDir, "package.json"), pkgJson);
+  console.log("\u2713 .mcpill/tools.js");
+  console.log("\u2713 .mcpill/prompts.json");
+  console.log("\u2713 .mcpill/resources.md");
+  console.log("\u2713 .mcpill/mcpill.config.json");
+  console.log("\u2713 tools/echo.md");
+  console.log("\u2713 prompts/greeting.md");
+  console.log("\u2713 server.md");
+  console.log("\u2713 package.json");
+  console.log("Edit your tools, then run: mcpill run");
+}
+
+// src/commands/run.ts
+import path7 from "path";
+import fs6 from "fs";
+import { z as z2 } from "mcpill-runtime";
+import { createServer } from "mcpster";
+
+// src/loaders/config.ts
+import fs2 from "fs";
+import path2 from "path";
+var defaults = {
+  name: "mcpill-server",
+  transport: "stdio",
+  port: 3333
+};
+async function loadConfig(mcpillDir) {
+  const configPath = path2.join(mcpillDir, "mcpill.config.json");
+  if (!fs2.existsSync(configPath)) {
+    return { ...defaults };
+  }
+  const raw = JSON.parse(
+    fs2.readFileSync(configPath, "utf-8")
+  );
+  return { ...defaults, ...raw };
+}
+
+// src/loaders/tools.ts
+import { pathToFileURL } from "url";
+import path3 from "path";
+async function loadTools(mcpillDir) {
+  const toolsPath = path3.join(mcpillDir, "tools.js");
+  let mod;
+  try {
+    mod = await import(pathToFileURL(toolsPath).href);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`tools.js failed to load: ${msg}`);
+  }
+  const tools = mod.default;
+  if (!Array.isArray(tools)) {
+    throw new Error("tools.js failed to load: default export must be an array");
+  }
+  for (let i = 0; i < tools.length; i++) {
+    const tool = tools[i];
+    for (const field of ["name", "description", "schema", "handler"]) {
+      if (tool[field] === void 0 || tool[field] === null) {
+        throw new Error(`Tool at index ${i} is missing required field: ${field}`);
+      }
+    }
+    if (typeof tool["name"] !== "string") {
+      throw new Error(`Tool at index ${i} is missing required field: name`);
+    }
+    if (typeof tool["description"] !== "string") {
+      throw new Error(`Tool at index ${i} is missing required field: description`);
+    }
+    if (typeof tool["schema"] !== "object" || Array.isArray(tool["schema"]) || tool["schema"] === null) {
+      throw new Error(`Tool at index ${i} is missing required field: schema`);
+    }
+    const name = tool["name"];
+    for (const [key, value] of Object.entries(tool["schema"])) {
+      if (value == null || typeof value !== "object" || !("_def" in value)) {
+        throw new Error(
+          `Tool '${name}': schema field '${key}' must be a Zod type (e.g. z.string()). Got a plain value instead.`
+        );
+      }
+    }
+    if (typeof tool["handler"] !== "function") {
+      throw new Error(`Tool '${tool["name"]}': handler must be a function`);
+    }
+  }
+  return tools;
+}
+
+// src/loaders/prompts.ts
+import fs3 from "fs";
+import path4 from "path";
+import { z } from "mcpill-runtime";
+var typeMap = {
+  string: z.string(),
+  number: z.number(),
+  boolean: z.boolean()
+};
+async function loadPrompts(mcpillDir) {
+  const promptsPath = path4.join(mcpillDir, "prompts.json");
+  let raw;
+  try {
+    const content = fs3.readFileSync(promptsPath, "utf-8");
+    raw = JSON.parse(content);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`prompts.json is not valid JSON: ${msg}`);
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("prompts.json is not valid JSON: must be an array");
+  }
+  const prompts = [];
+  for (const entry of raw) {
+    const argsShape = {};
+    const args = entry["args"] ?? {};
+    for (const [argName, argDef] of Object.entries(args)) {
+      const typeName = argDef.type;
+      if (!(typeName in typeMap)) {
+        throw new Error(
+          `Prompt '${entry["name"]}': arg '${argName}' uses unsupported type '${typeName}'. Supported: string, number, boolean`
+        );
+      }
+      argsShape[argName] = typeMap[typeName];
+    }
+    prompts.push({
+      name: entry["name"],
+      description: entry["description"],
+      argsShape,
+      messages: entry["messages"]
+    });
+  }
+  return prompts;
+}
+
+// src/loaders/resources.ts
+import fs4 from "fs";
+import path5 from "path";
+function parseFrontmatter(block) {
+  const result = {};
+  for (const line of block.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+async function loadResources(mcpillDir) {
+  const resourcesPath = path5.join(mcpillDir, "resources.md");
+  const fileContent = fs4.readFileSync(resourcesPath, "utf-8");
+  const blocks = fileContent.split("\n---\n");
+  const resources = [];
+  for (let i = 0; i < blocks.length; i += 2) {
+    const frontmatterBlock = blocks[i] ?? "";
+    if (frontmatterBlock.trim() === "") continue;
+    const bodyBlock = blocks[i + 1] ?? "";
+    const frontmatter = parseFrontmatter(frontmatterBlock);
+    if (!frontmatter["uri"]) {
+      throw new Error(
+        `resources.md block ${i + 1} is missing required frontmatter field: uri`
+      );
+    }
+    resources.push({
+      uri: frontmatter["uri"],
+      name: frontmatter["name"],
+      mimeType: frontmatter["mimeType"],
+      content: bodyBlock.trim()
+    });
+  }
+  return resources;
+}
+
+// src/commands/validate.ts
+import fs5 from "fs";
+import path6 from "path";
+async function validateOne(mcpillDir) {
+  const errors = [];
+  let toolCount = 0;
+  let promptCount = 0;
+  let resourceCount = 0;
+  try {
+    const tools = await loadTools(mcpillDir);
+    toolCount = tools.length;
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  try {
+    const prompts = await loadPrompts(mcpillDir);
+    promptCount = prompts.length;
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  try {
+    const resources = await loadResources(mcpillDir);
+    resourceCount = resources.length;
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  try {
+    await loadConfig(mcpillDir);
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  if (errors.length > 0) {
+    for (const error of errors) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Valid: ${toolCount} tools, ${promptCount} prompts, ${resourceCount} resources`);
+}
+async function runValidate(baseDir) {
+  const pillDirs = fs5.readdirSync(baseDir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory() && /^\.[a-z][a-z0-9-]*$/.test(e.name) && fs5.existsSync(path6.join(baseDir, e.name, "mcpill.config.json"))
+  ).map((e) => path6.join(baseDir, e.name));
+  if (pillDirs.length === 0) {
+    console.error("No pill directories found \u2014 run mcpill compile first");
+    process.exit(1);
+  }
+  for (const mcpillDir of pillDirs) {
+    await validateOne(mcpillDir);
+  }
+}
+
+// src/commands/run.ts
+async function runServer(opts) {
+  const baseDir = path7.resolve(opts.dir ?? process.cwd());
+  await runValidate(baseDir);
+  const pillDirs = fs6.readdirSync(baseDir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory() && /^\.[a-z][a-z0-9-]*$/.test(e.name) && fs6.existsSync(path7.join(baseDir, e.name, "mcpill.config.json"))
+  ).map((e) => path7.join(baseDir, e.name));
+  const mcpillDir = pillDirs[0];
+  const [tools, prompts, resources, config] = await Promise.all([
+    loadTools(mcpillDir),
+    loadPrompts(mcpillDir),
+    loadResources(mcpillDir),
+    loadConfig(mcpillDir)
+  ]);
+  const transport = opts.transport ?? config.transport;
+  const port = opts.port ?? config.port;
+  const { name } = config;
+  const server = createServer({
+    name,
+    version: "0.1.0",
+    transport,
+    http: { port }
+  });
+  for (const { name: toolName, description, schema, handler } of tools) {
+    server.defineTool({
+      name: toolName,
+      description,
+      schema: z2.object(schema),
+      handler
+    });
+  }
+  for (const { name: promptName, description, messages } of prompts) {
+    server.definePrompt({
+      name: promptName,
+      description,
+      handler: async (args) => messages.map(
+        (m) => m.content.replace(
+          /\{\{(\w+)\}\}/g,
+          (_, k) => String(args[k] ?? "")
+        )
+      ).join("\n")
+    });
+  }
+  for (const { uri, name: resourceName, content } of resources) {
+    server.defineResource({
+      uri,
+      description: resourceName ?? uri,
+      resolver: async () => content
+    });
+  }
+  try {
+    await server.start();
+  } catch (err) {
+    const nodeErr = err;
+    if (nodeErr.code === "EADDRINUSE") {
+      console.error(
+        `Port ${port} is already in use. Use --port to specify another.`
+      );
+      process.exit(1);
+    }
+    throw err;
+  }
+  process.stderr.write(
+    `\u2713 MCPill running \u2014 ${tools.length} tools, ${prompts.length} prompts, ${resources.length} resources [${transport}]
+`
+  );
+}
+
+// src/commands/compile.ts
+import { resolve, join as join3 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync, readdirSync as readdirSync2 } from "fs";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/compiler/parse.ts
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+function extractSections(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const pieces = ("\n" + content).split("\n## ");
+  for (const piece of pieces) {
+    if (!piece.trim()) continue;
+    const nlIdx = piece.indexOf("\n");
+    if (nlIdx === -1) continue;
+    const name = piece.slice(0, nlIdx).trim();
+    const body = piece.slice(nlIdx + 1);
+    sections.set(name, body);
+  }
+  return sections;
+}
+function extractFencedBlock(body, lang) {
+  const startMarker = "```" + lang + "\n";
+  const start = body.indexOf(startMarker);
+  if (start === -1) return null;
+  const contentStart = start + startMarker.length;
+  const end = body.indexOf("\n```", contentStart);
+  if (end === -1) return body.slice(contentStart).trim();
+  return body.slice(contentStart, end).trim();
+}
+function parseKvBlock(body) {
+  const result = {};
+  for (const line of body.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+function parseFrontmatter2(block) {
+  return parseKvBlock(block);
+}
+function parseResourcesSection(body) {
+  const resources = [];
+  const blocks = body.split("\n---\n");
+  for (let i = 0; i < blocks.length; i += 2) {
+    const frontmatterBlock = (blocks[i] ?? "").trim();
+    if (!frontmatterBlock) continue;
+    const bodyBlock = blocks[i + 1] ?? "";
+    const frontmatter = parseFrontmatter2(frontmatterBlock);
+    if (!frontmatter["uri"]) continue;
+    resources.push({
+      uri: frontmatter["uri"],
+      name: frontmatter["name"],
+      mimeType: frontmatter["mimeType"],
+      content: bodyBlock.trim()
+    });
+  }
+  return resources;
+}
+function parseToolFile(content) {
+  const lines = content.split("\n");
+  const h1Line = lines.find((l) => l.startsWith("# "));
+  const name = h1Line ? h1Line.slice(2).trim() : "";
+  let h1Seen = false;
+  let description = "";
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      h1Seen = true;
+      continue;
+    }
+    if (!h1Seen) continue;
+    if (line.startsWith("#")) break;
+    const trimmed = line.trim();
+    if (trimmed) {
+      description = trimmed;
+      break;
+    }
+  }
+  const sections = extractSections(content);
+  const parametersBody = sections.get("Parameters") ?? "";
+  const schema = {};
+  for (const line of parametersBody.split("\n")) {
+    if (!line.startsWith("- ")) continue;
+    const m = line.match(/^- (\w+) \(([^)]+)\): (.+)/);
+    if (!m) continue;
+    const pName = m[1];
+    const typeStr = m[2].split(",")[0].trim();
+    const desc = m[3].trim();
+    schema[pName] = { type: typeStr, description: desc };
+  }
+  const handlerBody = sections.get("Handler") ?? "";
+  const handler = extractFencedBlock(handlerBody, "js") ?? void 0;
+  return { name, description, schema, handler };
+}
+function parsePromptFile(content) {
+  const lines = content.split("\n");
+  const h1Line = lines.find((l) => l.startsWith("# "));
+  const name = h1Line ? h1Line.slice(2).trim() : "";
+  let h1Seen = false;
+  let description = "";
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      h1Seen = true;
+      continue;
+    }
+    if (!h1Seen) continue;
+    if (line.startsWith("#")) break;
+    const trimmed = line.trim();
+    if (trimmed) {
+      description = trimmed;
+      break;
+    }
+  }
+  const sections = extractSections(content);
+  const argsBody = sections.get("Args") ?? "";
+  const args = {};
+  for (const line of argsBody.split("\n")) {
+    if (!line.startsWith("- ")) continue;
+    const m = line.match(/^- (\w+) \(([^)]+)\): .+/);
+    if (!m) continue;
+    args[m[1]] = { type: m[2].trim() };
+  }
+  const messageBody = sections.get("Message") ?? "";
+  const messages = [];
+  for (const line of messageBody.split("\n")) {
+    if (!line.startsWith("> ")) continue;
+    const colonIdx = line.indexOf(": ", 2);
+    if (colonIdx === -1) continue;
+    const role = line.slice(2, colonIdx).trim();
+    const msgContent = line.slice(colonIdx + 2).trim();
+    messages.push({ role, content: msgContent });
+  }
+  return { name, description, args, messages };
+}
+function parseServerDir(dir) {
+  const serverMdContent = readFileSync(join(dir, "server.md"), "utf-8");
+  const sections = extractSections(serverMdContent);
+  const configBody = sections.get("Config") ?? "";
+  const configKv = parseKvBlock(configBody);
+  const config = {
+    name: configKv["name"] ?? "",
+    transport: configKv["transport"] ?? "stdio",
+    ...configKv["port"] ? { port: parseInt(configKv["port"], 10) } : {}
+  };
+  const resourcesBody = sections.get("Resources") ?? "";
+  const resources = parseResourcesSection(resourcesBody);
+  const toolsDir = join(dir, "tools");
+  const tools = [];
+  let toolFiles = [];
+  try {
+    toolFiles = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
+  } catch {
+  }
+  for (const file of toolFiles) {
+    tools.push(parseToolFile(readFileSync(join(toolsDir, file), "utf-8")));
+  }
+  const promptsDir = join(dir, "prompts");
+  const prompts = [];
+  let promptFiles = [];
+  try {
+    promptFiles = readdirSync(promptsDir).filter((f) => f.endsWith(".md"));
+  } catch {
+  }
+  for (const file of promptFiles) {
+    prompts.push(parsePromptFile(readFileSync(join(promptsDir, file), "utf-8")));
+  }
+  return { config, tools, prompts, resources };
+}
+
+// src/compiler/serialize.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+function serializeResources(resources) {
+  return resources.map((r) => {
+    let fm = `uri: ${r.uri}`;
+    if (r.name) fm += `
+name: ${r.name}`;
+    if (r.mimeType) fm += `
+mimeType: ${r.mimeType}`;
+    return `${fm}
+---
+${r.content}`;
+  }).join("\n---\n");
+}
+function serializeServerDir(doc, dir) {
+  mkdirSync(join2(dir, "tools"), { recursive: true });
+  mkdirSync(join2(dir, "prompts"), { recursive: true });
+  let serverMd = "## Config\n";
+  serverMd += `name: ${doc.config.name}
+`;
+  serverMd += `transport: ${doc.config.transport}
+`;
+  if (doc.config.port !== void 0) serverMd += `port: ${doc.config.port}
+`;
+  if (doc.resources.length > 0) {
+    serverMd += `
+## Resources
+${serializeResources(doc.resources)}
+`;
+  } else {
+    serverMd += "\n## Resources\n";
+  }
+  writeFileSync(join2(dir, "server.md"), serverMd);
+  console.log("\u2713 server.md updated");
+  for (const tool of doc.tools) {
+    let md = `# ${tool.name}
+
+${tool.description}
+
+## Parameters
+
+`;
+    for (const [pName, pDef] of Object.entries(tool.schema)) {
+      md += `- ${pName} (${pDef.type}): ${pDef.description ?? pName}
+`;
+    }
+    if (tool.handler !== void 0) {
+      const cleanHandler = tool.handler.split("\n").filter((l) => !l.trim().startsWith("// @handler:") && !l.trim().startsWith("// @end-handler:")).join("\n").trim();
+      md += `
+## Handler
+
+\`\`\`js
+${cleanHandler}
+\`\`\`
+`;
+    }
+    writeFileSync(join2(dir, "tools", `${tool.name}.md`), md);
+  }
+  for (const prompt of doc.prompts) {
+    let md = `# ${prompt.name}
+
+`;
+    if (prompt.description) md += `${prompt.description}
+
+`;
+    if (Object.keys(prompt.args).length > 0) {
+      md += "## Args\n\n";
+      for (const [argName, argDef] of Object.entries(prompt.args)) {
+        md += `- ${argName} (${argDef.type}): ${argName}
+`;
+      }
+      md += "\n";
+    }
+    if (prompt.messages.length > 0) {
+      md += "## Message\n\n";
+      for (const msg of prompt.messages) {
+        md += `> ${msg.role}: ${msg.content}
+`;
+      }
+    }
+    writeFileSync(join2(dir, "prompts", `${prompt.name}.md`), md);
+  }
+  console.log(`\u2713 tools/ updated (${doc.tools.length} files)`);
+  console.log(`\u2713 prompts/ updated (${doc.prompts.length} files)`);
+}
+
+// src/compiler/merge-tools.ts
+function dedent(s) {
+  const lines = s.split("\n");
+  const nonEmpty = lines.filter((l) => l.trim());
+  if (nonEmpty.length === 0) return s;
+  const minIndent = nonEmpty.reduce((min, l) => {
+    const m = l.match(/^([ \t]*)/);
+    return Math.min(min, m?.[1]?.length ?? 0);
+  }, Infinity);
+  return lines.map((l) => l.slice(minIndent === Infinity ? 0 : minIndent)).join("\n");
+}
+function extractHandlers(toolsJsContent) {
+  const result = /* @__PURE__ */ new Map();
+  const markerRegex = /[ \t]*\/\/ @handler:([^\n]+)\n([\s\S]*?)\n[ \t]*\/\/ @end-handler:[^\n]+/g;
+  let match;
+  while ((match = markerRegex.exec(toolsJsContent)) !== null) {
+    result.set(match[1].trim(), dedent(match[2]).trim());
+  }
+  if (result.size > 0) return result;
+  const nameRegex = /name:\s*["']([^"']+)["']/g;
+  while ((match = nameRegex.exec(toolsJsContent)) !== null) {
+    const toolName = match[1];
+    const handlerKeyIdx = toolsJsContent.indexOf("handler:", match.index);
+    if (handlerKeyIdx === -1) continue;
+    const expr = extractExpression(toolsJsContent, handlerKeyIdx + "handler:".length);
+    if (expr) result.set(toolName, expr);
+  }
+  return result;
+}
+function extractExpression(src, start) {
+  let i = start;
+  while (i < src.length && /[ \t]/.test(src[i])) i++;
+  const exprStart = i;
+  let depth = 0;
+  let inStr = null;
+  while (i < src.length) {
+    const ch = src[i];
+    if (inStr) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === inStr) inStr = null;
+    } else if (ch === '"' || ch === "'" || ch === "`") {
+      inStr = ch;
+    } else if (ch === "{" || ch === "(" || ch === "[") {
+      depth++;
+    } else if (ch === "}" || ch === ")" || ch === "]") {
+      depth--;
+      if (depth === 0) {
+        const rest = src.slice(i + 1);
+        const arrowMatch = rest.match(/^[ \t]*=>/);
+        if (arrowMatch) {
+          i += 1 + arrowMatch[0].length;
+          while (i < src.length && /[ \t]/.test(src[i])) i++;
+          continue;
+        }
+        return src.slice(exprStart, i + 1).trim();
+      }
+    } else if (depth === 0 && (ch === "," || ch === ";" || ch === "\n")) {
+      break;
+    }
+    i++;
+  }
+  if (i > exprStart) return src.slice(exprStart, i).trim();
+  return null;
+}
+function mergeHandlers(doc, existing) {
+  const stubbed = [];
+  const tools = doc.tools.map((tool) => {
+    if (tool.handler !== void 0) return tool;
+    const found = existing.get(tool.name);
+    if (found !== void 0) return { ...tool, handler: found };
+    stubbed.push(tool.name);
+    return {
+      ...tool,
+      handler: `async () => ({ content: [{ type: 'text', text: 'TODO: implement ${tool.name}' }] })`
+    };
+  });
+  return { doc: { ...doc, tools }, stubbed };
+}
+
+// src/commands/compile.ts
+var zodTypeNameMap = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBoolean: "boolean"
+};
+function generateToolsJs(tools) {
+  const lines = [`import { z } from 'mcpill-runtime';
+
+export default [`];
+  for (const tool of tools) {
+    const schemaLines = Object.entries(tool.schema).map(([key, def]) => {
+      const zodCall = def.description ? `z.${def.type}().describe(${JSON.stringify(def.description)})` : `z.${def.type}()`;
+      return `      ${key}: ${zodCall},`;
+    });
+    const handlerBody = (tool.handler ?? "").split("\n").map((l) => `      ${l}`).join("\n");
+    lines.push(
+      `  {`,
+      `    name: ${JSON.stringify(tool.name)},`,
+      `    description: ${JSON.stringify(tool.description)},`,
+      `    schema: {`,
+      ...schemaLines,
+      `    },`,
+      `    handler:`,
+      `      // @handler:${tool.name}`,
+      handlerBody,
+      `      // @end-handler:${tool.name}`,
+      `    ,`,
+      `  },`
+    );
+  }
+  lines.push(`];`);
+  return lines.join("\n") + "\n";
+}
+function serializeResourcesMd(resources) {
+  if (resources.length === 0) return "";
+  return resources.map((r) => {
+    let fm = `uri: ${r.uri}`;
+    if (r.name) fm += `
+name: ${r.name}`;
+    if (r.mimeType) fm += `
+mimeType: ${r.mimeType}`;
+    return `${fm}
+---
+${r.content}`;
+  }).join("\n---\n") + "\n";
+}
+function findPillDirs(baseDir) {
+  return readdirSync2(baseDir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory() && /^\.[a-z][a-z0-9-]*$/.test(e.name) && existsSync(join3(baseDir, e.name, "mcpill.config.json"))
+  ).map((e) => join3(baseDir, e.name));
+}
+async function runCompile(opts) {
+  const baseDir = resolve(opts.dir ?? process.cwd());
+  if (opts.toMd) {
+    const pillDirs = findPillDirs(baseDir);
+    if (pillDirs.length === 0) {
+      throw new Error("No pill directories found \u2014 run mcpill compile first");
+    }
+    const mcpillDir2 = pillDirs[0];
+    const config = await loadConfig(mcpillDir2);
+    const resources = await loadResources(mcpillDir2);
+    const promptsPath = join3(mcpillDir2, "prompts.json");
+    const prompts = JSON.parse(readFileSync2(promptsPath, "utf-8"));
+    const toolsPath = join3(mcpillDir2, "tools.js");
+    const handlers = existsSync(toolsPath) ? extractHandlers(readFileSync2(toolsPath, "utf-8")) : /* @__PURE__ */ new Map();
+    let tools = [];
+    if (existsSync(toolsPath)) {
+      const mod = await import(pathToFileURL2(toolsPath).href);
+      tools = mod.default.map((t) => {
+        const schema = {};
+        for (const [key, val] of Object.entries(t.schema)) {
+          const def = val._def;
+          const type = zodTypeNameMap[def.typeName] ?? "string";
+          schema[key] = def.description ? { type, description: def.description } : { type };
+        }
+        return {
+          name: t.name,
+          description: t.description,
+          schema,
+          handler: handlers.get(t.name)
+        };
+      });
+    }
+    const doc2 = {
+      config: {
+        name: config.name,
+        transport: config.transport,
+        ...config.port !== 3333 ? { port: config.port } : {}
+      },
+      tools,
+      prompts,
+      resources
+    };
+    serializeServerDir(doc2, baseDir);
+    return;
+  }
+  const doc = parseServerDir(baseDir);
+  const mcpillDir = join3(baseDir, "." + doc.config.name);
+  const toolsJsPath = join3(mcpillDir, "tools.js");
+  const existing = existsSync(toolsJsPath) ? extractHandlers(readFileSync2(toolsJsPath, "utf-8")) : /* @__PURE__ */ new Map();
+  const { doc: mergedDoc, stubbed } = mergeHandlers(doc, existing);
+  if (opts.strict && stubbed.length > 0) {
+    throw new Error("Missing handlers for: " + stubbed.join(", "));
+  }
+  for (const name of stubbed) {
+    console.warn(`\u26A0  Stub generated for tool: ${name}`);
+  }
+  mkdirSync2(mcpillDir, { recursive: true });
+  writeFileSync2(join3(mcpillDir, "mcpill.config.json"), JSON.stringify(mergedDoc.config, null, 2));
+  writeFileSync2(join3(mcpillDir, "prompts.json"), JSON.stringify(mergedDoc.prompts, null, 2));
+  writeFileSync2(join3(mcpillDir, "resources.md"), serializeResourcesMd(mergedDoc.resources));
+  writeFileSync2(toolsJsPath, generateToolsJs(mergedDoc.tools));
+  const pillDirName = "." + doc.config.name;
+  console.log(`\u2713 ${pillDirName}/ updated from server.md, tools/, prompts/`);
+}
+
+// src/commands/pack.ts
+import fs7 from "fs";
+import path8 from "path";
+var SERVER_ENTRY_TEMPLATE = "import { runPill } from 'mcpill-runtime';\nrunPill();\n";
+function resolvePillDir(baseDir) {
+  const entries = fs7.readdirSync(baseDir, { withFileTypes: true });
+  const pill = entries.find(
+    (e) => e.isDirectory() && /^\.[a-z][a-z0-9-]*$/.test(e.name) && fs7.existsSync(path8.join(baseDir, e.name, "mcpill.config.json"))
+  );
+  if (!pill) {
+    throw new Error("No pill directory found \u2014 run mcpill compile first");
+  }
+  return path8.join(baseDir, pill.name);
+}
+async function runPack(dir) {
+  const baseDir = path8.resolve(dir);
+  await runValidate(baseDir);
+  const pillDir = resolvePillDir(baseDir);
+  const config = await loadConfig(pillDir);
+  const { name } = config;
+  fs7.mkdirSync(path8.join(baseDir, "bin"), { recursive: true });
+  fs7.writeFileSync(path8.join(baseDir, "bin", "server.js"), SERVER_ENTRY_TEMPLATE);
+  const pkgPath = path8.join(baseDir, "package.json");
+  let pkg2 = {};
+  if (fs7.existsSync(pkgPath)) {
+    pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  }
+  pkg2.type = "module";
+  pkg2.bin = { [name]: "bin/server.js" };
+  const deps = pkg2.dependencies ?? {};
+  if (!deps["mcpill-runtime"]) {
+    deps["mcpill-runtime"] = "^0.1.0";
+  }
+  pkg2.dependencies = deps;
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n");
+  console.log(`\u2713 ${name} packed \u2014 bin/server.js + package.json ready`);
+}
+
+// src/commands/publish.ts
+import { spawnSync } from "child_process";
+import path9 from "path";
+async function runPublish(dir, access) {
+  const baseDir = path9.resolve(dir);
+  await runPack(baseDir);
+  const result = spawnSync("npm", ["publish", "--access", access], {
+    cwd: baseDir,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    throw new Error("npm publish failed");
+  }
+}
+
+// src/cli.ts
+var pkgDir = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(
+  readFileSync3(join4(pkgDir, "../package.json"), "utf-8")
+);
+var 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) => {
+  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) => {
+    await runServer(opts);
+  }
+);
+program.command("validate").description("Validate .mcpill/ configuration").option("--dir <path>", "Directory containing .mcpill/").action(async (opts) => {
+  const { resolve: resolve2 } = await import("path");
+  await runValidate(resolve2(opts.dir ?? process.cwd()));
+});
+program.command("compile").description("Compile server.md \u2194 .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").action(async (opts) => {
+  await runCompile(opts);
+});
+program.command("pack").description("Prepare pill for npm distribution").option("--dir <path>", "pill project root", ".").action(({ dir }) => 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 }) => runPublish(dir, access));
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});