@wirecat/cli-base 0.21.0 → 0.22.0

package/dist/standards/output.d.ts

@@ -0,0 +1,126 @@
+import * as v from "valibot";
+/** At most three next steps per answer, the most useful first. */
+export declare const MAX_NEXT_STEPS = 3;
+export declare const isoTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time with a zone">]>;
+export declare const nextStepSchema: v.StrictObjectSchema<{
+    readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+    /** The command path as one string, `messages list` — what the MCP router tools take as `command`. */
+    readonly command: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    readonly args: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+}, undefined>;
+export declare const missingSchema: v.StrictObjectSchema<{
+    readonly field: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+}, undefined>;
+export declare const pageSchema: v.StrictObjectSchema<{
+    readonly limit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly hasMore: v.BooleanSchema<undefined>;
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>;
+}, undefined>;
+export declare const metaSchema: v.StrictObjectSchema<{
+    readonly runId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    readonly durationMs: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly accounts: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>, undefined>;
+    readonly skipped: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    }, undefined>, undefined>, undefined>;
+    readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export declare const listEnvelopeSchema: <T extends v.GenericSchema>(item: T) => v.StrictObjectSchema<{
+    readonly items: v.ArraySchema<T, undefined>;
+    readonly page: v.StrictObjectSchema<{
+        readonly limit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly hasMore: v.BooleanSchema<undefined>;
+        readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>;
+    }, undefined>;
+    readonly next: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
+        readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+        /** The command path as one string, `messages list` — what the MCP router tools take as `command`. */
+        readonly command: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly args: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+        readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        step: string;
+        command: string;
+        args: {
+            [x: string]: unknown;
+        };
+        why: string;
+    }[], 3, undefined>]>, undefined>;
+    readonly missing: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly field: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+    }, undefined>, undefined>, undefined>;
+    readonly meta: v.StrictObjectSchema<{
+        readonly runId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly durationMs: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly accounts: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>, undefined>;
+        readonly skipped: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+            readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        }, undefined>, undefined>, undefined>;
+        readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const itemEnvelopeSchema: <T extends v.GenericSchema>(item: T) => v.StrictObjectSchema<{
+    readonly item: T;
+    readonly next: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
+        readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+        /** The command path as one string, `messages list` — what the MCP router tools take as `command`. */
+        readonly command: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly args: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+        readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    }, undefined>, undefined>, v.MaxLengthAction<{
+        step: string;
+        command: string;
+        args: {
+            [x: string]: unknown;
+        };
+        why: string;
+    }[], 3, undefined>]>, undefined>;
+    readonly missing: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly field: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly step: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+    }, undefined>, undefined>, undefined>;
+    readonly meta: v.StrictObjectSchema<{
+        readonly runId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly durationMs: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly accounts: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>, undefined>;
+        readonly skipped: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+            readonly why: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        }, undefined>, undefined>, undefined>;
+        readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type NextStep = v.InferOutput<typeof nextStepSchema>;
+export type Missing = v.InferOutput<typeof missingSchema>;
+export type Page = v.InferOutput<typeof pageSchema>;
+export type Meta = v.InferOutput<typeof metaSchema>;
+export interface ListEnvelope<T> {
+    items: T[];
+    page: Page;
+    next?: NextStep[];
+    missing?: Missing[];
+    meta: Meta;
+}
+export interface ItemEnvelope<T> {
+    item: T;
+    next?: NextStep[];
+    missing?: Missing[];
+    meta: Meta;
+}
+declare const fieldRuleSchema: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+    readonly rule: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+}, undefined>;
+export type FieldRule = v.InferOutput<typeof fieldRuleSchema>;
+export declare const defineFieldRules: (input: unknown) => FieldRule[];
+export declare const FIELD_RULES: FieldRule[];
+export {};
+//# sourceMappingURL=output.d.ts.map

