@modootoday/pmcp 0.9.2 → 0.10.0

package/dist/{chunk-D3OZVMHN.js → chunk-ZUFFVIHQ.js}

@@ -1,68 +1,80 @@
+import {
+  loadEmbedder,
+  openEntryVectors
+} from "./chunk-XEH4ZGGJ.js";
 import {
   frontmatterObject,
   readCatalog,
   specProblems
-} from "./chunk-A5NOHVHN.js";
+} from "./chunk-VRZFM2M5.js";
+import {
+  ConfigError
+} from "./chunk-MSTKY33C.js";
+import {
+  DEFAULT_MODEL_ID,
+  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";
-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;
+// src/search.ts
+import { existsSync } from "fs";
+async function prepareSearch(catalog, options) {
+  const lexical = (reason) => ({
+    ranking: "lexical",
+    reason,
+    options: {}
+  });
+  if (!existsSync(options.indexPath)) return lexical("index_missing");
+  let store;
   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"];
-  if (section === void 0) return { path: absolute, dir, catalog: {}, raw };
-  if (section === null || typeof section !== "object" || Array.isArray(section)) {
-    throw new ConfigError(absolute, "[catalog] must be a table");
+    store = await openEntryVectors(options.indexPath, { readOnly: true });
+  } catch {
+    return lexical("index_unavailable");
   }
-  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));
+  if (!store) return lexical("index_unavailable");
+  try {
+    const entries = (options.loadCatalog ?? readCatalog)(catalog);
+    const selected = resolveEncoder(
+      options.modelId ?? options.embedder?.modelId ?? DEFAULT_MODEL_ID,
+      options
+    );
+    const modelId = selected.modelId;
+    const key = selected.indexKey;
+    if (options.embedder?.indexKey !== void 0 && options.embedder.indexKey !== key)
+      return lexical("vector_mismatch");
+    const descriptions = new Map(
+      entries.map((entry2) => [entry2.name, entry2.description])
+    );
+    if (entries.length === 0 || store.stale(key, descriptions).length > 0)
+      return lexical("index_stale");
+    const vectors = store.read(key);
+    const embedder = options.embedder ?? await loadEmbedder(selected.modelId, {
+      ...options,
+      localOnly: options.localOnly ?? true
+    });
+    if (!embedder || embedder.modelId !== modelId)
+      return lexical("encoder_unavailable");
+    if (embedder.indexKey !== void 0 && embedder.indexKey !== key)
+      return lexical("vector_mismatch");
+    const probe = await embedder.embed("pmcp");
+    if (probe.length === 0 || !entries.every(
+      (entry2) => vectors.get(entry2.name)?.length === probe.length
+    ))
+      return lexical("vector_mismatch");
+    return {
+      ranking: "semantic",
+      options: { embedder, vectors, loadCatalog: () => entries }
+    };
+  } catch {
+    return lexical("encoder_unavailable");
+  } finally {
+    store.close();
   }
-  return { path: absolute, dir, catalog, raw };
 }
 
 // src/project/package-rules.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync2, lstatSync, readdirSync, readlinkSync } from "fs";
