@wirecat/cli-base 0.63.0 → 0.65.0

package/CHANGELOG.md

@@ -8,6 +8,238 @@ Versions before 0.8.0 are in the [git tags](https://github.com/WireCatLabs/cli-b
 Every entry says what changed as a caller sees it, why, and what to watch for — the rules are
 [`docs/dev/CONVENTIONS.md`](docs/dev/CONVENTIONS.md#the-changelog).
 
+## 0.65.0 — 27.10.2026
+
+### Added
+
+- **Calendar words for moving an event and for "this and all following".** Flag `--following` (`target`, switch):
+  this occurrence and every later one of a repeating event (`events update|delete --following`), beside `--series`.
+  `--scope` already means personal or work, so it is not reused. Flag `--to-calendar <id>` (`target`, id): the
+  calendar an event moves to (`events move --to-calendar`); `--calendar` keeps its meaning, the calendar the event is
+  on. The verb `move` now says what moves in general: a file to a folder, an event to a calendar. cli-core's shared
+  calendar commands use all three; gcal-cli carries `lint/overrides.json` entries for them until this release.
+- **Every CLI that signs in has `session start`, `session status`, `session end` and a profile-free `session list`.**
+  [WC-ACCT-12](docs/standards/accounts.md#wc-acct-12--sign-in-is-session-start-status-and-end-and-session-list-names-the-profiles)
+  is the owner's ruling: `status` says whether one profile is signed in, `list` which profiles exist. Each
+  CLI's missing commands are listed as known gaps: tg, max and wa lack `session status` and list profiles with
+  `account list`; drive lacks `session status`; gcal lacks `session list`; zm lacks `session end` and `session list`;
+  memo has no `session` group.
+- **A sync spends a request budget sized to its deadline and says how to continue.**
+  [WC-LIFE-16](docs/standards/lifecycle.md#wc-life-16--a-sync-spends-a-request-budget-sized-to-its-deadline-and-its-answer-says-how-to-continue)
+  describes what cli-core 0.464.0 (cli-core #2118) builds for the calendar sync: `floor((deadline − margin) /
+  requestMs)` requests, one `requestMs` per CLI, `--max-pages` only lowering it, a partial stop that exits 0 with the
+  exact command to continue, and progress in the sync's status command. The other syncs and gcal's own `requestMs`
+  are listed as gaps.
+
+- **The command vocabulary has the verbs `serve` (run a server in this process and answer its clients until stopped)
+  and `revoke` (take back what was granted, so it stops working).** cli-core 0.463.0 names the MCP server
+  `mcp serve` and gives forgetting browser logins its own command, `mcp revoke`; `revoke` also covers
+  `chats link revoke` and the `consents revoke` commands that were baselined as unknown verbs.
+
+### Changed — may break callers
+
+- **A command that reads the service and only saves what it read is a read, also over MCP.**
+  [WC-CMD-17](docs/standards/commands.md#wc-cmd-17--declare-effects-on-every-command) defines a write, and WC-CMD-6,
+  WC-CMD-28, [WC-MCP-4](docs/standards/mcp.md#wc-mcp-4--read-runs-only-reading-commands-and-write-only-writing-ones)
+  and WC-OUT-9 point at it: `{ remote: "read", local: "write" }` (`sync`, `calendars list`) runs through the `read`
+  tool; `{ remote: "none", local: "write" }` (`store reindex`) stays a write. cli-base's `writes()` still counts every
+  local write, so cli-core serves `sync` through `write` until a follow-up changes it; watch for that release, which
+  moves those commands between tools.
+- **Deadlines: 30 s for a one-shot command, 5 min for a cooperative one at a terminal and 45 s over MCP.**
+  [WC-LIFE-5](docs/standards/lifecycle.md#wc-life-5--bound-every-one-shot-command-by-a-deadline) and WC-LIFE-10 say
+  so, as cli-core 0.464.0 builds it, because MCP clients cut a tool call at about 60 s.
+- **A non-messenger CLI allows ordinary writes, asks before deletes, and denies mail to other people and deleting
+  a whole series.**
+  [WC-PERM-22](docs/standards/permissions.md#wc-perm-22--a-cli-that-is-not-a-messenger-declares-its-own-keys-and-defaults-with-commandpermissions)
+  follows the owner's ruling, and a CLI's generic API path must check the shared keys (`events.notify`,
+  `events.delete.series`) too. Its example said sharing a calendar is `deny`; the owner made it `ask`. cli-core's
+  `CALENDAR_WRITE_DEFAULTS` and gcal's `api` defaults do not follow it yet; both are listed as gaps.
+- **Meeting passcodes stay out of command output and agent answers, not only out of the store.**
+  [WC-SECR-23](docs/standards/security.md) covers answers that come straight from the provider: gcal's `api` answers
+  still keep a description's passcode lines, a listed gap.
+- **Each CLI pins the command catalogue behind its MCP tools.** The [MCP](docs/standards/mcp.md) page no longer
+  claims `mcp-tools.json` pins the catalogue: with three tools it does not. `contracts/mcp-catalogue.json` does; tg and
+  max have it, and wa, zm, gcal and drive do not yet.
+
+- **An MCP server serves the profiles it is told, and refuses without them.**
+  [WC-MCP-9](docs/standards/mcp.md#wc-mcp-9--a-server-serves-the-profiles-it-is-told-with-one-connection-for-each)
+  now allows one named profile (`<cli> <profile> mcp serve`), a list (`<cli> mcp serve --profiles work,personal`) or
+  every profile (`<cli> mcp serve --profiles all`), with one messenger connection per served profile. With no profile
+  and no `--profiles`, `mcp serve` fails with `validation_error` and lists the profiles; it never serves every profile
+  by default. With several profiles, each call names its profile. WC-ACCT-1, WC-ACCT-2 and WC-ACCT-5 say how
+  `--profiles` fits the profile rules, and a profile lock refuses `--profiles all`. The flag registry has `--profiles`.
+  The owner ruled it; cli-core does not build `--profiles` yet.
+- **The handbook names the MCP server `mcp serve` and has no `mcp --revoke` exception.** The
+  [MCP](docs/standards/mcp.md) and [Lifecycle](docs/standards/lifecycle.md) pages say `mcp serve`, `mcp serve --http`,
+  `mcp serve --permission`, `bot mcp serve` and `mcp revoke`, as cli-core 0.463.0 builds them.
+  [WC-CMD-6](docs/standards/commands.md#wc-cmd-6--give-one-action-or-one-report-one-leaf-command) no longer lets
+  `--revoke` stay an option: forgetting every browser login is the `mcp revoke` command. A CLI with its own server
+  (drive, memo, zoom) moves to the same shape.
+- **A lint baseline entry for `serve` or `revoke` goes stale, and `cli-dev lint` fails on it.** cli-core lists
+  `bot mcp serve`, `mcp serve`, `mcp revoke` and `replies consents revoke` in `lint/baseline/unknown-verb.json`;
+  tg-cli and max-cli list `replies consents revoke`. Remove those entries in the same change that takes this version.
+- **The HTTP MCP server rule covers every CLI that offers `mcp serve --http`, not only the messenger CLIs.**
+  [WC-MCP-12](docs/standards/mcp.md#wc-mcp-12--an-mcp-server-over-http-follows-the-same-permissions-and-short-lived-logins)
+  now applies to cli-template and every CLI made from it, which have offered `mcp serve --http` with no rule over it.
+  The template already follows it; a CLI that changed its copy of the HTTP server checks it against the rule.
+
+### Fixed
+
+- **`cli-dev audit` compares gcal only on the commands it already shares with every CLI, for now.** cli-base 0.64.0
+  put gcal into the `all` parity group, and gcal's release audit then blocked on 20 `same-path-contract` differences
+  in `doctor`, `mcp`, `search` and `skill` that already exist among the other six published CLIs and that gcal
+  cannot remove alone (gcal-cli#13). gcal leaves `all` and has its own group, `gcal-shared`, with every CLI over
+  `commands`, `upgrade`, `notes` and `meetings`. It rejoins `all` once tg, max, wa, drive, zoom and memo release on
+  cli-core's shared `mcp serve`, `doctor` and `skill` ([#390](https://github.com/WireCatLabs/cli-base/issues/390)).
+  The other CLIs' audits are unchanged: a path is compared across every member of every group that covers it.
+
+- **`cli-dev bundle`'s loader finds a server after a flag: `<cli> personal --read-only mcp serve`.** It looked for
+  `serve`, `watch` or `mcp` in the first three words of the command, and since cli-core 0.463 named the server
+  `mcp serve`, a flag before it pushed `serve` to the fourth word. Such a server loaded no chunks ahead and could fail
+  after an in-place upgrade (measured on drive: 91 of 138 chunks loaded, instead of 138). The loader now skips flags
+  and looks at four words. Rebuild a CLI with this release to take it.
+- **The handbook no longer contradicts itself on gcal's audit findings.**
+  - WC-OUT-8 and WC-OUT-14: an answer with `meta.complete: false` is an answer on stdout, also after a non-zero
+    exit; only a run with no answer prints one JSON error with stdout empty.
+  - WC-CMD-10 names `--max-pages` a `budget` option, not a paging one, and says why the calendar `--id` exists beside
+    `--operation-id`; gcal's `events create`, with `--id` and no `--operation-id`, is a listed gap. WC-CMD-11 lists `--duration-minutes` as a known gap until the vocabulary has
+    `--duration <duration>`.
+  - WC-REL-16 says `packContents` checks the pack against the list it is given, so a check that passes the `files`
+    list itself cannot fail on a wrong list; the fix belongs in cli-template.
+  - WC-TIME-5 matches an all-day event by local dates, not UTC moments; cli-core's event filter is a listed gap.
+  - WC-ARCH-3 counts generated API types as vendor types, WC-ARCH-5 and WC-ARCH-6 cover calendar CLIs, and
+    WC-ARCH-21's example is gcal's real provider entry.
+  - WC-TOOL-16 puts a word waiting for the vocabulary in `lint/overrides.json` with a link and a date, never in the
+    baseline. The [Documents](docs/standards/docs.md#wc-doc-3--every-document-states-current-facts-rewrite-a-wrong-sentence-in-place)
+    rule on current facts sends a false template-owned file to cli-template.
+  - WC-DATA-3 makes a calendar entry's `external_id` unique per calendar, WC-STORE-3 lists the calendar areas as not
+    bound, WC-TEST-12 says what a reason names, and WC-TEST-14 counts the shared store as local state.
+  - The "who follows" lists name gcal.
+
+- **The handbook's pages on the template match cli-template 0.9.0.** The [Kit surface](docs/standards/kit-surface.md)
+  table lists `LOCAL_WRITE` and `revokeAll`, which the template now imports, and counts imports loaded on demand.
+  [New CLI](docs/standards/new-cli.md) says the MCP server has three tools that reach every command, not a tool for
+  every command.
+- **The handbook says where a lint violation that a shared package forces goes, and which cli-core files are not a
+  CLI's local state.** [WC-TOOL-16](docs/standards/toolchain.md) puts such a violation in the CLI's lint baseline
+  until the shared package catches up.
+  [WC-TEST-14](docs/standards/testing.md#wc-test-14--check-the-upgrade-from-the-previous-published-version) names
+  the update check, MCP logins and lock files that only cli-core writes as outside the upgrade contract; tests still
+  keep them in the sandboxed home.
+
+## 0.64.0 — 27.10.2026
+
+### Added
+
+- **`cli-dev bundle --bin dist/bin/<cli>.js` builds the published bin as an esbuild bundle, the way tg-cli 0.100.0
+  ships.** It moves tg's `scripts/bundle.ts` into cli-base so every CLI builds the same way: code splitting that keeps
+  each lazy `import()` lazy; `import.meta.url` and run-time package lookups that stay at the original module's place
+  in the CLI, cli-core and cli-base; CommonJS named exports for a dynamic `import("yaml")`; kept names; native and
+  by-name packages left outside. The bin becomes a loader that answers `--version`, turns the compile cache on and,
+  under `serve`, `watch` and `mcp`, preloads every chunk so a running server survives an in-place upgrade. The build
+  fails when a bundled module would look in the wrong place. Add `esbuild` (an optional peer, `^0.28.0`) as a
+  devDependency and name the CLI's own outside packages with `--external`. The rule is
+  [WC-LAY-10](docs/standards/layout.md#wc-lay-10--ship-the-bin-as-a-bundle-that-cli-dev-bundle-builds).
+- **WC-PERM-22 on the [Permissions](docs/standards/permissions.md) page: a CLI that is not a messenger declares its
+  own permission keys and defaults with cli-core's `commandPermissions`** (cli-core 0.450.0). It says how such a CLI
+  keys its commands, picks built-in defaults for what its writes do, and runs writes through the read-only lock and the
+  write guard. The example is a calendar: event writes ask, deleting a whole series and mailing attendees are denied
+  until the owner allows them. The page covered messenger CLIs only, and WC-PERM-6's "ask only before what cannot be
+  undone" read as if it applied to a calendar too; it now says it is the messengers' list. drive, zoom and memo do
+  not declare `commandPermissions` yet; the rule names them as known gaps.
+- **`cli-dev audit` compares gcal (`@wirecat/gcal-cli`, the Google Calendar CLI) in the `all` parity group**, next to
+  tg, max, memo, drive, zm and wa, so its shared root commands are held to the same options and summaries. A run
+  without gcal's command tree skips it, as before; the weekly audit adds it once gcal is published on npm.
+- **The command vocabulary has the words a calendar CLI needs.** Verbs `unsync` (stop syncing a thing; what is
+  stored stays), `review` (list what waits for the owner's decision) and `resolve` (settle one such thing with the
+  owner's choice); collections `calendars`, `events` and `people`. `events` was only a view word, so a command group
+  named `events` was reported by `unknown-resource`.
+- **The vocabulary has the flags and the verb of calendar writes** (cli-core's `events create | update | delete |
+  respond`). Flags `--end-time`, `--start-date`, `--end-date`, `--location`, `--attendee` (repeat it for more),
+  `--id` (the id a create is made with) as `value`; `--calendar` and `--series` as `target`; `--no-notify` as `mode`.
+  `--notify` now means telling the people a change concerns — a chat's members or an event's attendees. Verb
+  `respond` (answer an invitation). Without them `option-role` and `unknown-verb` reported every calendar CLI's
+  write commands.
+- **The vocabulary has the words of free/busy and repeating events** (cli-core's `calendars busy` and
+  `events create | update --repeat`). View `busy` (when calendars or people are taken, without what takes them);
+  flags `--repeat <rule>` (an RFC 5545 rule) as `value` and `--hours <from-to>` (the working hours to look in) as
+  `target`. gcal-cli overrides the four lint reports they cause until it takes this release.
+
+- **`requestSchema(operation, definitions)` in `@wirecat/cli-base/codegen` builds the JSON Schema of a generated
+  operation's request body**, every referenced definition under `$defs`, or returns `null` when the operation takes
+  no body. drive-cli and gcal-cli each kept an identical copy for `api show`. Pass a manifest operation and the
+  `definitions` that `definitionsGenerator` wrote.
+
+### Changed — may break callers
+
+- **A lint baseline entry or override for a word that is now in the vocabulary goes stale, and `cli-dev lint` fails
+  on it.** This release adds `unsync`, `review`, `resolve`, `calendars`, `events` and `people`. zoom-cli lists
+  `events` in `lint/baseline/unknown-resource.json`; gcal-cli lists `calendars`, `events`, `people`,
+  `calendars unsync`, `links review` and `links resolve` in its baseline; drive-cli overrides `unknown-verb` for
+  `comments resolve`, and cli-memo for `search people`, in `lint/overrides.json`. Remove those entries in the same
+  change that takes this version.
+- **The calendar write words make gcal-cli's write baseline stale too.** Its `lint/baseline/option-role.json` (20
+  entries under `events create | update | delete | respond`) and `events respond` in `unknown-verb.json` go stale
+  with this release; remove them when gcal takes it. No other CLI's baseline or overrides on `main` name these words.
+- **The free/busy and repeat words make four of gcal-cli's overrides stale.** `lint/overrides.json` names
+  `calendars busy` (`unknown-verb`), `calendars busy --hours` and `events create | update --repeat` (`option-role`);
+  remove them when gcal takes this release.
+
+- **`describeAlone` is no longer exported from `@wirecat/cli-base/commands`.** It was made public by accident in
+  0.62.0; it is a helper of the shared-command check and only works with a map kept for one check. No known caller
+  imports it. Describe a whole tree with `describeProgram` instead.
+
+### Fixed
+
+- **Handbook corrections from gcal-cli's first-release audit.**
+  - The Toolchain, CI, Security, Testing and Store pages listed "the ten repositories" and "the six CLIs" without
+    gcal. They now say "the WireCat repositories": every WireCat CLI, a new one from its first commit, and the shared
+    repositories. `gcal-cli` is a known repository name for "Enforced by".
+  - WC-SECR-4 said the keyring service is the command's name. It is the CLI's app name (`max-cli`, `gcal-cli`,
+    `cli-memo`), as cli-core passes it.
+  - WC-REL-16 says what a CLI's package `files` holds: `dist`, `skills`, `README.md`, `LICENSE` and what the CLI
+    reads or runs after install (`scenarios`, `install`, notices); `CHANGELOG.md` may ship. Never `src/`, tests,
+    scripts, workflows, `bin/release`, `config/`, `lint/`, `contracts/` or `template.json`.
+  - WC-REL-11 names its one exception: a package's first version, published by the owner with `bin/release --local`,
+    since npm sets a trusted publisher only for a package that exists. Step 2 of
+    [New CLI](docs/standards/new-cli.md) says the same.
+  - [New CLI](docs/standards/new-cli.md) says which copied files a CLI rewrites (seeds) and which it leaves to
+    cli-template (template-owned), and that a template-owned page wrong for the CLI is fixed in cli-template.
+  - "Done when" told authors to add a new CLI's shared audit findings to `audit/baseline`, which has not accepted
+    them since cli-base 0.51.0. It now says to fix each one, or declare an exact difference in the parity group.
+  - WC-CI-8 says the fresh-agent audit is given the pinned cli-base workflows.
+  - WC-TEST-12 has one exception: commands generated from an API description share one reason that names an
+    options-against-the-snapshot test and a test that drives a generated command through `run()`.
+
+- **`syncDiscovery` writes the same snapshot for the same revision of a Google API.** Google serves one revision with
+  its object keys in a different order on each download, so two syncs gave different files, hashes and generated
+  code. The snapshot is now the parsed document with its keys sorted and 2-space indentation; values and array order
+  are unchanged. `sha256` is stable; `sourceSha256` is still the hash of the bytes Google served, so it can change
+  between syncs. The first sync after upgrading rewrites each snapshot once, and `pnpm generate` then reorders the
+  generated types, schemas and manifest once.
+- **`skill show` now names every agent `skill install` serves: Claude Code, Codex, Gemini CLI, OpenClaw, and Hermes
+  on request.** Its help named only the first three, so OpenClaw and Hermes users could not tell the skill was meant
+  for them.
+- **The [CI](docs/standards/ci.md) page lists the monthly cron minutes WireCat repositories already use**, under
+  WC-CI-9, and [New CLI](docs/standards/new-cli.md) step 3 points to it. Finding a free minute meant reading
+  `monthly.yml` in every repository. A new CLI adds its minute to the list in the same pull request that joins the
+  parity groups.
+- **The [Kit surface](docs/standards/kit-surface.md) page lists every cli-core and cli-base export cli-template
+  0.7.0 imports**, among them the ones for MCP over HTTP: `mcpServerCommand`, `serveOverHttp`, `httpLockFile` and
+  the rest. The page left them out, so a change to them would not have been seen as one that reaches every new CLI.
+- **[New CLI](docs/standards/new-cli.md) lets the fresh audit agent read the cli-base workflow files a CLI's
+  workflows pin.** WC-CI-8 tells an audit to read them, but the audit was limited to the handbook and the
+  repository. A release audit prompt kept in a CLI repository needs the same change.
+- **WC-TEST-5 on the [Testing](docs/standards/testing.md) page says that a test may wait for a local process or
+  server it started**, polling with a timeout shorter than the test's own; a fixed sleep is still not allowed. It
+  was unclear whether such a wait counts as waiting for real time.
+- **WC-CMD-6 on the [Commands](docs/standards/commands.md) page names `mcp --revoke` as an exception.** The rule says
+  an option never turns a command into a different action, and `--revoke` does: it forgets every browser login
+  instead of starting a server. The owner kept it an option on `mcp` because it belongs with the HTTP server's login
+  state. No other option gets this exception.
+- **The handbook's examples start `gcal-cli` with the command `gcal`, not `cal`**, the system calendar program on macOS
+  and many Linux systems. A CLI named after it would shadow it.
+
 ## 0.63.0 — 27.10.2026
 
 ### Added

package/dist/codegen/discovery.d.ts

@@ -33,7 +33,7 @@ export interface DiscoveryProvenance {
     version: string;
     /** Of the committed file; `readDiscovery` refuses a snapshot that no longer matches it. */
     sha256: string;
-    /** Of the bytes Google served. Equal to `sha256` unless the file was normalized after download. */
+    /** Of the bytes Google served. Google varies its key order, so this one can change while `sha256` does not. */
     sourceSha256: string;
     normalization: string;
 }
@@ -43,8 +43,8 @@ export interface SyncDiscoveryOptions {
     fetch?: typeof globalThis.fetch;
 }
 /**
- * Downloads each Discovery document byte for byte and records where it came from. Run by hand, then review
- * the diff: the build never fetches. `provenance.json` keeps the order of `sources`, and that order is
+ * Downloads each Discovery document, sorts its object keys so the same revision always gives the same file, and
+ * records where it came from. Run by hand, then review the diff: the build never fetches. `provenance.json` keeps the order of `sources`, and that order is
  * the order of the generated schemas.
  */
 export declare const syncDiscovery: (sources: Readonly<Record<string, string>>, options: SyncDiscoveryOptions) => Promise<Record<string, DiscoveryProvenance>>;

package/dist/codegen/discovery.js

@@ -240,9 +240,18 @@ export const adaptDiscovery = (documents, options = {}) => {
     };
 };
 const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+/** Google serves the same revision with its keys in a different order each time; arrays keep theirs. */
+const sortKeys = (value) => Array.isArray(value)
+    ? value.map(sortKeys)
+    : object(value)
+        ? Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [key, sortKeys(value[key])]))
+        : value;
+const NORMALIZATION = "object keys sorted, 2-space JSON; values and array order unchanged";
 /**
- * Downloads each Discovery document byte for byte and records where it came from. Run by hand, then review
- * the diff: the build never fetches. `provenance.json` keeps the order of `sources`, and that order is
+ * Downloads each Discovery document, sorts its object keys so the same revision always gives the same file, and
+ * records where it came from. Run by hand, then review the diff: the build never fetches. `provenance.json` keeps the order of `sources`, and that order is
  * the order of the generated schemas.
  */
 export const syncDiscovery = async (sources, options) => {
@@ -257,20 +266,20 @@ export const syncDiscovery = async (sources, options) => {
         const document = JSON.parse(raw);
         if (!object(document) || document.name !== service)
             throw new Error(`${source} is not the Discovery document of ${service}`);
-        const hash = sha256(raw);
-        downloaded[service] = raw;
+        const written = `${JSON.stringify(sortKeys(document), null, 2)}\n`;
+        downloaded[service] = written;
         provenance[service] = {
             source,
             revision: String(document.revision),
             version: String(document.version),
-            sha256: hash,
-            sourceSha256: hash,
-            normalization: "none",
+            sha256: sha256(written),
+            sourceSha256: sha256(raw),
+            normalization: NORMALIZATION,
         };
     }
     mkdirSync(options.dir, { recursive: true });
-    for (const [service, raw] of Object.entries(downloaded))
-        writeFileSync(join(options.dir, `${service}.json`), raw);
+    for (const [service, text] of Object.entries(downloaded))
+        writeFileSync(join(options.dir, `${service}.json`), text);
     writeFileSync(join(options.dir, "provenance.json"), `${JSON.stringify(provenance, null, 2)}\n`);
     return provenance;
 };

package/dist/codegen/index.d.ts

@@ -1,10 +1,12 @@
 /**
  * Turns an official API description into committed code: types, Valibot schemas, an operation
- * manifest and a coverage page. Build-time only, and format-neutral: it parses no file format and
+ * manifest and a coverage page. Build-time, apart from the small helpers a CLI reads the generated
+ * files with (`identifier`, `requestSchema`), and format-neutral: it parses no file format and
  * adds no dependency. `adaptOpenApi` reads an OpenAPI document and `adaptDiscovery` Google Discovery
  * documents the consumer has parsed; an adapter from Postman or anything else lives in the consumer.
  */
 export { adaptDiscovery, type DiscoveryMetadata, type DiscoveryOptions, type DiscoveryProvenance, type DiscoveryResult, type DiscoveryService, readDiscovery, type SyncDiscoveryOptions, syncDiscovery, } from "./discovery.js";
+export { requestSchema } from "./json-schema.js";
 export { type CoverageOptions, coverageGenerator, definitionsGenerator, type ManifestOperation, manifestGenerator, } from "./manifest.js";
 export type { ApiBody, ApiModel, ApiOperation, ApiParameter, ApiSchema, Binding, CodeGenerator, Confidence, Discriminator, Effect, GeneratedArtifact, HttpBinding, HttpMethod, Override, RpcBinding, SchemaNode, SourceInfo, SourceReference, } from "./model.js";
 export { identifier, kebab } from "./names.js";

package/dist/codegen/index.js

@@ -1,10 +1,12 @@
 /**
  * Turns an official API description into committed code: types, Valibot schemas, an operation
- * manifest and a coverage page. Build-time only, and format-neutral: it parses no file format and
+ * manifest and a coverage page. Build-time, apart from the small helpers a CLI reads the generated
+ * files with (`identifier`, `requestSchema`), and format-neutral: it parses no file format and
  * adds no dependency. `adaptOpenApi` reads an OpenAPI document and `adaptDiscovery` Google Discovery
  * documents the consumer has parsed; an adapter from Postman or anything else lives in the consumer.
  */
 export { adaptDiscovery, readDiscovery, syncDiscovery, } from "./discovery.js";
+export { requestSchema } from "./json-schema.js";
 export { coverageGenerator, definitionsGenerator, manifestGenerator, } from "./manifest.js";
 export { identifier, kebab } from "./names.js";
 export { adaptOpenApi, OpenApiError } from "./openapi.js";

package/dist/codegen/json-schema.d.ts

@@ -0,0 +1,8 @@
+import type { ManifestOperation } from "./manifest.js";
+import type { SchemaNode } from "./model.js";
+/**
+ * The JSON Schema (draft 2020-12) of an operation's request body, built from the `definitions` that
+ * `definitionsGenerator` wrote, with every referenced definition under `$defs`; `null` when the operation takes no
+ * body. For a CLI's `api show`, so an agent sees what to send before it calls.
+ */
+export declare const requestSchema: (operation: Pick<ManifestOperation, "request">, definitions: Readonly<Record<string, SchemaNode>>) => Record<string, unknown> | null;

package/dist/codegen/json-schema.js

@@ -0,0 +1,78 @@
+import { identifier } from "./names.js";
+/**
+ * The JSON Schema (draft 2020-12) of an operation's request body, built from the `definitions` that
+ * `definitionsGenerator` wrote, with every referenced definition under `$defs`; `null` when the operation takes no
+ * body. For a CLI's `api show`, so an agent sees what to send before it calls.
+ */
+export const requestSchema = (operation, definitions) => {
+    if (!operation.request?.schema)
+        return null;
+    const defs = {};
+    const visiting = new Set();
+    const node = (value) => {
+        const common = { ...(value.description ? { description: value.description } : {}) };
+        switch (value.type) {
+            case "ref": {
+                const name = identifier(value.ref);
+                add(name);
+                return { ...common, $ref: `#/$defs/${name}` };
+            }
+            case "unknown":
+                return common;
+            case "union":
+                return { ...common, anyOf: value.of.map(node) };
+            case "allOf":
+                return { ...common, allOf: value.of.map(node) };
+            case "object":
+                return {
+                    ...common,
+                    type: "object",
+                    properties: Object.fromEntries(Object.entries(value.properties).map(([key, item]) => [key, node(item)])),
+                    required: value.required,
+                    additionalProperties: value.additionalProperties ? node(value.additionalProperties) : true,
+                };
+            case "array":
+                return {
+                    ...common,
+                    type: "array",
+                    items: node(value.items),
+                    ...(value.minItems === undefined ? {} : { minItems: value.minItems }),
+                    ...(value.maxItems === undefined ? {} : { maxItems: value.maxItems }),
+                };
+            case "string":
+                return {
+                    ...common,
+                    type: "string",
+                    ...(value.enum ? { enum: value.enum } : {}),
+                    ...(value.pattern ? { pattern: value.pattern } : {}),
+                    ...(value.minLength === undefined ? {} : { minLength: value.minLength }),
+                    ...(value.maxLength === undefined ? {} : { maxLength: value.maxLength }),
+                };
+            case "boolean":
+                return { ...common, type: "boolean" };
+            case "integer":
+            case "number":
+                return {
+                    ...common,
+                    type: value.type,
+                    ...(value.minimum === undefined ? {} : { minimum: value.minimum }),
+                    ...(value.maximum === undefined ? {} : { maximum: value.maximum }),
+                };
+        }
+    };
+    const add = (name) => {
+        if (visiting.has(name))
+            return;
+        visiting.add(name);
+        const value = definitions[name];
+        if (!value)
+            throw new Error(`generated schema reference is missing: ${name}`);
+        defs[name] = node(value);
+    };
+    add(operation.request.schema);
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        $ref: `#/$defs/${operation.request.schema}`,
+        $defs: defs,
+    };
+};