package/dist/standards/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/standards/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,kEAAkE;AAClE,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,eAAO,MAAM,OAAO,sHAAqE,CAAA;AAEzF,eAAO,MAAM,cAAc;;IAEzB,qGAAqG;;;;aAIrG,CAAA;AAEF,eAAO,MAAM,aAAa;;;;aAIxB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;aAIrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;aAMrB,CAAA;AAIF,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,CAAC,CAAC,aAAa,QAAQ,CAAC;;;;;;;;;QA5BnE,qGAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmCnG,CAAA;AAEJ,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,CAAC,CAAC,aAAa,QAAQ,CAAC;;;;QArCnE,qGAAqG;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2CnG,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAA;AAC3D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,aAAa,CAAC,CAAA;AACzD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,UAAU,CAAC,CAAA;AACnD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,UAAU,CAAC,CAAA;AACnD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,EAAE,CAAA;IACV,IAAI,EAAE,IAAI,CAAA;IACV,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,EAAE,IAAI,CAAA;CACX;AACD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAA;IACP,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,EAAE,IAAI,CAAA;CACX;AAED,QAAA,MAAM,eAAe;;;aAA2C,CAAA;AAChE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,SAAS,EAGxD,CAAA;AAEH,eAAO,MAAM,WAAW,EAAE,SAAS,EAOjC,CAAA"}

package/dist/standards/output.js

@@ -0,0 +1,54 @@
+import * as v from "valibot";
+import { dottedId, duplicates, parseRegistry, text, word } from "./registry.js";
+/** At most three next steps per answer, the most useful first. */
+export const MAX_NEXT_STEPS = 3;
+export const isoTime = v.pipe(v.string(), v.isoTimestamp("an ISO 8601 time with a zone"));
+export const nextStepSchema = v.strictObject({
+    step: dottedId,
+    /** The command path as one string, `messages list` — what the MCP router tools take as `command`. */
+    command: text,
+    args: v.record(v.string(), v.unknown()),
+    why: text,
+});
+export const missingSchema = v.strictObject({
+    field: text,
+    why: text,
+    step: dottedId,
+});
+export const pageSchema = v.strictObject({
+    limit: v.pipe(v.number(), v.integer(), v.minValue(1)),
+    hasMore: v.boolean(),
+    cursor: v.optional(text),
+});
+export const metaSchema = v.strictObject({
+    runId: text,
+    durationMs: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    accounts: v.optional(v.array(text)),
+    skipped: v.optional(v.array(v.strictObject({ account: text, why: text }))),
+    truncated: v.optional(v.boolean()),
+});
+const nextSteps = v.optional(v.pipe(v.array(nextStepSchema), v.maxLength(MAX_NEXT_STEPS)));
+export const listEnvelopeSchema = (item) => v.strictObject({
+    items: v.array(item),
+    page: pageSchema,
+    next: nextSteps,
+    missing: v.optional(v.array(missingSchema)),
+    meta: metaSchema,
+});
+export const itemEnvelopeSchema = (item) => v.strictObject({
+    item,
+    next: nextSteps,
+    missing: v.optional(v.array(missingSchema)),
+    meta: metaSchema,
+});
+const fieldRuleSchema = v.strictObject({ id: word, rule: text });
+export const defineFieldRules = (input) => parseRegistry("output field rules", v.array(fieldRuleSchema), input, (rules) => duplicates(rules.map((rule) => rule.id)).map((id) => `"${id}" is listed twice`));
+export const FIELD_RULES = defineFieldRules([
+    { id: "envelope", rule: "every JSON answer is one object: a list `{items, page, …}`, one thing `{item, …}`" },
+    { id: "time", rule: "a time is an ISO 8601 string with a zone, never epoch milliseconds" },
+    { id: "duration", rule: "a length of time is a number of milliseconds in a field ending in `Ms`" },
+    { id: "ref", rule: "a stored thing is named by `ref`; a message's `ref` value is its locator" },
+    { id: "camel-case", rule: "keys are camelCase words, no abbreviations a reader has to decode" },
+    { id: "one-meaning", rule: "a key has one meaning and one type in every answer of every CLI" },
+]);
+//# sourceMappingURL=output.js.map

package/dist/standards/output.js.map

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

package/dist/standards/registry.d.ts

