@geonosis/cli 1.0.0

package/dist/geonosis-cli.js

@@ -0,0 +1,62 @@
+import {
+  COMMANDS,
+  commandById,
+  inputFor
+} from "./chunk-U3TBZWD3.js";
+
+// src/geonosis-cli.ts
+var REFUSED = 2;
+var usage = () => [
+  "geonosis [--json] <command> [args\u2026]",
+  "",
+  "One declarative registry, many doors. Every command below is the same command the MCP server",
+  "serves and the plugin calls; the ones that front a bin spawn it and pass its exit code through",
+  "unchanged \u2014 0 clean, 1 a finding or a refusal, 2 a run that could not be made at all.",
+  "",
+  ...COMMANDS.map((one) => `  ${one.id.padEnd(12)} ${one.kind.padEnd(6)} ${one.description}`),
+  "",
+  "  --json   print { command, ok, exitCode, output } instead of the command\u2019s own bytes",
+  "",
+  "  A flag written BEFORE the command is this door\u2019s; everything after the command is the",
+  "  command\u2019s own, --help included.",
+  ""
+].join("\n");
+var DOOR_FLAGS = /* @__PURE__ */ new Set(["--help", "--json", "-h"]);
+var main = async () => {
+  const argv = process.argv.slice(2);
+  const at = argv.findIndex((one) => !one.startsWith("-"));
+  const mine = at === -1 ? argv : argv.slice(0, at);
+  const unknown = mine.find((one) => !DOOR_FLAGS.has(one));
+  if (unknown !== void 0) {
+    process.stderr.write(`geonosis: ${unknown} is not a flag of this command \u2014 ${usage()}`);
+    return REFUSED;
+  }
+  const id = at === -1 ? void 0 : argv[at];
+  if (id === void 0) {
+    process.stdout.write(usage());
+    return mine.some((one) => one === "--help" || one === "-h") ? 0 : REFUSED;
+  }
+  const json = mine.includes("--json");
+  const rest = argv.slice(at);
+  let command;
+  try {
+    command = commandById(id);
+  } catch (error) {
+    process.stderr.write(`geonosis: ${error.message}
+`);
+    return REFUSED;
+  }
+  const result = await command.run(inputFor(id, rest.slice(1), process.cwd()));
+  process.stdout.write(
+    json ? `${JSON.stringify({ command: id, exitCode: result.exitCode, ok: result.ok, output: result.output }, void 0, 2)}
+` : result.output
+  );
+  return result.exitCode;
+};
+try {
+  process.exit(await main());
+} catch (error) {
+  process.stderr.write(`geonosis: ${error.message}
+`);
+  process.exit(REFUSED);
+}

package/dist/index.d.ts

