kiriya 0.1.0

package/dist/src/core/presentation/cli/cli-application.js

@@ -0,0 +1,201 @@
+import { InterruptedError, KiriyaError, UsageError } from "../../domain/errors.js";
+import { message } from "../../domain/message.js";
+import { Translator } from "../i18n/translator.js";
+import { parseCommandArguments, splitGlobalFlags } from "./argv.js";
+import { CliViewFormat } from "./cli-view-format.js";
+import { MCP_INPUT } from "../mcp/mcp-application.js";
+import { commandHelp, mainHelp, mcpHelp, moduleHelp } from "./help.js";
+import { errorJson, resultJson } from "./json-output.js";
+import { createStyle } from "./style.js";
+import { closest } from "./suggest.js";
+import { TerminalConfirmation } from "./terminal-confirmation.js";
+const EXIT_CODES = {
+    usage: 2,
+    "not-found": 1,
+    conflict: 1,
+    refused: 1,
+    "capability-unavailable": 1,
+    failed: 1,
+    interrupted: 130,
+};
+const verbsOf = (module) => [...module.commands.keys()].filter((verb) => verb !== "");
+/** The command line: finds the command, runs it, prints its result, and maps errors to exit codes once. */
+export class CliApplication {
+    deps;
+    translator;
+    constructor(deps) {
+        this.deps = deps;
+        this.translator = new Translator(deps.catalog);
+    }
+    async run(argv, cwd) {
+        const { flags, rest } = splitGlobalFlags(argv);
+        const colour = !flags.noColor &&
+            !this.deps.environment.variable("KIRIYA_NO_COLOR") &&
+            this.deps.environment.variable("TERM") !== "dumb";
+        const out = createStyle(colour, this.deps.stdout);
+        const err = createStyle(colour, this.deps.stderr);
+        // Help wraps to the terminal's width, and shows the wordmark, only when writing to one.
+        const terminal = this.deps.stdout.isTTY === true;
+        const columns = this.deps.stdout.columns;
+        const help = {
+            translator: this.translator,
+            style: out,
+            version: this.deps.version,
+            ...(terminal && typeof columns === "number" && columns > 0 ? { width: columns } : {}),
+            logo: terminal && colour,
+        };
+        try {
+            if (flags.version)
+                return this.print(this.deps.stdout, [this.deps.version]);
+            const [first, ...words] = rest;
+            if (first === undefined)
+                return this.print(this.deps.stdout, mainHelp(this.deps.registry.list(), help));
+            if (first === "help")
+                return this.help(words[0], words[1], help);
+            if (first === "mcp")
+                return await this.mcp(words, cwd, flags.help, help);
+            const module = this.findModule(first);
+            const { entry, args } = this.resolveCommand(module, words);
+            if (entry === undefined)
+                return this.print(this.deps.stdout, moduleHelp(module, help));
+            if (flags.help)
+                return this.print(this.deps.stdout, commandHelp(module, entry, help));
+            const { spec } = entry.command;
+            const input = spec.input.parse(parseCommandArguments(spec.input, args));
+            const controller = new AbortController();
+            const interrupt = () => controller.abort();
+            process.once("SIGINT", interrupt);
+            let result;
+            try {
+                result = await entry.command.execute(input, {
+                    cwd,
+                    signal: controller.signal,
+                    confirmation: new TerminalConfirmation({
+                        input: this.deps.stdin,
+                        output: this.deps.stderr,
+                        interactive: this.deps.stdin.isTTY === true && !flags.noInput,
+                        translator: this.translator,
+                        style: err,
+                    }),
+                    passthrough: {
+                        write: (text, stream) => {
+                            (flags.json || stream === "stderr" ? this.deps.stderr : this.deps.stdout).write(text);
+                        },
+                    },
+                });
+            }
+            finally {
+                process.removeListener("SIGINT", interrupt);
+            }
+            // The first Ctrl+C asks the command to stop; a second one ends the process as usual.
+            if (controller.signal.aborted)
+                throw new InterruptedError("core.error.interrupted");
+            return this.report(spec.id, result, flags, cwd, out, err, entry.view);
+        }
+        catch (error) {
+            return this.fail(error, flags, err);
+        }
+    }
+    /**
+     * A verb picks a command. A module that is one command takes every word after its
+     * name as arguments. Without either, the module's help is shown.
+     */
+    resolveCommand(module, words) {
+        const [verb, ...rest] = words;
+        const named = verb === undefined || verb === "" ? undefined : module.commands.get(verb);
+        if (named !== undefined)
+            return { entry: named, args: rest };
+        const own = module.commands.get("");
+        if (own !== undefined)
+            return { entry: own, args: words };
+        if (verb === undefined)
+            return { entry: undefined, args: [] };
+        throw this.unknown("core.usage.unknown-command", { module: module.id, name: verb }, verb, verbsOf(module));
+    }
+    /** `kiriya mcp` serves every exposed command to an AI agent until the agent closes stdin. */
+    async mcp(words, cwd, showHelp, context) {
+        if (showHelp)
+            return this.print(this.deps.stdout, mcpHelp(MCP_INPUT, context));
+        return this.deps.serveMcp(MCP_INPUT.parse(parseCommandArguments(MCP_INPUT, words)), cwd);
+    }
+    help(moduleName, verb, context) {
+        if (moduleName === undefined)
+            return this.print(this.deps.stdout, mainHelp(this.deps.registry.list(), context));
+        if (moduleName === "mcp")
+            return this.print(this.deps.stdout, mcpHelp(MCP_INPUT, context));
+        const module = this.findModule(moduleName);
+        if (verb === undefined) {
+            const own = module.commands.get("");
+            const lines = own === undefined ? moduleHelp(module, context) : commandHelp(module, own, context);
+            return this.print(this.deps.stdout, lines);
+        }
+        const entry = verb === "" ? undefined : module.commands.get(verb);
+        if (entry === undefined) {
+            throw this.unknown("core.usage.unknown-command", { module: module.id, name: verb }, verb, verbsOf(module));
+        }
+        return this.print(this.deps.stdout, commandHelp(module, entry, context));
+    }
+    findModule(name) {
+        const module = this.deps.registry.module(name);
+        if (module !== undefined)
+            return module;
+        throw this.unknown("core.usage.unknown-module", { name }, name, this.deps.registry.list().map((item) => item.id));
+    }
+    unknown(key, params, input, candidates) {
+        const suggestion = closest(input, candidates);
+        return new UsageError(key, suggestion === undefined ? params : { ...params, hint: message("core.usage.did-you-mean", { suggestion }) });
+    }
+    report(commandId, result, flags, cwd, out, err, view) {
+        const failures = result.kind === "done" ? result.failures : [];
+        if (flags.json) {
+            this.print(this.deps.stdout, [resultJson(commandId, result, this.translator)]);
+        }
+        else {
+            this.print(this.deps.stdout, view(result.data, new CliViewFormat(this.translator, out, cwd)));
+            for (const warning of result.warnings)
+                this.print(this.deps.stderr, [err.yellow(this.translator.text(warning))]);
+            for (const failure of failures)
+                this.print(this.deps.stderr, [err.red(this.translator.text(failure))]);
+            if (result.kind === "preview") {
+                const note = result.applyFlag === ""
+                    ? message("core.result.dry-run")
+                    : message("core.result.preview", { flag: result.applyFlag });
+                this.print(this.deps.stderr, [err.dim(this.translator.text(note))]);
+            }
+        }
+        return failures.length > 0 ? 1 : 0;
+    }
+    fail(error, flags, err) {
+        if (flags.json)
+            this.print(this.deps.stdout, [errorJson(error, this.translator)]);
+        if (error instanceof KiriyaError) {
+            if (!flags.json) {
+                const hint = error.detail.params["hint"];
+                const lines = [
+                    `${err.red(this.translator.text(message("core.error.label")))}: ${this.translator.text(error.detail)}`,
+                ];
+                if (hint !== undefined && typeof hint === "object")
+                    lines.push(this.translator.text(hint));
+                this.print(this.deps.stderr, lines);
+            }
+            if (flags.debug && error.cause !== undefined) {
+                this.print(this.deps.stderr, [String(error.cause.stack ?? error.cause)]);
+            }
+            return EXIT_CODES[error.kind];
+        }
+        if (!flags.json) {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.print(this.deps.stderr, [err.red(this.translator.text(message("core.error.unexpected", { detail })))]);
+            if (flags.debug && error instanceof Error && error.stack !== undefined) {
+                this.print(this.deps.stderr, [error.stack]);
+            }
+        }
+        return 1;
+    }
+    print(stream, lines) {
+        if (lines.length > 0)
+            stream.write(`${lines.join("\n")}\n`);
+        return 0;
+    }
+}
+//# sourceMappingURL=cli-application.js.map