@@ -0,0 +1,18 @@
+import * as v from "valibot";
+export declare const word: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+export declare const text: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+export declare const dottedId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+export declare class RegistryError extends Error {
+    readonly registry: string;
+    readonly problems: readonly string[];
+    constructor(registry: string, problems: readonly string[]);
+}
+export declare const issuesOf: (issues: readonly v.BaseIssue<unknown>[]) => string[];
+/** Parses a registry, then runs its own checks over the parsed entries; throws one error naming every problem. */
+export declare const parseRegistry: <S extends v.GenericSchema>(registry: string, schema: S, input: unknown, check?: (parsed: v.InferOutput<S>) => string[]) => v.InferOutput<S>;
+export declare const duplicates: (values: readonly string[]) => string[];
+export declare const jsonSchemaOf: (schema: v.GenericSchema, definitions?: Record<string, v.GenericSchema>) => import("@valibot/to-json-schema").JsonSchema;
+export declare const placeholders: (template: string) => string[];
+/** Fills `{name}` from `values`; a placeholder with no value throws, so a half-filled sentence never ships. */
+export declare const fill: (template: string, values: Readonly<Record<string, string | number>>) => string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/standards/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/standards/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,IAAI,uHAAuG,CAAA;AACxH,eAAO,MAAM,IAAI,oGAAyD,CAAA;AAC1E,eAAO,MAAM,QAAQ,+HAGpB,CAAA;AAED,qBAAa,aAAc,SAAQ,KAAK;IAEpC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE;IAFtC,YACW,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAIrC;CACF;AAED,eAAO,MAAM,QAAQ,WAAY,SAAS,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,KAAG,MAAM,EAIrE,CAAA;AAEJ,kHAAkH;AAClH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,CAAC,CAAC,aAAa,YAC3C,MAAM,UACR,CAAC,SACF,OAAO,UACP,CAAC,MAAM,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,KAC5C,CAAC,CAAC,WAAW,CAAC,CAAC,CAMjB,CAAA;AAED,eAAO,MAAM,UAAU,WAAY,SAAS,MAAM,EAAE,KAAG,MAAM,EAC0B,CAAA;AAEvF,eAAO,MAAM,YAAY,WAAY,CAAC,CAAC,aAAa,gBAAgB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,aAAa,CAAC,iDACP,CAAA;AAI5F,eAAO,MAAM,YAAY,aAAc,MAAM,KAAG,MAAM,EACc,CAAA;AAEpE,+GAA+G;AAC/G,eAAO,MAAM,IAAI,aAAc,MAAM,UAAU,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,KAAG,MAKvF,CAAA"}

package/dist/standards/registry.js

@@ -0,0 +1,41 @@
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+export const word = v.pipe(v.string(), v.regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "a lower-case word, words joined by -"));
+export const text = v.pipe(v.string(), v.regex(/\S/, "must not be empty"));
+export const dottedId = v.pipe(v.string(), v.regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/, "dotted lower-case words, such as `page.next`"));
+export class RegistryError extends Error {
+    registry;
+    problems;
+    constructor(registry, problems) {
+        super(`${registry} registry: ${problems.join("; ")}`);
+        this.registry = registry;
+        this.problems = problems;
+        this.name = "RegistryError";
+    }
+}
+export const issuesOf = (issues) => issues.map((issue) => {
+    const path = v.getDotPath(issue);
+    return path ? `${path}: ${issue.message}` : issue.message;
+});
+/** Parses a registry, then runs its own checks over the parsed entries; throws one error naming every problem. */
+export const parseRegistry = (registry, schema, input, check = () => []) => {
+    const parsed = v.safeParse(schema, input);
+    if (!parsed.success)
+        throw new RegistryError(registry, issuesOf(parsed.issues));
+    const problems = check(parsed.output);
+    if (problems.length > 0)
+        throw new RegistryError(registry, problems);
+    return parsed.output;
+};
+export const duplicates = (values) => [...new Set(values.filter((value, index) => values.indexOf(value) !== index))].sort();
+export const jsonSchemaOf = (schema, definitions) => toJsonSchema(schema, { target: "draft-2020-12", ...(definitions ? { definitions } : {}) });
+const PLACEHOLDER = /\{([a-zA-Z][a-zA-Z0-9]*)\}/g;
+export const placeholders = (template) => [...template.matchAll(PLACEHOLDER)].map((match) => match[1] ?? "");
+/** Fills `{name}` from `values`; a placeholder with no value throws, so a half-filled sentence never ships. */
+export const fill = (template, values) => template.replace(PLACEHOLDER, (_, name) => {
+    const value = values[name];
+    if (value === undefined)
+        throw new Error(`no value for {${name}} in "${template}"`);
+    return String(value);
+});
+//# sourceMappingURL=registry.js.map