-import { dirname as dirname2, join as join2, posix } from "path";
+import { dirname, join, posix } from "path";
 var ProjectError = class extends Error {
   constructor(message) {
     super(message);
@@ -107,11 +119,11 @@ function linkTarget(abs) {
 }
 function legacyLinks(root) {
   const found = /* @__PURE__ */ new Map();
-  const dir = join2(root, RULES_DIR);
+  const dir = join(root, RULES_DIR);
   if (!existsSync2(dir)) return found;
   for (const entry2 of readdirSync(dir).sort()) {
     if (!entry2.endsWith(".md")) continue;
-    const target = linkTarget(join2(dir, entry2));
+    const target = linkTarget(join(dir, entry2));
     if (target === null || !target.startsWith("../../")) continue;
     found.set(entry2.slice(0, -3), target.slice("../../".length));
   }
@@ -131,14 +143,14 @@ function packageRuleOutputs(root, spec, owned) {
   const legacyByDir = /* @__PURE__ */ new Map();
   for (const [name, target] of legacy) {
     if (!byTarget.has(target)) byTarget.set(target, name);
-    const dir = dirname2(target);
+    const dir = dirname(target);
     if (!legacyByDir.has(dir)) legacyByDir.set(dir, name);
   }
   const outputs = [];
   const taken = /* @__PURE__ */ new Map();
   for (const file of files) {
     const pkg = file.slice(0, -suffix.length);
-    const name = byTarget.get(file) ?? legacyByDir.get(dirname2(file)) ?? deriveName(pkg, spec.strip);
+    const name = byTarget.get(file) ?? legacyByDir.get(dirname(file)) ?? deriveName(pkg, spec.strip);
     const other = taken.get(name);
     if (other !== void 0) {
       throw new ProjectError(
@@ -156,15 +168,15 @@ function packageRuleOutputs(root, spec, owned) {
 }
 
 // src/project/plan.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/project/frontmatter.ts
-import { parse as parse2 } from "yaml";
+import { parse } from "yaml";
 function splitFrontmatter(source) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/u.exec(source);
   if (!match) return { meta: {}, body: source };
-  const meta = parse2(match[1] ?? "");
+  const meta = parse(match[1] ?? "");
   const object = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
   return { meta: object, body: match[2] ?? "" };
 }
@@ -208,6 +220,20 @@ function splitKeyed(path) {
 }
 
 // src/project/mcp.ts
+var runtimeByTool = {
+  claude: "claude-code",
+  codex: "codex-cli",
+  gemini: "gemini-cli",
+  grok: "grok-cli",
+  antigravity: "antigravity"
+};
+function launchForTool(server, tool) {
+  if (!server.mailbox) return launch(server);
+  return launch({
+    ...server,
+    env: { ...server.env, PMCP_MAILBOX_RUNTIME: runtimeByTool[tool] }
+  });
+}
 var ROOT_VAR = "${PROJECT_ROOT}";
 var quote = (text) => `'${text.replaceAll("'", "'\\''")}'`;
 function shellWord(text) {
@@ -259,16 +285,18 @@ function tomlServers(servers) {
 `;
 }
 function mcpOutputs(spec) {
-  const servers = Object.entries(spec.mcp).map(
-    ([alias, server]) => [alias, launch(server)]
-  );
+  const servers = Object.entries(spec.mcp);
   if (servers.length === 0) return [];
   const outputs = [];
   for (const [alias, server] of servers) {
     const tools = spec.mcp[alias]?.tools;
     if (spec.tools.has("claude")) {
       outputs.push(
-        jsonOutput(".mcp.json", ["mcpServers", alias], entry(server))
+        jsonOutput(
+          ".mcp.json",
+          ["mcpServers", alias],
+          entry(launchForTool(server, "claude"))
+        )
       );
     }
     if (spec.tools.has("gemini")) {
@@ -277,7 +305,7 @@ function mcpOutputs(spec) {
         jsonOutput(
           ".gemini/settings.json",
           ["mcpServers", alias],
-          entry(server, extra)
+          entry(launchForTool(server, "gemini"), extra)
         )
       );
     }
@@ -286,16 +314,36 @@ function mcpOutputs(spec) {
         jsonOutput(
           ".agents/mcp_config.json",
           ["mcpServers", alias],
-          entry(server)
+          entry(launchForTool(server, "antigravity"))
         )
       );
     }
   }
   if (spec.tools.has("codex")) {
-    outputs.push(blockOutput(".codex/config.toml", tomlServers(servers)));
+    outputs.push(
+      blockOutput(
+        ".codex/config.toml",
+        tomlServers(
+          servers.map(([alias, server]) => [
+            alias,
+            launchForTool(server, "codex")
+          ])
+        )
+      )
+    );
   }
   if (spec.tools.has("grok")) {
-    outputs.push(blockOutput(".grok/config.toml", tomlServers(servers)));
+    outputs.push(
+      blockOutput(
+        ".grok/config.toml",
+        tomlServers(
+          servers.map(([alias, server]) => [
+            alias,
+            launchForTool(server, "grok")
+          ])
+        )
+      )
+    );
   }
   return outputs;
 }
@@ -312,15 +360,15 @@ function listDirs(dir) {
 }
 var tomlString = (value) => JSON.stringify(typeof value === "string" ? value : String(value ?? ""));
 function skillNames(root) {
-  const dir = join3(root, ".agents/skills");
+  const dir = join2(root, ".agents/skills");
   return listDirs(dir).filter(
-    (name) => existsSync3(join3(dir, name, "SKILL.md"))
+    (name) => existsSync3(join2(dir, name, "SKILL.md"))
   );
 }
 function agentNames(root) {
-  const dir = join3(root, ".agents/agents");
+  const dir = join2(root, ".agents/agents");
   return listDirs(dir).filter(
-    (name) => existsSync3(join3(dir, name, "agent.md"))
+    (name) => existsSync3(join2(dir, name, "agent.md"))
   );
 }
 function skillOutputs(spec) {
@@ -354,13 +402,13 @@ policy:
 }
 function ruleOutputs(spec) {
   if (!spec.tools.has("claude")) return [];
-  const dir = join3(spec.root, ".agents/rules");
+  const dir = join2(spec.root, ".agents/rules");
   if (!existsSync3(dir)) return [];
   const outputs = [];
   for (const file of readdirSync2(dir).filter((f) => f.endsWith(".md")).sort()) {
     const rel = `.agents/rules/${file}`;
     const { meta, body } = splitFrontmatter(
-      readFileSync2(join3(spec.root, rel), "utf8")
+      readFileSync(join2(spec.root, rel), "utf8")
     );
     const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
     const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
@@ -379,7 +427,7 @@ function agentOutputs(spec) {
   for (const name of agentNames(spec.root)) {
     const rel = `.agents/agents/${name}/agent.md`;
     const { meta, body } = splitFrontmatter(
-      readFileSync2(join3(spec.root, rel), "utf8")
+      readFileSync(join2(spec.root, rel), "utf8")
     );
     const overrides = spec.agents[name] ?? {};
     const note = `<!-- ${MARK} from ${rel} -->
@@ -453,14 +501,14 @@ import {
   existsSync as existsSync4,
   lstatSync as lstatSync2,
   mkdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync2,
   readdirSync as readdirSync3,
   readlinkSync as readlinkSync2,
   rmSync,
   symlinkSync,
   writeFileSync
 } from "fs";
-import { dirname as dirname3, join as join4, posix as posix2 } from "path";
+import { dirname as dirname2, join as join3, posix as posix2 } from "path";
 var LOCK_FILE = "pmcp.lock";
 var BEGIN = "# >>> pmcp project (edit pmcp.toml, not this block) >>>";
 var END = "# <<< pmcp project <<<";
@@ -470,9 +518,9 @@ var PREDECESSORS = [
 ];
 var sha = (text) => createHash("sha256").update(text).digest("hex");
 function readLock(root) {
-  const path = join4(root, LOCK_FILE);
+  const path = join3(root, LOCK_FILE);
   if (!existsSync4(path)) return [];
-  const lock = JSON.parse(readFileSync3(path, "utf8"));
+  const lock = JSON.parse(readFileSync2(path, "utf8"));
   return lock.outputs ?? [];
 }
 function linkOf(abs) {
@@ -485,7 +533,7 @@ function linkOf(abs) {
 var exists = (abs) => existsSync4(abs) || linkOf(abs) !== null;
 function readJson(abs) {
   if (!existsSync4(abs)) return {};
-  const value = JSON.parse(readFileSync3(abs, "utf8"));
+  const value = JSON.parse(readFileSync2(abs, "utf8"));
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function getKey(object, key) {
@@ -532,29 +580,29 @@ function withoutBlock(text) {
   return `${text.slice(0, start).replace(/\n+$/u, "\n")}${after}`;
 }
 function present(root, output) {
-  const abs = join4(root, "file" in output ? output.file : output.path);
+  const abs = join3(root, "file" in output ? output.file : output.path);
   switch (output.kind) {
     case "link":
       return linkOf(abs) === output.target;
     case "file":
-      return existsSync4(abs) && linkOf(abs) === null && readFileSync3(abs, "utf8") === output.content;
+      return existsSync4(abs) && linkOf(abs) === null && readFileSync2(abs, "utf8") === output.content;
     case "json":
       return same(getKey(readJson(abs), output.key), output.value);
     case "block":
-      return existsSync4(abs) && readFileSync3(abs, "utf8").includes(block(output.content));
+      return existsSync4(abs) && readFileSync2(abs, "utf8").includes(block(output.content));
   }
 }
 function replaceable(root, output, owned) {
   if (output.kind === "json" || output.kind === "block") return true;
   if (owned.has(output.path)) return true;
-  const abs = join4(root, output.path);
+  const abs = join3(root, output.path);
   if (!exists(abs)) return true;
   const target = linkOf(abs);
   if (target !== null) {
     return output.kind === "link" && target === output.target;
   }
   if (lstatSync2(abs).isDirectory()) return false;
-  const text = readFileSync3(abs, "utf8");
+  const text = readFileSync2(abs, "utf8");
   if (output.kind === "file" && text === output.content) return true;
   return PREDECESSORS.some((mark) => text.includes(mark));
 }
@@ -562,14 +610,14 @@ function undeclared(spec, outputs) {
   const declared = new Set(outputs.map((o) => o.path));
   const found = [];
   for (const dir of censusDirs(spec)) {
-    const abs = join4(spec.root, dir);
+    const abs = join3(spec.root, dir);
     if (!existsSync4(abs)) continue;
     for (const entry2 of readdirSync3(abs)) {
       const path = `${dir}/${entry2}`;
       if (!declared.has(path)) found.push(path);
     }
   }
-  const rules = join4(spec.root, RULES_DIR);
+  const rules = join3(spec.root, RULES_DIR);
   if (spec.tools.has("grok") && existsSync4(rules)) {
     for (const entry2 of readdirSync3(rules, { withFileTypes: true })) {
       if (entry2.isDirectory()) continue;
@@ -597,9 +645,9 @@ function deadGlobs(root, outputs) {
     if (rule.kind === "file") {
       text = rule.content;
     } else if (rule.kind === "link") {
-      const abs = join4(root, posix2.join(posix2.dirname(rule.path), rule.target));
+      const abs = join3(root, posix2.join(posix2.dirname(rule.path), rule.target));
       if (!existsSync4(abs)) continue;
-      text = readFileSync3(abs, "utf8");
+      text = readFileSync2(abs, "utf8");
     } else {
       continue;
     }
@@ -659,8 +707,8 @@ function project(spec, options) {
   for (const output of outputs) {
     if (output.kind !== "link" && output.kind !== "file") continue;
     if (present(spec.root, output)) continue;
-    const abs = join4(spec.root, output.path);
-    mkdirSync(dirname3(abs), { recursive: true });
+    const abs = join3(spec.root, output.path);
+    mkdirSync(dirname2(abs), { recursive: true });
     rmSync(abs, { force: true, recursive: true });
     if (output.kind === "link") symlinkSync(output.target, abs);
     else writeFileSync(abs, output.content);
@@ -685,12 +733,12 @@ function project(spec, options) {
       group.drops.push(keyed.key);
       jsonFiles.set(keyed.file, group);
     } else {
-      rmSync(join4(spec.root, entry2.path), { force: true, recursive: true });
+      rmSync(join3(spec.root, entry2.path), { force: true, recursive: true });
     }
     pruned += 1;
   }
   for (const [file, { sets, drops }] of jsonFiles) {
-    const abs = join4(spec.root, file);
+    const abs = join3(spec.root, file);
     const before = readJson(abs);
     const after = structuredClone(before);
     for (const key of drops) deleteKey(after, key);
@@ -699,20 +747,20 @@ function project(spec, options) {
     }
     if (same(before, after)) continue;
     if (!existsSync4(abs) && Object.keys(after).length === 0) continue;
-    mkdirSync(dirname3(abs), { recursive: true });
+    mkdirSync(dirname2(abs), { recursive: true });
     writeFileSync(abs, `${JSON.stringify(after, null, 2)}
 `);
   }
   for (const [file, content] of blockFiles) {
-    const abs = join4(spec.root, file);
-    const before = existsSync4(abs) ? readFileSync3(abs, "utf8") : "";
+    const abs = join3(spec.root, file);
+    const before = existsSync4(abs) ? readFileSync2(abs, "utf8") : "";
     let after = withoutBlock(before);
     if (content !== null) {
       const sep = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
       after = `${after}${sep}${block(content)}`;
     }
     if (after === before) continue;
-    mkdirSync(dirname3(abs), { recursive: true });
+    mkdirSync(dirname2(abs), { recursive: true });
     writeFileSync(abs, after);
   }
   if (spec.packageRules) {
@@ -724,7 +772,7 @@ function project(spec, options) {
       )
     );
     for (const [name, target] of legacyLinks(spec.root)) {
-      const abs = join4(spec.root, RULES_DIR, `${name}.md`);
+      const abs = join3(spec.root, RULES_DIR, `${name}.md`);
       const broken = !existsSync4(abs);
       if (!broken && !linkedDirs.has(posix2.dirname(target))) continue;
       rmSync(abs, { force: true });
@@ -732,7 +780,7 @@ function project(spec, options) {
     }
   }
   writeFileSync(
-    join4(spec.root, LOCK_FILE),
+    join3(spec.root, LOCK_FILE),
     `${JSON.stringify({ version: 1, outputs: outputs.map(lockEntry) }, null, 2)}
 `
   );
@@ -741,9 +789,9 @@ function project(spec, options) {
 
 // src/project/doctor.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
-import { parse as parse3 } from "smol-toml";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { parse as parse2 } from "smol-toml";
 var spawnRunner = (command, args, cwd) => {
   const result = spawnSync(command, [...args], {
     cwd,
@@ -804,10 +852,10 @@ function claude(spec, o) {
 }
 function codex(spec, o) {
   const findings = [];
-  const config = join5(o.home, ".codex/config.toml");
+  const config = join4(o.home, ".codex/config.toml");
   let trusted = false;
   if (existsSync5(config)) {
-    const projects = parse3(readFileSync4(config, "utf8")).projects ?? {};
+    const projects = parse2(readFileSync3(config, "utf8")).projects ?? {};
     const root = spec.root.replace(/\/$/u, "");
     trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
   }
@@ -934,8 +982,8 @@ function grok(spec, o) {
 }
 function antigravity(spec) {
   const foreign = agentNames(spec.root).filter((name) => {
-    const text = readFileSync4(
-      join5(spec.root, ".agents/agents", name, "agent.md"),
+    const text = readFileSync3(
+      join4(spec.root, ".agents/agents", name, "agent.md"),
       "utf8"
     );
     return splitFrontmatter(text).meta["tools"] !== void 0;
@@ -1074,6 +1122,9 @@ function readSpec(config) {
       throw new ConfigError(path, `${where} command is required`);
     }
     const env = {};
+    if (entry2["mailbox"] !== void 0 && typeof entry2["mailbox"] !== "boolean") {
+      throw new ConfigError(path, `${where} mailbox must be a boolean`);
+    }
     for (const [key, v] of Object.entries(
       table(path, `${where} env`, entry2["env"])
     )) {
@@ -1083,6 +1134,7 @@ function readSpec(config) {
       env[key] = v;
     }
     mcp[named(path, "[mcp]", alias)] = {
+      ...entry2["mailbox"] === true ? { mailbox: true } : {},
       command,
       args: entry2["args"] === void 0 ? [] : strings(path, `${where} args`, entry2["args"]),
       env,
@@ -1093,16 +1145,16 @@ function readSpec(config) {
 }
 
 // src/validate.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, statSync } from "fs";
-import { basename, join as join6, resolve as resolve2 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, statSync } from "fs";
+import { basename, join as join5, resolve } from "path";
 function validateSkillDir(dir) {
-  const root = resolve2(dir);
-  const skillMd = basename(root) === "SKILL.md" ? root : join6(root, "SKILL.md");
+  const root = resolve(dir);
+  const skillMd = basename(root) === "SKILL.md" ? root : join5(root, "SKILL.md");
   if (!existsSync6(skillMd) || !statSync(skillMd).isFile()) {
     return [{ path: root, reason: "no SKILL.md", level: "error" }];
   }
-  const front = frontmatterObject(readFileSync5(skillMd, "utf8"));
-  const directory = basename(skillMd === root ? join6(root, "..") : root);
+  const front = frontmatterObject(readFileSync4(skillMd, "utf8"));
+  const directory = basename(skillMd === root ? join5(root, "..") : root);
   return specProblems(front, directory).map((reason) => ({
     path: skillMd,
     reason,
@@ -1120,10 +1172,7 @@ function validateCatalog(options) {
 }
 
 export {
-  CONFIG_FILE,
-  ConfigError,
-  findConfig,
-  readConfig,
+  prepareSearch,
   splitFrontmatter,
   renderFrontmatter,
   ProjectError,
@@ -1139,4 +1188,4 @@ export {
   validateSkillDir,
   validateCatalog
 };
-//# sourceMappingURL=chunk-D3OZVMHN.js.map
+//# sourceMappingURL=chunk-ZUFFVIHQ.js.map