mcpill 1.1.0

package/src/loaders/prompts.ts

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import { z } from "mcpill-runtime";
+
+type ZodRawShape = Record<string, z.ZodTypeAny>;
+
+export type RawPromptDef = {
+  name: string;
+  description?: string;
+  argsShape: ZodRawShape;
+  messages: Array<{ role: string; content: string }>;
+};
+
+const typeMap: Record<string, z.ZodTypeAny> = {
+  string: z.string(),
+  number: z.number(),
+  boolean: z.boolean(),
+};
+
+export async function loadPrompts(mcpillDir: string): Promise<RawPromptDef[]> {
+  const promptsPath = path.join(mcpillDir, "prompts.json");
+  let raw: unknown;
+  try {
+    const content = fs.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: RawPromptDef[] = [];
+
+  for (const entry of raw as Array<Record<string, unknown>>) {
+    const argsShape: ZodRawShape = {};
+    const args = (entry["args"] ?? {}) as Record<string, { type: string }>;
+
+    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"] as string,
+      description: entry["description"] as string | undefined,
+      argsShape,
+      messages: entry["messages"] as Array<{ role: string; content: string }>,
+    });
+  }
+
+  return prompts;
+}

package/src/loaders/resources.ts

@@ -0,0 +1,54 @@
+import fs from "fs";
+import path from "path";
+
+export type RawResourceDef = {
+  uri: string;
+  name?: string;
+  mimeType?: string;
+  content: string;
+};
+
+function parseFrontmatter(block: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  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;
+}
+
+export async function loadResources(mcpillDir: string): Promise<RawResourceDef[]> {
+  const resourcesPath = path.join(mcpillDir, "resources.md");
+  const fileContent = fs.readFileSync(resourcesPath, "utf-8");
+  const blocks = fileContent.split("\n---\n");
+
+  const resources: RawResourceDef[] = [];
+
+  // blocks alternate: [frontmatter, body, frontmatter, body, ...]
+  // even indices (0-indexed) = frontmatter = block N (1-indexed odd)
+  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;
+}

package/src/loaders/tools.ts

@@ -0,0 +1,63 @@
+import { pathToFileURL } from "url";
+import path from "path";
+
+export type RawToolDef = {
+  name: string;
+  description: string;
+  schema: Record<string, unknown>;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  handler: Function;
+};
+
+export async function loadTools(mcpillDir: string): Promise<RawToolDef[]> {
+  const toolsPath = path.join(mcpillDir, "tools.js");
+  let mod: unknown;
+  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 as { default?: unknown }).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] as Record<string, unknown>;
+
+    for (const field of ["name", "description", "schema", "handler"] as const) {
+      if (tool[field] === undefined || 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"] as string;
+    for (const [key, value] of Object.entries(tool["schema"] as Record<string, unknown>)) {
+      if (value == null || typeof value !== "object" || !("_def" in (value as object))) {
+        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 as RawToolDef[];
+}

package/src/templates/prompts/greeting.md

@@ -0,0 +1,11 @@
+# greeting
+
+Generate a greeting
+
+## Args
+
+- name (string): The name to greet
+
+## Message
+
+> user: Say hello to {{name}}

package/src/templates/server.md

@@ -0,0 +1,9 @@
+## Config
+name: my-server
+transport: stdio
+
+## Resources
+uri: info://status
+name: Status
+---
+The server is running.

package/src/templates/tools/echo.md

@@ -0,0 +1,15 @@
+# echo
+
+Echo a message back
+
+## Parameters
+
+- message (string): The message to echo
+
+## Handler
+
+```js
+async ({ message }) => {
+  return { content: [{ type: "text", text: message }] };
+}
+```

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/cli.ts"],
+  format: ["esm"],
+  target: "node18",
+  platform: "node",
+  shims: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "lcov"],
+    },
+  },
+});