package/dist/src/core/presentation/cli/cli-view-format.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { formatBytes } from "../../domain/values/bytes.js";
+export class CliViewFormat {
+    translator;
+    style;
+    cwd;
+    constructor(translator, style, cwd) {
+        this.translator = translator;
+        this.style = style;
+        this.cwd = cwd;
+    }
+    text(value) {
+        return this.translator.text(value);
+    }
+    bold(text) {
+        return this.style.bold(text);
+    }
+    dim(text) {
+        return this.style.dim(text);
+    }
+    red(text) {
+        return this.style.red(text);
+    }
+    green(text) {
+        return this.style.green(text);
+    }
+    yellow(text) {
+        return this.style.yellow(text);
+    }
+    bytes(count) {
+        return formatBytes(count);
+    }
+    /** Local time as YYYY-MM-DD HH:MM. */
+    time(epochMs) {
+        const date = new Date(epochMs);
+        const pad = (value) => String(value).padStart(2, "0");
+        return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+    }
+    path(absolutePath) {
+        const relative = path.relative(this.cwd, absolutePath);
+        if (relative === "")
+            return ".";
+        return relative.startsWith("..") || path.isAbsolute(relative) ? absolutePath : relative;
+    }
+}
+//# sourceMappingURL=cli-view-format.js.map

