@modootoday/pmcp 0.9.1 → 0.10.0

package/dist/chunk-JRSR4JBR.js

@@ -0,0 +1,88 @@
+import {
+  createSkillServer
+} from "./chunk-VRZFM2M5.js";
+import {
+  attachMailbox
+} from "./chunk-HNAVQG6R.js";
+
+// src/stdio.ts
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+function resolveRoots(argv, cwd) {
+  const given = argv.filter((arg) => !arg.startsWith("-"));
+  return given.length > 0 ? given : [`${cwd}/node_modules`];
+}
+function serve(catalog, serving = {}) {
+  const options = {
+    ...catalog,
+    ...serving,
+    onReject: ({ path, reason }) => process.stderr.write(`pmcp: skipped ${path}: ${reason}
+`),
+    onWarning: ({ path, reason }) => process.stderr.write(`pmcp: warning ${path}: ${reason}
+`)
+  };
+  return serveStdio(() => createSkillServer(options), {
+    // stdout is the protocol. A diagnostic written there corrupts the stream,
+    // so out-of-band errors go to stderr and nowhere else.
+    onerror: (error) => process.stderr.write(`pmcp: ${error.message}
+`)
+  });
+}
+async function serveWithMailbox(catalog, mailbox, serving = {}) {
+  let stop;
+  const attachment = await attachMailbox({
+    ...mailbox,
+    onExpired: () => {
+      process.stderr.write("pmcp: mailbox attachment expired or superseded\n");
+      void stop?.().catch(() => {
+        process.exitCode = 1;
+      });
+    }
+  });
+  let handle;
+  try {
+    handle = serve(catalog, { ...serving, mailbox: attachment.service });
+  } catch (error) {
+    await attachment.close();
+    throw error;
+  }
+  let shutdown;
+  const onExit = () => {
+    void stop().catch(() => {
+      process.exitCode = 1;
+    });
+  };
+  stop = () => {
+    if (shutdown) return shutdown;
+    process.removeListener("SIGINT", onExit);
+    process.removeListener("SIGTERM", onExit);
+    process.stdin.removeListener("end", onExit);
+    shutdown = (async () => {
+      try {
+        await handle.close();
+      } finally {
+        await attachment.close();
+      }
+    })();
+    return shutdown;
+  };
+  process.once("SIGINT", onExit);
+  process.once("SIGTERM", onExit);
+  process.stdin.once("end", onExit);
+  return stop;
+}
+function main(argv = process.argv.slice(2)) {
+  const scopeArg = argv.find((arg) => arg.startsWith("--scope="));
+  const scopes = scopeArg ? scopeArg.slice("--scope=".length).split(",") : [];
+  serve({
+    roots: resolveRoots(argv, process.cwd()),
+    ...scopes.length > 0 ? { scopes } : {}
+  });
+}
+
+export {
+  resolveRoots,
+  serve,
+  serveWithMailbox,
+  main
+};
+//# sourceMappingURL=chunk-JRSR4JBR.js.map

package/dist/chunk-MSTKY33C.js