@@ -0,0 +1,229 @@
+import { ZodType } from 'zod';
+
+type Parsed = {
+    flags: Record<string, string>;
+    positional: string[];
+    switches: Set<string>;
+};
+/**
+ * `--flag value`, `--flag=value` and bare `--switch`, told apart by a declared set rather than by
+ * guessing from the next token — the ledger learned this the hard way, where `--note --plan 3`
+ * would otherwise eat the next flag as a note.
+ */
+declare const parseArgv: (argv: readonly string[], valued: ReadonlySet<string>) => Parsed;
+/**
+ * argv into the input the registry's schema accepts. Turning one door's spelling into the
+ * registry's shape is exactly what a door is for; the registry never learns what a flag looks like.
+ */
+declare const inputFor: (id: string, argv: readonly string[], cwd: string) => unknown;
+
+/**
+ * What every command answers, whatever door asked. `exitCode` is the child bin's own, never a
+ * translation: the nine bins agree that 0 is clean, 1 is a finding or a refusal and 2 is a run that
+ * could not be made at all (D-030), and a wrapper that normalised a 2 into a 1 would have invented
+ * a finding out of a tool that never ran.
+ */
+type CommandResult = {
+    exitCode: number;
+    ok: boolean;
+    output: string;
+};
+/**
+ * Whether the command can change something outside this process that a reviewer would want to have
+ * approved — a file the repo TRACKS, or a send to a third party. It is the fact the MCP door builds
+ * its preview→confirm gate out of, and it is recorded here so that every door reads one answer:
+ * `verify` is a write because the tiers a repo declares include the ratchet, which rewrites the
+ * baseline when a number shrinks.
+ */
+type CommandKind = 'read' | 'write';
+/**
+ * One declarative registry, many doors — musa's `tools/registry.ts` behind an npm embed, an HTTP
+ * server, an MCP and an editor; Midday's 103 tools behind one `McpServer` that the in-app assistant
+ * reaches over `InMemoryTransport` rather than re-registering. A door that carried its own list of
+ * commands would be the second list, and the second list is the one that goes stale.
+ */
+type Command = {
+    description: string;
+    id: string;
+    inputSchema: ZodType;
+    kind: CommandKind;
+    run: (input: unknown) => Promise<CommandResult>;
+};
+declare const resultOf: (exitCode: number, output: string) => CommandResult;
+/** A refusal: the command could not be made at all. Never a finding. */
+declare const refused: (output: string) => CommandResult;
+
+type Candidate = {
+    count: number;
+    rule: string;
+    sites: string[];
+};
+/**
+ * The findings a repo's own config already produces, grouped by rule. Agent OS mines standards out
+ * of code; this mines `fixShape` candidates out of the enforcement already running — the rule, how
+ * loud it is, and the first three places to read. Loudest first, because the shape worth writing
+ * down is the one the tree keeps producing.
+ */
+declare const candidatesOf: (findings: readonly string[]) => Candidate[];
+declare const formatCandidates: (candidates: readonly Candidate[]) => string;
+type DiscoverInput = {
+    config?: string;
+    cwd: string;
+    paths?: string[];
+};
+/**
+ * Read-only by construction: it runs the linter and prints. The scored agent never writes the
+ * scoreboard, and a tool that edited the standards it had just mined would be exactly that.
+ */
+declare const runDiscover: ({ config, cwd, paths, }: DiscoverInput) => Promise<CommandResult>;
+
+type Runtime = 'bun' | 'pnpm';
+type InitInput = {
+    brand?: string;
+    cwd: string;
+    presets: string[];
+    runtime?: Runtime;
+};
+declare const runtimeOf: (cwd: string) => Runtime | undefined;
+declare const countersFor: (runtime: Runtime) => Record<string, unknown>[];
+type Rules = {
+    rules: Record<string, unknown>;
+    unanswered: [string, string][];
+};
+/**
+ * The rules of the named presets, with the options the caller has answers for.
+ *
+ * A rule whose option nobody answered is left OUT and reported, never written with a placeholder:
+ * an enabled rule without its options refuses the whole oxlint run at load (D-031), so a config
+ * that guessed would be one oxlint will not read. Which rules need an answer is measured, not
+ * listed — `optionsNeededBy` asks the rules themselves.
+ */
+declare const rulesFor: (presets: string[], answers?: Record<string, unknown[]>) => Rules;
+/**
+ * The four files an existing repo needs before any gate can run, written once and never over the
+ * top of anything. A tool that overwrote a config would be a tool nobody dares run twice, and the
+ * one thing worse than a repo without a baseline is a repo whose baseline was silently replaced.
+ */
+declare const runInit: ({ brand, cwd, presets, runtime, }: InitInput) => Promise<CommandResult>;
+
+/**
+ * Which rules refuse to run without options, MEASURED by asking them.
+ *
+ * D-031 makes an enabled rule without its options a config error that stops the whole run, so a
+ * skeleton that wrote one would hand a repo an `.oxlintrc.json` oxlint will not read. The list of
+ * which rules those are is a fact about the rules, and a second copy of it in this package would be
+ * the copy that goes stale the next time one is added — so it is not copied. Each rule is
+ * constructed with no options, and the ones that refuse say so, naming what they wanted.
+ */
+declare const optionsNeededBy: () => Record<string, string>;
+
+type Wrapped = {
+    bin: string;
+    description: string;
+    id: string;
+    kind: CommandKind;
+    lead?: string[];
+    package: string;
+};
+/**
+ * Every bin the kit ships, wrapped and never re-implemented. A second implementation of a gate is a
+ * second answer to the question the gate exists to settle, and the two disagree the first time one
+ * of them is fixed.
+ *
+ * `kind` is whether the command can change something outside this process that a reviewer would
+ * want to have approved: a file the repo TRACKS, or a send to a third party. `verify` is a write
+ * because the tiers a repo declares include the ratchet, which rewrites the baseline down when a
+ * number shrank; `observability` is one because a real sink is somebody else's project.
+ */
+declare const WRAPPED: Wrapped[];
+/** The one list every door reads. */
+declare const COMMANDS: Command[];
+declare const commandById: (id: string) => Command;
+
+declare const LOCK_FILE = "skills-lock.json";
+declare const SKILL_FILE = "SKILL.md";
+type LockEntry = {
+    computedHash: string;
+    skillPath: string;
+    source: string;
+    sourceType: string;
+};
+type Lock = {
+    skills: Record<string, LockEntry>;
+    version: number;
+};
+type FoundSkill = {
+    dir: string;
+    hash: string;
+    name: string;
+    skillPath: string;
+};
+declare const hashOf: (bytes: Buffer) => string;
+declare const rootsIn: (cwd: string) => string[];
+/**
+ * Every skill directory under every root, by the hash of the one file a lock pins. Sorted, so two
+ * runs over one tree write the same bytes and a lock diff is a change and never an ordering.
+ */
+declare const skillsIn: (cwd: string) => FoundSkill[];
+/**
+ * Files a markdown lock cannot see. Vercel disclosed the class in one sentence — "a skill that
+ * looked completely clean at the markdown level but included a Python file that opened a remote
+ * shell on install" — and a hash over `SKILL.md` is blind to every byte beside it.
+ */
+declare const executablesIn: (dir: string, cwd: string) => string[];
+declare const lockFor: (cwd: string) => Lock;
+type SkillsInput = {
+    cwd: string;
+    verb: string;
+};
+declare const runSkills: ({ cwd, verb }: SkillsInput) => Promise<CommandResult>;
+
+type BinRef = {
+    bin: string;
+    package: string;
+};
+type Found = {
+    note: string;
+    path: string;
+};
+/**
+ * The repo's copy first, this CLI's own second — and it SAYS when it fell back.
+ *
+ * Running the CLI's own bundled ratchet over a repo that pins a different one is the declared ≠
+ * loaded failure `geonosis-doctor` exists to catch, one level up. It is still better than refusing
+ * to run at all, so it happens and it is printed: a fallback nobody can see is the version skew
+ * nobody can see.
+ */
+declare const findBin: (cwd: string, ref: BinRef) => Found;
+/**
+ * The child's whole answer, and the child's own status. stdout and stderr are joined because a
+ * caller reading one of them is a caller who will miss the refusal that was written to the other.
+ */
+declare const runBin: (cwd: string, ref: BinRef, args: readonly string[]) => Promise<CommandResult>;
+
+declare const LAW_FILE = "CLAUDE.md";
+declare const AGENTS_FILE = "AGENTS.md";
+declare const CURSOR_RULES = ".cursor/rules";
+type Generated = Record<string, string>;
+/**
+ * One law, every tool (D-002).
+ *
+ * The law is written once, for Claude Code, and every other tool's file is DERIVED from it —
+ * agents.md for Codex and the rest, `.cursor/rules/*.mdc` for Cursor. A hand-maintained AGENTS.md
+ * beside a CLAUDE.md is two laws, and the second one is the stale one by the end of the week.
+ */
+declare const generate: (cwd: string) => Generated;
+type SyncInput = {
+    check?: boolean;
+    cwd: string;
+    into?: string;
+    target?: string;
+    write?: boolean;
+};
+/**
+ * `--target` is the edges table, and the edges table is the ledger's. Handing it over — exit code
+ * and all — is what keeps there from being a second reader of one table.
+ */
+declare const runSync: (input: SyncInput) => Promise<CommandResult>;
+
+export { AGENTS_FILE, type BinRef, COMMANDS, CURSOR_RULES, type Candidate, type Command, type CommandKind, type CommandResult, type DiscoverInput, type FoundSkill, type Generated, type InitInput, LAW_FILE, LOCK_FILE, type Lock, type LockEntry, type Parsed, type Runtime, SKILL_FILE, type SkillsInput, type SyncInput, WRAPPED, type Wrapped, candidatesOf, commandById, countersFor, executablesIn, findBin, formatCandidates, generate, hashOf, inputFor, lockFor, optionsNeededBy, parseArgv, refused, resultOf, rootsIn, rulesFor, runBin, runDiscover, runInit, runSkills, runSync, runtimeOf, skillsIn };