package/dist/src/core/presentation/cli/help.js

@@ -0,0 +1,202 @@
+import { GLOBAL_OPTIONS } from "../../domain/global-options.js";
+import { message } from "../../domain/message.js";
+/** The list of modules and their guides, for main help to point to. */
+const GUIDES = "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/README.md";
+/** Prose reads best in a column this wide, even in a much wider terminal. */
+const PARAGRAPH_WIDTH = 80;
+/** The width prose wraps to: the terminal when it is narrower than a comfortable column, else 80. */
+function proseWidth(context) {
+    return context.width === undefined ? PARAGRAPH_WIDTH : Math.min(context.width, PARAGRAPH_WIDTH);
+}
+function globalLabel(option) {
+    return option.short === null ? `--${option.name}` : `-${option.short}, --${option.name}`;
+}
+/**
+ * A `--flag` in cyan and a `<value>` in yellow, so an option and its argument stand out in a
+ * usage line. Every other character, brackets and spaces included, is left exactly as it was,
+ * so with colour off the string is unchanged and stays safe to measure and to pad.
+ */
+function colorize(text, style) {
+    return text.replace(/(--?[A-Za-z][\w-]*)|(<[^>]*>)/g, (_match, flag, value) => flag !== undefined ? style.cyan(flag) : style.yellow(value ?? ""));
+}
+function table(rows, options = {}) {
+    const nameWidth = Math.max(0, ...rows.map(([left]) => left.length));
+    const start = 2 + nameWidth + 2;
+    const lines = [];
+    for (const [left, right] of rows) {
+        const name = options.paint === undefined ? left : options.paint(left);
+        const padding = " ".repeat(nameWidth - left.length);
+        const wrapped = options.width === undefined ? [right] : wrap(right, Math.max(20, options.width - start));
+        lines.push(`  ${name}${padding}  ${wrapped[0] ?? ""}`);
+        for (const line of wrapped.slice(1))
+            lines.push(`${" ".repeat(start)}${line}`);
+    }
+    return lines;
+}
+/** Text broken between words into lines of at most `width` characters, unless one word is longer. */
+function wrap(text, width) {
+    const lines = [];
+    let line = "";
+    for (const word of text.split(/\s+/)) {
+        if (word === "")
+            continue;
+        if (line === "") {
+            line = word;
+        }
+        else if (line.length + 1 + word.length > width) {
+            lines.push(line);
+            line = word;
+        }
+        else {
+            line = `${line} ${word}`;
+        }
+    }
+    return line === "" ? lines : [...lines, line];
+}
+/** A paragraph of prose, always wrapped for readability (the module `about` text). */
+function paragraph(text, context) {
+    return wrap(text, proseWidth(context));
+}
+/**
+ * A line of prose that was one line before: wrapped only to a known terminal width, and left
+ * whole for piped output, so a script or a doc reads the summary and each hint on one line.
+ */
+function flow(text, context) {
+    return context.width === undefined ? [text] : wrap(text, proseWidth(context));
+}
+/** A small wordmark for a terminal: the name in a rounded box, then the version. */
+function wordmark(context) {
+    const { style } = context;
+    const inner = "  kiriya  ";
+    const bar = "─".repeat(inner.length);
+    return [
+        style.cyan(`╭${bar}╮`),
+        `${style.cyan("│  ")}${style.bold(style.cyan("kiriya"))}${style.cyan("  │")}`,
+        style.cyan(`╰${bar}╯`),
+        style.dim(`v${context.version}`),
+    ];
+}
+/** `-i, --ignore-case` or `--to <file>`, as help and the generated docs show an option. */
+export function optionLabel(name, spec) {
+    const value = spec.type === "string" ? ` ${spec.valueName ?? "<value>"}` : "";
+    const short = spec.short === undefined ? "" : `-${spec.short}, `;
+    return `${short}--${name}${value}`;
+}
+/** `kiriya files list`, or `kiriya doctor` for a module that is one command. */
+function commandName(module, entry) {
+    return ["kiriya", module.id, entry.verb].filter((part) => part !== "").join(" ");
+}
+/** How a command is typed, such as `kiriya files delete <paths...> [options]`. */
+export function usageLine(module, entry) {
+    const { input } = entry.command.spec;
+    const positionals = input.positionals.map((positional) => {
+        const label = positional.variadic ? `${positional.name}...` : positional.name;
+        return positional.required ? `<${label}>` : `[${label}]`;
+    });
+    const options = Object.keys(input.options).length > 0 ? ["[options]"] : [];
+    return [commandName(module, entry), ...positionals, ...options].join(" ");
+}
+function aboutLines(module, context) {
+    return module.about === null ? [] : ["", ...paragraph(context.translator.text(message(module.about)), context)];
+}
+function exampleLines(examples, context) {
+    if (examples.length === 0)
+        return [];
+    const heading = context.style.bold(context.translator.text(message("core.help.examples")));
+    return ["", heading, ...examples.map((example) => `  ${colorize(example, context.style)}`)];
+}
+function guideLines(module, context) {
+    return module.guide === null
+        ? []
+        : flow(context.translator.text(message("core.help.guide", { address: module.guide })), context);
+}
+/** An options table, its labels coloured and its descriptions wrapped to the terminal. */
+function optionsTable(options, context) {
+    return table(Object.entries(options).map(([name, spec]) => [optionLabel(name, spec), context.translator.text(message(spec.description))]), { width: context.width, paint: (label) => colorize(label, context.style) });
+}
+function argumentsTable(input, context) {
+    return table(input.positionals.map((positional) => [positional.name, context.translator.text(message(positional.description))]), { width: context.width, paint: (name) => context.style.yellow(name) });
+}
+export function mainHelp(modules, context) {
+    const { translator, style } = context;
+    const heading = context.logo === true ? wordmark(context) : [`${style.bold("kiriya")} ${context.version}`];
+    return [
+        ...heading,
+        ...flow(translator.text(message("core.app.summary")), context),
+        "",
+        style.bold(translator.text(message("core.help.usage"))),
+        `  ${colorize("kiriya <module> <command> [arguments] [options]", style)}`,
+        "",
+        style.bold(translator.text(message("core.help.modules"))),
+        ...table(modules.map((module) => [module.id, translator.text(message(module.summary))]), { width: context.width, paint: (id) => style.green(id) }),
+        "",
+        style.bold(translator.text(message("core.help.global-options"))),
+        ...table(GLOBAL_OPTIONS.map((option) => [globalLabel(option), translator.text(message(option.description))]), { width: context.width, paint: (label) => colorize(label, style) }),
+        "",
+        ...flow(translator.text(message("core.help.module-hint", { command: "kiriya help <module>" })), context),
+        ...flow(translator.text(message("core.help.mcp-hint", { command: "kiriya mcp --help" })), context),
+        ...flow(translator.text(message("core.help.guides", { address: GUIDES })), context),
+    ];
+}
+/** `kiriya mcp`, which serves the commands to AI agents instead of being one of them. */
+export function mcpHelp(input, context) {
+    const { translator, style } = context;
+    return [
+        `${style.bold("kiriya mcp")} — ${translator.text(message("core.mcp.summary"))}`,
+        "",
+        style.bold(translator.text(message("core.help.usage"))),
+        `  ${colorize("kiriya mcp [folders...] [--root <folder>]...", style)}`,
+        "",
+        style.bold(translator.text(message("core.help.arguments"))),
+        ...argumentsTable(input, context),
+        "",
+        style.bold(translator.text(message("core.help.options"))),
+        ...optionsTable(input.options, context),
+        "",
+        ...flow(translator.text(message("core.mcp.help-details")), context),
+    ];
+}
+export function moduleHelp(module, context) {
+    const { translator, style } = context;
+    const commands = [...module.commands.values()]
+        .filter((entry) => entry.verb !== "")
+        .sort((a, b) => (a.verb < b.verb ? -1 : a.verb > b.verb ? 1 : 0));
+    return [
+        `${style.bold(`kiriya ${module.id}`)} — ${translator.text(message(module.summary))}`,
+        ...aboutLines(module, context),
+        "",
+        style.bold(translator.text(message("core.help.commands"))),
+        ...table(commands.map((entry) => [entry.verb, translator.text(message(entry.command.spec.summary))]), { width: context.width, paint: (verb) => style.green(verb) }),
+        ...exampleLines(module.examples, context),
+        "",
+        ...guideLines(module, context),
+        ...flow(translator.text(message("core.help.command-hint", { command: `kiriya help ${module.id} <command>` })), context),
+    ];
+}
+export function commandHelp(module, entry, context) {
+    const { translator, style } = context;
+    const { spec } = entry.command;
+    // A module that is one command has no help of its own, so its command's help also explains the module.
+    const own = entry.verb === "";
+    const lines = [
+        `${style.bold(commandName(module, entry))} — ${translator.text(message(spec.summary))}`,
+        ...(own ? aboutLines(module, context) : []),
+        "",
+        style.bold(translator.text(message("core.help.usage"))),
+        `  ${colorize(usageLine(module, entry), style)}`,
+    ];
+    if (spec.input.positionals.length > 0) {
+        lines.push("", style.bold(translator.text(message("core.help.arguments"))));
+        lines.push(...argumentsTable(spec.input, context));
+    }
+    if (Object.keys(spec.input.options).length > 0) {
+        lines.push("", style.bold(translator.text(message("core.help.options"))));
+        lines.push(...optionsTable(spec.input.options, context));
+    }
+    lines.push(...exampleLines(spec.examples, context));
+    const guide = own ? guideLines(module, context) : [];
+    if (guide.length > 0)
+        lines.push("", ...guide);
+    return lines;
+}
+//# sourceMappingURL=help.js.map