package/dist/commands/index.d.ts

@@ -12,7 +12,7 @@
 import type { Command } from "commander";
 export { type CommandsDocument, type CommandsDocumentAbout, commandsDocument, commandsDocumentJsonSchema, commandsDocumentSchema, parseCommandsDocument, } from "./document.js";
 export { COMMANDS_PAGE_LABELS, type CommandsPage, type CommandsPageLabels, type CommandsPageText, commandsPage, } from "./page.js";
-export * from "./registry.js";
+export { type ArgumentInfo, annotate, annotateOption, type CommandInfo, type CommandLifetime, type CommandMeta, type CommandOutput, type CommandReach, type CommandState, describeOptions, describeProgram, flatten, metaOf, type OptionInfo, type OptionMeta, type Origin, optionMetaOf, stepTargets, } from "./registry.js";
 /**
  * Refuses a command path that arrived as one argument — `"projects add" --help`, what a zsh loop over
  * `$c` passes. Commander settles `--help` for an unknown word before any hook runs and prints the root

package/dist/commands/index.js

@@ -1,7 +1,7 @@
 import { CliError } from "../errors.js";
 export { commandsDocument, commandsDocumentJsonSchema, commandsDocumentSchema, parseCommandsDocument, } from "./document.js";
 export { COMMANDS_PAGE_LABELS, commandsPage, } from "./page.js";
-export * from "./registry.js";
+export { annotate, annotateOption, describeOptions, describeProgram, flatten, metaOf, optionMetaOf, stepTargets, } from "./registry.js";
 /**
  * Refuses a command path that arrived as one argument — `"projects add" --help`, what a zsh loop over
  * `$c` passes. Commander settles `--help` for an unknown word before any hook runs and prints the root

package/dist/credentials.d.ts

@@ -9,7 +9,7 @@ export interface StoredCredential {
 export interface CredentialsOptions {
     /** Where the fallback file lives when the keyring cannot be used. */
     configDir: string;