package/dist/standards/registry.js.map

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

package/dist/standards/steps.d.ts

@@ -0,0 +1,28 @@
+import * as v from "valibot";
+import type { NextStep } from "./output.js";
+/** A step's command: a path such as `messages sync`, or `*` for the command that gave the answer (`page.next`). */
+export declare const SAME_COMMAND = "*";
+declare const stepSchema: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>;
+    readonly command: v.UnionSchema<[v.LiteralSchema<"*", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a command path such as `messages sync`">]>], undefined>;
+    readonly args: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "an argument or option name in camelCase">]>;
+        readonly required: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly why: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, v.MaxLengthAction<string, 120, undefined>]>;
+}, undefined>;
+export type StepDefinition = v.InferOutput<typeof stepSchema>;
+export declare const defineSteps: (input: unknown) => StepDefinition[];
+export interface StepInput {
+    args: Readonly<Record<string, unknown>>;
+    /** Values for the `{placeholders}` of `why` that are not arguments. */
+    values?: Readonly<Record<string, string | number>>;
+    /** Required when the step's command is `*`. */
+    command?: string;
+}
+/** One `next` entry from its definition: checks the arguments and fills `why`. */
+export declare const stepOf: (definition: StepDefinition, input: StepInput) => NextStep;
+/** The steps every CLI has; each package adds its own with `defineSteps`. */
+export declare const STEPS: StepDefinition[];
+export {};
+//# sourceMappingURL=steps.d.ts.map

package/dist/standards/steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../src/standards/steps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C,mHAAmH;AACnH,eAAO,MAAM,YAAY,MAAM,CAAA;AAE/B,QAAA,MAAM,UAAU;;;;;;;;aAad,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,UAAU,CAAC,CAAA;AAE7D,eAAO,MAAM,WAAW,UAAW,OAAO,KAAG,cAAc,EAMvD,CAAA;AAEJ,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACvC,uEAAuE;IACvE,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAA;IAClD,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,kFAAkF;AAClF,eAAO,MAAM,MAAM,eAAgB,cAAc,SAAS,SAAS,KAAG,QAsBrE,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,KAAK,EAAE,cAAc,EAWhC,CAAA"}

package/dist/standards/steps.js

@@ -0,0 +1,56 @@
+import * as v from "valibot";
+import { dottedId, duplicates, fill, parseRegistry, text } from "./registry.js";
+/** A step's command: a path such as `messages sync`, or `*` for the command that gave the answer (`page.next`). */
+export const SAME_COMMAND = "*";
+const stepSchema = v.strictObject({
+    id: dottedId,
+    command: v.union([
+        v.literal(SAME_COMMAND),
+        v.pipe(v.string(), v.regex(/^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*)*$/, "a command path such as `messages sync`")),
+    ]),
+    args: v.array(v.strictObject({
+        name: v.pipe(v.string(), v.regex(/^[a-z][a-zA-Z0-9]*$/, "an argument or option name in camelCase")),
+        required: v.boolean(),
+    })),
+    why: v.pipe(text, v.maxLength(120)),
+});
+export const defineSteps = (input) => parseRegistry("steps", v.array(stepSchema), input, (steps) => [
+    ...duplicates(steps.map((step) => step.id)).map((id) => `"${id}" is listed twice`),
+    ...steps.flatMap((step) => duplicates(step.args.map((arg) => arg.name)).map((name) => `${step.id}: argument "${name}" is listed twice`)),
+]);
+/** One `next` entry from its definition: checks the arguments and fills `why`. */
+export const stepOf = (definition, input) => {
+    const command = definition.command === SAME_COMMAND ? input.command : definition.command;
+    if (!command)
+        throw new Error(`${definition.id}: the step runs the same command, so pass the command`);
+    const known = new Set(definition.args.map((arg) => arg.name));
+    // A step that reruns the answer's command carries that command's own arguments too.
+    if (definition.command !== SAME_COMMAND)
+        for (const name of Object.keys(input.args))
+            if (!known.has(name))
+                throw new Error(`${definition.id}: no argument "${name}"`);
+    for (const arg of definition.args)
+        if (arg.required && input.args[arg.name] === undefined)
+            throw new Error(`${definition.id}: argument "${arg.name}" is required`);
+    const scalars = Object.fromEntries(Object.entries(input.args).filter((entry) => ["string", "number"].includes(typeof entry[1])));
+    return {
+        step: definition.id,
+        command,
+        args: { ...input.args },
+        why: fill(definition.why, { ...scalars, ...input.values }),
+    };
+};
+/** The steps every CLI has; each package adds its own with `defineSteps`. */
+export const STEPS = defineSteps([
+    {
+        id: "page.next",
+        command: SAME_COMMAND,
+        args: [
+            { name: "cursor", required: false },
+            { name: "page", required: false },
+            { name: "limit", required: false },
+        ],
+        why: "{shown} shown, more exist",
+    },
+]);
+//# sourceMappingURL=steps.js.map