package/dist/src/core/presentation/cli/json-output.js

@@ -0,0 +1,28 @@
+import { KiriyaError } from "../../domain/errors.js";
+import { isMessage } from "../../domain/message.js";
+/**
+ * JSON keeps every message's key and parameters, so scripts never depend on wording,
+ * and adds its text. Nested messages in parameters get the same treatment on the way down.
+ */
+function stringify(value, translator) {
+    return JSON.stringify(value, (_key, item) => isMessage(item) && !("text" in item) ? { key: item.key, params: item.params, text: translator.text(item) } : item, 2);
+}
+export function resultJson(commandId, result, translator) {
+    const failures = result.kind === "done" ? result.failures : [];
+    return stringify({
+        ok: failures.length === 0,
+        command: commandId,
+        kind: result.kind,
+        ...(result.kind === "preview" ? { applyFlag: result.applyFlag } : {}),
+        data: result.data,
+        warnings: result.warnings,
+        failures,
+    }, translator);
+}
+export function errorJson(error, translator) {
+    if (error instanceof KiriyaError) {
+        return stringify({ ok: false, error: { kind: error.kind, message: error.detail } }, translator);
+    }
+    return stringify({ ok: false, error: { kind: "unexpected", message: String(error) } }, translator);
+}
+//# sourceMappingURL=json-output.js.map

