@masculinecache/wrangler-axi 0.1.0

package/dist/src/commands/workers.js

@@ -0,0 +1,431 @@
+import { callWrangler, parseJson } from "../wrangler.js";
+import { takeAllFlags, takeFlag, takeNumber, getPositional, pushRepeated } from "../args.js";
+import { validateFlags, wantsHelp } from "../util.js";
+import { formatCountLine } from "../format.js";
+import { AxiError, mapWranglerError } from "../errors.js";
+import { addExtraDefs, parseFields, } from "../fields.js";
+import { custom, field, relativeTime, pluck, renderDetail, renderHelp, renderList, renderOutput, } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const versionsAvailable = {
+    modified: { def: relativeTime("modified_on", "modified") },
+    deployment: { def: pluck("resources", "script", "deployment") },
+};
+const deploymentsAvailable = {
+    modified: { def: relativeTime("modified_on", "modified") },
+    source: { def: pluck("source", "type", "source") },
+};
+const DEPLOY_FLAGS = [
+    "--name", "--tag", "--message", "--no-bundle", "--outdir", "--outfile",
+    "--compatibility-date", "--compatibility-flags", "--latest", "--assets",
+    "--var", "--define", "--alias", "--tsconfig", "--minify", "--dry-run",
+    "--secrets-file", "--keep-vars", "--strict", "--triggers", "--routes",
+    "--domains", "--dispatch-namespace", "--autoconfig", "--json", "--full",
+];
+/** Pass-through filter flags for `wrangler tail` (single-valued). */
+const TAIL_VALUE_FLAGS = ["--search", "--sampling-rate", "--version-id"];
+/** Pass-through filter flags for `wrangler tail` (repeatable). */
+const TAIL_ARRAY_FLAGS = ["--status", "--method", "--ip", "--header"];
+/** Our own control flags on top of the wrangler filters. */
+const TAIL_VALID_FLAGS = [
+    "--max-entries", "--timeout", "--json", "--full",
+    ...TAIL_VALUE_FLAGS,
+    ...TAIL_ARRAY_FLAGS,
+];
+export const workersCommand = {
+    name: "workers",
+    aliases: ["worker"],
+    description: "manage Workers (deploy, versions, deployments, tail)",
+    help: [
+        "Usage: wrangler-axi workers <deploy|versions|deployments|tail> [args]",
+        "  deploy       — deploy a Worker (mutating)",
+        "  versions     — list/upload versioned deployments",
+        "  deployments  — list recent deployments",
+        "  tail         — stream bounded live logs (stops at --max-entries or --timeout)",
+        "Example: wrangler-axi workers deployments list --name my-worker",
+    ],
+    async run(ctx, args) {
+        const sub = args[0];
+        if (sub === undefined) {
+            return { stdout: renderHelp(workersCommand.help), exitCode: 0 };
+        }
+        if (sub.startsWith("-")) {
+            return { stdout: renderHelp(workersCommand.help), exitCode: 0 };
+        }
+        const rest = args.slice(1);
+        switch (sub) {
+            case "deploy":
+                return deploy(ctx, rest);
+            case "versions":
+                return versions(ctx, rest);
+            case "deployments":
+                return deployments(ctx, rest);
+            case "tail":
+                return tail(ctx, rest);
+            default:
+                const validSubcommands = ["deploy", "versions", "deployments", "tail"];
+                throw new AxiError(`Unknown workers subcommand "${sub}". Valid subcommands are: ${validSubcommands.join(", ")}`, "VALIDATION_ERROR");
+        }
+    },
+};
+async function deploy(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi workers deploy [path] [--name <worker>] [flags]",
+                "Deploys a Worker. Mirrors wrangler deploy; pass through flags like --compatibility-date, --var, --minify, --full.",
+                "Use --dry-run to preview without deploying.",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const userJson = takeAllFlags(args, ["--json"]).length > 0;
+    const full = takeAllFlags(args, ["--full"]).length > 0;
+    validateFlags(args, DEPLOY_FLAGS, "workers deploy");
+    const wArgs = ["deploy"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    // Pass through single-value flags verbatim BEFORE extracting the positional path.
+    for (const f of ["--name", "--tag", "--message", "--compatibility-date", "--assets", "--outdir", "--outfile", "--tsconfig", "--secrets-file", "--dispatch-namespace"]) {
+        const v = takeFlag(args, f);
+        if (v !== undefined) {
+            wArgs.push(f, v);
+        }
+    }
+    // Pass through repeatable flags (space or = form).
+    let aliasOut = "";
+    for (const f of ["--compatibility-flags", "--var", "--define", "--alias", "--routes", "--domains", "--triggers"]) {
+        const values = extractRepeatable(args, f);
+        if (values.length > 0) {
+            pushRepeated(wArgs, f, values);
+            if (f === "--alias") {
+                aliasOut = values.join(", ");
+            }
+        }
+    }
+    // Pass through boolean flags.
+    for (const f of ["--no-bundle", "--latest", "--minify", "--dry-run", "--keep-vars", "--strict", "--autoconfig"]) {
+        if (takeAllFlags(args, [f]).length > 0) {
+            wArgs.push(f);
+        }
+    }
+    const path = args.filter((a) => !a.startsWith("-"))[0];
+    if (path) {
+        wArgs.push(path);
+    }
+    // Add --json to get structured output
+    wArgs.push("--json");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    let version = "";
+    let url = "";
+    try {
+        const json = JSON.parse(stdout);
+        // Assuming the structure: { result: { id: "...", deployment: { url: "..." } } }
+        if (json.result && json.result.id) {
+            version = json.result.id;
+        }
+        if (json.result && json.result.deployment && json.result.deployment.url) {
+            url = json.result.deployment.url;
+        }
+    }
+    catch {
+        // If parsing fails, we leave version and url empty
+    }
+    if (userJson) {
+        return { stdout, exitCode: 0 };
+    }
+    return {
+        stdout: renderDetail("deploy", { path: path ?? "(config)", status: "deployed", version, url, alias: aliasOut }, {
+            path: custom((d) => d.path),
+            status: custom((d) => d.status),
+            version: custom((d) => d.version),
+            url: custom((d) => d.url),
+            alias: custom((d) => d.alias),
+            output: custom(() => {
+                const truncated = truncateTail(stdout.trim(), 120, full);
+                return truncated || "(no output)";
+            }),
+        }),
+        exitCode: 0,
+    };
+}
+function extractRepeatable(args, flag) {
+    const values = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === flag || a.startsWith(`${flag}=`)) {
+            if (a.startsWith(`${flag}=`)) {
+                values.push(a.slice(flag.length + 1));
+                args.splice(i, 1);
+                i--;
+            }
+            else {
+                const v = args[i + 1];
+                if (v !== undefined && !v.startsWith("-")) {
+                    values.push(v);
+                    args.splice(i, 2);
+                    i--;
+                }
+                else {
+                    args.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
+    return values;
+}
+async function versions(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi workers versions list [--name <worker>]",
+                "Flags: --name <worker>, --fields, --limit <n> (default 20), --full, --json",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub !== undefined && sub !== "list" && !sub.startsWith("-")) {
+        throw new AxiError(`Unknown versions subcommand "${sub}"`, "VALIDATION_ERROR", [
+            "Run `wrangler-axi workers versions --help` for valid subcommands",
+        ]);
+    }
+    const listArgs = sub === "list" ? args.slice(1) : args;
+    const json = takeAllFlags(listArgs, ["--json"]).length > 0;
+    const full = takeAllFlags(listArgs, ["--full"]).length > 0;
+    validateFlags(listArgs, ["--name", "--fields", "--limit", "--full", "--json"], "workers versions list");
+    const wArgs = ["versions", "list", "--json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const worker = takeFlag(listArgs, "--name");
+    if (worker) {
+        wArgs.push("--name", worker);
+    }
+    const limit = full ? undefined : (takeNumber(listArgs, "--limit") ?? 20);
+    const fieldsArg = takeFlag(listArgs, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    const items = parseJson(stdout, "versions");
+    const { extraDefs } = parseFields(fieldsArg, versionsAvailable);
+    const schema = addExtraDefs({
+        id: field("id"),
+        created: relativeTime("created_on", "created"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "versions",
+            items,
+            schema,
+            limit,
+            empty: "versions: no versions found for this worker",
+            truncatedHint: "Run `wrangler-axi workers versions list --json` for the full set wrangler returns",
+        }),
+        exitCode: 0,
+    };
+}
+async function deployments(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi workers deployments list [--name <worker>]",
+                "Flags: --name <worker>, --fields, --limit <n> (default 20), --full, --json",
+                "Note: wrangler caps this list to the 10 most recent deployments.",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub !== undefined && sub !== "list" && !sub.startsWith("-")) {
+        throw new AxiError(`Unknown deployments subcommand "${sub}"`, "VALIDATION_ERROR", [
+            "Run `wrangler-axi workers deployments --help` for valid subcommands",
+        ]);
+    }
+    const listArgs = sub === "list" ? args.slice(1) : args;
+    const json = takeAllFlags(listArgs, ["--json"]).length > 0;
+    const full = takeAllFlags(listArgs, ["--full"]).length > 0;
+    validateFlags(listArgs, ["--name", "--fields", "--limit", "--full", "--json"], "workers deployments list");
+    const wArgs = ["deployments", "list", "--json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const worker = takeFlag(listArgs, "--name");
+    if (worker) {
+        wArgs.push("--name", worker);
+    }
+    const limit = full ? undefined : (takeNumber(listArgs, "--limit") ?? 20);
+    const fieldsArg = takeFlag(listArgs, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    const items = parseJson(stdout, "deployments");
+    const { extraDefs } = parseFields(fieldsArg, deploymentsAvailable);
+    const schema = addExtraDefs({
+        id: field("id"),
+        url: field("url"),
+        created: relativeTime("created_on", "created"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "deployments",
+            items,
+            schema,
+            limit,
+            empty: "deployments: no deployments found",
+            truncatedHint: "Run `wrangler-axi workers deployments list --json` for the full set wrangler returns",
+        }),
+        exitCode: 0,
+    };
+}
+/** Truncate a summary value to a readable width, noting how much was cut. */
+function truncateTail(raw, max = 120, full = false) {
+    if (full || raw.length <= max) {
+        return raw;
+    }
+    const cut = raw.length - max;
+    return `${raw.slice(0, max)}\u2026 (+${cut} more)`;
+}
+/** Parse one raw `wrangler tail --format json` line into a compact row. */
+function parseTailLine(line, full) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return {
+            event: "raw",
+            outcome: "unknown",
+            summary: truncateTail(line, 120, full),
+        };
+    }
+    const ev = parsed.event ?? {};
+    const type = ev.type ?? parsed.eventType ?? "unknown";
+    const outcome = ev.outcome ?? parsed.outcome ?? "unknown";
+    if (type === "request" && ev.request) {
+        const method = ev.request.method ?? "?";
+        const url = ev.request.url ?? "";
+        return { event: type, outcome, summary: truncateTail(`${method} ${url}`, 120, full) };
+    }
+    const exc = ev.exception ?? ev.error;
+    if (exc) {
+        return {
+            event: type,
+            outcome,
+            summary: truncateTail(`${exc.name ?? "error"}: ${exc.message ?? ""}`, 120, full),
+        };
+    }
+    if (ev.message) {
+        return { event: type, outcome, summary: truncateTail(ev.message, 120, full) };
+    }
+    return { event: type, outcome, summary: truncateTail(line, 120, full) };
+}
+/** Stopped-by size hint, so agents know the stream was bounded and how to widen it. */
+function tailStopHint(result) {
+    if (result.stoppedBy === "limit") {
+        return `captured ${result.captured} entries (stopped at --max-entries ${result.maxEntries}); raise --max-entries to keep streaming`;
+    }
+    if (result.stoppedBy === "timeout") {
+        return `stopped after ${result.timeoutSec}s (--timeout) before --max-entries; raise --timeout to sample longer`;
+    }
+    return `stream ended (exit ${result.exitCode}) before limits — retry, or use --status to filter`;
+}
+async function tail(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi workers tail [worker] [flags]",
+                "Streams live Worker logs with a hard bound: stops at --max-entries or --timeout.",
+                `Flags: --max-entries <n> (default 20), --timeout <sec> (default 15), --json (raw lines), --full (disable truncation)`,
+                `Filters (passed through): ${TAIL_VALUE_FLAGS.join(", ")}, ${TAIL_ARRAY_FLAGS.join(", ")}`,
+                "Example: wrangler-axi workers tail my-worker --search \"error\" --status error --max-entries 5",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, TAIL_VALID_FLAGS, "workers tail");
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    const full = takeAllFlags(args, ["--full"]).length > 0;
+    let maxEntries = takeNumber(args, "--max-entries");
+    if (maxEntries === undefined) {
+        maxEntries = 20;
+    }
+    else if (!Number.isInteger(maxEntries)) {
+        throw new AxiError("--max-entries must be an integer", "VALIDATION_ERROR");
+    }
+    let timeoutSec = takeNumber(args, "--timeout");
+    if (timeoutSec === undefined) {
+        timeoutSec = 15;
+    }
+    else if (!Number.isInteger(timeoutSec)) {
+        throw new AxiError("--timeout must be an integer", "VALIDATION_ERROR");
+    }
+    if (maxEntries <= 0 && timeoutSec <= 0) {
+        throw new AxiError("workers tail needs a bound — set --max-entries > 0 or --timeout > 0", "VALIDATION_ERROR");
+    }
+    const wArgs = ["tail", "--format", "json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    for (const f of TAIL_VALUE_FLAGS) {
+        const v = takeFlag(args, f);
+        if (v !== undefined) {
+            wArgs.push(f, v);
+        }
+    }
+    for (const f of TAIL_ARRAY_FLAGS) {
+        const values = extractRepeatable(args, f);
+        if (values.length > 0) {
+            pushRepeated(wArgs, f, values);
+        }
+    }
+    const worker = getPositional(args);
+    if (worker) {
+        wArgs.push(worker);
+    }
+    const tailFn = ctx.runner.tail;
+    if (!tailFn) {
+        throw new AxiError("workers tail requires a runner with streaming support", "UNKNOWN");
+    }
+    const result = await tailFn({
+        args: wArgs,
+        maxEntries,
+        timeoutMs: timeoutSec * 1000,
+    });
+    if (result.exitCode !== 0 && result.stoppedBy === "exit") {
+        throw mapWranglerError(result.stderr, result.exitCode);
+    }
+    if (json) {
+        return {
+            stdout: result.entries.length > 0 ? result.entries.join("\n") : "",
+            exitCode: 0,
+        };
+    }
+    const rows = result.entries.map((line) => parseTailLine(line, full));
+    const schema = {
+        event: field("event"),
+        outcome: field("outcome"),
+        summary: field("summary"),
+    };
+    if (rows.length === 0) {
+        const hint = `no log events in ${timeoutSec}s — the worker may have no traffic`;
+        return {
+            stdout: renderOutput([
+                formatCountLine({ count: 0, limit: maxEntries > 0 ? maxEntries : undefined }),
+                `tail: ${hint}`,
+            ]),
+            exitCode: 0,
+        };
+    }
+    return {
+        stdout: renderOutput([
+            formatCountLine({ count: rows.length, limit: maxEntries > 0 ? maxEntries : undefined }),
+            renderList(`tail[${rows.length}]`, rows, schema),
+            renderHelp([tailStopHint({ ...result, maxEntries, timeoutSec, captured: rows.length })]),
+        ]),
+        exitCode: 0,
+    };
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,6 @@
+import { AxiError, exitCodeForError } from "axi-sdk-js";
+export { AxiError, exitCodeForError };
+export declare function stripAnsi(text: string): string;
+/** Translate wrangler stderr + exit code into a structured AxiError. */
+export declare function mapWranglerError(stderr: string, exitCode: number): AxiError;
+export declare function wranglerNotInstalledError(): AxiError;

package/dist/src/errors.js

@@ -0,0 +1,77 @@
+import { AxiError, exitCodeForError } from "axi-sdk-js";
+export { AxiError, exitCodeForError };
+function firstErrorLine(stderr) {
+    return stderr.trim().split("\n")[0] ?? "";
+}
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, "");
+}
+const patterns = [
+    {
+        pattern: /set a CLOUDFLARE_API_TOKEN environment variable/i,
+        code: "NOT_AUTHENTICATED",
+        message: () => "No Cloudflare credentials available in this non-interactive environment",
+        suggestions: () => [
+            "Set CLOUDFLARE_API_TOKEN in your environment",
+            "Run `npx wrangler login` once to authenticate the wrangler CLI",
+        ],
+    },
+    {
+        pattern: /You are not authenticated\./i,
+        code: "NOT_AUTHENTICATED",
+        message: () => "You are not authenticated with Cloudflare",
+        suggestions: () => [
+            "Set CLOUDFLARE_API_TOKEN in your environment",
+            "Run `npx wrangler login` once to authenticate the wrangler CLI",
+        ],
+    },
+    {
+        pattern: /Authentication needs a valid API token/i,
+        code: "AUTH_INVALID",
+        message: (m) => m[0] || "Authentication needs a valid API token",
+        suggestions: () => ["Set a valid CLOUDFLARE_API_TOKEN in your environment"],
+    },
+    {
+        pattern: /Unable to find.*(?:namespace|bucket|database|worker|project)/i,
+        code: "NOT_FOUND",
+        message: (m) => m[0] || "Requested resource was not found",
+        suggestions: () => ["Check the resource name and account"],
+    },
+    {
+        pattern: /The specified.*does not exist/i,
+        code: "NOT_FOUND",
+        message: (m) => m[0] || "Resource does not exist",
+    },
+    {
+        pattern: /not found/i,
+        code: "NOT_FOUND",
+        message: (m) => m[0] || "Resource not found",
+    },
+    {
+        pattern: /Unknown (?:argument|command)/i,
+        code: "VALIDATION_ERROR",
+        message: (m) => m[0] || "Unknown argument or command",
+        suggestions: () => ["Run `wrangler-axi <command> --help` for valid flags"],
+    },
+];
+/** Translate wrangler stderr + exit code into a structured AxiError. */
+export function mapWranglerError(stderr, exitCode) {
+    // wrangler colorizes its output when it expects a TTY; strip escapes so
+    // patterns match and messages stay clean regardless of the environment.
+    const clean = stripAnsi(stderr);
+    for (const p of patterns) {
+        const match = clean.match(p.pattern);
+        if (match) {
+            return new AxiError(p.message(match, clean), p.code, p.suggestions ? p.suggestions(match) : []);
+        }
+    }
+    const line = firstErrorLine(clean);
+    if (/not found/i.test(clean)) {
+        return new AxiError(line || "Resource not found", "NOT_FOUND");
+    }
+    return new AxiError(line || `wrangler exited with code ${exitCode}`, "UNKNOWN");
+}
+export function wranglerNotInstalledError() {
+    return new AxiError("wrangler CLI is not installed — install it via `npm install -g wrangler`", "WRANGLER_NOT_INSTALLED");
+}

package/dist/src/fields.d.ts

@@ -0,0 +1,15 @@
+import type { FieldDef } from "./toon.js";
+export interface AvailableField {
+    def?: FieldDef;
+    key?: string;
+}
+/**
+ * Validate a comma-separated --fields argument against a map of known fields.
+ * Unknown fields fail loudly (VALIDATION_ERROR, exit 2).
+ */
+export declare function parseFields(fieldsArg: string | undefined, available: Record<string, AvailableField>): {
+    extraDefs: [string, FieldDef][];
+    extraKeys: string[];
+};
+/** Merge extra defs into a base schema (returning a new object). */
+export declare function addExtraDefs(base: Record<string, FieldDef>, extra: [string, FieldDef][]): Record<string, FieldDef>;

package/dist/src/fields.js

@@ -0,0 +1,36 @@
+import { AxiError } from "axi-sdk-js";
+/**
+ * Validate a comma-separated --fields argument against a map of known fields.
+ * Unknown fields fail loudly (VALIDATION_ERROR, exit 2).
+ */
+export function parseFields(fieldsArg, available) {
+    if (fieldsArg === undefined) {
+        return { extraDefs: [], extraKeys: [] };
+    }
+    const names = [...new Set(fieldsArg.split(",").map((s) => s.trim()).filter(Boolean))];
+    const unknown = names.filter((n) => !(n in available));
+    if (unknown.length > 0) {
+        throw new AxiError(`Unknown field(s): ${unknown.join(", ")}. Available: ${Object.keys(available)
+            .sort()
+            .join(", ")}`, "VALIDATION_ERROR");
+    }
+    const extraDefs = [];
+    const extraKeys = [];
+    for (const name of names) {
+        if (available[name].def) {
+            extraDefs.push([name, available[name].def]);
+        }
+        if (available[name].key) {
+            extraKeys.push(available[name].key);
+        }
+    }
+    return { extraDefs, extraKeys };
+}
+/** Merge extra defs into a base schema (returning a new object). */
+export function addExtraDefs(base, extra) {
+    const merged = { ...base };
+    for (const [name, def] of extra) {
+        merged[name] = def;
+    }
+    return merged;
+}

package/dist/src/format.d.ts

@@ -0,0 +1,13 @@
+export interface CountLineOptions {
+    count: number;
+    limit?: number;
+    totalCount?: number;
+    apiLimitHit?: boolean;
+    displayLimit?: number;
+}
+/**
+ * Render a definitive `count:` line satisfying AXI's pre-computed aggregate +
+ * definitive empty state principles. All diagnostics (totals, truncation, api
+ * limits) are folded into the single line so agents don't paginate blindly.
+ */
+export declare function formatCountLine(opts: CountLineOptions): string;

package/dist/src/format.js

@@ -0,0 +1,21 @@
+/**
+ * Render a definitive `count:` line satisfying AXI's pre-computed aggregate +
+ * definitive empty state principles. All diagnostics (totals, truncation, api
+ * limits) are folded into the single line so agents don't paginate blindly.
+ */
+export function formatCountLine(opts) {
+    const { count, limit, totalCount, apiLimitHit, displayLimit } = opts;
+    if (apiLimitHit) {
+        return `count: ${count}+ (api limit reached)`;
+    }
+    if (totalCount !== undefined && totalCount >= count) {
+        return `count: ${count} of ${totalCount} total`;
+    }
+    if (displayLimit !== undefined && count > displayLimit) {
+        return `count: ${count} (showing first ${displayLimit})`;
+    }
+    if (limit !== undefined && count === limit && count > 0) {
+        return `count: ${count} (showing first ${count})`;
+    }
+    return `count: ${count}`;
+}

package/dist/src/list.d.ts

@@ -0,0 +1,18 @@
+import { type Schema } from "./toon.js";
+export interface ListBlockOptions {
+    noun: string;
+    items: unknown[];
+    schema: Schema;
+    limit?: number;
+    /** totalCount shown in the count line when it differs from items.length. */
+    totalCount?: number;
+    empty: string;
+    truncatedHint?: string;
+}
+/**
+ * Render a definitive list block: aggregate count line, item list (respecting a
+ * display limit), a definitive empty state, and a truncated-list hint. This is
+ * the single place every `--limit` list renders, keeping empty/truncated output
+ * consistent across commands.
+ */
+export declare function renderListBlock(opts: ListBlockOptions): string;

package/dist/src/list.js

@@ -0,0 +1,23 @@
+import { formatCountLine } from "./format.js";
+import { renderHelp, renderList } from "./toon.js";
+/**
+ * Render a definitive list block: aggregate count line, item list (respecting a
+ * display limit), a definitive empty state, and a truncated-list hint. This is
+ * the single place every `--limit` list renders, keeping empty/truncated output
+ * consistent across commands.
+ */
+export function renderListBlock(opts) {
+    const { noun, items, schema, limit, totalCount, empty, truncatedHint } = opts;
+    const display = limit !== undefined ? items.slice(0, limit) : items;
+    const total = totalCount ?? items.length;
+    const countLine = formatCountLine({ count: total, limit, displayLimit: display.length });
+    if (items.length === 0) {
+        return [countLine, empty].filter(Boolean).join("\n");
+    }
+    const blocks = [countLine];
+    blocks.push(renderList(`${noun}[${display.length}]`, display, schema));
+    if (truncatedHint && limit !== undefined && items.length > limit) {
+        blocks.push(renderHelp([truncatedHint]));
+    }
+    return blocks.filter(Boolean).join("\n");
+}

package/dist/src/stdin.d.ts

@@ -0,0 +1,2 @@
+export declare function readStdin(): Promise<string>;
+export declare function isStdinTTY(): boolean;

package/dist/src/stdin.js

@@ -0,0 +1,14 @@
+export function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", (err) => reject(err));
+    });
+}
+export function isStdinTTY() {
+    return Boolean(process.stdin.isTTY);
+}