@modootoday/pmcp 0.5.1 → 0.6.0

package/dist/chunk-6TSHDCUY.js

@@ -0,0 +1,1238 @@
+import {
+  normaliseIntent
+} from "./chunk-5TX2IAVD.js";
+
+// src/cache.ts
+async function openDatabase(path) {
+  try {
+    const { DatabaseSync } = await import(`node:${"sqlite"}`);
+    return { db: new DatabaseSync(path), provider: "node:sqlite" };
+  } catch {
+  }
+  try {
+    const { Database } = await import(`bun:${"sqlite"}`);
+    const bun = new Database(path, { create: true });
+    return {
+      db: {
+        exec: (sql) => bun.run(sql),
+        prepare: (sql) => bun.query(sql),
+        close: () => bun.close()
+      },
+      provider: "bun:sqlite"
+    };
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_INTENT_CACHE_LIMIT = 4096;
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS intent_vector (
+    intent   TEXT    NOT NULL PRIMARY KEY,
+    model_id TEXT    NOT NULL,
+    dims     INTEGER NOT NULL,
+    vector   BLOB    NOT NULL,
+    used_at  INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS intent_vector_used_at ON intent_vector (used_at);
+`;
+async function openIntentCache(options) {
+  const opened = await openDatabase(options.path);
+  if (!opened) return null;
+  const { db, provider } = opened;
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(SCHEMA);
+  } catch {
+    db.close();
+    return null;
+  }
+  const limit = options.limit ?? DEFAULT_INTENT_CACHE_LIMIT;
+  const now = options.now ?? (() => Date.now());
+  let hits = 0;
+  let misses = 0;
+  let mismatched = 0;
+  const selectRow = db.prepare("SELECT model_id, dims, vector FROM intent_vector WHERE intent = ?");
+  const touch = db.prepare(
+    "UPDATE intent_vector SET used_at = ? WHERE intent = ?"
+  );
+  const upsert = db.prepare(
+    `INSERT INTO intent_vector (intent, model_id, dims, vector, used_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(intent) DO UPDATE SET
+       model_id = excluded.model_id,
+       dims     = excluded.dims,
+       vector   = excluded.vector,
+       used_at  = excluded.used_at`
+  );
+  const countRows = db.prepare(
+    "SELECT count(*) AS n FROM intent_vector"
+  );
+  const evict = db.prepare(
+    `DELETE FROM intent_vector WHERE intent IN (
+       SELECT intent FROM intent_vector ORDER BY used_at ASC LIMIT ?
+     )`
+  );
+  return {
+    get(intent) {
+      const key = normaliseIntent(intent);
+      const row = selectRow.get(key) ?? null;
+      if (!row) {
+        misses += 1;
+        return null;
+      }
+      if (row.model_id !== options.modelId || row.dims !== options.dims) {
+        mismatched += 1;
+        return null;
+      }
+      hits += 1;
+      touch.run(now(), key);
+      const bytes = row.vector;
+      return new Float32Array(
+        bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        )
+      );
+    },
+    put(intent, vector) {
+      if (vector.length !== options.dims) {
+        throw new Error(
+          `intent vector is ${vector.length} wide, cache holds ${options.dims}`
+        );
+      }
+      const key = normaliseIntent(intent);
+      upsert.run(
+        key,
+        options.modelId,
+        options.dims,
+        new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength),
+        now()
+      );
+      const rows = countRows.get()?.n ?? 0;
+      if (rows > limit) evict.run(rows - limit);
+    },
+    stats() {
+      return {
+        hits,
+        misses,
+        mismatched,
+        rows: countRows.get()?.n ?? 0,
+        provider
+      };
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+// 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;
+  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");
+  }
+  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 };
+}
+
+// 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";
+var ProjectError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectError";
+  }
+};
+var RULES_DIR = ".claude/rules";
+function trackedFiles(root, recurse = false) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["ls-files", "-z", ...recurse ? ["--recurse-submodules"] : []],
+      { cwd: root, encoding: "utf8", maxBuffer: 1 << 28 }
+    );
+    return out.split("\0").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function deriveName(dir, strip) {
+  const segments = dir.split("/");
+  if (segments.length > 1 && strip.includes(segments[0] ?? "")) {
+    segments.shift();
+  }
+  const tokens = [];
+  for (const segment of segments) {
+    if (segment === "packages") continue;
+    for (const token of segment.split("-")) {
+      if (token === tokens[tokens.length - 1]) continue;
+      tokens.push(token);
+    }
+  }
+  return tokens.join("-");
+}
+function linkTarget(abs) {
+  try {
+    if (!lstatSync(abs).isSymbolicLink()) return null;
+    return readlinkSync(abs);
+  } catch {
+    return null;
+  }
+}
+function legacyLinks(root) {
+  const found = /* @__PURE__ */ new Map();
+  const dir = join2(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));
+    if (target === null || !target.startsWith("../../")) continue;
+    found.set(entry2.slice(0, -3), target.slice("../../".length));
+  }
+  return found;
+}
+function packageRuleOutputs(root, spec, owned) {
+  const suffix = `/${spec.file}`;
+  const files = trackedFiles(root).filter((file) => file.endsWith(suffix)).sort();
+  const prefix = `${RULES_DIR}/${spec.dir}/`;
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const [path, target] of owned) {
+    if (!path.startsWith(prefix)) continue;
+    const rel = posix.normalize(posix.join(posix.dirname(path), target));
+    byTarget.set(rel, path.slice(prefix.length, -3));
+  }
+  const legacy = legacyLinks(root);
+  const legacyByDir = /* @__PURE__ */ new Map();
+  for (const [name, target] of legacy) {
+    if (!byTarget.has(target)) byTarget.set(target, name);
+    const dir = dirname2(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 other = taken.get(name);
+    if (other !== void 0) {
+      throw new ProjectError(
+        `two packages want rule link ${prefix}${name}.md: ${other} and ${pkg}`
+      );
+    }
+    taken.set(name, pkg);
+    outputs.push({
+      kind: "link",
+      path: `${prefix}${name}.md`,
+      target: `../../../${file}`
+    });
+  }
+  return outputs;
+}
+
+// src/project/plan.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/project/frontmatter.ts
+import { parse as parse2 } 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 object = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
+  return { meta: object, body: match[2] ?? "" };
+}
+function scalar(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function renderFrontmatter(meta) {
+  const lines2 = [];
+  for (const [key, value] of Object.entries(meta)) {
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "string" && value.includes("\n")) {
+      const block2 = value.replace(/\n$/u, "").split("\n").map((line) => `  ${line}`);
+      lines2.push(`${key}: |`, ...block2);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      lines2.push(`${key}: [${value.map((v) => JSON.stringify(v)).join(", ")}]`);
+      continue;
+    }
+    lines2.push(`${key}: ${scalar(value)}`);
+  }
+  return `---
+${lines2.join("\n")}
+---
+`;
+}
+
+// src/project/outputs.ts
+var MARK = "AUTO-GENERATED by pmcp project";
+function jsonOutput(file, key, value) {
+  return { kind: "json", path: `${file}#${key.join(".")}`, file, key, value };
+}
+function blockOutput(file, content) {
+  return { kind: "block", path: `${file}#pmcp`, file, content };
+}
+function splitKeyed(path) {
+  const at = path.indexOf("#");
+  if (at === -1) return null;
+  return { file: path.slice(0, at), key: path.slice(at + 1).split(".") };
+}
+
+// src/project/mcp.ts
+var ROOT_VAR = "${PROJECT_ROOT}";
+var quote = (text) => `'${text.replaceAll("'", "'\\''")}'`;
+function shellWord(text) {
+  return text.split(ROOT_VAR).map((piece) => piece === "" ? "" : quote(piece)).join('"$d"');
+}
+function launch(spec) {
+  const words = [spec.command, ...spec.args, ...Object.values(spec.env)];
+  if (!words.some((word) => word.includes(ROOT_VAR))) {
+    return { command: spec.command, args: spec.args, env: spec.env };
+  }
+  const exports = Object.entries(spec.env).map(
+    ([key, value]) => `export ${key}=${shellWord(value)}; `
+  );
+  const script = 'd=$PWD; while [ ! -f "$d/pmcp.toml" ]; do [ "$d" = / ] && exit 1; d=$(dirname "$d"); done; ' + exports.join("") + `exec ${[spec.command, ...spec.args].map(shellWord).join(" ")}`;
+  return { command: "sh", args: ["-c", script], env: {} };
+}
+function entry(server, extra = {}) {
+  return {
+    command: server.command,
+    args: [...server.args],
+    ...Object.keys(server.env).length > 0 ? { env: { ...server.env } } : {},
+    ...extra
+  };
+}
+var tomlValue = (value) => {
+  if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
+  if (value !== null && typeof value === "object") {
+    const parts = Object.entries(value).map(
+      ([k, v]) => `${JSON.stringify(k)} = ${tomlValue(v)}`
+    );
+    return `{ ${parts.join(", ")} }`;
+  }
+  return JSON.stringify(value);
+};
+function tomlServers(servers) {
+  const lines2 = [`# ${MARK} from pmcp.toml [mcp]`];
+  for (const [alias, server] of servers) {
+    lines2.push(
+      "",
+      `[mcp_servers.${alias}]`,
+      `command = ${tomlValue(server.command)}`,
+      `args = ${tomlValue(server.args)}`
+    );
+    if (Object.keys(server.env).length > 0) {
+      lines2.push(`env = ${tomlValue(server.env)}`);
+    }
+  }
+  return `${lines2.join("\n")}
+`;
+}
+function mcpOutputs(spec) {
+  const servers = Object.entries(spec.mcp).map(
+    ([alias, server]) => [alias, launch(server)]
+  );
+  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))
+      );
+    }
+    if (spec.tools.has("gemini")) {
+      const extra = tools ? { includeTools: [...tools] } : {};
+      outputs.push(
+        jsonOutput(
+          ".gemini/settings.json",
+          ["mcpServers", alias],
+          entry(server, extra)
+        )
+      );
+    }
+    if (spec.tools.has("antigravity")) {
+      outputs.push(
+        jsonOutput(
+          ".agents/mcp_config.json",
+          ["mcpServers", alias],
+          entry(server)
+        )
+      );
+    }
+  }
+  if (spec.tools.has("codex")) {
+    outputs.push(blockOutput(".codex/config.toml", tomlServers(servers)));
+  }
+  if (spec.tools.has("grok")) {
+    outputs.push(blockOutput(".grok/config.toml", tomlServers(servers)));
+  }
+  return outputs;
+}
+
+// src/project/plan.ts
+var AGENT_FIELDS = {
+  claude: ["name", "description", "tools", "model", "effort"],
+  gemini: ["name", "description"]
+};
+var SETTINGS = ".claude/settings.json";
+function listDirs(dir) {
+  if (!existsSync3(dir)) return [];
+  return readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+var tomlString = (value) => JSON.stringify(typeof value === "string" ? value : String(value ?? ""));
+function skillNames(root) {
+  const dir = join3(root, ".agents/skills");
+  return listDirs(dir).filter(
+    (name) => existsSync3(join3(dir, name, "SKILL.md"))
+  );
+}
+function agentNames(root) {
+  const dir = join3(root, ".agents/agents");
+  return listDirs(dir).filter(
+    (name) => existsSync3(join3(dir, name, "agent.md"))
+  );
+}
+function skillOutputs(spec) {
+  const outputs = [];
+  for (const name of skillNames(spec.root)) {
+    const target = `../../.agents/skills/${name}`;
+    if (spec.tools.has("claude")) {
+      outputs.push({ kind: "link", path: `.claude/skills/${name}`, target });
+    }
+    if (spec.tools.has("grok")) {
+      outputs.push({ kind: "link", path: `.grok/skills/${name}`, target });
+    }
+    if (spec.skills[name]?.invocation !== "user") continue;
+    if (spec.tools.has("claude")) {
+      outputs.push(
+        jsonOutput(SETTINGS, ["skillOverrides", name], "user-invocable-only")
+      );
+    }
+    if (spec.tools.has("codex")) {
+      outputs.push({
+        kind: "file",
+        path: `.agents/skills/${name}/agents/openai.yaml`,
+        content: `# ${MARK}
+policy:
+  allow_implicit_invocation: false
+`
+      });
+    }
+  }
+  return outputs;
+}
+function ruleOutputs(spec) {
+  if (!spec.tools.has("claude")) return [];
+  const dir = join3(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")
+    );
+    const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
+    const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
+    outputs.push({
+      kind: "file",
+      path: `${RULES_DIR}/pmcp/${file}`,
+      content: `${head}
+<!-- ${MARK} from ${rel} -->
+${body}`
+    });
+  }
+  return outputs;
+}
+function agentOutputs(spec) {
+  const outputs = [];
+  for (const name of agentNames(spec.root)) {
+    const rel = `.agents/agents/${name}/agent.md`;
+    const { meta, body } = splitFrontmatter(
+      readFileSync2(join3(spec.root, rel), "utf8")
+    );
+    const overrides = spec.agents[name] ?? {};
+    const note = `<!-- ${MARK} from ${rel} -->
+`;
+    const pick = (tool) => {
+      const merged = {
+        ...meta,
+        ...overrides[tool] ?? {}
+      };
+      const kept = {};
+      for (const key of AGENT_FIELDS[tool] ?? []) {
+        if (merged[key] !== void 0) kept[key] = merged[key];
+      }
+      return kept;
+    };
+    for (const tool of ["claude", "gemini"]) {
+      if (!spec.tools.has(tool)) continue;
+      outputs.push({
+        kind: "file",
+        path: `.${tool}/agents/${name}.md`,
+        content: `${renderFrontmatter(pick(tool))}
+${note}${body}`
+      });
+    }
+    if (spec.tools.has("codex")) {
+      const toml = [
+        `# ${MARK} from ${rel}`,
+        `name = ${tomlString(meta["name"])}`,
+        `description = ${tomlString(meta["description"])}`,
+        `developer_instructions = ${tomlString(body.trim())}`,
+        ""
+      ].join("\n");
+      outputs.push({
+        kind: "file",
+        path: `.codex/agents/${name}.toml`,
+        content: toml
+      });
+    }
+  }
+  return outputs;
+}
+function plan(spec, owned = /* @__PURE__ */ new Map()) {
+  const outputs = [
+    ...skillOutputs(spec),
+    ...ruleOutputs(spec),
+    ...agentOutputs(spec),
+    ...mcpOutputs(spec)
+  ];
+  if (spec.packageRules && spec.tools.has("claude")) {
+    outputs.push(...packageRuleOutputs(spec.root, spec.packageRules, owned));
+  }
+  return outputs;
+}
+function censusDirs(spec) {
+  const dirs = [
+    ".claude/skills",
+    ".claude/agents",
+    ".claude/commands",
+    ".gemini/agents",
+    ".codex/agents",
+    ".grok/skills",
+    `${RULES_DIR}/pmcp`
+  ];
+  if (spec.packageRules) dirs.push(`${RULES_DIR}/${spec.packageRules.dir}`);
+  return dirs;
+}
+
+// src/project/apply.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync4,
+  lstatSync as lstatSync2,
+  mkdirSync,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync3,
+  readlinkSync as readlinkSync2,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname3, join as join4, posix as posix2 } from "path";
+var LOCK_FILE = "pmcp.lock";
+var BEGIN = "# >>> pmcp project (edit pmcp.toml, not this block) >>>";
+var END = "# <<< pmcp project <<<";
+var PREDECESSORS = [
+  "by sync-claude-projection.sh",
+  "AUTO-GENERATED by scripts/agent/project.mjs"
+];
+var sha = (text) => createHash("sha256").update(text).digest("hex");
+function readLock(root) {
+  const path = join4(root, LOCK_FILE);
+  if (!existsSync4(path)) return [];
+  const lock = JSON.parse(readFileSync3(path, "utf8"));
+  return lock.outputs ?? [];
+}
+function linkOf(abs) {
+  try {
+    return lstatSync2(abs).isSymbolicLink() ? readlinkSync2(abs) : null;
+  } catch {
+    return null;
+  }
+}
+var exists = (abs) => existsSync4(abs) || linkOf(abs) !== null;
+function readJson(abs) {
+  if (!existsSync4(abs)) return {};
+  const value = JSON.parse(readFileSync3(abs, "utf8"));
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function getKey(object, key) {
+  let node = object;
+  for (const part of key) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[part];
+  }
+  return node;
+}
+function setKey(object, key, value) {
+  let node = object;
+  for (const part of key.slice(0, -1)) {
+    const next = node[part];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) {
+      node[part] = {};
+    }
+    node = node[part];
+  }
+  node[key[key.length - 1] ?? ""] = value;
+}
+function deleteKey(object, key) {
+  const [head, ...rest] = key;
+  if (head === void 0 || !(head in object)) return;
+  if (rest.length === 0) {
+    delete object[head];
+    return;
+  }
+  const child = object[head];
+  if (child === null || typeof child !== "object") return;
+  deleteKey(child, rest);
+  if (Object.keys(child).length === 0) delete object[head];
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var block = (content) => `${BEGIN}
+${content}${END}
+`;
+function withoutBlock(text) {
+  const start = text.indexOf(BEGIN);
+  if (start === -1) return text;
+  const end = text.indexOf(END, start);
+  if (end === -1) return text;
+  const after = text.slice(end + END.length).replace(/^\n/u, "");
+  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);
+  switch (output.kind) {
+    case "link":
+      return linkOf(abs) === output.target;
+    case "file":
+      return existsSync4(abs) && linkOf(abs) === null && readFileSync3(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));
+  }
+}
+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);
+  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");
+  if (output.kind === "file" && text === output.content) return true;
+  return PREDECESSORS.some((mark) => text.includes(mark));
+}
+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);
+    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);
+  if (spec.tools.has("grok") && existsSync4(rules)) {
+    for (const entry2 of readdirSync3(rules, { withFileTypes: true })) {
+      if (entry2.isDirectory()) continue;
+      found.push(`${RULES_DIR}/${entry2.name}`);
+    }
+  }
+  return found.sort();
+}
+function deadGlobs(root, outputs) {
+  const rules = outputs.filter(
+    (o) => (o.kind === "link" || o.kind === "file") && o.path.startsWith(`${RULES_DIR}/`)
+  );
+  if (rules.length === 0) return [];
+  const tracked = trackedFiles(root, true);
+  if (tracked.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of tracked) {
+    const parts = file.split("/");
+    for (let i = 1; i <= parts.length; i += 1)
+      seen.add(parts.slice(0, i).join("/"));
+  }
+  const dead = [];
+  for (const rule of rules) {
+    let text;
+    if (rule.kind === "file") {
+      text = rule.content;
+    } else if (rule.kind === "link") {
+      const abs = join4(root, posix2.join(posix2.dirname(rule.path), rule.target));
+      if (!existsSync4(abs)) continue;
+      text = readFileSync3(abs, "utf8");
+    } else {
+      continue;
+    }
+    const paths = splitFrontmatter(text).meta["paths"];
+    for (const glob of [paths ?? []].flat()) {
+      if (typeof glob !== "string") continue;
+      const prefix = glob.replace(/\*.*$/u, "").replace(/\/$/u, "");
+      if (prefix !== "" && !seen.has(prefix))
+        dead.push(`${rule.path}: ${glob}`);
+    }
+  }
+  return dead;
+}
+function lockEntry(output) {
+  switch (output.kind) {
+    case "link":
+      return { path: output.path, kind: "link", target: output.target };
+    case "file":
+      return { path: output.path, kind: "file", sha256: sha(output.content) };
+    case "json":
+      return {
+        path: output.path,
+        kind: "json",
+        sha256: sha(JSON.stringify(output.value))
+      };
+    case "block":
+      return { path: output.path, kind: "block", sha256: sha(output.content) };
+  }
+}
+function project(spec, options) {
+  const lock = readLock(spec.root);
+  const ownedTargets = new Map(
+    lock.filter((e) => e.kind === "link" && e.target !== void 0).map((e) => [e.path, e.target])
+  );
+  const outputs = plan(spec, ownedTargets);
+  const owned = new Set(lock.map((e) => e.path));
+  const planned = new Set(outputs.map((o) => o.path));
+  const stale = lock.filter((e) => !planned.has(e.path));
+  if (options.check) {
+    const problems = [
+      ...outputs.filter((o) => !present(spec.root, o)).map((o) => `drift: ${o.path}`),
+      ...stale.map((e) => `stale: ${e.path}`),
+      ...undeclared(spec, outputs).map((p) => `undeclared: ${p}`),
+      ...deadGlobs(spec.root, outputs).map((p) => `dead glob: ${p}`)
+    ];
+    return {
+      code: problems.length > 0 ? 2 : 0,
+      problems,
+      outputs: outputs.length,
+      pruned: 0
+    };
+  }
+  const refused = outputs.filter((o) => !replaceable(spec.root, o, owned)).map((o) => `refusing to overwrite a file it did not write: ${o.path}`);
+  if (refused.length > 0) {
+    return { code: 3, problems: refused, outputs: outputs.length, pruned: 0 };
+  }
+  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 });
+    rmSync(abs, { force: true, recursive: true });
+    if (output.kind === "link") symlinkSync(output.target, abs);
+    else writeFileSync(abs, output.content);
+  }
+  let pruned = 0;
+  const jsonFiles = /* @__PURE__ */ new Map();
+  const blockFiles = /* @__PURE__ */ new Map();
+  for (const output of outputs) {
+    if (output.kind === "json") {
+      const entry2 = jsonFiles.get(output.file) ?? { sets: [], drops: [] };
+      entry2.sets.push(output);
+      jsonFiles.set(output.file, entry2);
+    }
+    if (output.kind === "block") blockFiles.set(output.file, output.content);
+  }
+  for (const entry2 of stale) {
+    const keyed = splitKeyed(entry2.path);
+    if (keyed && keyed.key.length === 1 && keyed.key[0] === "pmcp") {
+      if (!blockFiles.has(keyed.file)) blockFiles.set(keyed.file, null);
+    } else if (keyed) {
+      const group = jsonFiles.get(keyed.file) ?? { sets: [], drops: [] };
+      group.drops.push(keyed.key);
+      jsonFiles.set(keyed.file, group);
+    } else {
+      rmSync(join4(spec.root, entry2.path), { force: true, recursive: true });
+    }
+    pruned += 1;
+  }
+  for (const [file, { sets, drops }] of jsonFiles) {
+    const abs = join4(spec.root, file);
+    const before = readJson(abs);
+    const after = structuredClone(before);
+    for (const key of drops) deleteKey(after, key);
+    for (const output of sets) {
+      if (output.kind === "json") setKey(after, output.key, output.value);
+    }
+    if (same(before, after)) continue;
+    if (!existsSync4(abs) && Object.keys(after).length === 0) continue;
+    mkdirSync(dirname3(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") : "";
+    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 });
+    writeFileSync(abs, after);
+  }
+  if (spec.packageRules) {
+    const linkedDirs = new Set(
+      outputs.filter(
+        (o) => o.kind === "link" && o.path.startsWith(`${RULES_DIR}/${spec.packageRules?.dir}/`)
+      ).map(
+        (o) => o.kind === "link" ? posix2.dirname(o.target.replace(/^(\.\.\/)+/u, "")) : ""
+      )
+    );
+    for (const [name, target] of legacyLinks(spec.root)) {
+      const abs = join4(spec.root, RULES_DIR, `${name}.md`);
+      const broken = !existsSync4(abs);
+      if (!broken && !linkedDirs.has(posix2.dirname(target))) continue;
+      rmSync(abs, { force: true });
+      pruned += 1;
+    }
+  }
+  writeFileSync(
+    join4(spec.root, LOCK_FILE),
+    `${JSON.stringify({ version: 1, outputs: outputs.map(lockEntry) }, null, 2)}
+`
+  );
+  return { code: 0, problems: [], outputs: outputs.length, pruned };
+}
+
+// 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";
+var spawnRunner = (command, args, cwd) => {
+  const result = spawnSync(command, [...args], {
+    cwd,
+    encoding: "utf8",
+    timeout: 18e4,
+    maxBuffer: 1 << 26
+  });
+  const code = result.error?.code;
+  return {
+    missing: code === "ENOENT",
+    status: result.status,
+    stdout: `${result.stdout ?? ""}${result.stderr ?? ""}`
+  };
+};
+var missingFrom = (names, present2) => names.filter((name) => !present2(name));
+function verdict(tool, check, missing) {
+  if (missing.length === 0) return { tool, check, status: "ok" };
+  return {
+    tool,
+    check,
+    status: "fail",
+    detail: `missing: ${missing.join(", ")}`
+  };
+}
+function listed(tool, check, result, names, present2) {
+  if (result.missing)
+    return { tool, check, status: "skip", detail: "not installed" };
+  if (result.status !== 0) {
+    return {
+      tool,
+      check,
+      status: "fail",
+      detail: `exit ${result.status}: ${result.stdout.trim().split("\n").pop() ?? ""}`
+    };
+  }
+  return verdict(
+    tool,
+    check,
+    missingFrom(names, (name) => present2(result.stdout, name))
+  );
+}
+var lines = (out) => out.split("\n").map((l) => l.trim());
+function claude(spec, o) {
+  const aliases = Object.keys(spec.mcp);
+  if (aliases.length === 0) return [];
+  const result = o.run("claude", ["mcp", "list"], spec.root);
+  return [
+    listed(
+      "claude",
+      "mcp servers connected",
+      result,
+      aliases,
+      (out, alias) => lines(out).some(
+        (l) => l.startsWith(`${alias}:`) && /connected/iu.test(l) && !/failed/iu.test(l)
+      )
+    )
+  ];
+}
+function codex(spec, o) {
+  const findings = [];
+  const config = join5(o.home, ".codex/config.toml");
+  let trusted = false;
+  if (existsSync5(config)) {
+    const projects = parse3(readFileSync4(config, "utf8")).projects ?? {};
+    const root = spec.root.replace(/\/$/u, "");
+    trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
+  }
+  findings.push(
+    trusted ? { tool: "codex", check: "project trusted", status: "ok" } : {
+      tool: "codex",
+      check: "project trusted",
+      status: "fail",
+      detail: "untrusted projects skip .codex/ and .agents/"
+    }
+  );
+  const aliases = Object.keys(spec.mcp);
+  if (aliases.length > 0) {
+    const result = o.run("codex", ["mcp", "list"], spec.root);
+    findings.push(
+      listed(
+        "codex",
+        "mcp servers listed",
+        result,
+        aliases,
+        (out, alias) => lines(out).some((l) => l.split(/\s+/u)[0] === alias)
+      )
+    );
+  }
+  return findings;
+}
+function gemini(spec, o) {
+  const findings = [];
+  const skills = skillNames(spec.root);
+  if (skills.length > 0) {
+    const result = o.run("gemini", ["skills", "list"], spec.root);
+    findings.push(
+      listed(
+        "gemini",
+        "project skills listed",
+        result,
+        skills,
+        (out, name) => lines(out).some((l) => l.startsWith(`${name} [`))
+      )
+    );
+  }
+  const aliases = Object.keys(spec.mcp);
+  if (aliases.length > 0) {
+    const result = o.run("gemini", ["mcp", "list"], spec.root);
+    findings.push(
+      listed(
+        "gemini",
+        "mcp servers connected",
+        result,
+        aliases,
+        (out, alias) => lines(out).some(
+          (l) => l.includes(`${alias}:`) && /connected/iu.test(l) && !/disconnected/iu.test(l)
+        )
+      )
+    );
+  }
+  return findings;
+}
+function grok(spec, o) {
+  const result = o.run("grok", ["inspect", "--json"], spec.root);
+  if (result.missing)
+    return [
+      {
+        tool: "grok",
+        check: "inspect",
+        status: "skip",
+        detail: "not installed"
+      }
+    ];
+  let report;
+  try {
+    report = JSON.parse(
+      result.stdout.slice(result.stdout.indexOf("{"))
+    );
+  } catch {
+    return [
+      {
+        tool: "grok",
+        check: "inspect",
+        status: "fail",
+        detail: "grok inspect --json did not return JSON"
+      }
+    ];
+  }
+  const findings = [];
+  findings.push(
+    report.projectTrusted ? { tool: "grok", check: "project trusted", status: "ok" } : {
+      tool: "grok",
+      check: "project trusted",
+      status: "fail",
+      detail: "untrusted projects skip .grok/ MCP and hooks"
+    }
+  );
+  const skills = new Set((report.skills ?? []).map((s) => s.name));
+  findings.push(
+    verdict(
+      "grok",
+      "project skills listed",
+      missingFrom(skillNames(spec.root), (n) => skills.has(n))
+    )
+  );
+  const leaked = (report.projectInstructions ?? []).filter(
+    (i) => i.path.includes("/.claude/rules/")
+  );
+  findings.push(
+    leaked.length === 0 ? { tool: "grok", check: "no .claude/rules loaded", status: "ok" } : {
+      tool: "grok",
+      check: "no .claude/rules loaded",
+      status: "fail",
+      detail: `${leaked.length} rule files load unscoped`
+    }
+  );
+  const servers = new Set((report.mcpServers ?? []).map((s) => s.name));
+  if (Object.keys(spec.mcp).length > 0) {
+    findings.push(
+      verdict(
+        "grok",
+        "mcp servers listed",
+        missingFrom(Object.keys(spec.mcp), (n) => servers.has(n))
+      )
+    );
+  }
+  return findings;
+}
+function antigravity(spec) {
+  const foreign = agentNames(spec.root).filter((name) => {
+    const text = readFileSync4(
+      join5(spec.root, ".agents/agents", name, "agent.md"),
+      "utf8"
+    );
+    return splitFrontmatter(text).meta["tools"] !== void 0;
+  });
+  return [
+    foreign.length === 0 ? {
+      tool: "antigravity",
+      check: "agents carry no tool lists",
+      status: "ok"
+    } : {
+      tool: "antigravity",
+      check: "agents carry no tool lists",
+      status: "fail",
+      detail: `move tools to pmcp.toml [agents.<name>.<tool>]: ${foreign.join(", ")}`
+    }
+  ];
+}
+function doctor(spec, options) {
+  const check = project(spec, { check: true });
+  const findings = [
+    check.code === 0 ? { tool: "project", check: "outputs match sources", status: "ok" } : {
+      tool: "project",
+      check: "outputs match sources",
+      status: "fail",
+      detail: check.problems.slice(0, 5).join("; ")
+    }
+  ];
+  const wanted = (tool) => spec.tools.has(tool) && (options.only === void 0 || options.only.has(tool));
+  if (wanted("claude")) findings.push(...claude(spec, options));
+  if (wanted("codex")) findings.push(...codex(spec, options));
+  if (wanted("gemini")) findings.push(...gemini(spec, options));
+  if (wanted("grok")) findings.push(...grok(spec, options));
+  if (wanted("antigravity")) findings.push(...antigravity(spec));
+  return findings;
+}
+
+// src/project/spec.ts
+var TOOLS = [
+  "claude",
+  "codex",
+  "gemini",
+  "grok",
+  "antigravity"
+];
+var NAME = /^[a-z0-9][a-z0-9-]*$/u;
+function table(path, where, value) {
+  if (value === void 0) return {};
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new ConfigError(path, `${where} must be a table`);
+  }
+  return value;
+}
+function strings(path, where, value) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new ConfigError(path, `${where} must be a list of strings`);
+  }
+  return value;
+}
+function named(path, where, name) {
+  if (!NAME.test(name)) {
+    throw new ConfigError(
+      path,
+      `${where} ${name}: use lowercase, digits and -`
+    );
+  }
+  return name;
+}
+function readSpec(config) {
+  const path = config.path;
+  const raw = config.raw;
+  const targets = table(path, "[targets]", raw["targets"]);
+  const tools = /* @__PURE__ */ new Set();
+  if (targets["tools"] !== void 0) {
+    for (const tool of strings(path, "[targets] tools", targets["tools"])) {
+      if (!TOOLS.includes(tool)) {
+        throw new ConfigError(path, `[targets] unknown tool ${tool}`);
+      }
+      tools.add(tool);
+    }
+  }
+  const skills = {};
+  for (const [name, value] of Object.entries(
+    table(path, "[skills]", raw["skills"])
+  )) {
+    const entry2 = table(path, `[skills.${name}]`, value);
+    const invocation = entry2["invocation"] ?? "any";
+    if (invocation !== "any" && invocation !== "user") {
+      throw new ConfigError(
+        path,
+        `[skills.${name}] invocation must be "any" or "user"`
+      );
+    }
+    skills[named(path, "[skills]", name)] = { invocation };
+  }
+  const agents = {};
+  for (const [name, value] of Object.entries(
+    table(path, "[agents]", raw["agents"])
+  )) {
+    const perTool = {};
+    for (const [tool, fields] of Object.entries(
+      table(path, `[agents.${name}]`, value)
+    )) {
+      if (!TOOLS.includes(tool)) {
+        throw new ConfigError(path, `[agents.${name}] unknown tool ${tool}`);
+      }
+      perTool[tool] = table(path, `[agents.${name}.${tool}]`, fields);
+    }
+    agents[named(path, "[agents]", name)] = perTool;
+  }
+  const rules = table(path, "[rules]", raw["rules"]);
+  let packageRules = null;
+  if (rules["packages"] !== void 0) {
+    const pkg = table(path, "[rules.packages]", rules["packages"]);
+    const file = pkg["file"];
+    if (typeof file !== "string" || file === "") {
+      throw new ConfigError(path, "[rules.packages] file is required");
+    }
+    const dir = pkg["dir"] ?? "pkg";
+    if (typeof dir !== "string" || !NAME.test(dir) || dir === "pmcp") {
+      throw new ConfigError(
+        path,
+        '[rules.packages] dir must be a plain name other than "pmcp"'
+      );
+    }
+    const strip = pkg["strip"] === void 0 ? [] : strings(path, "[rules.packages] strip", pkg["strip"]);
+    packageRules = { file, dir, strip };
+  }
+  const mcp = {};
+  for (const [alias, value] of Object.entries(
+    table(path, "[mcp]", raw["mcp"])
+  )) {
+    const where = `[mcp.${alias}]`;
+    const entry2 = table(path, where, value);
+    const command = entry2["command"];
+    if (typeof command !== "string" || command === "") {
+      throw new ConfigError(path, `${where} command is required`);
+    }
+    const env = {};
+    for (const [key, v] of Object.entries(
+      table(path, `${where} env`, entry2["env"])
+    )) {
+      if (typeof v !== "string") {
+        throw new ConfigError(path, `${where} env ${key} must be a string`);
+      }
+      env[key] = v;
+    }
+    mcp[named(path, "[mcp]", alias)] = {
+      command,
+      args: entry2["args"] === void 0 ? [] : strings(path, `${where} args`, entry2["args"]),
+      env,
+      ...entry2["tools"] === void 0 ? {} : { tools: strings(path, `${where} tools`, entry2["tools"]) }
+    };
+  }
+  return { root: config.dir, tools, skills, agents, packageRules, mcp };
+}
+
+export {
+  openDatabase,
+  DEFAULT_INTENT_CACHE_LIMIT,
+  openIntentCache,
+  CONFIG_FILE,
+  ConfigError,
+  findConfig,
+  readConfig,
+  splitFrontmatter,
+  renderFrontmatter,
+  ProjectError,
+  deriveName,
+  plan,
+  LOCK_FILE,
+  deadGlobs,
+  project,
+  spawnRunner,
+  doctor,
+  TOOLS,
+  readSpec
+};
+//# sourceMappingURL=chunk-6TSHDCUY.js.map