package/dist/src/core/presentation/cli/style.js

@@ -0,0 +1,21 @@
+import { styleText } from "node:util";
+const plain = (text) => text;
+/**
+ * Colour through util.styleText, which already turns it off for a stream that is
+ * not a terminal, for NO_COLOR and NODE_DISABLE_COLORS, and on for FORCE_COLOR.
+ * `enabled` adds kiriya's own switches: --no-color, KIRIYA_NO_COLOR and TERM=dumb.
+ */
+export function createStyle(enabled, stream) {
+    if (!enabled)
+        return { bold: plain, dim: plain, red: plain, green: plain, yellow: plain, cyan: plain };
+    const paint = (format) => (text) => styleText(format, text, { stream });
+    return {
+        bold: paint("bold"),
+        dim: paint("dim"),
+        red: paint("red"),
+        green: paint("green"),
+        yellow: paint("yellow"),
+        cyan: paint("cyan"),
+    };
+}
+//# sourceMappingURL=style.js.map

package/dist/src/core/presentation/cli/suggest.js

@@ -0,0 +1,25 @@
+function distance(a, b) {
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        let diagonal = previous[0] ?? 0;
+        previous[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const above = previous[j] ?? 0;
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            previous[j] = Math.min(above + 1, (previous[j - 1] ?? 0) + 1, diagonal + cost);
+            diagonal = above;
+        }
+    }
+    return previous[b.length] ?? 0;
+}
+/** The closest known name within two edits, for "did you mean". */
+export function closest(input, candidates) {
+    let best;
+    for (const candidate of candidates) {
+        const score = distance(input.toLowerCase(), candidate.toLowerCase());
+        if (score <= 2 && (best === undefined || score < best.score))
+            best = { name: candidate, score };
+    }
+    return best?.name;
+}
+//# sourceMappingURL=suggest.js.map

