@oprt/cli 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1445 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CliError: () => CliError,
+  DEFAULT_OUT: () => DEFAULT_OUT,
+  TOOLS: () => TOOLS,
+  VERSION: () => VERSION,
+  applyBlock: () => applyBlock,
+  blockVersion: () => blockVersion,
+  checkPaths: () => checkPaths,
+  checkSource: () => checkSource,
+  componentDetail: () => componentDetail,
+  componentIndex: () => componentIndex,
+  contract: () => contract,
+  doctor: () => doctor,
+  handleMessage: () => handleMessage,
+  init: () => init,
+  install: () => install,
+  parseArgs: () => parseArgs,
+  registry: () => registry,
+  removeBlock: () => removeBlock,
+  renderAgentBlock: () => renderAgentBlock,
+  renderComponent: () => renderComponent,
+  resolveEntries: () => resolveEntries,
+  runAgentCommand: () => runAgentCommand,
+  search: () => search,
+  serve: () => serve
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postcss@8.5.30_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var import_node_url3 = require("url");
+
+// package.json
+var package_default = {
+  name: "@oprt/cli",
+  version: "0.1.0",
+  description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
+  keywords: [
+    "design-system",
+    "cli",
+    "coding-agents",
+    "mcp",
+    "model-context-protocol",
+    "code-check",
+    "components"
+  ],
+  homepage: "https://oprt.dev/docs/agents/cli",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    oprt: "./dist/bin.js"
+  },
+  engines: {
+    node: ">=22"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./read": {
+      import: {
+        types: "./dist/read.d.ts",
+        default: "./dist/read.js"
+      },
+      require: {
+        types: "./dist/read.d.cts",
+        default: "./dist/read.cjs"
+      }
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
+    build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
+    dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src scripts"
+  },
+  devDependencies: {
+    tsup: "^8.3.0",
+    typescript: "^5.6.3",
+    vitest: "^2.1.3"
+  },
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/contract.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+function loadContract() {
+  const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  const candidates = [(0, import_node_path.join)(here, "contract.json"), (0, import_node_path.join)(here, "../generated/contract.json")];
+  const found = candidates.find((candidate) => (0, import_node_fs.existsSync)(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `contract.json is missing next to ${here}. Install @oprt/cli again: the contract ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse((0, import_node_fs.readFileSync)(found, "utf8"));
+}
+
+// src/installer.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// src/types.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1, details = {}) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+    this.code = details.code ?? (exitCode === 2 ? "ERR_USAGE" : "ERR_FAILED");
+    if (details.suggestions !== void 0) this.suggestions = details.suggestions;
+  }
+  exitCode;
+  code;
+  suggestions;
+};
+
+// src/args.ts
+var DEFAULT_OUT = "src/components/operator";
+function split(command, rest, spec) {
+  const flags = /* @__PURE__ */ new Set();
+  const values = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (!token.startsWith("-")) {
+      positional.push(token);
+      continue;
+    }
+    const kind = spec[token];
+    if (kind === void 0)
+      throw new CliError(
+        `Unknown option ${JSON.stringify(token)} for ${command}. Run oprt --help.`,
+        2
+      );
+    if (flags.has(token) || values.has(token)) throw new CliError(`Duplicate option ${token}.`, 2);
+    if (kind === "flag") flags.add(token);
+    else {
+      const value = rest[++i];
+      if (!value || value.startsWith("-")) throw new CliError(`${token} requires a value.`, 2);
+      values.set(token, value);
+    }
+  }
+  return {
+    has: (flag) => flags.has(flag),
+    value: (name) => values.get(name),
+    positional
+  };
+}
+var AGENT_COMMANDS = {
+  component(rest) {
+    const { has, positional } = split("component", rest, {
+      "--list": "flag",
+      "--dense": "flag",
+      "--json": "flag"
+    });
+    if (has("--list") ? positional.length > 0 : positional.length === 0)
+      throw new CliError("Usage: oprt component <Name...> [--dense], or component --list", 2);
+    return {
+      command: "component",
+      names: positional,
+      list: has("--list"),
+      dense: has("--dense"),
+      json: has("--json")
+    };
+  },
+  search(rest) {
+    const { has, value, positional } = split("search", rest, {
+      "--limit": "value",
+      "--json": "flag"
+    });
+    if (positional.length === 0) throw new CliError("Usage: oprt search <need> [--limit <n>]", 2);
+    const limit = value("--limit") === void 0 ? 10 : Number(value("--limit"));
+    if (!Number.isInteger(limit) || limit < 1)
+      throw new CliError("--limit takes a whole number above zero.", 2);
+    return { command: "search", query: positional.join(" "), limit, json: has("--json") };
+  },
+  init(rest) {
+    const { has, value, positional } = split("init", rest, {
+      "--agent": "value",
+      "--path": "value",
+      "--remove": "flag",
+      "--dry-run": "flag",
+      "--json": "flag"
+    });
+    const agent = value("--agent");
+    const path = value("--path");
+    if (positional.length > 0 || agent !== void 0 && path !== void 0)
+      throw new CliError(
+        "Usage: oprt init [--agent <name> | --path <file>] [--remove] [--dry-run]",
+        2
+      );
+    return {
+      command: "init",
+      ...agent === void 0 ? {} : { agent },
+      ...path === void 0 ? {} : { path },
+      remove: has("--remove"),
+      dryRun: has("--dry-run"),
+      json: has("--json")
+    };
+  },
+  check(rest) {
+    const { has, positional } = split("check", rest, { "--strict": "flag", "--json": "flag" });
+    if (positional.length === 0)
+      throw new CliError("Usage: oprt check <file or folder...> [--strict]", 2);
+    return { command: "check", paths: positional, strict: has("--strict"), json: has("--json") };
+  },
+  mcp(rest) {
+    if (rest.length > 0) throw new CliError("Usage: oprt mcp", 2);
+    return { command: "mcp" };
+  },
+  doctor(rest) {
+    const { has, positional } = split("doctor", rest, { "--json": "flag" });
+    if (positional.length > 0) throw new CliError("Usage: oprt doctor", 2);
+    return { command: "doctor", json: has("--json") };
+  }
+};
+function parseArgs(args) {
+  if (!args.length || args.length === 1 && ["--help", "-h", "help"].includes(args[0]))
+    return { command: "help" };
+  if (args.length === 1 && ["--version", "-v"].includes(args[0])) return { command: "version" };
+  const [command, ...rest] = args;
+  if ([...Object.keys(AGENT_COMMANDS), "list", "add"].includes(command) && rest.length === 1 && ["--help", "-h"].includes(rest[0]))
+    return { command: "help" };
+  if (Object.hasOwn(AGENT_COMMANDS, command)) return AGENT_COMMANDS[command](rest);
+  if (command === "list") {
+    if (rest.length === 0) return { command, json: false };
+    if (rest.length === 1 && rest[0] === "--json") return { command, json: true };
+    throw new CliError("Usage: oprt list [--json]", 2);
+  }
+  if (command !== "add")
+    throw new CliError(`Unknown command ${JSON.stringify(command)}. Run oprt --help.`, 2);
+  const parsed = {
+    command,
+    names: [],
+    out: DEFAULT_OUT,
+    dryRun: false,
+    overwrite: false
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (!token.startsWith("-")) {
+      parsed.names.push(token);
+      continue;
+    }
+    if (!["--out", "--dry-run", "--overwrite"].includes(token))
+      throw new CliError(`Unknown option ${JSON.stringify(token)}. Run oprt --help.`, 2);
+    if (seen.has(token)) throw new CliError(`Duplicate option ${token}.`, 2);
+    seen.add(token);
+    if (token === "--out") {
+      const value = rest[++i];
+      if (!value || value.startsWith("-"))
+        throw new CliError("--out requires a relative directory.", 2);
+      parsed.out = value;
+    } else if (token === "--dry-run") parsed.dryRun = true;
+    else parsed.overwrite = true;
+  }
+  if (!parsed.names.length)
+    throw new CliError("add requires one or more component or recipe names. Run oprt list.", 2);
+  return parsed;
+}
+
+// src/installer.ts
+function resolveEntries(names, registry2) {
+  if (!names.length) throw new CliError("add requires one or more names.", 2);
+  const selected = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const normalized = name.toLowerCase();
+    const entry = registry2.entries.find(
+      (candidate) => candidate.slug === normalized || candidate.name.toLowerCase() === normalized
+    );
+    if (!entry)
+      throw new CliError(`Unknown component or recipe ${JSON.stringify(name)}. Run oprt list.`, 2);
+    selected.set(entry.name, entry);
+  }
+  return [...selected.values()];
+}
+function validateRelative(path) {
+  if (!path || (0, import_node_path2.isAbsolute)(path) || /[\\:\0]/.test(path) || path.split("/").includes(".."))
+    throw new CliError(
+      `Unsafe path ${JSON.stringify(path)}: use a nonempty relative path without traversal.`,
+      2
+    );
+}
+function stat(path) {
+  try {
+    return (0, import_node_fs2.lstatSync)(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function inspectPath(root, destination, directory = false) {
+  const path = (0, import_node_path2.relative)(root, destination);
+  if (path === ".." || path.startsWith(`..${import_node_path2.sep}`) || (0, import_node_path2.isAbsolute)(path))
+    throw new CliError("Output path escapes the working directory.");
+  let cursor = root;
+  const segments = path ? path.split(import_node_path2.sep) : [];
+  for (let i = 0; i < segments.length; i++) {
+    cursor = (0, import_node_path2.resolve)(cursor, segments[i]);
+    const info = stat(cursor);
+    if (!info) continue;
+    if (info.isSymbolicLink()) throw new CliError(`Refusing symlink in output path: ${cursor}`);
+    const needsDirectory = i < segments.length - 1 || directory;
+    if (needsDirectory && !info.isDirectory())
+      throw new CliError(`Output ancestor is not a directory: ${cursor}`);
+    if (!needsDirectory && !info.isFile())
+      throw new CliError(`Output target is not a regular file: ${cursor}`);
+  }
+  return stat(destination);
+}
+function installSources(options, context) {
+  const entries = resolveEntries(options.names, context.registry);
+  const out = options.out ?? DEFAULT_OUT;
+  validateRelative(out);
+  const root = (0, import_node_fs2.realpathSync)(context.cwd);
+  const outputDirectory = (0, import_node_path2.resolve)(root, out);
+  inspectPath(root, outputDirectory, true);
+  const paths = [...new Set(entries.flatMap((entry) => entry.files))].sort();
+  const files = paths.map((path) => {
+    validateRelative(path);
+    const content = context.registry.files[path];
+    if (!Object.hasOwn(context.registry.files, path) || typeof content !== "string")
+      throw new CliError(`Registry is missing source ${path}.`);
+    const destination = (0, import_node_path2.resolve)(outputDirectory, path);
+    const info = inspectPath(root, destination);
+    if (!info) return { path, destination, action: "create" };
+    if ((0, import_node_fs2.readFileSync)(destination, "utf8") === content) return { path, destination, action: "skip" };
+    if (!options.overwrite)
+      throw new CliError(
+        `Refusing to overwrite modified file ${destination}. Use --overwrite to replace it explicitly.`
+      );
+    return { path, destination, action: "overwrite" };
+  });
+  const dependencies = [...new Set(entries.flatMap((entry) => entry.dependencies))].sort();
+  const runtime = new Set(
+    entries.flatMap(
+      (entry) => entry.dependencies.filter((name) => !(entry.devDependencies ?? []).includes(name))
+    )
+  );
+  const result = {
+    outputDirectory,
+    entries: entries.map((entry) => entry.name),
+    dependencies,
+    devDependencies: dependencies.filter(
+      (name) => !runtime.has(name) && entries.some((entry) => (entry.devDependencies ?? []).includes(name))
+    ),
+    ranges: Object.fromEntries(
+      dependencies.flatMap((name) => {
+        const range = context.registry.ranges?.[name];
+        return range === void 0 ? [] : [[name, range]];
+      })
+    ),
+    files,
+    dryRun: options.dryRun ?? false
+  };
+  if (result.dryRun) return result;
+  for (const file of files) {
+    if (file.action === "skip") continue;
+    inspectPath(root, file.destination);
+    const parent = (0, import_node_path2.dirname)(file.destination);
+    (0, import_node_fs2.mkdirSync)(parent, { recursive: true });
+    inspectPath(root, parent, true);
+    const flags = import_node_fs2.constants.O_WRONLY | import_node_fs2.constants.O_CREAT | (import_node_fs2.constants.O_NOFOLLOW ?? 0) | (file.action === "create" ? import_node_fs2.constants.O_EXCL : import_node_fs2.constants.O_TRUNC);
+    const descriptor = (0, import_node_fs2.openSync)(file.destination, flags, 420);
+    try {
+      (0, import_node_fs2.writeFileSync)(descriptor, context.registry.files[file.path]);
+    } finally {
+      (0, import_node_fs2.closeSync)(descriptor);
+    }
+  }
+  return result;
+}
+
+// src/check.ts
+var import_node_fs3 = require("fs");
+var import_node_module = require("module");
+var import_node_path3 = require("path");
+var import_node_url2 = require("url");
+
+// src/lookup.ts
+var squash = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+var firstSentence = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = row[j];
+      row[j] = Math.min(above + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return row[b.length];
+}
+function nearest(wanted, names, limit = 5) {
+  const target = squash(wanted);
+  return names.map((name) => {
+    const candidate = squash(name);
+    const apart = distance(target, candidate);
+    const close = apart <= 2 || target.length >= 3 && (candidate.includes(target) || target.includes(candidate));
+    return { name, apart, close };
+  }).filter(({ close }) => close).sort((a, b) => a.apart - b.apart || a.name.localeCompare(b.name)).slice(0, limit).map(({ name }) => name);
+}
+function resolveComponent(contract2, wanted) {
+  const names = Object.keys(contract2.components);
+  const found = names.find((name) => name === wanted) ?? names.find((name) => squash(name) === squash(wanted));
+  if (found !== void 0) return found;
+  const suggestions = nearest(wanted, names);
+  throw new CliError(
+    `Unknown component ${JSON.stringify(wanted)}.` + (suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "") + " Run oprt component --list.",
+    2,
+    { code: "ERR_UNKNOWN_COMPONENT", suggestions }
+  );
+}
+function allowedChildren(rules, name) {
+  for (const [parent, rule] of Object.entries(rules ?? {})) {
+    if (parent === name) return rule.allowed_children;
+    const nested = allowedChildren(rule.children, name);
+    if (nested !== void 0) return nested;
+  }
+  return void 0;
+}
+var partsOf = (contract2, name) => Object.keys(contract2.components).filter(
+  (part) => contract2.guidance.components[part]?.part_of === name
+);
+function componentIndex(contract2) {
+  return Object.keys(contract2.components).filter((name) => (contract2.guidance.components[name]?.use_for ?? []).length > 0).sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    purpose: contract2.guidance.components[name].use_for.join("; "),
+    parts: partsOf(contract2, name)
+  }));
+}
+function componentDetail(contract2, wanted) {
+  const name = resolveComponent(contract2, wanted);
+  const component = contract2.components[name];
+  const guide = contract2.guidance.components[name] ?? {};
+  const props = Object.entries(component.props).map(([prop, definition]) => {
+    const notes = guide.values?.[prop];
+    return { name: prop, ...definition, ...notes === void 0 ? {} : { notes } };
+  });
+  const allowed = allowedChildren(contract2.composition_rules, name);
+  return {
+    name,
+    description: component.description,
+    use_for: guide.use_for ?? [],
+    not_for: guide.not_for ?? [],
+    ...guide.part_of === void 0 ? {} : { part_of: guide.part_of },
+    parts: partsOf(contract2, name),
+    props,
+    ...component.slots === void 0 ? {} : { slots: component.slots },
+    composable_with: component.composable_with ?? [],
+    never_inside: component.never_inside ?? [],
+    ...allowed === void 0 ? {} : { allowed_children: allowed },
+    example: component.example
+  };
+}
+function propLine(prop, dense) {
+  const kind = prop.type === "enum" ? (prop.values ?? []).map((value) => value === prop.default ? `${value} (default)` : value).join(" | ") : (prop.type === "union" ? (prop.types ?? []).join(" or ") : prop.type) + (prop.default === void 0 ? "" : ` (default ${String(prop.default)})`);
+  const description = prop.description === void 0 ? "" : dense ? firstSentence(prop.description) : prop.description;
+  const lines = [
+    `  ${prop.name}: ${kind}${prop.required ? ", required" : ""}${description ? `. ${description}` : ""}`
+  ];
+  for (const [value, note] of Object.entries(prop.notes ?? {})) lines.push(`    ${value}: ${note}`);
+  return lines;
+}
+function renderComponent(detail, { dense }) {
+  const lines = [
+    detail.part_of === void 0 ? `${detail.name}: ${detail.use_for.join("; ")}` : `${detail.name}: a part of ${detail.part_of}. ${firstSentence(detail.description)}`
+  ];
+  if (detail.not_for.length > 0)
+    lines.push(
+      `Not for: ${detail.not_for.map(({ need, use }) => `${need} (use ${use})`).join("; ")}`
+    );
+  if (!dense) lines.push("", detail.description, "");
+  if (detail.props.length > 0) {
+    lines.push("Props:");
+    for (const prop of detail.props) lines.push(...propLine(prop, dense));
+  }
+  for (const [slot, { type, required }] of Object.entries(detail.slots ?? {}))
+    lines.push(
+      `${slot === "children" ? "Children" : `Slot ${slot}`}: ${type}${required ? ", required" : ""}`
+    );
+  if (detail.parts.length > 0) lines.push(`Parts: ${detail.parts.join(", ")}`);
+  if (detail.allowed_children !== void 0)
+    lines.push(`Takes directly inside: ${detail.allowed_children.join(", ")}`);
+  if (detail.composable_with.length > 0)
+    lines.push(`Goes inside: ${detail.composable_with.join(", ")}`);
+  if (detail.never_inside.length > 0) lines.push(`Never inside: ${detail.never_inside.join(", ")}`);
+  lines.push(
+    detail.example.includes("\n") ? `Example:
+${detail.example.split("\n").map((line) => `  ${line}`).join("\n")}` : `Example: ${detail.example}`
+  );
+  return `${lines.join("\n")}
+`;
+}
+var STOP = new Set(
+  "a an the to of for in on at with and or i we need want that which is are it its my some from by".split(
+    " "
+  )
+);
+var words = (text2) => (text2.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((word) => !STOP.has(word)).map((word) => word.length > 4 ? word.replace(/(?:ing|ed|es|s)$/, "") : word);
+var matched = (query, text2) => {
+  const present = new Set(words(text2));
+  return query.filter((word) => present.has(word)).length;
+};
+function search(contract2, registry2, query, limit = 10) {
+  const wanted = words(query);
+  if (wanted.length === 0) return [];
+  const whole = squash(query);
+  const scores = /* @__PURE__ */ new Map();
+  const add = (name, points, why) => {
+    const before = scores.get(name) ?? { score: 0 };
+    scores.set(name, {
+      score: before.score + points,
+      ...before.why !== void 0 ? { why: before.why } : why !== void 0 ? { why } : {}
+    });
+  };
+  for (const [name, component] of Object.entries(contract2.components)) {
+    const guide = contract2.guidance.components[name] ?? {};
+    const plain = squash(name);
+    if (plain === whole) add(name, 100);
+    else if (wanted.some((word) => word.length >= 3 && plain.includes(word))) add(name, 15);
+    else if (wanted.some((word) => word.length >= 4 && distance(word, plain) <= 1)) add(name, 12);
+    for (const phrase of guide.use_for ?? []) {
+      const hits = matched(wanted, phrase);
+      if (hits > 0) add(name, 12 * hits + (hits === wanted.length ? 40 : 0));
+    }
+    for (const { need, use } of guide.not_for ?? []) {
+      const hits = matched(wanted, need);
+      if (hits > 0 && hits >= Math.ceil(wanted.length * 0.6))
+        add(use, 10 * hits + (hits === wanted.length ? 15 : 0), `${name} is not for this: ${need}`);
+    }
+    const inDescription = matched(wanted, component.description);
+    if (inDescription > 0) add(name, 2 * inDescription);
+  }
+  const results = [];
+  for (const [name, { score, why }] of scores) {
+    const guide = contract2.guidance.components[name] ?? {};
+    results.push({
+      kind: "component",
+      name,
+      purpose: guide.part_of === void 0 ? (guide.use_for ?? []).join("; ") : `a part of ${guide.part_of}`,
+      score,
+      ...why === void 0 ? {} : { why },
+      next: `oprt component ${name}`
+    });
+  }
+  for (const entry of registry2.entries.filter(({ kind }) => kind === "recipe")) {
+    const recipe = contract2.patterns?.[entry.name];
+    const plain = squash(entry.name);
+    const inName = plain === whole ? 100 : wanted.some((word) => word.length >= 3 && plain.includes(word)) ? 15 : 0;
+    const hits = matched(wanted, entry.description);
+    const score = inName + (hits > 0 ? 10 * hits + (hits === wanted.length ? 15 : 0) : 0);
+    if (score > 0)
+      results.push({
+        kind: "recipe",
+        name: entry.name,
+        purpose: firstSentence(entry.description),
+        score,
+        next: recipe?.install ?? `oprt add ${entry.slug}`
+      });
+  }
+  results.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  const floor = Math.max(4, (results[0]?.score ?? 0) * 0.15);
+  return results.filter(({ score }) => score >= floor).slice(0, limit);
+}
+
+// src/check.ts
+var PACKAGE = "@oprt/react";
+var NATIVE = {
+  button: "Button",
+  input: "Input, or the control for its type (Checkbox, RadioGroup, NumberInput, Slider, DatePicker, FileUpload)",
+  select: "Select",
+  textarea: "Textarea",
+  table: "DataTable or DataGrid",
+  dialog: "Dialog",
+  progress: "Progress",
+  hr: "Divider"
+};
+var NATIVE_ATTRIBUTES = new Set(
+  `key ref children className style id title role tabIndex hidden lang dir slot draggable spellCheck
+  translate inert accessKey autoCapitalize contentEditable enterKeyHint inputMode
+  dangerouslySetInnerHTML suppressHydrationWarning suppressContentEditableWarning htmlFor type name
+  value defaultValue checked defaultChecked disabled readOnly required placeholder autoComplete
+  autoFocus min max step minLength maxLength pattern multiple accept form formAction href target rel
+  download src alt width height loading rows cols wrap open colSpan rowSpan scope headers label list
+  size method action encType noValidate popover popoverTarget popoverTargetAction asChild`.split(
+    /\s+/
+  )
+);
+var nativeAttribute = (name) => NATIVE_ATTRIBUTES.has(name) || /^(aria-|data-)/.test(name) || /^on[A-Z]/.test(name);
+var RAW_COLOR_CLASS = /\[(?:#[0-9a-fA-F]{3,8}\b|rgba?\(|hsla?\()/;
+var RAW_COLOR_VALUE = /^#[0-9a-fA-F]{3,8}$|^(?:rgb|hsl)a?\(/;
+var ARBITRARY_SIZE = /(?:^|[\s:])-?[a-z][a-z0-9-]*-\[-?\d*\.?\d+px\]/;
+var ROUNDED_CORNER = /(?:^|[\s:])rounded(?!-none(?:\s|$))(?:-[^\s]+)?(?=\s|$)/;
+function allowedChildren2(rules, name) {
+  for (const [parent, rule] of Object.entries(rules ?? {})) {
+    if (parent === name) return rule.allowed_children;
+    const nested = allowedChildren2(rule.children, name);
+    if (nested !== void 0) return nested;
+  }
+  return void 0;
+}
+function checkSource(typescript, contract2, file, text2) {
+  const ts = typescript;
+  const kind = /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
+  const source = ts.createSourceFile(file, text2, ts.ScriptTarget.Latest, true, kind);
+  const findings = [];
+  const report = (node, finding) => {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    findings.push({
+      code: finding.code,
+      severity: finding.severity,
+      file,
+      line: line + 1,
+      column: character + 1,
+      ...finding.component === void 0 ? {} : { component: finding.component },
+      ...finding.prop === void 0 ? {} : { prop: finding.prop },
+      message: finding.message,
+      ...finding.valid_values === void 0 ? {} : { valid_values: finding.valid_values },
+      ...finding.suggestions === void 0 ? {} : { suggestions: finding.suggestions }
+    });
+  };
+  const isComponent = (name) => Object.hasOwn(contract2.components, name);
+  const named = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const from = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause || clause.isTypeOnly || !clause.namedBindings) continue;
+    const copied = from !== PACKAGE && /[./@]/.test(from[0] ?? "") && isComponent((0, import_node_path3.basename)(from));
+    if (from !== PACKAGE && !copied) continue;
+    if (ts.isNamespaceImport(clause.namedBindings)) {
+      if (from === PACKAGE) namespaces.add(clause.namedBindings.name.text);
+      continue;
+    }
+    for (const element2 of clause.namedBindings.elements) {
+      if (element2.isTypeOnly) continue;
+      const exported = (element2.propertyName ?? element2.name).text;
+      if (from === PACKAGE && !contract2.exports.includes(exported)) {
+        let suggestions = nearest(exported, Object.keys(contract2.components));
+        if (suggestions.length === 0) suggestions = nearest(exported, contract2.exports);
+        let hint = suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "";
+        if (suggestions.length === 0) {
+          const [byPurpose] = search(
+            contract2,
+            { version: contract2.version, entries: [], files: {} },
+            exported.replace(/([a-z0-9])([A-Z])/g, "$1 $2"),
+            1
+          );
+          if (byPurpose !== void 0) {
+            suggestions = [byPurpose.name];
+            hint = ` Closest by purpose: ${byPurpose.name} (${byPurpose.purpose}).`;
+          }
+        }
+        report(element2, {
+          code: "UNKNOWN_EXPORT",
+          severity: "error",
+          message: `${PACKAGE} has no export ${JSON.stringify(exported)}.${hint}`,
+          ...suggestions.length > 0 ? { suggestions } : {}
+        });
+        continue;
+      }
+      if (isComponent(exported)) named.set(element2.name.text, exported);
+    }
+  }
+  const literals = (expression) => {
+    if (!expression) return [];
+    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
+      return [expression.text];
+    if (ts.isParenthesizedExpression(expression)) return literals(expression.expression);
+    if (ts.isConditionalExpression(expression))
+      return [...literals(expression.whenTrue), ...literals(expression.whenFalse)];
+    return [];
+  };
+  const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const classText = (expression) => {
+    if (!expression) return "";
+    if (ts.isTemplateExpression(expression))
+      return [
+        expression.head.text,
+        ...expression.templateSpans.map((span) => span.literal.text)
+      ].join(" ");
+    return literals(expression).join(" ");
+  };
+  const houseRules = (attribute, name) => {
+    const value = valueOf(attribute);
+    if (name === "className") {
+      const classes = classText(value);
+      if (RAW_COLOR_CLASS.test(classes))
+        report(attribute, {
+          code: "RAW_COLOR",
+          severity: "warning",
+          message: "A color written out by hand. Use an OPERATOR color token (bg-oprt-\u2026, text-oprt-\u2026)."
+        });
+      if (ARBITRARY_SIZE.test(classes))
+        report(attribute, {
+          code: "ARBITRARY_SIZE",
+          severity: "warning",
+          message: "A size in pixels written out by hand. Use the spacing scale (p-2u, gap-3u, h-oprt-md)."
+        });
+      if (ROUNDED_CORNER.test(classes))
+        report(attribute, {
+          code: "ROUNDED_CORNER",
+          severity: "warning",
+          message: "A rounded corner. The radius is 0 everywhere in OPERATOR."
+        });
+    }
+    if (name === "style" && value && ts.isObjectLiteralExpression(value)) {
+      for (const property of value.properties)
+        if (ts.isPropertyAssignment(property) && literals(property.initializer).some((literal) => RAW_COLOR_VALUE.test(literal)))
+          report(attribute, {
+            code: "RAW_COLOR",
+            severity: "warning",
+            message: "A color written out by hand. Use an OPERATOR color token (var(--oprt-\u2026))."
+          });
+    }
+  };
+  const element = (opening, ancestors, parent, hasChildren, renderedAs) => {
+    const tag = opening.tagName;
+    let component = null;
+    if (ts.isIdentifier(tag)) {
+      component = named.get(tag.text) ?? null;
+      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.text))
+        report(opening, {
+          code: "NATIVE_CONTROL",
+          severity: "warning",
+          message: `A native <${tag.text}>: use ${NATIVE[tag.text]}.`
+        });
+    } else if (ts.isPropertyAccessExpression(tag) && ts.isIdentifier(tag.expression)) {
+      const owner = tag.expression.text;
+      if (namespaces.has(owner) && isComponent(tag.name.text)) component = tag.name.text;
+      else if (named.has(owner)) {
+        const joined = `${named.get(owner)}${tag.name.text}`;
+        report(opening, {
+          code: "DOT_NOTATION",
+          severity: "error",
+          message: `${owner}.${tag.name.text} is not a component.` + (isComponent(joined) ? ` Use <${joined}>.` : " OPERATOR's parts are components of their own, imported by name.")
+        });
+      }
+    }
+    const attributes = opening.attributes.properties;
+    for (const attribute of attributes)
+      if (ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name))
+        houseRules(attribute, attribute.name.text);
+    if (component === null) return null;
+    const definition = contract2.components[component];
+    const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute));
+    const given = /* @__PURE__ */ new Set();
+    for (const attribute of attributes) {
+      if (!ts.isJsxAttribute(attribute)) continue;
+      const prop = ts.isIdentifier(attribute.name) ? attribute.name.text : attribute.name.getText(source);
+      given.add(prop);
+      const known = Object.hasOwn(definition.props, prop) ? definition.props[prop] : void 0;
+      if (known === void 0) {
+        if (nativeAttribute(prop) || Object.hasOwn(definition.slots ?? {}, prop)) continue;
+        const names = Object.keys(definition.props);
+        report(attribute, {
+          code: "UNKNOWN_PROP",
+          severity: "warning",
+          component,
+          prop,
+          message: `${component} has no prop ${prop}.` + (names.length === 0 ? " It takes no props of its own." : ` Its props: ${names.slice(0, 14).join(", ")}${names.length > 14 ? ", \u2026" : ""}.`)
+        });
+        continue;
+      }
+      if (known.type !== "enum" || known.values === void 0) continue;
+      for (const literal of literals(valueOf(attribute))) {
+        if (known.values.includes(literal)) continue;
+        const elsewhere = Object.entries(contract2.components).filter(([, other]) => other.props[prop]?.values?.includes(literal)).map(([name]) => name);
+        report(attribute, {
+          code: "INVALID_PROP_VALUE",
+          severity: "error",
+          component,
+          prop,
+          message: `${component} ${prop}=${JSON.stringify(literal)} is not an option. Use one of: ${known.values.join(", ")}.` + (elsewhere.length > 0 ? ` ${JSON.stringify(literal)} is a ${elsewhere.slice(0, 3).join(" or ")} ${prop}.` : ""),
+          valid_values: known.values
+        });
+      }
+    }
+    if (!spread) {
+      const needed = [
+        ...Object.entries(definition.props),
+        ...Object.entries(definition.slots ?? {})
+      ].filter(([, { required }]) => required);
+      for (const [prop] of needed)
+        if (!given.has(prop) && !(prop === "children" && hasChildren))
+          report(opening, {
+            code: "MISSING_REQUIRED_PROP",
+            severity: "error",
+            component,
+            prop,
+            message: `${component} needs ${prop}.`
+          });
+    }
+    const banned = (definition.never_inside ?? []).find((name) => ancestors.includes(name));
+    if (banned !== void 0)
+      report(opening, {
+        code: "INVALID_NESTING",
+        severity: "error",
+        component,
+        message: `${component} must not be inside ${banned}.`
+      });
+    const allowed = parent === null ? void 0 : allowedChildren2(contract2.composition_rules, parent);
+    if (allowed !== void 0 && !allowed.includes("any") && !allowed.includes(component))
+      report(opening, {
+        code: "INVALID_CHILD",
+        severity: "error",
+        component,
+        message: `${parent} takes only ${allowed.filter((name) => name !== "text").join(", ")} directly inside it, not ${component}.`
+      });
+    return component;
+  };
+  const visit = (node, ancestors, parent, renderedAs = false) => {
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const opening = ts.isJsxElement(node) ? node.openingElement : node;
+      const hasChildren = ts.isJsxElement(node) && node.children.some(
+        (child) => !(ts.isJsxText(child) && child.containsOnlyTriviaWhiteSpaces)
+      );
+      const component = element(opening, ancestors, parent, hasChildren, renderedAs);
+      const asChild = component !== null && opening.attributes.properties.some(
+        (attribute) => ts.isJsxAttribute(attribute) && attribute.name.getText(source) === "asChild"
+      );
+      for (const attribute of opening.attributes.properties) visit(attribute, [], null);
+      if (ts.isJsxElement(node))
+        for (const child of node.children)
+          visit(
+            child,
+            component === null ? ancestors : [...ancestors, component],
+            component,
+            asChild
+          );
+      return;
+    }
+    ts.forEachChild(node, (child) => visit(child, ancestors, parent));
+  };
+  visit(source, [], null);
+  return findings.sort((a, b) => a.line - b.line || a.column - b.column);
+}
+var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
+var READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+var NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
+function* sources(path) {
+  const name = (0, import_node_path3.basename)(path);
+  if (SKIPPED.has(name) || name.startsWith(".") && name !== "." && name !== "..") return;
+  if ((0, import_node_fs3.statSync)(path).isDirectory()) {
+    for (const entry of (0, import_node_fs3.readdirSync)(path).sort()) yield* sources((0, import_node_path3.join)(path, entry));
+  } else if (READ.has((0, import_node_path3.extname)(path)) && !NOT_INTERFACE.test(name)) yield path;
+}
+function findTypeScript(cwd) {
+  for (const from of [(0, import_node_path3.join)(cwd, "package.json"), (0, import_node_url2.fileURLToPath)(importMetaUrl)]) {
+    try {
+      return (0, import_node_module.createRequire)(from)("typescript");
+    } catch {
+    }
+  }
+  return null;
+}
+function checkPaths(paths, context) {
+  const root = (0, import_node_path3.resolve)(context.cwd);
+  const files = [];
+  for (const path of paths) {
+    const absolute = (0, import_node_path3.resolve)(root, path);
+    if (!(0, import_node_fs3.existsSync)(absolute))
+      throw new CliError(`No such file or folder: ${path}`, 2, { code: "ERR_PATH_NOT_FOUND" });
+    files.push(...sources(absolute));
+  }
+  const ts = context.typescript === void 0 ? findTypeScript(root) : context.typescript;
+  if (ts === null)
+    throw new CliError(
+      "oprt check reads code with the project's TypeScript, and found none. Install typescript in this project (npm install -D typescript) and run it again.",
+      1,
+      { code: "ERR_TYPESCRIPT_MISSING" }
+    );
+  const findings = [...new Set(files)].flatMap(
+    (file) => checkSource(
+      ts,
+      context.contract,
+      (0, import_node_path3.relative)(root, file).split(import_node_path3.sep).join("/"),
+      (0, import_node_fs3.readFileSync)(file, "utf8")
+    )
+  );
+  return {
+    files: new Set(files).size,
+    findings,
+    summary: {
+      errors: findings.filter(({ severity }) => severity === "error").length,
+      warnings: findings.filter(({ severity }) => severity === "warning").length
+    }
+  };
+}
+
+// src/doctor.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+
+// src/agent-block.ts
+var START = "<!-- OPERATOR:START -->";
+var END = "<!-- OPERATOR:END -->";
+var firstSentence2 = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+function renderAgentBlock(contract2) {
+  const lines = [
+    START,
+    `<!-- Written by oprt ${contract2.version}. Do not edit between these markers: run \`oprt init\` to refresh. -->`,
+    "## OPERATOR design system",
+    "",
+    "This project builds its interface with OPERATOR (`@oprt/react`). Use its components, and look them up instead of guessing: these commands print the facts for the version installed here. Run them with the project's package runner (`npx oprt \u2026`, `pnpm exec oprt \u2026`).",
+    "",
+    "- `oprt search <need>`: which component or recipe answers a need",
+    "- `oprt component <Name>`: one component's options, nesting rules and example (`--dense` for the short form)",
+    "- `oprt add <recipe>`: copy a working screen into the project to adapt",
+    "- `oprt check <paths>`: check written code against the contract",
+    "",
+    "### Rules",
+    ""
+  ];
+  contract2.guidance.rules.forEach(({ rule, wrong, right }, index) => {
+    lines.push(`${index + 1}. ${rule}`);
+    if (wrong !== void 0) lines.push(`   Wrong: \`${wrong}\``);
+    if (right !== void 0) lines.push(`   Right: \`${right}\``);
+  });
+  lines.push("", "### Components", "");
+  for (const { name, purpose, parts } of componentIndex(contract2))
+    lines.push(`- ${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`);
+  const recipes = Object.entries(contract2.patterns ?? {});
+  if (recipes.length > 0) {
+    lines.push("", "### Recipes (whole screens to start from)", "");
+    for (const [name, { description, install: install2 }] of recipes)
+      lines.push(`- ${name}: ${firstSentence2(description)} \`${install2}\``);
+  }
+  lines.push(END);
+  return `${lines.join("\n")}
+`;
+}
+function blockVersion(text2) {
+  const start = text2.indexOf(START);
+  if (start === -1) return void 0;
+  return /Written by oprt (\S+)\. Do not edit/.exec(text2.slice(start))?.[1];
+}
+function region(text2) {
+  const start = text2.indexOf(START);
+  if (start === -1) return void 0;
+  const end = text2.indexOf(END, start);
+  if (end === -1) return void 0;
+  const after = end + END.length;
+  return [start, text2[after] === "\n" ? after + 1 : after];
+}
+function applyBlock(existing, block) {
+  if (existing === null) return { text: block, action: "create" };
+  const found = region(existing);
+  if (found === void 0) {
+    const before = existing === "" || existing.endsWith("\n") ? existing : `${existing}
+`;
+    return { text: `${before}${before === "" ? "" : "\n"}${block}`, action: "append" };
+  }
+  const text2 = existing.slice(0, found[0]) + block + existing.slice(found[1]);
+  return { text: text2, action: text2 === existing ? "unchanged" : "update" };
+}
+function removeBlock(existing) {
+  const found = region(existing);
+  if (found === void 0) return { text: existing, found: false };
+  const before = existing.slice(0, found[0]);
+  return {
+    text: (before.endsWith("\n\n") ? before.slice(0, -1) : before) + existing.slice(found[1]),
+    found: true
+  };
+}
+
+// src/doctor.ts
+var PACKAGES = ["@oprt/react", "@oprt/tokens", "@oprt/tailwind"];
+var INSTRUCTION_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".claude/CLAUDE.md",
+  ".cursor/rules/operator.mdc"
+];
+var minor = (version) => version.split(".").slice(0, 2).join(".");
+function installedVersion(cwd, name) {
+  for (let folder = cwd; ; folder = (0, import_node_path4.dirname)(folder)) {
+    const manifest = (0, import_node_path4.join)(folder, "node_modules", name, "package.json");
+    if ((0, import_node_fs4.existsSync)(manifest))
+      return JSON.parse((0, import_node_fs4.readFileSync)(manifest, "utf8")).version;
+    if ((0, import_node_path4.dirname)(folder) === folder) return void 0;
+  }
+}
+function doctor({ cwd, contract: contract2 }) {
+  const checks = [];
+  for (const name of PACKAGES) {
+    const version = installedVersion(cwd, name);
+    const id = `package:${name}`;
+    if (version === void 0)
+      checks.push({
+        id,
+        status: "warn",
+        message: `${name} is not installed.`,
+        fix: `Install ${name}, or copy the sources you need with oprt add.`
+      });
+    else if (minor(version) !== minor(contract2.version))
+      checks.push({
+        id,
+        status: "warn",
+        message: `${name} is ${version}; this installer describes ${contract2.version}.`,
+        fix: "Install matching versions of the OPERATOR packages and @oprt/cli."
+      });
+    else checks.push({ id, status: "ok", message: `${name} ${version} is installed.` });
+  }
+  const written = INSTRUCTION_FILES.map((path) => {
+    const file = (0, import_node_path4.join)(cwd, path);
+    return {
+      path,
+      version: (0, import_node_fs4.existsSync)(file) ? blockVersion((0, import_node_fs4.readFileSync)(file, "utf8")) : void 0
+    };
+  }).filter(({ version }) => version !== void 0);
+  const stale = written.find(({ version }) => version !== contract2.version);
+  if (written.length === 0)
+    checks.push({
+      id: "agent-instructions",
+      status: "warn",
+      message: "No agent instruction file carries the OPERATOR block.",
+      fix: "oprt init"
+    });
+  else if (stale !== void 0)
+    checks.push({
+      id: "agent-instructions",
+      status: "warn",
+      message: `${stale.path} was written by oprt ${stale.version}; this is ${contract2.version}.`,
+      fix: "oprt init"
+    });
+  else
+    checks.push({
+      id: "agent-instructions",
+      status: "ok",
+      message: `${written.map(({ path }) => path).join(", ")} carries the OPERATOR block (${contract2.version}).`
+    });
+  const count = (status) => checks.filter((check) => check.status === status).length;
+  return { checks, summary: { ok: count("ok"), warn: count("warn"), fail: count("fail") } };
+}
+
+// src/init.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var AGENT_FILES = {
+  claude: ["CLAUDE.md"],
+  cursor: [".cursor/rules/operator.mdc"],
+  codex: ["AGENTS.md"],
+  all: ["AGENTS.md", "CLAUDE.md", ".cursor/rules/operator.mdc"]
+};
+var DEFAULT_FILES = ["AGENTS.md"];
+var CURSOR_FRONT_MATTER = "---\nalwaysApply: true\n---\n\n";
+function targets({ agent, path }) {
+  if (path !== void 0) return [path];
+  if (agent === void 0) return DEFAULT_FILES;
+  const files = AGENT_FILES[agent];
+  if (files === void 0)
+    throw new CliError(
+      `Unknown agent ${JSON.stringify(agent)}. Use one of: ${Object.keys(AGENT_FILES).join(", ")}; or --path <file>.`,
+      2,
+      { code: "ERR_UNKNOWN_AGENT", suggestions: Object.keys(AGENT_FILES) }
+    );
+  return files;
+}
+var withoutFrontMatter = (text2) => text2.replace(/^---\n[\s\S]*?\n---\n?/, "");
+function init(options, context) {
+  const root = (0, import_node_fs5.realpathSync)(context.cwd);
+  const block = renderAgentBlock(context.contract);
+  const dryRun = options.dryRun ?? false;
+  const files = targets(options).map((path) => {
+    validateRelative(path);
+    const destination = (0, import_node_path5.resolve)(root, path);
+    inspectPath(root, destination);
+    const existing = (0, import_node_fs5.existsSync)(destination) ? (0, import_node_fs5.readFileSync)(destination, "utf8") : null;
+    if (options.remove) {
+      if (existing === null) return { path, action: "absent" };
+      const { text: text3, found } = removeBlock(existing);
+      if (!found) return { path, action: "absent" };
+      const empty = withoutFrontMatter(text3).trim() === "";
+      if (!dryRun) {
+        if (empty) (0, import_node_fs5.rmSync)(destination);
+        else (0, import_node_fs5.writeFileSync)(destination, text3);
+      }
+      return { path, action: empty ? "delete" : "remove" };
+    }
+    const fresh = existing === null && path.endsWith(".mdc") ? CURSOR_FRONT_MATTER : existing;
+    const { text: text2, action } = applyBlock(fresh, block);
+    if (action !== "unchanged" && !dryRun) {
+      (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(destination), { recursive: true });
+      (0, import_node_fs5.writeFileSync)(destination, text2);
+    }
+    return { path, action: existing === null ? "create" : action };
+  });
+  return { version: context.contract.version, dryRun, files };
+}
+
+// src/agent-commands.ts
+var envelope = (type, data) => ({ apiVersion: 1, type, data });
+function runAgentCommand(command, context) {
+  const { contract: contract2, registry: registry2, cwd } = context;
+  switch (command.command) {
+    case "component": {
+      if (command.list) {
+        const components = componentIndex(contract2);
+        return {
+          text: components.map(
+            ({ name, purpose, parts }) => `${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}
+`
+          ).join(""),
+          json: envelope("component.list", { components }),
+          exitCode: 0
+        };
+      }
+      const details = command.names.map((name) => componentDetail(contract2, name));
+      return {
+        text: details.map((detail) => renderComponent(detail, { dense: command.dense })).join("\n"),
+        json: details.length === 1 ? envelope("component.detail", details[0]) : envelope("component.batch", { components: details }),
+        exitCode: 0
+      };
+    }
+    case "search": {
+      const results = search(contract2, registry2, command.query, command.limit);
+      return {
+        text: results.length === 0 ? `Nothing matches ${JSON.stringify(command.query)}. Run oprt component --list to see what there is.
+` : results.map(
+          ({ kind, name, purpose, why, next }) => `${name} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
+  ${next}
+`
+        ).join(""),
+        json: envelope("search", { query: command.query, matchCount: results.length, results }),
+        exitCode: 0
+      };
+    }
+    case "init": {
+      const result = init(command, { cwd, contract: contract2 });
+      const lines = [
+        `OPERATOR ${result.version} agent instructions${result.dryRun ? " (dry run)" : ""}`,
+        ...result.files.map(({ path, action }) => `  ${action.padEnd(9)} ${path}`),
+        command.remove ? "The block was taken out; the rest of each file is as it was." : "Run oprt init again after an upgrade to refresh the block."
+      ];
+      return { text: `${lines.join("\n")}
+`, json: envelope("init", result), exitCode: 0 };
+    }
+    case "check": {
+      const report = checkPaths(command.paths, { cwd, contract: contract2 });
+      const { errors, warnings } = report.summary;
+      const lines = report.findings.map(
+        ({ file, line, column, severity, code, message }) => `${file}:${line}:${column}  ${severity}  ${code}  ${message}`
+      );
+      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+      lines.push(
+        `${count(errors, "error")}, ${count(warnings, "warning")} in ${count(report.files, "file")}.`
+      );
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope("check", report),
+        // Warnings fail the run only when asked to: they are house rules, or may be native attributes.
+        exitCode: errors > 0 || command.strict && warnings > 0 ? 1 : 0
+      };
+    }
+    case "doctor": {
+      const report = doctor({ cwd, contract: contract2 });
+      const lines = report.checks.flatMap(({ status, message, fix }) => [
+        `[${status}] ${message}`,
+        ...fix === void 0 ? [] : [`       fix: ${fix}`]
+      ]);
+      lines.push(
+        `${report.summary.ok} ok, ${report.summary.warn} to look at, ${report.summary.fail} failed.`
+      );
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope("doctor", report),
+        exitCode: report.summary.fail > 0 ? 1 : 0
+      };
+    }
+  }
+}
+
+// src/mcp.ts
+var import_node_readline = require("readline");
+var VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+var text = (value) => ({ type: "text", text: value });
+var string = (description) => ({ type: "string", description });
+var TOOLS = [
+  {
+    name: "search",
+    description: "Find the OPERATOR component or recipe that answers a need, such as 'show a status' or 'table with selection'. Call this before writing interface code.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: string("The need, in plain words."),
+        limit: { type: "number", description: "How many results to return. Default 10." }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "get_component",
+    description: "One OPERATOR component: what it is for, what to use instead, every prop and option value, its nesting rules and an example. Call this before using a component.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: string("The component's name, such as Button or DataGrid."),
+        dense: {
+          type: "boolean",
+          description: "The short form, which is the default. Pass false for full descriptions."
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_components",
+    description: "Every OPERATOR component in one line each, with its parts.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_instructions",
+    description: "OPERATOR's house rules, its component index and its recipes: what to read once before building with it.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "check_code",
+    description: "Check TSX code against OPERATOR's contract: option values, nesting, required props and the house rules. Call this on what you wrote before you finish.",
+    inputSchema: {
+      type: "object",
+      properties: { code: string("The TSX source of one file.") },
+      required: ["code"]
+    }
+  }
+];
+function runTool(name, args, context) {
+  const { contract: contract2, registry: registry2 } = context;
+  const required = (key) => {
+    const value = args[key];
+    if (typeof value !== "string" || value.trim() === "")
+      throw new Error(`${name} needs ${key}, a string.`);
+    return value;
+  };
+  switch (name) {
+    case "search": {
+      const query = required("query");
+      const results = search(
+        contract2,
+        registry2,
+        query,
+        typeof args.limit === "number" ? args.limit : 10
+      );
+      return results.length === 0 ? `Nothing matches ${JSON.stringify(query)}. Call list_components to see what there is.` : results.map(
+        ({ kind, name: found, purpose, why, next }) => `${found} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
+  ${next}`
+      ).join("\n");
+    }
+    case "get_component":
+      return renderComponent(componentDetail(contract2, required("name")), {
+        dense: args.dense !== false
+      });
+    case "list_components":
+      return componentIndex(contract2).map(
+        ({ name: component, purpose, parts }) => `${component}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`
+      ).join("\n");
+    case "get_instructions":
+      return renderAgentBlock(contract2).split("\n").filter((line) => line !== START && line !== END && !line.startsWith("<!-- Written by")).join("\n");
+    case "check_code": {
+      const code = required("code");
+      const ts = context.typescript === void 0 ? findTypeScript(context.cwd ?? process.cwd()) : context.typescript;
+      if (ts === null)
+        throw new Error("check_code reads code with TypeScript, and found none installed.");
+      const findings = checkSource(ts, contract2, "snippet.tsx", code);
+      if (findings.length === 0) return "No findings.";
+      const errors = findings.filter(({ severity }) => severity === "error").length;
+      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+      return [
+        ...findings.map(
+          ({ line, column, severity, code: finding, message }) => `${line}:${column}  ${severity}  ${finding}  ${message}`
+        ),
+        `${count(errors, "error")}, ${count(findings.length - errors, "warning")}.`
+      ].join("\n");
+    }
+    default:
+      throw new UnknownTool(name);
+  }
+}
+var UnknownTool = class extends Error {
+  constructor(name) {
+    super(
+      `Unknown tool ${JSON.stringify(name)}. Its tools: ${TOOLS.map((tool) => tool.name).join(", ")}.`
+    );
+  }
+};
+function handleMessage(raw, context) {
+  const failure = (id2, code, message) => ({
+    jsonrpc: "2.0",
+    id: id2 ?? null,
+    error: { code, message }
+  });
+  if (typeof raw !== "object" || raw === null) return failure(null, -32700, "Parse error");
+  const { id, method, params } = raw;
+  if (typeof method !== "string") return failure(id, -32600, "Invalid request");
+  if (id === void 0) return null;
+  const result = (value) => ({ jsonrpc: "2.0", id, result: value });
+  switch (method) {
+    case "initialize": {
+      const asked = params?.protocolVersion;
+      return result({
+        protocolVersion: asked !== void 0 && VERSIONS.includes(asked) ? asked : VERSIONS[0],
+        capabilities: { tools: {} },
+        serverInfo: { name: "oprt", version: context.contract.version },
+        instructions: "OPERATOR design system. Call get_instructions once, search for the component that answers a need, get_component before using one, and check_code before you finish."
+      });
+    }
+    case "ping":
+      return result({});
+    case "tools/list":
+      return result({ tools: TOOLS });
+    case "tools/call": {
+      const { name, arguments: args } = params ?? {};
+      try {
+        return result({ content: [text(runTool(String(name), args ?? {}, context))] });
+      } catch (error) {
+        if (error instanceof UnknownTool) return failure(id, -32602, error.message);
+        return result({
+          content: [text(error instanceof Error ? error.message : String(error))],
+          isError: true
+        });
+      }
+    }
+    default:
+      return failure(id, -32601, `Method not found: ${method}`);
+  }
+}
+function serve(input, output, context) {
+  const lines = (0, import_node_readline.createInterface)({ input, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    if (line.trim() === "") return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      message = line;
+    }
+    const response = handleMessage(message, context);
+    if (response !== null) output.write(`${JSON.stringify(response)}
+`);
+  });
+  return new Promise((done) => lines.on("close", done));
+}
+
+// src/index.ts
+var VERSION = package_default.version;
+function loadRegistry() {
+  const here = (0, import_node_path6.dirname)((0, import_node_url3.fileURLToPath)(importMetaUrl));
+  const candidates = [(0, import_node_path6.join)(here, "registry.json"), (0, import_node_path6.join)(here, "../generated/registry.json")];
+  const found = candidates.find((candidate) => (0, import_node_fs6.existsSync)(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `registry.json is missing next to ${here}. Install @oprt/cli again: the registry ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse((0, import_node_fs6.readFileSync)(found, "utf8"));
+}
+var registry = loadRegistry();
+var loaded;
+var contract = () => loaded ??= loadContract();
+function install(options, context = {}) {
+  return installSources(options, {
+    cwd: context.cwd ?? process.cwd(),
+    registry: context.registry ?? registry
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CliError,
+  DEFAULT_OUT,
+  TOOLS,
+  VERSION,
+  applyBlock,
+  blockVersion,
+  checkPaths,
+  checkSource,
+  componentDetail,
+  componentIndex,
+  contract,
+  doctor,
+  handleMessage,
+  init,
+  install,
+  parseArgs,
+  registry,
+  removeBlock,
+  renderAgentBlock,
+  renderComponent,
+  resolveEntries,
+  runAgentCommand,
+  search,
+  serve
+});