package/dist/index.js

@@ -0,0 +1,64 @@
+import {
+  AGENTS_FILE,
+  COMMANDS,
+  CURSOR_RULES,
+  LAW_FILE,
+  LOCK_FILE,
+  SKILL_FILE,
+  WRAPPED,
+  candidatesOf,
+  commandById,
+  countersFor,
+  executablesIn,
+  findBin,
+  formatCandidates,
+  generate,
+  hashOf,
+  inputFor,
+  lockFor,
+  optionsNeededBy,
+  parseArgv,
+  refused,
+  resultOf,
+  rootsIn,
+  rulesFor,
+  runBin,
+  runDiscover,
+  runInit,
+  runSkills,
+  runSync,
+  runtimeOf,
+  skillsIn
+} from "./chunk-U3TBZWD3.js";
+export {
+  AGENTS_FILE,
+  COMMANDS,
+  CURSOR_RULES,
+  LAW_FILE,
+  LOCK_FILE,
+  SKILL_FILE,
+  WRAPPED,
+  candidatesOf,
+  commandById,
+  countersFor,
+  executablesIn,
+  findBin,
+  formatCandidates,
+  generate,
+  hashOf,
+  inputFor,
+  lockFor,
+  optionsNeededBy,
+  parseArgv,
+  refused,
+  resultOf,
+  rootsIn,
+  rulesFor,
+  runBin,
+  runDiscover,
+  runInit,
+  runSkills,
+  runSync,
+  runtimeOf,
+  skillsIn
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@geonosis/cli",
+  "version": "1.0.0",
+  "description": "One declarative command registry over every geonosis bin — the CLI door onto it, plus init, sync, discover and skills.",
+  "keywords": [
+    "cli",
+    "registry",
+    "monorepo",
+    "gates",
+    "ratchet",
+    "scaffold",
+    "skills"
+  ],
+  "homepage": "https://github.com/microcompanies/geonosis/tree/main/packages/cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microcompanies/geonosis.git",
+    "directory": "packages/cli"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "geonosis": "bin/geonosis.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.0.0",
+    "@geonosis/doctor": "1.0.0",
+    "@geonosis/lint-parity": "1.0.0",
+    "@geonosis/observability": "1.0.0",
+    "@geonosis/ledger": "1.0.0",
+    "@geonosis/oxlint-plugin-biological-architecture": "1.0.0",
+    "@geonosis/testbed": "1.0.0",
+    "@geonosis/verify": "1.0.0",
+    "@geonosis/verify-arch": "1.0.0",
+    "@geonosis/ratchet": "1.0.0",
+    "@geonosis/review": "1.0.0",
+    "@geonosis/visual-diff": "1.0.0",
+    "@geonosis/walk": "1.0.0"
+  },
+  "peerDependencies": {
+    "oxlint": ">=1.77"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}