package/dist/src/core/presentation/cli/terminal-confirmation.js

@@ -0,0 +1,63 @@
+import { createInterface } from "node:readline/promises";
+import { InterruptedError } from "../../domain/errors.js";
+import { message } from "../../domain/message.js";
+export class TerminalConfirmation {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async approve(question, assumeYes) {
+        if (assumeYes)
+            return true;
+        if (!this.options.interactive) {
+            this.write(this.text(message("core.confirm.no-terminal-yes")));
+            return false;
+        }
+        const answer = await this.ask(`${this.text(question)} ${this.text(message("core.confirm.yes-no"))} `);
+        return answer.trim().toLowerCase() === "y";
+    }
+    async typed(warning, expected, provided) {
+        if (provided !== undefined)
+            return provided === expected;
+        if (!this.options.interactive) {
+            this.write(this.text(message("core.confirm.no-terminal-typed", { flag: `--confirm=${expected}` })));
+            return false;
+        }
+        this.write(`${this.options.style.red(this.text(message("core.confirm.cannot-undo")))} ${this.text(warning)}`);
+        const answer = await this.ask(`${this.text(message("core.confirm.type", { expected: this.options.style.bold(expected) }))} `);
+        return answer.trim() === expected;
+    }
+    text(value) {
+        return this.options.translator.text(value);
+    }
+    write(line) {
+        this.options.output.write(`${line}\n`);
+    }
+    /** Ctrl+C at the prompt interrupts the command; input that ends without an answer declines. */
+    async ask(prompt) {
+        const readline = createInterface({ input: this.options.input, output: this.options.output });
+        const controller = new AbortController();
+        let interrupted = false;
+        readline.once("SIGINT", () => {
+            interrupted = true;
+            controller.abort();
+        });
+        readline.once("close", () => controller.abort());
+        try {
+            return await readline.question(prompt, { signal: controller.signal });
+        }
+        catch (error) {
+            if (interrupted) {
+                this.options.output.write("\n");
+                throw new InterruptedError("core.error.interrupted");
+            }
+            if (controller.signal.aborted)
+                return "";
+            throw error;
+        }
+        finally {
+            readline.close();
+        }
+    }
+}
+//# sourceMappingURL=terminal-confirmation.js.map