@@ -0,0 +1,147 @@
+import {
+  resolveEncoder
+} from "./chunk-XOH2CW6P.js";
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { parse } from "smol-toml";
+var CONFIG_FILE = "pmcp.toml";
+function embeddingSection(path, dir, value) {
+  if (value === void 0) return void 0;
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new ConfigError(path, "[embedding] must be a table");
+  const section = value;
+  const allowed = /* @__PURE__ */ new Set([
+    "enabled",
+    "model",
+    "dtype",
+    "dimensions",
+    "revision",
+    "model_path",
+    "cache_dir",
+    "encoder"
+  ]);
+  for (const key of Object.keys(section)) {
+    if (!allowed.has(key))
+      throw new ConfigError(path, `unknown key [embedding] ${key}`);
+  }
+  if (section.enabled !== void 0 && typeof section.enabled !== "boolean")
+    throw new ConfigError(path, "[embedding] enabled must be a boolean");
+  const string = (key) => {
+    const item = section[key];
+    if (item === void 0) return void 0;
+    if (typeof item !== "string" || !item.trim())
+      throw new ConfigError(
+        path,
+        `[embedding] ${key} must be a non-empty string`
+      );
+    return item;
+  };
+  let encoder;
+  if (section.encoder !== void 0) {
+    if (section.encoder === null || typeof section.encoder !== "object" || Array.isArray(section.encoder))
+      throw new ConfigError(path, "[embedding.encoder] must be a table");
+    const source = section.encoder;
+    const keys = /* @__PURE__ */ new Set([
+      "query_prefix",
+      "passage_prefix",
+      "pooling",
+      "projected"
+    ]);
+    for (const key of Object.keys(source)) {
+      if (!keys.has(key))
+        throw new ConfigError(path, `unknown key [embedding.encoder] ${key}`);
+    }
+    encoder = {};
+    if (source.query_prefix !== void 0)
+      encoder = { ...encoder, queryPrefix: source.query_prefix };
+    if (source.passage_prefix !== void 0)
+      encoder = { ...encoder, passagePrefix: source.passage_prefix };
+    if (source.pooling !== void 0)
+      encoder = { ...encoder, pooling: source.pooling };
+    if (source.projected !== void 0)
+      encoder = { ...encoder, projected: source.projected };
+  }
+  const modelPath = string("model_path");
+  const cacheDir = string("cache_dir");
+  const result = {
+    modelId: string("model"),
+    dtype: string("dtype"),
+    dimensions: section.dimensions,
+    revision: string("revision"),
+    encoder,
+    enabled: section.enabled,
+    modelPath: modelPath === void 0 ? void 0 : resolve(dir, modelPath),
+    cacheDir: cacheDir === void 0 ? void 0 : resolve(dir, cacheDir)
+  };
+  try {
+    resolveEncoder(result.modelId, result);
+  } catch (error) {
+    throw new ConfigError(
+      path,
+      error instanceof Error ? error.message : "Invalid embedding configuration"
+    );
+  }
+  return result;
+}
+var ConfigError = class extends Error {
+  constructor(path, message) {
+    super(`${path}: ${message}`);
+    this.name = "ConfigError";
+  }
+};
+var PATH_KEYS = ["roots", "workspaces", "packages", "marketplaces"];
+var CATALOG_KEYS = /* @__PURE__ */ new Set([...PATH_KEYS, "scopes"]);
+function findConfig(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    const candidate = join(dir, CONFIG_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function stringList(path, key, value) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new ConfigError(path, `[catalog] ${key} must be a list of strings`);
+  }
+  return value;
+}
+function readConfig(path) {
+  const absolute = resolve(path);
+  const dir = dirname(absolute);
+  let raw;
+  try {
+    raw = parse(readFileSync(absolute, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unreadable";
+    throw new ConfigError(absolute, reason.split("\n")[0] ?? reason);
+  }
+  const section = raw["catalog"];
+  const embedding = embeddingSection(absolute, dir, raw.embedding);
+  const configured = embedding === void 0 ? {} : { embedding };
+  if (section === void 0)
+    return { path: absolute, dir, catalog: {}, raw, ...configured };
+  if (section === null || typeof section !== "object" || Array.isArray(section)) {
+    throw new ConfigError(absolute, "[catalog] must be a table");
+  }
+  const catalog = {};
+  for (const [key, value] of Object.entries(section)) {
+    if (!CATALOG_KEYS.has(key)) {
+      throw new ConfigError(absolute, `unknown key [catalog] ${key}`);
+    }
+    const list = stringList(absolute, key, value);
+    catalog[key] = key === "scopes" ? list : list.map((p) => resolve(dir, p));
+  }
+  return { path: absolute, dir, catalog, raw, ...configured };
+}
+
+export {
+  CONFIG_FILE,
+  ConfigError,
+  findConfig,
+  readConfig
+};
+//# sourceMappingURL=chunk-MSTKY33C.js.map

package/dist/{chunk-VQHNG3KM.js → chunk-VRZFM2M5.js}

@@ -1,3 +1,10 @@
+import {
+  RUNTIMES,
+  detectRuntime,
+  registerMailboxTools,
+  verifiedRuntimesOf
+} from "./chunk-XOH2CW6P.js";
+
 // src/intent.ts
 function normaliseIntent(intent) {
   return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
@@ -935,6 +942,7 @@ function registerSkillResources(server, skills) {
 }
 
 // src/find.ts
+import { createHash as createHash2 } from "crypto";
 var DEFAULT_FIND_LIMIT = 5;
 function tokens(text) {
   return normaliseIntent(text).split(" ").filter(Boolean);
@@ -977,15 +985,17 @@ async function find(options) {
   if (semantic) {
     const embedder = options.embedder;
     const vectors = options.vectors;
-    let query = options.cache?.get(options.intent) ?? null;
+    const namespace = createHash2("sha256").update(embedder.indexKey ?? embedder.modelId).digest("hex");
+    const cacheKey = `${namespace} ${normaliseIntent(options.intent)}`;
+    let query = options.cache?.get(cacheKey) ?? null;
     if (!query) {
       query = await embedder.embed(options.intent);
-      options.cache?.put(options.intent, query);
+      options.cache?.put(cacheKey, query);
     }
     const scored = [];
     for (const entry of options.entries) {
       const vector = vectors.get(entry.name);
-      if (!vector) continue;
+      if (!vector || vector.length !== query.length) continue;
       scored.push({
         name: entry.name,
         package: entry.package,
@@ -1035,44 +1045,6 @@ function bundleSkill(entry) {
   };
 }
 
-// src/runtime.ts
-import { CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
-var RUNTIMES = [
-  "claude-code",
-  "codex-cli",
-  "gemini-cli",
-  "grok-cli",
-  "antigravity"
-];
-var VERIFIED_RUNTIMES_KEY = "verified-runtimes";
-var isRuntime = (value) => RUNTIMES.includes(value);
-function verifiedRuntimesOf(metadata) {
-  const raw = metadata?.[VERIFIED_RUNTIMES_KEY];
-  if (raw === void 0) return [];
-  const words = typeof raw === "string" ? raw.split(/[\s,]+/u) : Array.isArray(raw) ? raw.map((word) => String(word).trim()) : [];
-  return [...new Set(words.filter(isRuntime))];
-}
-var CLIENT_PATTERNS = [
-  [/claude[-_ ]?code/u, "claude-code"],
-  [/codex/u, "codex-cli"],
-  [/gemini/u, "gemini-cli"],
-  [/grok/u, "grok-cli"],
-  [/antigravity/u, "antigravity"]
-];
-function runtimeOfClient(name) {
-  if (!name) return null;
-  const lower = name.toLowerCase();
-  for (const [pattern, runtime] of CLIENT_PATTERNS)
-    if (pattern.test(lower)) return runtime;
-  return null;
-}
-function detectRuntime(server, ctx) {
-  const envelope = ctx?.mcpReq?.envelope;
-  const fromEnvelope = envelope?.[CLIENT_INFO_META_KEY]?.name;
-  if (typeof fromEnvelope === "string") return runtimeOfClient(fromEnvelope);
-  return runtimeOfClient(server.server?.getClientVersion?.()?.name);
-}
-
 // src/server.ts
 import { readFileSync as readFileSync6 } from "fs";
 var DESCRIBE_FILE_LIMIT = FILE_LIST_LIMIT;
@@ -1103,7 +1075,8 @@ function matches(entry, filters) {
   }
   return true;
 }
-function verification(entry, runtime) {
+function verification(entry, runtime, asked) {
+  if (!asked) return {};
   const verifiedRuntimes = verifiedRuntimesOf(entry?.metadata);
   return {
     ...verifiedRuntimes.length > 0 ? { verifiedRuntimes } : {},
@@ -1116,15 +1089,28 @@ function verifiedFirst(items) {
     ...items.filter((item) => item.verified !== true)
   ];
 }
-function catalogItem(entry, runtime) {
+function catalogItem(entry, runtime, asked) {
   return {
     name: entry.name,
     description: entry.description,
     ...entry.tier === void 0 ? {} : { tier: entry.tier },
     ...kindOf(entry) === "skill" ? {} : { kind: kindOf(entry) },
-    ...verification(entry, runtime)
+    ...verification(entry, runtime, asked)
   };
 }
+function flatMetadata(metadata) {
+  const flat = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      flat[key] = value;
+      continue;
+    }
+    for (const [inner, leaf] of Object.entries(value ?? {})) {
+      flat[`${key}.${inner}`] = leaf;
+    }
+  }
+  return flat;
+}
 function createSkillTools(options) {
   const load = options.loadCatalog ?? readCatalog;
   let entries = null;
@@ -1149,6 +1135,7 @@ function createSkillTools(options) {
     catalog(request = {}) {
       const client = options.rankByClientRuntime ? request.clientRuntime : null;
       const runtime = request.runtime ?? client ?? null;
+      const asked = runtime !== null || request.verifiedOnly !== void 0;
       const byPackage = /* @__PURE__ */ new Map();
       let count = 0;
       for (const entry of catalog()) {
@@ -1161,7 +1148,7 @@ function createSkillTools(options) {
           continue;
         count += 1;
         const list = byPackage.get(entry.package) ?? [];
-        list.push(catalogItem(entry, runtime));
+        list.push(catalogItem(entry, runtime, asked));
         byPackage.set(entry.package, list);
       }
       const groups = [...byPackage.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pkg, skills]) => [
@@ -1186,6 +1173,7 @@ function createSkillTools(options) {
     find(intent, limit, filters, clientRuntime) {
       const client = options.rankByClientRuntime ? clientRuntime : null;
       const runtime = filters?.runtime ?? client ?? null;
+      const asked = runtime !== null || filters?.verifiedOnly !== void 0;
       const scoped = catalog().filter((entry) => matches(entry, filters)).map(
         (entry) => entry.keywords && entry.keywords.length > 0 ? {
           ...entry,
@@ -1205,13 +1193,13 @@ function createSkillTools(options) {
           return {
             ...match,
             description: entry?.description ?? match.description,
-            ...verification(entry, runtime)
+            ...verification(entry, runtime, asked)
           };
         });
         const ordered = runtime === null ? marked : verifiedFirst(marked);
         return {
           ...result,
-          runtime,
+          ...asked ? { runtime } : {},
           matches: runtime === null ? ordered : ordered.slice(0, limit ?? DEFAULT_FIND_LIMIT)
         };
       });
@@ -1228,9 +1216,9 @@ function createSkillTools(options) {
         package: entry.package,
         description: entry.description,
         ...entry.tier === void 0 ? {} : { tier: entry.tier },
-        metadata: entry.metadata ?? {},
+        metadata: flatMetadata(entry.metadata),
         frontmatter: readFrontmatterText(source),
-        files: [...listing2.files],
+        files: listing2.files.map((file) => ({ ...file })),
         filesTruncated: listing2.truncated
       };
     },
@@ -1276,7 +1264,7 @@ function createSkillTools(options) {
 }
 
 // src/extension/entry.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
 import { basename as basename5, dirname as dirname5, join as join5, relative as relative4, sep as sep3 } from "path";
 var MAX_RESOURCES = 512;
@@ -1288,7 +1276,7 @@ function facts(path) {
   const cached = digests.get(path);
   if (cached?.key === key) return cached;
   const bytes = servedBytes(path, readFileSync7(path));
-  const digest = `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
+  const digest = `sha256:${createHash3("sha256").update(bytes).digest("hex")}`;
   const fresh = { key, digest, size: bytes.length };
   digests.set(path, fresh);
   return fresh;
@@ -1404,7 +1392,7 @@ function registerSkillsExtension(server, skills, options = {}) {
 import { z as z3 } from "zod";
 var kind = z3.enum(ASSET_KINDS);
 var runtimeSchema = z3.enum(RUNTIMES);
-var catalogItemSchema = z3.object({
+var catalogItemSchema = z3.looseObject({
   name: z3.string(),
   description: z3.string(),
   tier: z3.string().optional(),
@@ -1412,20 +1400,20 @@ var catalogItemSchema = z3.object({
   verifiedRuntimes: z3.array(runtimeSchema).optional(),
   verified: z3.boolean().optional()
 });
-var catalogResponseSchema = z3.object({
+var catalogResponseSchema = z3.looseObject({
   count: z3.number().int(),
   page: z3.number().int(),
   totalPages: z3.number().int(),
   hasNext: z3.boolean(),
   packages: z3.array(
-    z3.object({ package: z3.string(), skills: z3.array(catalogItemSchema) })
+    z3.looseObject({ package: z3.string(), skills: z3.array(catalogItemSchema) })
   )
 });
-var findResultSchema = z3.object({
+var findResultSchema = z3.looseObject({
   ranking: z3.enum(["semantic", "lexical"]),
-  runtime: runtimeSchema.nullable(),
+  runtime: runtimeSchema.nullable().optional(),
   matches: z3.array(
-    z3.object({
+    z3.looseObject({
       name: z3.string(),
       package: z3.string(),
       description: z3.string(),
@@ -1435,16 +1423,12 @@ var findResultSchema = z3.object({
     })
   )
 });
-var skillFileSchema = z3.object({
+var skillFileSchema = z3.looseObject({
   path: z3.string(),
   bytes: z3.number().int(),
   sha256: z3.string()
 });
-var metadataLeafSchema = z3.union([
-  z3.string(),
-  z3.array(z3.string()).readonly()
-]);
-var describeResponseSchema = z3.object({
+var describeResponseSchema = z3.looseObject({
   name: z3.string(),
   kind,
   package: z3.string(),
@@ -1452,16 +1436,13 @@ var describeResponseSchema = z3.object({
   tier: z3.string().optional(),
   metadata: z3.record(
     z3.string(),
-    z3.union([
-      metadataLeafSchema,
-      z3.record(z3.string(), metadataLeafSchema).readonly()
-    ])
+    z3.union([z3.string(), z3.array(z3.string()).readonly()])
   ),
   frontmatter: z3.string(),
   files: z3.array(skillFileSchema),
   filesTruncated: z3.boolean()
 });
-var bundleResponseSchema = z3.object({
+var bundleResponseSchema = z3.looseObject({
   name: z3.string(),
   truncated: z3.boolean(),
   files: z3.array(
@@ -1641,7 +1622,7 @@ function registerDescribeTool(server, tools) {
     "skill_describe",
     {
       ...readOnlyTool("Describe a skill"),
-      description: "One skill's frontmatter, metadata (tier, level, requirements as a nested requires map, verified-runtimes, licence, approval), and the files it carries with sizes and sha256, without any body.",
+      description: "One skill's frontmatter, metadata (tier, level, requirements as requires.<name> entries, verified-runtimes, licence, approval), and the files it carries with sizes and sha256, without any body.",
       inputSchema: z8.object({ name: skillNameInput }),
       outputSchema: describeResponseSchema
     },
@@ -1718,7 +1699,7 @@ function registerReadTool(server, tools) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.9.1";
+var SERVER_VERSION = "0.10.0";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -1734,6 +1715,7 @@ function createSkillServer(options) {
   registerSkillsExtension(server, tools.skills, options.skillsExtension);
   registerSkillResources(server, tools.skills);
   if (options.prompts) registerSkillPrompts(server, tools);
+  if (options.mailbox) registerMailboxTools(server, options.mailbox);
   return registerSkillTools(server, tools);
 }
 
@@ -1773,10 +1755,6 @@ export {
   cosine,
   find,
   bundleSkill,
-  RUNTIMES,
-  verifiedRuntimesOf,
-  runtimeOfClient,
-  detectRuntime,
   DESCRIBE_FILE_LIMIT,
   CATALOG_PAGE_SIZE,
   CATALOG_PAGE_MAX,
@@ -1793,4 +1771,4 @@ export {
   registerSkillTools,
   createSkillServer
 };
-//# sourceMappingURL=chunk-VQHNG3KM.js.map
+//# sourceMappingURL=chunk-VRZFM2M5.js.map