@pithy-sh/core 0.8.0 → 0.10.0

package/dist/cli/command.d.ts

@@ -0,0 +1,364 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import type { DEFAULT_ENVIRONMENTS, LOCAL_ENVIRONMENT } from "../naming/environment";
+import { COMMANDS, GROUPS } from "./commandCatalog.generated";
+import { CONFIRM_FLAGS, type DestructiveFlag, type DestructivePath, EVERY_ENVIRONMENT_ALWAYS, MEANING_FLAGS, MEANING_ONLY_WITH, PRODUCTION_ENVIRONMENTS, type ProductionPath, type WorkerScopedPath } from "./commandFacts";
+/**
+ * **The one place a `pithy` command line is spelled (#711).**
+ *
+ * #697 held every `fix` to one rule: it runs as written. The sentences beside it were held to nothing, and three
+ * review rounds each found new ones that did not run — a `--worker` dropped, an `--env` left to default to `dev`,
+ * a placeholder an agent pasted verbatim, a command that destroyed far more than the fault it was offered for.
+ * Every one was a command spelled by hand at its own site, so every fix was one site, and the next site was
+ * still spelled by hand.
+ *
+ * So no site spells one. A line that names a command gets it from here, and this module knows the tree
+ * (`commandCatalog.generated.ts`, projected from the CLI's own parser) and the facts the parser cannot state
+ * (`commandFacts.ts`). It refuses to build:
+ *
+ * - **a command that does not exist**, or a flag the command does not declare — at compile time for a literal
+ *   path, at run time for one assembled from a capability's name;
+ * - **a command missing a flag it needs**: one the parser requires, one a rule over several flags requires, an
+ *   `--env` whose default would change what the command acts on, or the `--worker` a command acting on one
+ *   Worker is refused without — and `--worker` takes a {@link WorkerDir}, the Worker's `apps/` directory, never
+ *   its deployed script name;
+ * - **a command that destroys something**, or a production provision. Those are a person's decision, and
+ *   {@link personDecision} says so in a sentence that carries no command an agent would run.
+ *
+ * ## A builder reached at run time never throws because of data
+ *
+ * Every refusal above is about what **the program spells** — a command path, a flag name, an enum choice, the
+ * shape of the line — and a value is one of two kinds:
+ *
+ * - **Spelled by the program**: the path, each flag's name, a choice from a flag's fixed set, a Worker directory
+ *   (a {@link WorkerDir}, which only {@link workerDirOf} makes). These are checked, at compile time where the path
+ *   is a literal.
+ * - **Supplied by a caller**: a `--set` value, a secret's name, free text, anything a run read. These are
+ *   shell-quoted as they are and never checked — `fromName=Acme <hi@acme.io>` is a value, not a placeholder, and a
+ *   builder that read it as one turned `pithy add email` into `core/internal` after it had installed the package
+ *   (#711). A `<placeholder>` is a fault of **spelling**, so the place that refuses one is the gate that reads
+ *   spellings, `packages/cli/src/ci/runnableCommands.test.ts`, which reads every literal handed to a builder too.
+ *
+ * So whether a line is a person's decision never turns on a value at run time either. An environment a run reads —
+ * a deployed Worker's `ENVIRONMENT`, a caller's `--env` — is data: {@link pithyCommand} takes no `--env` on a
+ * command a production run makes a person's decision except a literal non-production one, {@link pithyCommandOf}
+ * takes none there at all, and a line that names one it read is {@link remedy}'s or {@link rerunRemedy}'s, which
+ * say a production one as a person's decision. {@link personDecision} takes only a command or flag that destroys
+ * something, which is shape. What is left to throw is a program that spelled a line wrong, every time it runs.
+ *
+ * `packages/cli/src/ci/runnableCommands.test.ts` reads every string in every package's shipped source and fails
+ * on a `pithy …` spelled anywhere but here, wherever it sits in the sentence.
+ */
+type Catalog = typeof COMMANDS;
+/** A command the CLI runs, as typed after `pithy`. */
+export type CommandPath = keyof Catalog;
+/** A group, which only lists its subcommands. A sentence may name one in prose. */
+export type GroupPath = (typeof GROUPS)[number];
+declare const WORKER_DIR: unique symbol;
+/**
+ * **A Worker as `--worker` takes it: its `apps/` directory.** Branded, so the deployed script name — a `string`
+ * every Worker also carries — cannot be passed where this is wanted. Made by {@link workerDirOf} from the
+ * Worker's directory.
+ */
+export type WorkerDir = string & {
+    readonly [WORKER_DIR]: true;
+};
+/**
+ * The Worker a directory holds, as `--worker` names it: the directory's own name. Takes the directory rather
+ * than a name, because a name in hand is as often the deployed script name, which `--worker` does not resolve.
+ */
+export declare function workerDirOf(worker: {
+    readonly dir: string;
+}): WorkerDir;
+declare const BUILT: unique symbol;
+/** A command line this module built, and so one that runs as written. The only thing a `fix` may carry. */
+export type Command = string & {
+    readonly [BUILT]: true;
+};
+type FlagDefs<P extends CommandPath> = Catalog[P]["flags"];
+type FlagName<P extends CommandPath> = Extract<keyof FlagDefs<P>, string>;
+type ConfirmFlag = (typeof CONFIRM_FLAGS)[number];
+type MeaningFlag = (typeof MEANING_FLAGS)[number];
+/**
+ * An environment no project's production run is: the local one, and the deployed one that is not `prod`. The only
+ * `--env` a literal line may give a command whose production run is a person's decision — so it is spelled, never
+ * read, and an environment a run read goes through {@link remedy}, which decides by its value.
+ */
+export type QuietEnvironment = typeof LOCAL_ENVIRONMENT | Exclude<(typeof DEFAULT_ENVIRONMENTS)[number], (typeof PRODUCTION_ENVIRONMENTS)[number]>;
+/**
+ * The value one flag takes: `true` for a boolean, a {@link WorkerDir} for `--worker`, one of a fixed set's choices,
+ * a {@link QuietEnvironment} for the `--env` of a command a production run makes a person's decision, else a string.
+ */
+type FlagValue<P, D, F> = F extends "--worker" ? WorkerDir : D extends {
+    type: "boolean";
+} ? true : F extends "--env" ? P extends ProductionPath ? QuietEnvironment : string : D extends {
+    enum: readonly (infer E)[];
+} ? D extends {
+    repeatable: true;
+} ? E | readonly E[] : E : D extends {
+    repeatable: true;
+} ? string | readonly string[] : string;
+/** Whether a line naming `P` must carry `F`. `add`'s Worker is its own builder's to name (`addCommand.ts`). */
+type IsNeeded<P extends CommandPath, F extends FlagName<P>> = FlagDefs<P>[F] extends {
+    required: true;
+} ? true : F extends MeaningFlag ? FlagDefs<P>[F] extends {
+    default: string;
+} ? P extends keyof typeof MEANING_ONLY_WITH ? false : true : false : F extends "--worker" ? P extends Exclude<WorkerScopedPath, "add"> ? true : false : false;
+type NeededFlag<P extends CommandPath> = {
+    [F in FlagName<P>]: IsNeeded<P, F> extends true ? F : never;
+}[FlagName<P>];
+/** The flags a line naming `P` passes: the ones it needs, and any other it declares that destroys nothing. */
+export type CommandFlags<P extends CommandPath> = {
+    [F in NeededFlag<P>]: FlagValue<P, FlagDefs<P>[F], F>;
+} & {
+    [F in Exclude<FlagName<P>, NeededFlag<P> | DestructiveFlag | ConfirmFlag>]?: FlagValue<P, FlagDefs<P>[F], F>;
+};
+type HasRequiredPositional<P extends CommandPath> = [
+    Extract<Catalog[P]["positionals"][number], {
+        required: true;
+    }>
+] extends [never] ? false : true;
+/** What a line naming `P` passes: its positional arguments, and its flags, in the order they are written. */
+export type CommandParts<P extends CommandPath> = (HasRequiredPositional<P> extends true ? {
+    args: readonly [string, ...string[]];
+} : {
+    args?: readonly string[];
+}) & ([NeededFlag<P>] extends [never] ? {
+    flags?: CommandFlags<P>;
+} : {
+    flags: CommandFlags<P>;
+});
+type PartsArgument<P extends CommandPath> = HasRequiredPositional<P> extends true ? [parts: CommandParts<P>] : [NeededFlag<P>] extends [never] ? [parts?: CommandParts<P>] : [parts: CommandParts<P>];
+/**
+ * A command that is built like any other: one that destroys nothing, and that does not act on every environment on
+ * every run — a line names that one through {@link remedy}, which says it as a person's decision.
+ */
+export type BuildablePath = Exclude<CommandPath, DestructivePath | (typeof EVERY_ENVIRONMENT_ALWAYS)[number]>;
+/** Parts as a builder holds them when the path is a value rather than a literal. */
+export interface LooseParts {
+    readonly args?: readonly string[];
+    readonly flags?: Readonly<Record<string, string | true | readonly string[] | undefined>>;
+}
+/** What {@link commandFaults} is asked to allow. */
+export interface FaultOptions {
+    /**
+     * A person's decision: a destructive command or flag, or a production run, is named for a person to choose,
+     * and the confirmation flags are theirs to add. {@link personDecision} asks for this; nothing else does.
+     */
+    readonly person?: boolean;
+    /** The project's `seed.productionEnvironments`, beyond the {@link PRODUCTION_ENVIRONMENTS} every project has. */
+    readonly productionEnvironments?: readonly string[];
+    /**
+     * A line said by a **deployed** Worker — into its own log, or to an HTTP caller — which cannot know the `apps/`
+     * directory that provisioned it. Every rule holds but `--worker`. Only the files
+     * `packages/cli/src/ci/runnableCommands.test.ts` lists as runtime lines may pass it.
+     */
+    readonly runtime?: boolean;
+    /**
+     * **Every value on the line was spelled by the program** — the gate, reading a line written in a literal — so a
+     * `<placeholder>` or a blank among them is a fault. No builder says this: a value handed to a builder is a
+     * caller's, and is shell-quoted as it is (see the module comment).
+     */
+    readonly spelled?: boolean;
+    /** Treat `<x>`, the gate's mark for interpolation, as a value rather than a placeholder. */
+    readonly interpolated?: boolean;
+}
+/**
+ * What a builder adds to {@link FaultOptions}: that every value is the caller's own run, handed back as it was
+ * given, so not even a fixed set of choices is held against it — the run's own parser has had its say.
+ */
+interface BuildOptions extends FaultOptions {
+    readonly given?: boolean;
+}
+/** Whether `path` is a command the CLI runs. */
+export declare function isCommandPath(path: string): path is CommandPath;
+/** Whether `path` is a group. */
+export declare function isGroupPath(path: string): path is GroupPath;
+/**
+ * What the catalog says about one flag of one command — its type, whether it is required, its default — or
+ * `undefined` when the command does not declare it.
+ */
+export declare function commandFlag(path: string, flag: string): {
+    readonly type: "boolean" | "string";
+    readonly required: boolean;
+    readonly default?: string;
+} | undefined;
+/**
+ * **Every reason a command line would not run as written, or would do more than a remedy may.** Empty when it
+ * runs. The builder throws on any; `runnableCommands.test.ts` holds every hand-spelled line it reads to the same
+ * function, so the gate and the builder cannot disagree about a rule.
+ */
+export declare function commandFaults(path: string, parts?: LooseParts, options?: BuildOptions): string[];
+/**
+ * **What a command does that only a person may decide**: what it deletes, or that it runs against production. Empty
+ * for a command a remedy may name.
+ */
+export declare function consequencesOf(path: string, parts?: LooseParts, options?: FaultOptions): string[];
+/**
+ * Whether `path` acts on every environment, production among them, when its `--env` is left off — `pithy testers
+ * provision` (`commandFacts.ts`'s {@link EVERY_ENVIRONMENT_WITHOUT_ENV}). A line about one environment names it.
+ */
+export declare function actsOnEveryEnvironment(path: string): boolean;
+/**
+ * Whether `path` acts on every environment, production among them, on every run, with no `--env` to narrow it —
+ * `pithy secrets provision` (`commandFacts.ts`'s {@link EVERY_ENVIRONMENT_ALWAYS}). A line naming it is a person's
+ * decision, always.
+ */
+export declare function actsOnEveryEnvironmentAlways(path: string): boolean;
+/**
+ * **A command line that runs as written**, from a literal path: the tree checks its command, its flags and the
+ * flags it needs at compile time, and {@link commandFaults} checks the rest when it is built.
+ */
+export declare function pithyCommand<P extends BuildablePath>(path: P, ...parts: PartsArgument<P>): Command;
+/** The parts of a line a deployed Worker builds: no `--env`, which it reads as data and names through {@link remedy}. */
+export interface RuntimeParts extends LooseParts {
+    readonly flags?: LooseParts["flags"] & {
+        readonly "--env"?: never;
+    };
+}
+/**
+ * **The same, from a path that is a value** — `` `${capability} provision` ``. Nothing is checked at compile
+ * time, so everything is checked here, and a path the CLI does not have is refused rather than spelled.
+ *
+ * Whether a command is a person's decision never turns on a value here. A runtime line names no `--env`: a deployed
+ * Worker's environment is data, and whether its command is a person's decision depends on it, so that line is
+ * {@link remedy}'s. Nor does any line name the `--env` of a command a production run makes a person's decision —
+ * `provision`, `seed`, `vector provision`. Each is refused for every value, so no environment is a surprise.
+ */
+export declare function pithyCommandOf(path: string, parts: RuntimeParts, options: {
+    readonly runtime: true;
+}): Command;
+export declare function pithyCommandOf(path: string, parts?: LooseParts): Command;
+/**
+ * **A command a person decides on, said as one.** For a fault whose only remedy destroys something, or runs
+ * against production: the sentence names the command, says what it does and that the choice is a person's, and
+ * leaves every confirmation flag for them to add. It returns a sentence, never a {@link Command}, so it cannot
+ * become a `fix`.
+ *
+ * It takes a command that destroys something, or a line naming a flag that does — shape, never a value. A command
+ * whose production run is a person's decision is a decision only for a production `--env`, which is data, so that
+ * line is {@link remedy}'s, which decides by the value; here it is refused for every value.
+ */
+export declare function personDecision(path: PersonPath, parts: LooseParts, options?: Pick<FaultOptions, "productionEnvironments" | "runtime">): string;
+/** A command that destroys something, or one declaring a flag that does: what {@link personDecision} takes. */
+export type PersonPath = {
+    [P in CommandPath]: P extends DestructivePath ? P : [Extract<FlagName<P>, DestructiveFlag>] extends [never] ? never : P;
+}[CommandPath];
+/** **A remedy**: the command a `fix` carries when one may, and the words a line says about it. */
+export interface Remedy {
+    /** The command, when it runs as written and a `fix` may carry it. `undefined` for a person's decision. */
+    readonly fix: Command | undefined;
+    /** The words: `wrap` around the command, or — for a person's decision — that sentence in its place. */
+    say(wrap: (command: string) => string): string;
+}
+/**
+ * **The remedy a line names**, decided by the command rather than by its site: a command a remedy may name is a
+ * `fix` and goes into the sentence; one that destroys something or runs against production is a person's
+ * decision, said as one, with no `fix`. A command that does not run is refused either way.
+ */
+export declare function remedy(path: string, parts?: LooseParts, options?: Pick<FaultOptions, "productionEnvironments" | "runtime">): Remedy;
+declare const CALLER: unique symbol;
+/**
+ * **The caller's own run (#711): the one input every rerun and every fix naming it again is built from.**
+ *
+ * Each review round of #711 found another run again that dropped what the caller gave — `--json`, `--worker`,
+ * `--dry-run`, a `--set`, an option the Worker's config already answers — because each was rebuilt at its own site
+ * from whatever flags that site held. So a rerun builder ({@link rerunCommand}, {@link rerunRemedy}, `pithy add`'s
+ * `addAgain`) takes this and nothing else, and this is made only by {@link callerOf}, from a run's parsed arguments.
+ * Branded, so loose flags do not type-check where one is wanted; `packages/cli/src/ci/runnableCommands.test.ts`
+ * fails on a cast to it and on a {@link callerOf} handed anything but a run's own arguments.
+ */
+export interface Caller<P extends CommandPath = CommandPath> {
+    /** The command the run was. */
+    readonly path: P;
+    /** Its parsed arguments, keyed as the parser keys them (`worker`, `routing-zone`, `dry-run`). */
+    readonly given: Readonly<Record<string, unknown>>;
+    /** Its `--set` values, by key, and every option it settled by a prompt ({@link settledBy}). */
+    readonly set: Readonly<Record<string, string>>;
+    /**
+     * The options the Worker's config already answers, for a command that reads one (`pithy add`): settled, so a
+     * rerun names no `--set` for them, which could contradict the config.
+     */
+    readonly answered: ReadonlySet<string>;
+    readonly [CALLER]: true;
+}
+/**
+ * **A run's own context**, from its parsed arguments. `set` is the raw `--set` entries where the parser keeps only the
+ * last (`collectSetFlags`); absent, they are read from `given.set`. `answered` is what the Worker's config states.
+ */
+export declare function callerOf<P extends CommandPath>(path: P, given: Readonly<Record<string, unknown>>, context?: {
+    readonly set?: readonly string[] | undefined;
+    readonly answered?: Iterable<string> | undefined;
+}): Caller<P>;
+/** The same caller, with what the run settled on its way — a prompt's answers — carried as `--set` too. */
+export declare function settledBy<P extends CommandPath>(caller: Caller<P>, values: Readonly<Record<string, string>>): Caller<P>;
+/** The same caller, with the options its Worker's config answers. */
+export declare function answeredBy<P extends CommandPath>(caller: Caller<P>, keys: Iterable<string>): Caller<P>;
+/** What a run-again is told beyond the arguments the run was given. */
+export interface RerunOptions {
+    /** The positional arguments, as the command takes them. */
+    readonly args?: readonly string[];
+    /** What the run resolved for itself — the Worker it picked when it was not named — or `undefined` to drop one. */
+    readonly flags?: LooseParts["flags"];
+    /** The project's `seed.productionEnvironments`, beyond the ones every project has. */
+    readonly productionEnvironments?: readonly string[] | undefined;
+}
+/** A command whose run again is always a command: it destroys nothing, and no production run of it is a person's. */
+export type RerunPath = Exclude<CommandPath, DestructivePath | ProductionPath>;
+/**
+ * **The caller's own command, to run again (#711)**, as a {@link Command} — rebuilt from the run's {@link Caller}, so
+ * a rerun asks for nothing the first run did not. `options.flags` adds what the run resolved for itself (the Worker it
+ * picked) or drops a flag whose work is done (`undefined`).
+ *
+ * It takes no command whose run again could be a person's decision — one that destroys something, or one a
+ * production `--env` makes a person's: that run again is {@link rerunRemedy}'s, which says so rather than throwing.
+ */
+export declare function rerunCommand(caller: Caller<RerunPath>, options?: Omit<RerunOptions, "productionEnvironments">): Command;
+/**
+ * **The caller's own command, as a line names it to run again (#711)** — the {@link Remedy} for
+ * {@link rerunCommand}'s parts, for any command. A run again that a production `--env` makes a person's decision is
+ * said as one, with no `fix`, rather than thrown after the run did its work. `say` hands `wrap` the command in code
+ * and — where the run was given a credential by flag, which no line repeats — the flags to pass again beside it.
+ */
+export declare function rerunRemedy(caller: Caller, options?: RerunOptions): Remedy;
+/**
+ * **A command named in prose, not given to run** — "as `pithy add` wrote it". Checked to exist, and spelled with
+ * nothing after it. A line that tells somebody to run a command builds it with {@link pithyCommand}.
+ */
+export declare function commandName(path: CommandPath | GroupPath): string;
+/** {@link commandName}, for a path that is a value: refused when the CLI has no such command or group. */
+export declare function commandNameOf(path: string): string;
+/**
+ * {@link commandNameOf}, for a path as a parser walked it, word by word. Empty is the root, which is the CLI
+ * itself rather than a command, and is named as such.
+ */
+export declare function commandNameOfPath(path: readonly string[]): string;
+/**
+ * **The CLI at a version** — `pithy 0.9.5`, as a line names a release rather than a command. A line never spells
+ * `pithy` before an interpolation: the gate reads that as a command it cannot check.
+ */
+export declare function cliAtVersion(version: string): string;
+/**
+ * **How each package manager runs a project's own binary**: `bun x`, `pnpm exec`, `yarn`, `npx`. The one table
+ * both a spawned process (`packages/cli/src/project/packageManager.ts`'s `execArgs`) and a line naming one read.
+ */
+export declare const PACKAGE_EXEC: {
+    readonly bun: readonly ["bun", "x"];
+    readonly pnpm: readonly ["pnpm", "exec"];
+    readonly yarn: readonly ["yarn"];
+    readonly npm: readonly ["npx"];
+};
+/** A package manager a project runs its own binaries through. */
+export type ExecPackageManager = keyof typeof PACKAGE_EXEC;
+/**
+ * **A built command, run through the project's own package manager** — the `pithy` the project installed, never
+ * a global one, which may be an older CLI than the line is about. Takes a {@link Command}, so what follows the
+ * prefix was built and runs as written.
+ */
+export declare function viaPackageManager(pm: ExecPackageManager, command: Command): Command;
+/** `a`, `a or b`, `a, b or c`, each in code: commands a reader picks one of. */
+export declare function commandAlternatives(commands: readonly string[]): string;
+/** `a`, `a and b`, `a, b and c`, each in code: commands that all run. */
+export declare function commandSequence(commands: readonly string[]): string;
+export {};
+//# sourceMappingURL=command.d.ts.map

package/dist/cli/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/cli/command.ts"],"names":[],"mappings":"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"}