package/dist/src/core/presentation/ended-processes.js

@@ -0,0 +1,18 @@
+import { message } from "../domain/message.js";
+/** One line per process that ended; the others arrive as failures and warnings. */
+export function endedLines(processes, format) {
+    return processes
+        .filter((entry) => entry.outcome === "ended")
+        .map((entry) => format.green(format.text(message("core.end.ended", { name: entry.name ?? "?", pid: entry.pid }))));
+}
+/** Rows as aligned columns two spaces apart; the last column is not padded, so long text can run on. */
+export function columns(rows) {
+    const widths = [];
+    for (const row of rows) {
+        row.forEach((cell, index) => {
+            widths[index] = Math.max(widths[index] ?? 0, cell.length);
+        });
+    }
+    return rows.map((row) => `  ${row.map((cell, index) => (index === row.length - 1 ? cell : cell.padEnd(widths[index] ?? 0))).join("  ")}`.trimEnd());
+}
+//# sourceMappingURL=ended-processes.js.map

package/dist/src/core/presentation/i18n/translator.js

@@ -0,0 +1,23 @@
+import { isMessage } from "../../domain/message.js";
+const PLACEHOLDER = /\{([A-Za-z0-9]+)\}/g;
+/**
+ * Turns messages into text; nested messages in parameters are translated too. The
+ * catalog is kiriya's own plus the messages of loaded plugins, so a key missing from
+ * it is shown as the key rather than failing.
+ */
+export class Translator {
+    catalog;
+    constructor(catalog) {
+        this.catalog = catalog;
+    }
+    text(value) {
+        const template = this.catalog[value.key] ?? value.key;
+        return template.replace(PLACEHOLDER, (whole, name) => {
+            const param = value.params[name];
+            if (param === undefined)
+                return whole;
+            return isMessage(param) ? this.text(param) : String(param);
+        });
+    }
+}
+//# sourceMappingURL=translator.js.map

package/dist/src/core/presentation/list-preview.js

@@ -0,0 +1,10 @@
+import { message } from "../domain/message.js";
+/** The first `limit` items as lines, then one line saying how many more there are. */
+export function previewLines(items, limit, render, format) {
+    const lines = items.slice(0, limit).map(render);
+    if (items.length > limit) {
+        lines.push(format.dim(format.text(message("core.list.more", { count: items.length - limit }))));
+    }
+    return lines;
+}
+//# sourceMappingURL=list-preview.js.map