@geonosis/cli 1.0.0

package/dist/chunk-U3TBZWD3.js

@@ -0,0 +1,773 @@
+// src/argv.ts
+var parseArgv = (argv, valued) => {
+  const flags = {};
+  const positional = [];
+  const switches = /* @__PURE__ */ new Set();
+  for (let at = 0; at < argv.length; at += 1) {
+    const token = argv[at] ?? "";
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const equals = token.indexOf("=");
+    if (equals !== -1) {
+      flags[token.slice(0, equals)] = token.slice(equals + 1);
+      continue;
+    }
+    if (!valued.has(token)) {
+      switches.add(token);
+      continue;
+    }
+    const value = argv[at + 1];
+    if (value === void 0) throw new Error(`${token} needs a value`);
+    flags[token] = value;
+    at += 1;
+  }
+  return { flags, positional, switches };
+};
+var VALUED = {
+  discover: /* @__PURE__ */ new Set(["--config"]),
+  init: /* @__PURE__ */ new Set(["--brand", "--presets", "--runtime"]),
+  sync: /* @__PURE__ */ new Set(["--into", "--target"])
+};
+var list = (value) => value === void 0 ? [] : value.split(",").map((one) => one.trim()).filter((one) => one !== "");
+var inputFor = (id, argv, cwd) => {
+  if (id === "skills") return { cwd, verb: argv[0] ?? "list" };
+  const valued = VALUED[id];
+  if (valued === void 0) return { args: [...argv], cwd };
+  const { flags, positional, switches } = parseArgv(argv, valued);
+  if (id === "init") {
+    return {
+      ...flags["--brand"] === void 0 ? {} : { brand: flags["--brand"] },
+      cwd,
+      presets: list(flags["--presets"]),
+      ...flags["--runtime"] === void 0 ? {} : { runtime: flags["--runtime"] }
+    };
+  }
+  if (id === "sync") {
+    return {
+      check: switches.has("--check"),
+      cwd,
+      ...flags["--into"] === void 0 ? {} : { into: flags["--into"] },
+      ...flags["--target"] === void 0 ? {} : { target: flags["--target"] },
+      write: switches.has("--write") || !switches.has("--check")
+    };
+  }
+  return {
+    ...flags["--config"] === void 0 ? {} : { config: flags["--config"] },
+    cwd,
+    ...positional.length === 0 ? {} : { paths: positional }
+  };
+};
+
+// src/types.ts
+var resultOf = (exitCode, output) => ({
+  exitCode,
+  ok: exitCode === 0,
+  output
+});
+var refused = (output) => resultOf(2, output);
+
+// src/discover.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { normaliseFindings, resolveOxlint, ruleIdOf } from "@geonosis/lint-parity";
+var SITES = 3;
+var siteOf = (line) => line.split(":").slice(0, 2).join(":");
+var candidatesOf = (findings) => {
+  const byRule = /* @__PURE__ */ new Map();
+  for (const line of findings) {
+    const rule = ruleIdOf(line);
+    byRule.set(rule, [...byRule.get(rule) ?? [], siteOf(line)]);
+  }
+  return [...byRule.entries()].map(([rule, sites]) => ({ count: sites.length, rule, sites: sites.slice(0, SITES) })).toSorted((a, b) => b.count - a.count || a.rule.localeCompare(b.rule));
+};
+var formatCandidates = (candidates) => candidates.length === 0 ? "discover \u2014 no finding in this tree, so there is no shape to propose.\n" : [
+  `discover \u2014 ${candidates.length} rule(s) firing, loudest first. Candidates for a fixShape; nothing was written.`,
+  "",
+  ...candidates.flatMap((one) => [
+    `${String(one.count).padStart(6)}  ${one.rule}`,
+    ...one.sites.map((site) => `          ${site}`)
+  ]),
+  ""
+].join("\n");
+var CONFIG = ".oxlintrc.json";
+var runDiscover = async ({
+  config,
+  cwd,
+  paths
+}) => {
+  const named = config ?? CONFIG;
+  if (!existsSync(join(cwd, named))) {
+    return refused(`geonosis discover: no ${named} in ${cwd} \u2014 there is no config to read with.
+`);
+  }
+  const done = spawnSync(
+    resolveOxlint(cwd),
+    ["--format=unix", "--config", named, ...paths ?? ["."]],
+    { cwd, encoding: "utf8", env: { ...process.env, NO_COLOR: "1" } }
+  );
+  if (done.error !== void 0) {
+    return refused(`geonosis discover: could not run oxlint: ${done.error.message}
+`);
+  }
+  const output = `${done.stdout ?? ""}${done.stderr ?? ""}`;
+  return resultOf(0, formatCandidates(candidatesOf(normaliseFindings(output, cwd))));
+};
+
+// src/options.ts
+import { rules } from "@geonosis/oxlint-plugin-biological-architecture";
+var MISSING = /is enabled but its `([^`]+)` option is/;
+var optionsNeededBy = () => {
+  const needed = {};
+  for (const [name, rule] of Object.entries(rules)) {
+    try {
+      rule.create({ options: [] });
+    } catch (error) {
+      const option = MISSING.exec(String(error.message))?.[1];
+      if (option !== void 0) needed[name] = option;
+    }
+  }
+  return needed;
+};
+
+// src/init.ts
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { PRESETS } from "@geonosis/oxlint-plugin-biological-architecture";
+var PREFIX = "biological-architecture/";
+var SCHEMA = "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json";
+var LOCKFILES = [
+  ["bun", "bun.lock"],
+  ["bun", "bun.lockb"],
+  ["pnpm", "pnpm-lock.yaml"]
+];
+var runtimeOf = (cwd) => LOCKFILES.find(([, file]) => existsSync2(join2(cwd, file)))?.[0];
+var execOf = (runtime) => runtime === "bun" ? "bunx" : "npx";
+var scriptOf = (runtime, name) => runtime === "bun" ? `bun run ${name}` : `pnpm ${name}`;
+var tiersOf = (runtime) => ({
+  fast: [scriptOf(runtime, "typecheck"), scriptOf(runtime, "lint"), scriptOf(runtime, "test")],
+  full: [scriptOf(runtime, "build"), "fast", scriptOf(runtime, "ratchet")]
+});
+var testCounter = (runtime) => runtime === "bun" ? { command: "bun test", counter: "testFailures" } : {
+  command: "npx vitest run --reporter=json --outputFile={report}",
+  counter: "testFailures",
+  report: "vitest-json"
+};
+var countersFor = (runtime) => {
+  const exec = execOf(runtime);
+  return [
+    {
+      command: `${exec} oxlint --format=unix --config .oxlintrc.json .`,
+      counter: "oxlintErrors",
+      expectFormat: "unix"
+    },
+    {
+      command: `${exec} oxlint --format=unix --config .oxlintrc.json .`,
+      counter: "oxlintWarnings",
+      expectFormat: "unix"
+    },
+    { command: `${exec} tsc --noEmit`, counter: "typecheckErrors" },
+    {
+      command: `${exec} oxfmt --config .oxfmtrc.json --list-different .`,
+      counter: "unformattedFiles"
+    },
+    testCounter(runtime),
+    { counter: "lawLineCount", path: "CLAUDE.md" },
+    { command: "true", counter: "disabledCiJobs" },
+    { command: "true", counter: "packagesWithoutTypecheck" }
+  ];
+};
+var keyOf = (entry) => typeof entry.key === "string" ? entry.key : String(entry.counter);
+var rulesFor = (presets, answers = {}) => {
+  const needed = optionsNeededBy();
+  const wanted = new Set(
+    presets.flatMap((name) => Object.keys(PRESETS[name].rules))
+  );
+  const rules2 = {};
+  const unanswered = [];
+  for (const id of [...wanted].toSorted()) {
+    const bare = id.startsWith(PREFIX) ? id.slice(PREFIX.length) : id;
+    const option = needed[bare];
+    if (option === void 0) {
+      rules2[id] = "error";
+      continue;
+    }
+    const answered = answers[bare];
+    if (answered === void 0) unanswered.push([bare, option]);
+    else rules2[id] = answered;
+  }
+  return { rules: rules2, unanswered };
+};
+var oxlintConfig = (rules2) => ({
+  $schema: SCHEMA,
+  categories: { correctness: "error", suspicious: "error" },
+  ignorePatterns: ["node_modules", "dist", "coverage"],
+  jsPlugins: ["@geonosis/oxlint-plugin-biological-architecture"],
+  plugins: ["typescript", "unicorn"],
+  rules: rules2
+});
+var json = (value) => `${JSON.stringify(value, void 0, 2)}
+`;
+var refusal = (output) => resultOf(1, output);
+var runInit = async ({
+  brand,
+  cwd,
+  presets,
+  runtime
+}) => {
+  const known = Object.keys(PRESETS).toSorted();
+  const unknown = presets.filter((name) => !known.includes(name));
+  if (presets.length === 0 || unknown.length > 0) {
+    return refusal(
+      `geonosis init: ${presets.length === 0 ? "name at least one preset" : `no preset called ${unknown.join(", ")}`} \u2014 the kit ships ${known.join(", ")}.
+`
+    );
+  }
+  const chosen = runtime ?? runtimeOf(cwd);
+  if (chosen === void 0) {
+    return refusal(
+      `geonosis init: no lockfile in ${cwd} says which package manager this repo uses \u2014 pass --runtime pnpm or --runtime bun.
+`
+    );
+  }
+  const { rules: rules2, unanswered } = rulesFor(
+    presets,
+    brand === void 0 ? {} : { "no-brand-names": ["error", { brands: [brand] }] }
+  );
+  const counters = countersFor(chosen);
+  const files = {
+    "geonosis.json": json({ verify: tiersOf(chosen) }),
+    ".oxlintrc.json": json(oxlintConfig(rules2)),
+    "geonosis.ratchet.json": json({ baseline: "gate-baseline.json", counters }),
+    "gate-baseline.json": json(Object.fromEntries(counters.map((one) => [keyOf(one), 0])))
+  };
+  const already = Object.keys(files).filter((file) => existsSync2(join2(cwd, file)));
+  if (already.length > 0) {
+    return refusal(
+      `geonosis init: ${already.join(", ")} already exists in ${cwd} \u2014 nothing was written. Move what is there, or edit it by hand.
+`
+    );
+  }
+  for (const [file, body] of Object.entries(files)) writeFileSync(join2(cwd, file), body);
+  return resultOf(
+    0,
+    [
+      `geonosis init \u2014 ${chosen}, ${Object.keys(rules2).length} rule(s) enabled from ${presets.join(" + ")}`,
+      "",
+      ...Object.keys(files).map((file) => `  wrote  ${file}`),
+      "",
+      ...unanswered.length === 0 ? [] : [
+        `  ${unanswered.length} rule(s) were NOT enabled: each needs an option only this repo can answer.`,
+        ...unanswered.map(([rule, option]) => `         ${rule} \u2014 needs \`${option}\``),
+        ""
+      ],
+      "  gate-baseline.json starts every counter at 0. Run `geonosis ratchet`: a number above zero",
+      "  today is this repo\u2019s existing debt, and recording it once \u2014 in the commit that adopts the",
+      "  gate, with the reason \u2014 is the only time a baseline goes up.",
+      ""
+    ].join("\n")
+  );
+};
+
+// src/skills.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readdirSync, readFileSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, relative, sep } from "path";
+var LOCK_FILE = "skills-lock.json";
+var SKILL_FILE = "SKILL.md";
+var ROOTS = ["skills", "plugin/skills", ".claude/skills"];
+var OWNER_EXECUTE = 64;
+var posix = (path) => path.split(sep).join("/");
+var hashOf = (bytes) => createHash("sha256").update(new Uint8Array(bytes)).digest("hex");
+var rootsIn = (cwd) => ROOTS.filter((root) => existsSync3(join3(cwd, root)) && statSync(join3(cwd, root)).isDirectory());
+var skillsIn = (cwd) => {
+  const found = [];
+  for (const root of rootsIn(cwd)) {
+    for (const entry of readdirSync(join3(cwd, root), { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dir = join3(cwd, root, entry.name);
+      const skill = join3(dir, SKILL_FILE);
+      if (!existsSync3(skill)) continue;
+      found.push({
+        dir,
+        hash: hashOf(readFileSync(skill)),
+        name: entry.name,
+        skillPath: posix(relative(cwd, skill))
+      });
+    }
+  }
+  return found.toSorted((a, b) => a.name.localeCompare(b.name));
+};
+var readLock = (cwd) => {
+  const path = join3(cwd, LOCK_FILE);
+  if (!existsSync3(path)) return void 0;
+  return JSON.parse(readFileSync(path, "utf8"));
+};
+var executablesIn = (dir, cwd) => {
+  const found = [];
+  const walk = (at) => {
+    for (const entry of readdirSync(at, { withFileTypes: true })) {
+      const path = join3(at, entry.name);
+      if (entry.isDirectory()) {
+        walk(path);
+        continue;
+      }
+      if (entry.isFile() && (statSync(path).mode & OWNER_EXECUTE) !== 0) {
+        found.push(posix(relative(cwd, path)));
+      }
+    }
+  };
+  walk(dir);
+  return found.toSorted();
+};
+var entryFor = (skill, previous) => ({
+  computedHash: skill.hash,
+  skillPath: skill.skillPath,
+  // A skill fetched from github stays a github pin: relocking must not quietly downgrade the
+  // provenance of every entry to "whatever is on this disk right now".
+  source: previous?.source ?? skill.skillPath.replace(`/${SKILL_FILE}`, ""),
+  sourceType: previous?.sourceType ?? "local"
+});
+var lockFor = (cwd) => {
+  const previous = readLock(cwd);
+  return {
+    skills: Object.fromEntries(
+      skillsIn(cwd).map((skill) => [skill.name, entryFor(skill, previous?.skills[skill.name])])
+    ),
+    version: 1
+  };
+};
+var listing = (cwd) => {
+  const skills = skillsIn(cwd);
+  return skills.length === 0 ? `geonosis skills: no ${SKILL_FILE} under ${ROOTS.join(", ")} in ${cwd}.
+` : `${skills.map((one) => `${one.hash.slice(0, 12)}  ${one.name}  ${one.skillPath}`).join("\n")}
+${skills.length} skill(s)
+`;
+};
+var audit = (cwd) => {
+  const lock = readLock(cwd);
+  if (lock === void 0) {
+    return refused(
+      `geonosis skills audit: no ${LOCK_FILE} in ${cwd} \u2014 run \`skills lock\` first.
+`
+    );
+  }
+  const found = skillsIn(cwd);
+  const complaints = [];
+  for (const skill of found) {
+    const pinned = lock.skills[skill.name];
+    if (pinned === void 0) {
+      complaints.push(`${skill.name}: on disk and in no lock \u2014 it was never pinned`);
+    } else if (pinned.computedHash !== skill.hash) {
+      complaints.push(
+        `${skill.name}: ${skill.skillPath} hashes ${skill.hash.slice(0, 12)}, the lock pins ${pinned.computedHash.slice(0, 12)}`
+      );
+    }
+    for (const file of executablesIn(skill.dir, cwd)) {
+      complaints.push(
+        `${skill.name}: ${file} is executable \u2014 a lock over ${SKILL_FILE} is blind to it`
+      );
+    }
+  }
+  for (const name of Object.keys(lock.skills).toSorted()) {
+    if (!found.some((one) => one.name === name)) {
+      complaints.push(`${name}: pinned by the lock and not on disk`);
+    }
+  }
+  return complaints.length === 0 ? resultOf(0, `skills audit PASS \u2014 ${found.length} skill(s), every hash as pinned.
+`) : resultOf(
+    1,
+    `${complaints.map((one) => `  ${one}`).join("\n")}
+skills audit FAIL \u2014 ${complaints.length} finding(s).
+`
+  );
+};
+var runSkills = async ({ cwd, verb }) => {
+  if (verb === "list") return resultOf(0, listing(cwd));
+  if (verb === "lock") {
+    const lock = lockFor(cwd);
+    writeFileSync2(join3(cwd, LOCK_FILE), `${JSON.stringify(lock, void 0, 2)}
+`);
+    return resultOf(
+      0,
+      `wrote ${LOCK_FILE} \u2014 ${Object.keys(lock.skills).length} skill(s) pinned by content hash.
+`
+    );
+  }
+  if (verb === "audit") return audit(cwd);
+  return refused(`geonosis skills: "${verb}" is not one of list, lock, audit.
+`);
+};
+
+// src/spawn.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import { join as join4 } from "path";
+import { fileURLToPath } from "url";
+import { packageDirOf } from "@geonosis/doctor";
+var OUTPUT_LIMIT = 8 * 1024 * 1024;
+var entryOf = (from, name) => createRequire(join4(from, "noop.js")).resolve(name);
+var binPath = (from, ref) => {
+  const dir = packageDirOf(entryOf(from, ref.package), ref.package);
+  const manifest = JSON.parse(readFileSync2(join4(dir, "package.json"), "utf8"));
+  const declared = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[ref.bin];
+  if (declared === void 0) {
+    throw new Error(`${ref.package} declares no bin called "${ref.bin}"`);
+  }
+  return join4(dir, declared);
+};
+var SELF = fileURLToPath(new URL("..", import.meta.url));
+var versionOf = (from, name) => {
+  try {
+    const dir = packageDirOf(entryOf(from, name), name);
+    const manifest = JSON.parse(readFileSync2(join4(dir, "package.json"), "utf8"));
+    return manifest.version ?? "an unknown version";
+  } catch {
+    return "an unknown version";
+  }
+};
+var findBin = (cwd, ref) => {
+  try {
+    return { note: "", path: binPath(cwd, ref) };
+  } catch {
+  }
+  const path = binPath(SELF, ref);
+  return {
+    note: `geonosis: ${ref.package} is not installed in ${cwd}; running the copy that came with @geonosis/cli (${versionOf(SELF, ref.package)}).
+`,
+    path
+  };
+};
+var runBin = async (cwd, ref, args) => {
+  let found;
+  try {
+    found = findBin(cwd, ref);
+  } catch (error) {
+    return refused(
+      `geonosis: ${ref.package} is installed neither in ${cwd} nor beside this CLI, so "${ref.bin}" could not be run \u2014 ${error.message}
+`
+    );
+  }
+  const done = spawnSync2(process.execPath, [found.path, ...args], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: OUTPUT_LIMIT
+  });
+  if (done.error !== void 0) {
+    return refused(`geonosis: could not run ${found.path}: ${done.error.message}
+`);
+  }
+  return resultOf(done.status ?? 2, `${found.note}${done.stdout ?? ""}${done.stderr ?? ""}`);
+};
+
+// src/sync.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join5 } from "path";
+var LAW_FILE = "CLAUDE.md";
+var AGENTS_FILE = "AGENTS.md";
+var CURSOR_RULES = ".cursor/rules";
+var GENERATED = "Generated by `geonosis sync` \u2014 edit CLAUDE.md and the skills, never this file.";
+var FRONTMATTER = /^---\n([\s\S]*?)\n---\n?/;
+var fieldOf = (block, name) => new RegExp(`^${name}:\\s*(.+)$`, "m").exec(block)?.[1]?.trim() ?? "";
+var frontOf = (source) => {
+  const found = FRONTMATTER.exec(source);
+  if (found?.[1] === void 0) return { body: source.trim(), description: "" };
+  return {
+    body: source.slice(found[0].length).trim(),
+    description: fieldOf(found[1], "description")
+  };
+};
+var generate = (cwd) => {
+  const law = readFileSync3(join5(cwd, LAW_FILE), "utf8").trimEnd();
+  const skills = skillsIn(cwd).map((skill) => ({
+    ...skill,
+    ...frontOf(readFileSync3(join5(skill.dir, "SKILL.md"), "utf8"))
+  }));
+  const files = {
+    [AGENTS_FILE]: [
+      `<!-- ${GENERATED} -->`,
+      "",
+      law,
+      "",
+      "## Skills",
+      "",
+      ...skills.length === 0 ? ["This repo ships no skills."] : skills.map((one) => `- **${one.name}** \u2014 ${one.description} (\`${one.skillPath}\`)`),
+      ""
+    ].join("\n")
+  };
+  files[`${CURSOR_RULES}/law.mdc`] = [
+    "---",
+    `description: ${LAW_FILE}, the law of this repo`,
+    "globs:",
+    "alwaysApply: true",
+    "---",
+    "",
+    `<!-- ${GENERATED} -->`,
+    "",
+    law,
+    ""
+  ].join("\n");
+  for (const skill of skills) {
+    files[`${CURSOR_RULES}/${skill.name}.mdc`] = [
+      "---",
+      `description: ${skill.description}`,
+      "globs:",
+      "alwaysApply: false",
+      "---",
+      "",
+      `<!-- ${GENERATED} -->`,
+      "",
+      skill.body,
+      ""
+    ].join("\n");
+  }
+  return files;
+};
+var ledgerArgs = ({ check, into, target, write }) => [
+  "sync",
+  "--target",
+  target ?? "",
+  ...write === true && into !== void 0 ? ["--write", into] : [],
+  ...check === true && into !== void 0 ? ["--check", into] : []
+];
+var runSync = async (input) => {
+  if (input.target !== void 0) {
+    return runBin(
+      input.cwd,
+      { bin: "geonosis-ledger", package: "@geonosis/ledger" },
+      ledgerArgs(input)
+    );
+  }
+  if (!existsSync4(join5(input.cwd, LAW_FILE))) {
+    return refused(
+      `geonosis sync: no ${LAW_FILE} in ${input.cwd} \u2014 there is no law to generate the other tools' files from.
+`
+    );
+  }
+  const files = generate(input.cwd);
+  if (input.check === true) {
+    const stale = Object.entries(files).filter(([file, body]) => {
+      const path = join5(input.cwd, file);
+      return !existsSync4(path) || readFileSync3(path, "utf8") !== body;
+    });
+    return stale.length === 0 ? resultOf(0, `sync check PASS \u2014 ${Object.keys(files).length} file(s) match the law.
+`) : resultOf(
+      1,
+      `${stale.map(([file]) => `  ${file}: not what the law generates`).join("\n")}
+sync check FAIL \u2014 run \`geonosis sync --write\`.
+`
+    );
+  }
+  for (const [file, body] of Object.entries(files)) {
+    const path = join5(input.cwd, file);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync3(path, body);
+  }
+  return resultOf(
+    0,
+    `${Object.keys(files).map((file) => `  wrote  ${file}`).join("\n")}
+sync \u2014 ${Object.keys(files).length} file(s) generated from ${LAW_FILE}.
+`
+  );
+};
+
+// src/registry.ts
+import { z } from "zod";
+var passthroughInput = z.object({
+  args: z.array(z.string()).default([]),
+  cwd: z.string()
+});
+var WRAPPED = [
+  {
+    bin: "geonosis-ratchet",
+    description: "Measure every counter in geonosis.ratchet.json against the baseline; fail on growth, rewrite the baseline down on a shrink.",
+    id: "ratchet",
+    kind: "write",
+    package: "@geonosis/ratchet"
+  },
+  {
+    bin: "geonosis-doctor",
+    description: "Ask the four questions a version bump is not finished without: loaded, exercised, baseline, runner.",
+    id: "doctor",
+    kind: "read",
+    package: "@geonosis/doctor"
+  },
+  {
+    bin: "geonosis-verify",
+    description: "Run a tier of gates declared in geonosis.json and write the gate report a Stop hook and CI read.",
+    id: "verify",
+    kind: "write",
+    package: "@geonosis/verify"
+  },
+  {
+    bin: "geonosis-lint-parity",
+    description: "Diff two oxlint configs over the same paths, or over a reach corpus \u2014 the adoption proof and the release check.",
+    id: "lint-parity",
+    kind: "read",
+    package: "@geonosis/lint-parity"
+  },
+  {
+    bin: "geonosis-verify-arch",
+    description: "Run the whole-graph architecture scans a per-file linter cannot: uniqueness, reachability, tier direction.",
+    id: "verify-arch",
+    kind: "read",
+    package: "@geonosis/verify-arch"
+  },
+  {
+    bin: "geonosis-visual-diff",
+    description: "Compare two PNGs pixel for pixel, or check a frame against a recorded baseline.",
+    id: "visual-diff",
+    kind: "write",
+    package: "@geonosis/visual-diff"
+  },
+  {
+    bin: "geonosis-ledger",
+    description: "The tick ledger: plans, ticks, proofs, decisions, the fallbacks journal, the handoff block, the edges table.",
+    id: "ledger",
+    kind: "write",
+    package: "@geonosis/ledger"
+  },
+  {
+    bin: "geonosis-walk",
+    description: "Drive a browser over a repo\u2019s URLs with the probes it declared, and write the walk report.",
+    id: "walk",
+    kind: "read",
+    package: "@geonosis/walk"
+  },
+  {
+    bin: "geonosis-review",
+    description: "Apply or check a review decision against the acceptance criteria a plan states \u2014 decision in, verdict out.",
+    id: "review",
+    kind: "write",
+    package: "@geonosis/review"
+  },
+  {
+    bin: "geonosis-testbed",
+    description: "Run a suite against the adapters a repo declares \u2014 installed only where the testbed is a dependency.",
+    id: "testbed",
+    kind: "read",
+    package: "@geonosis/testbed"
+  },
+  {
+    bin: "geonosis-observability",
+    description: "Plant an error and prove it reached the sink \u2014 a write, because with a real sink it sends to a third party.",
+    id: "observability",
+    kind: "write",
+    package: "@geonosis/observability"
+  },
+  {
+    bin: "geonosis-ledger",
+    description: "The digest: six lines, always the same six, whatever the size of the repo.",
+    id: "status",
+    kind: "read",
+    lead: ["status"],
+    package: "@geonosis/ledger"
+  }
+];
+var wrap = (one) => ({
+  description: one.description,
+  id: one.id,
+  inputSchema: passthroughInput,
+  kind: one.kind,
+  run: async (input) => {
+    const { args, cwd } = passthroughInput.parse(input);
+    return runBin(cwd, { bin: one.bin, package: one.package }, [...one.lead ?? [], ...args]);
+  }
+});
+var initInput = z.object({
+  brand: z.string().optional(),
+  cwd: z.string(),
+  presets: z.array(z.string()),
+  runtime: z.enum(["bun", "pnpm"]).optional()
+});
+var syncInput = z.object({
+  check: z.boolean().optional(),
+  cwd: z.string(),
+  into: z.string().optional(),
+  target: z.enum(["layer-walls", "restricted-imports", "turbo"]).optional(),
+  write: z.boolean().optional()
+});
+var discoverInput = z.object({
+  config: z.string().optional(),
+  cwd: z.string(),
+  paths: z.array(z.string()).optional()
+});
+var skillsInput = z.object({ cwd: z.string(), verb: z.string() });
+var OWN = [
+  {
+    description: "Write the four config files an existing repo needs \u2014 geonosis.json, .oxlintrc.json, geonosis.ratchet.json, gate-baseline.json \u2014 refusing to overwrite any of them.",
+    id: "init",
+    inputSchema: initInput,
+    kind: "write",
+    run: async (input) => runInit(initInput.parse(input))
+  },
+  {
+    description: "Generate AGENTS.md and the Cursor rules from CLAUDE.md and this repo\u2019s skills, or hand a --target to the ledger\u2019s edges table.",
+    id: "sync",
+    inputSchema: syncInput,
+    kind: "write",
+    run: async (input) => runSync(syncInput.parse(input))
+  },
+  {
+    description: "Read the findings this repo\u2019s own oxlint config produces into fixShape candidates: rule, count, first three sites. Writes nothing.",
+    id: "discover",
+    inputSchema: discoverInput,
+    kind: "read",
+    run: async (input) => runDiscover(discoverInput.parse(input))
+  },
+  {
+    description: "list, lock or audit the skills this repo ships \u2014 pinned by content hash, and failed on drift or on an executable file inside a skill directory.",
+    id: "skills",
+    inputSchema: skillsInput,
+    kind: "write",
+    run: async (input) => runSkills(skillsInput.parse(input))
+  }
+];
+var COMMANDS = [...WRAPPED.map(wrap), ...OWN].toSorted(
+  (a, b) => a.id.localeCompare(b.id)
+);
+var commandById = (id) => {
+  const found = COMMANDS.find((one) => one.id === id);
+  if (found === void 0) {
+    throw new Error(
+      `no command called "${id}" \u2014 the registry has ${COMMANDS.map((one) => one.id).join(", ")}`
+    );
+  }
+  return found;
+};
+
+export {
+  parseArgv,
+  inputFor,
+  resultOf,
+  refused,
+  candidatesOf,
+  formatCandidates,
+  runDiscover,
+  optionsNeededBy,
+  runtimeOf,
+  countersFor,
+  rulesFor,
+  runInit,
+  LOCK_FILE,
+  SKILL_FILE,
+  hashOf,
+  rootsIn,
+  skillsIn,
+  executablesIn,
+  lockFor,
+  runSkills,
+  findBin,
+  runBin,
+  LAW_FILE,
+  AGENTS_FILE,
+  CURSOR_RULES,
+  generate,
+  runSync,
+  WRAPPED,
+  COMMANDS,
+  commandById
+};