@geonosis/ledger 1.0.0

package/dist/ledger-cli.js

@@ -0,0 +1,339 @@
+import {
+  appendFallback,
+  captureProof,
+  checkArchitecture,
+  checkCommitMessage,
+  checkDelivery,
+  checkPlans,
+  formatProve,
+  formatStatus,
+  loadLedgerConfig,
+  messageOf,
+  newPlan,
+  parseArgs,
+  readStatus,
+  rejectUnknownSwitches,
+  required,
+  runDecide,
+  runHandoff,
+  runProve,
+  runSync,
+  runTick
+} from "./chunk-WI3N5B3J.js";
+
+// src/ledger-cli.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+var USAGE = `geonosis-ledger <command> [--root <dir>]
+
+The tick ledger: it validates, it refuses, and it appends one row. It authors nothing else.
+
+  plan check [<file>|<dir>] [--since <NNN>]
+              A plan needs a status header, an EARS criterion UNDER its acceptance-criteria
+              heading, and a verification section. Prints every violation; exits 1 on any.
+              --since exempts lower-numbered plans, reported as legacy.
+
+  plan new <slug>
+              Writes plans/<next NNN>-<slug>.md: the header, the two headings, and a placeholder
+              that plan check REFUSES until it is replaced. The skeleton is deliberately red.
+
+  tick --plan <NNN> --commit <hash> --proof <path> [--note "\u2026"]
+              Four refusals: the hash is not a commit \xB7 the plan does not pass plan check \xB7 the
+              proof file is not there \xB7 the commit's diff holds no runtime code (G0). On success
+              it appends ONE row to the progress file, and that append is its only write.
+
+  proof capture <slug> --command "<cmd>" [--url <url>]
+              Runs the command; writes proofs/<next NNN>-<slug>.md with the HEAD hash, the
+              command, the exit code and the output, bounded by ledger.maxLines. The exit code
+              is the COMMAND's \u2014 a failing proof is recorded and still fails.
+
+  journal --kind stub|mock|guess|skip --where <path:line> --why "\u2026"
+              Appends a dated row to the fallbacks journal. An unknown kind is refused.
+
+  decide --id D-NNN --text "\u2026" --why "\u2026" --evidence "\u2026" --revisit "\u2026" [--status "\u2026"]
+              Appends a row to the decisions register, each value under the column that names
+              it. Refuses without a revisit trigger, and refuses a register whose header has no
+              column for one \u2014 printing the header to add. It never rewrites that header itself.
+
+  handoff [--dry-run]
+              Rewrites the SESSION CLOSE block of the handoff file between its markers, from the
+              tree alone: HEAD, uncommitted files, the last tick, the last gate report, the open
+              plans. Deterministic \u2014 the same tree gives byte-identical output.
+
+  status [--json]
+              The digest: six lines, always the same six, whatever the size of the repo.
+
+  architecture check [--no-workspace]
+              The architecture file has to carry "| tag | packages | may depend on |"; every
+              package cell has to name a workspace directory and every edge a declared tag.
+              Exit 1 listing the violations. Edges it cannot enforce are printed as notes.
+
+  sync --target turbo|layer-walls|restricted-imports [--write <file>] [--check <file>]
+              One table, three spellings (C8), all generated from it. --write splices only the
+              named fragment; --check exits 1 with what is committed beside what is generated.
+
+  sync --target agents-md|cursor [--write <path>] [--check <path>]
+              The same law, in the vocabulary of the other tools. agents-md writes AGENTS.md \u2014
+              the law's rules section, one line per skill, and what each scoped rule binds to.
+              cursor writes one .cursor/rules/geonosis-<area>.mdc per scoped rule, with Cursor's
+              comma-separated globs (a rule scoped to ** becomes alwaysApply). --write takes the
+              FILE for agents-md and the DIRECTORY for cursor; --check the same, and a generated
+              file that is not there at all is drift.
+
+  commit-msg <file> | --message "<text>" | --commit <hash>
+              Refuses a message longer than ledger.commitMessageLines (default 4 = subject + 3).
+              Blank lines, the "#" lines git puts in the editor file, everything past the
+              --verbose scissors, and a trailing block of trailers are not counted. Made for a
+              commit-msg hook, which is handed the path to the file.
+
+  delivery check --cached | --commit <hash>
+              Refuses a diff whose every changed line is a comment or whitespace. The comment
+              tokens are per language, by extension. Deleting comments counts too: a sweep rides
+              along with runtime code, the way G0 lets docs ride along.
+
+  --prove
+              Plants a 40-line message and a comments-only diff and requires both to be refused.
+              A gate that has never been shown refusing is a claim, not a gate.
+
+Every path and pattern is a key of the "ledger" block of geonosis.json. Exit 1 is a refusal with
+its reason on stdout; exit 2 is a run that could not be made at all, with the reason on stderr.`;
+var VALUED = /* @__PURE__ */ new Set([
+  "--command",
+  "--check",
+  "--commit",
+  "--evidence",
+  "--id",
+  "--kind",
+  "--message",
+  "--note",
+  "--plan",
+  "--proof",
+  "--revisit",
+  "--package",
+  "--root",
+  "--since",
+  "--status",
+  "--target",
+  "--text",
+  "--url",
+  "--where",
+  "--why",
+  "--write"
+]);
+var KNOWN_SWITCHES = /* @__PURE__ */ new Set(["--cached", "--dry-run", "--help", "--json", "--no-workspace"]);
+var contextOf = (argv, cwd) => {
+  const args = parseArgs(argv, VALUED);
+  rejectUnknownSwitches(args, KNOWN_SWITCHES);
+  const root = resolve(cwd, args.flags["--root"] ?? cwd);
+  return { args, config: loadLedgerConfig(root), root };
+};
+var planCommand = ({ args, config, root }, verb) => {
+  if (verb === "check") {
+    const since = args.flags["--since"];
+    const report = checkPlans({
+      config,
+      root,
+      ...since === void 0 ? {} : { since: Number(since) },
+      ...args.positional[0] === void 0 ? {} : { target: args.positional[0] }
+    });
+    const lines = [
+      ...report.legacy.map((file) => `${file}: legacy`),
+      ...report.violations,
+      report.violations.length === 0 ? `plan check PASS \u2014 ${report.checked} plan(s), ${report.legacy.length} legacy` : `plan check FAIL \u2014 ${report.violations.length} violation(s) over ${report.checked} plan(s)`
+    ];
+    return { code: report.violations.length === 0 ? 0 : 1, out: `${lines.join("\n")}
+` };
+  }
+  if (verb === "new") {
+    const slug = args.positional[0];
+    if (slug === void 0) throw new Error("plan new needs a slug");
+    return { code: 0, out: `wrote ${newPlan({ config, root, slug })}
+` };
+  }
+  throw new Error(`unknown plan command "${verb ?? ""}"`);
+};
+var tickCommand = ({ args, config, root }) => {
+  const note = args.flags["--note"];
+  const done = runTick({
+    commit: required(args, "--commit"),
+    config,
+    ...note === void 0 ? {} : { note },
+    now: /* @__PURE__ */ new Date(),
+    plan: required(args, "--plan"),
+    proof: required(args, "--proof"),
+    root
+  });
+  if (done.refusal !== void 0) return { code: 1, out: `tick REFUSED \u2014 ${done.refusal}
+` };
+  return { code: 0, out: `tick ${done.number} recorded in ${config.progress}
+${done.row ?? ""}` };
+};
+var proofCommand = ({ args, config, root }, verb) => {
+  if (verb !== "capture") throw new Error(`unknown proof command "${verb ?? ""}"`);
+  const slug = args.positional[0];
+  if (slug === void 0) throw new Error("proof capture needs a slug");
+  const url = args.flags["--url"];
+  const done = captureProof({
+    command: required(args, "--command"),
+    config,
+    root,
+    slug,
+    ...url === void 0 ? {} : { url }
+  });
+  return { code: done.exitCode, out: `wrote ${done.file} \u2014 exit ${done.exitCode}
+` };
+};
+var journalCommand = ({ args, config, root }) => {
+  const row = appendFallback({
+    config,
+    kind: required(args, "--kind"),
+    now: /* @__PURE__ */ new Date(),
+    root,
+    where: required(args, "--where"),
+    why: required(args, "--why")
+  });
+  return { code: 0, out: `recorded in ${config.journal}
+${row}` };
+};
+var decideCommand = ({ args, config, root }) => {
+  const status = args.flags["--status"];
+  const done = runDecide({
+    config,
+    evidence: required(args, "--evidence"),
+    id: required(args, "--id"),
+    revisit: args.flags["--revisit"] ?? "",
+    root,
+    ...status === void 0 ? {} : { status },
+    text: required(args, "--text"),
+    why: required(args, "--why")
+  });
+  if (done.refusal !== void 0) return { code: 1, out: `decide REFUSED \u2014 ${done.refusal}
+` };
+  return { code: 0, out: `recorded in ${config.decisions}
+${done.row ?? ""}
+` };
+};
+var handoffCommand = ({ args, config, root }) => {
+  const done = runHandoff({ config, root, write: !args.switches.has("--dry-run") });
+  return {
+    code: 0,
+    out: done.written ? `rewrote the SESSION CLOSE block of ${config.handoff}
+` : `${done.block}
+`
+  };
+};
+var statusCommand = ({ args, config, root }) => {
+  const digest = readStatus({ config, root });
+  return {
+    code: 0,
+    out: args.switches.has("--json") ? `${JSON.stringify(digest, void 0, 2)}
+` : `${formatStatus(digest)}
+`
+  };
+};
+var architectureCommand = ({ args, config, root }, verb) => {
+  if (verb !== "check") throw new Error(`unknown architecture command "${verb ?? ""}"`);
+  const report = checkArchitecture({
+    config,
+    root,
+    workspace: !args.switches.has("--no-workspace")
+  });
+  const lines = [
+    ...report.notes.map((note) => `note: ${note}`),
+    ...report.violations,
+    report.violations.length === 0 ? `architecture check PASS \u2014 ${report.edges.length} tag(s)` : `architecture check FAIL \u2014 ${report.violations.length} violation(s)`
+  ];
+  return { code: report.violations.length === 0 ? 0 : 1, out: `${lines.join("\n")}
+` };
+};
+var syncCommand = ({ args, config, root }) => {
+  const check = args.flags["--check"];
+  const packageName = args.flags["--package"];
+  const write = args.flags["--write"];
+  const target = required(args, "--target");
+  const done = runSync({
+    ...check === void 0 ? {} : { check },
+    config,
+    ...packageName === void 0 ? {} : { packageName },
+    root,
+    target,
+    ...write === void 0 ? {} : { write }
+  });
+  if (done.written !== void 0) return { code: 0, out: `wrote ${done.written}
+` };
+  if (check !== void 0) {
+    return done.ok ? { code: 0, out: `sync check PASS \u2014 ${check} is what ${target} generates
+` } : { code: 1, out: `sync check FAIL
+${done.diff ?? ""}
+` };
+  }
+  return { code: 0, out: `${done.generated}
+` };
+};
+var messageFrom = ({ args, root }) => {
+  const given = args.flags["--message"];
+  if (given !== void 0) return given;
+  const named = args.flags["--commit"];
+  if (named !== void 0) {
+    const found = messageOf(named, root);
+    if (found === void 0) throw new Error(`${named} is not a commit`);
+    return found;
+  }
+  const file = args.positional[0];
+  if (file === void 0) throw new Error("commit-msg needs a file, --message or --commit");
+  return readFileSync(resolve(root, file), "utf8");
+};
+var commitMessageCommand = (context) => {
+  const done = checkCommitMessage(messageFrom(context), context.config);
+  return done.refusal === void 0 ? { code: 0, out: "commit-msg PASS\n" } : { code: 1, out: `commit-msg REFUSED \u2014 ${done.refusal}
+` };
+};
+var deliveryCommand = ({ args, root }, verb) => {
+  if (verb !== "check") throw new Error(`unknown delivery command "${verb ?? ""}"`);
+  const named = args.flags["--commit"];
+  const done = checkDelivery({
+    ...named === void 0 ? {} : { commit: named },
+    root,
+    staged: args.switches.has("--cached") || named === void 0
+  });
+  return done.refusal === void 0 ? { code: 0, out: "delivery check PASS\n" } : { code: 1, out: `delivery REFUSED \u2014 ${done.refusal}
+` };
+};
+var runLedger = (argv, cwd) => {
+  const command = argv[0];
+  if (command === void 0 || command === "--help" || command === "help") {
+    return { code: command === void 0 ? 2 : 0, out: `${USAGE}
+` };
+  }
+  if (command === "plan") return planCommand(contextOf(argv.slice(2), cwd), argv[1]);
+  if (command === "proof") return proofCommand(contextOf(argv.slice(2), cwd), argv[1]);
+  if (command === "tick") return tickCommand(contextOf(argv.slice(1), cwd));
+  if (command === "journal") return journalCommand(contextOf(argv.slice(1), cwd));
+  if (command === "decide") return decideCommand(contextOf(argv.slice(1), cwd));
+  if (command === "handoff") return handoffCommand(contextOf(argv.slice(1), cwd));
+  if (command === "status") return statusCommand(contextOf(argv.slice(1), cwd));
+  if (command === "architecture") return architectureCommand(contextOf(argv.slice(2), cwd), argv[1]);
+  if (command === "sync") return syncCommand(contextOf(argv.slice(1), cwd));
+  if (command === "commit-msg") return commitMessageCommand(contextOf(argv.slice(1), cwd));
+  if (command === "delivery") return deliveryCommand(contextOf(argv.slice(2), cwd), argv[1]);
+  if (command === "--prove") {
+    const report = runProve(contextOf(argv.slice(1), cwd).config);
+    return { code: report.ok ? 0 : 2, out: formatProve(report) };
+  }
+  throw new Error(`unknown command "${command}"`);
+};
+var main = () => {
+  try {
+    const { code, out } = runLedger(process.argv.slice(2), process.cwd());
+    process.stdout.write(out);
+    return code;
+  } catch (error) {
+    process.stderr.write(`geonosis-ledger: ${error.message}
+`);
+    return 2;
+  }
+};
+process.exitCode = main();
+export {
+  runLedger
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@geonosis/ledger",
+  "version": "1.0.0",
+  "description": "The tick ledger — validate and refuse, never author: no criteria, no proof, no runtime code, no revisit trigger, no delivery.",
+  "keywords": [
+    "ledger",
+    "gate",
+    "plan",
+    "proof",
+    "ci",
+    "monorepo",
+    "architecture"
+  ],
+  "homepage": "https://github.com/microcompanies/geonosis/tree/main/packages/ledger",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microcompanies/geonosis.git",
+    "directory": "packages/ledger"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "geonosis-ledger": "bin/geonosis-ledger.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}