-    /** The keyring service name — the command's name, e.g. `max-cli`. */
+    /** The keyring service name — the CLI's app name, e.g. `max-cli`, not its command word. */
     service: string;
     /**
      * **True when the config directory came from the environment rather than the OS convention.**

package/dist/dev/bundle.d.ts

@@ -0,0 +1,31 @@
+export interface BundleOptions {
+    /** The CLI's root: `dist/` and `package.json` are under it. */
+    root: string;
+    /** The compiled bin, relative to `root`, e.g. `dist/bin/tg.js`. It becomes the loader. */
+    bin: string;
+    /** Packages that stay outside the bundle, besides `DEFAULT_EXTERNAL`. `*` matches anything. */
+    external?: readonly string[];
+    /** Packages whose modules keep their installed place, besides `DEFAULT_ANCHORED`. */
+    anchored?: readonly string[];
+    /** Third-party files read and found harmless, besides `DEFAULT_HARMLESS` (a path suffix each). */
+    harmless?: readonly string[];
+}
+export interface BundleResult {
+    problems: string[];
+    /** The chunks a server preloads, as the loader names them. */
+    chunks: string[];
+}
+/** Native modules, Bun's SQLite, and what cli-core loads only by name or starts as a worker from its own file. */
+export declare const DEFAULT_EXTERNAL: string[];
+export declare const DEFAULT_ANCHORED: string[];
+export declare const DEFAULT_HARMLESS: string[];
+export declare const LOADER_MARK = "// cli-dev bundle loader\n";
+/**
+ * Whether the loader runs a server: `serve`, `watch` or `mcp serve`, or `mcp` alone as before cli-core 0.463. Flags
+ * are skipped, so `<cli> personal --read-only mcp serve` counts; four words leave room for one flag's value. It is
+ * written into the loader as source, so it uses nothing from outside.
+ */
+export declare const isServer: (words: readonly string[]) => boolean;
+/** The bin that replaces the compiled one: `name` is the bundle's entry, `chunks` what a server preloads. */
+export declare const loaderSource: (name: string, version: string, chunks: readonly string[]) => string;
+export declare const bundle: (options: BundleOptions) => Promise<BundleResult>;