package/dist/standards/steps.js.map

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

package/dist/standards/vocabulary.d.ts

@@ -0,0 +1,40 @@
+import * as v from "valibot";
+export declare const FLAG_TYPES: readonly ["switch", "count", "number", "string", "id", "time", "duration", "choice", "list", "path", "cursor"];
+export declare const vocabularySchema: v.StrictObjectSchema<{
+    readonly verbs: v.ArraySchema<v.StrictObjectSchema<{
+        readonly word: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+        readonly meaning: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly replaces: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly nouns: v.ArraySchema<v.StrictObjectSchema<{
+        readonly word: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+        readonly meaning: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly kind: v.PicklistSchema<["collection", "singular"], undefined>;
+        readonly replaces: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly views: v.ArraySchema<v.StrictObjectSchema<{
+        readonly word: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+        readonly meaning: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    }, undefined>, undefined>;
+    readonly roots: v.ArraySchema<v.StrictObjectSchema<{
+        readonly word: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a lower-case word, words joined by -">]>;
+        readonly meaning: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+    }, undefined>, undefined>;
+    readonly flags: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a long flag: --lower-case-words">]>;
+        readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a value name such as <n>">]>, undefined>;
+        readonly type: v.PicklistSchema<readonly ["switch", "count", "number", "string", "id", "time", "duration", "choice", "list", "path", "cursor"], undefined>;
+        readonly meaning: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
+        readonly unit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type Vocabulary = v.InferOutput<typeof vocabularySchema>;
+export type VocabularyVerb = Vocabulary["verbs"][number];
+export type VocabularyNoun = Vocabulary["nouns"][number];
+export type VocabularyFlag = Vocabulary["flags"][number];
+export type FlagType = (typeof FLAG_TYPES)[number];
+/** One word, one meaning within its kind: a second entry for the same verb, noun, view, root or flag is refused. */
+export declare const defineVocabulary: (input: unknown) => Vocabulary;
+/** The words every CLI on cli-base is judged against. Seeded from STANDARD's command-name rules and the glossary. */
+export declare const VOCABULARY: Vocabulary;
+//# sourceMappingURL=vocabulary.d.ts.map

package/dist/standards/vocabulary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabulary.d.ts","sourceRoot":"","sources":["../../src/standards/vocabulary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,eAAO,MAAM,UAAU,YACrB,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,UAAU,EACV,QAAQ,EACR,MAAM,EACN,MAAM,EACN,QAAQ,CACA,CAAA;AAoBV,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAM3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAA;AACxD,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAA;AACxD,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAA;AACxD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAElD,oHAAoH;AACpH,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,UAoB9C,CAAA;AA6KJ,qHAAqH;AACrH,eAAO,MAAM,UAAU,EAAE,UAavB,CAAA"}