kiriya 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -7,6 +7,33 @@ output shapes are kiriya's public API.
 
 ## [Unreleased]
 
+## [0.1.3] - 2026-10-03
+
+### Added
+
+- `self-update` asks npm's registry whether a newer kiriya exists, and installs it with
+  `--apply`. Without `--apply` nothing changes, so it is safe to run just to find out.
+  It names the exact version the registry answered with rather than `latest`, never offers
+  a prerelease, and refuses to run npm over an install npm did not make, such as a source
+  checkout or a future Homebrew tap. It is never offered to AI agents: an agent must not
+  upgrade, mid-session, the tool it is calling.
+- `doctor` ends with a line naming `self-update`. It still reaches no network itself —
+  until now nothing told anyone that a newer version existed at all.
+
+## [0.1.2] - 2026-09-24
+
+### Changed
+
+- An option that takes one of a list of values now declares that list, so an MCP tool
+  offers it as a JSON Schema `enum` instead of naming it only in prose an agent would have
+  to read. Eleven options gained one: `files list --sort`, `files find --type`,
+  `files hash --algo`, `files info --hash`, `files rename --case` and `--only`,
+  `convert case --to`, `convert time --unit`, `gen token --format` and `net dns --type`.
+  Help and the generated reference are unchanged, since a declared list names itself.
+- Tab completion reads the same list, rather than parsing the value name it was displayed
+  under. `docker logs --tail <n|all>` therefore offers nothing instead of offering `n`,
+  which was never a value it took.
+
 ## [0.1.1] - 2026-09-24
 
 ### Changed

package/README.md

@@ -87,6 +87,7 @@ option, what each does, and whether it can be undone.
 | [`open`](docs/modules/open.md) | Open a file or folder in its default application, or a web address in the browser. |
 | [`port`](docs/modules/port.md) | See which process listens on a TCP port, end it, or find a free port, the same on every OS. |
 | [`proc`](docs/modules/proc.md) | List, find and end processes, and show them as a tree, the same on every OS. |
+| [`self-update`](docs/modules/self-update.md) | Ask the registry whether a newer kiriya exists, and install it with --apply. |
 | [`sys`](docs/modules/sys.md) | This machine and the developer tools on it, described the same way on every OS. |
 | [`wait`](docs/modules/wait.md) | Wait until a port listens, a web address answers or a file appears, the same way on every OS. |
 <!-- /kiriya:modules -->

package/dist/src/config/modules.js

@@ -13,6 +13,7 @@ import { netModule } from "../modules/net/net.module.js";
 import { openModule } from "../modules/open/open.module.js";
 import { portModule } from "../modules/port/port.module.js";
 import { procModule } from "../modules/proc/proc.module.js";
+import { selfUpdateModule } from "../modules/self-update/self-update.module.js";
 import { sysModule } from "../modules/sys/sys.module.js";
 import { waitModule } from "../modules/wait/wait.module.js";
 /** Built-in modules, in no particular order; help lists them sorted. Adding a module is one line here. */
@@ -34,5 +35,6 @@ export const BUILT_IN_MODULES = [
     openModule,
     completionModule,
     waitModule,
+    selfUpdateModule,
 ];
 //# sourceMappingURL=modules.js.map

package/dist/src/core/infrastructure/node/node-network.adapter.js

@@ -141,6 +141,61 @@ export class NodeNetworkAdapter {
             outgoing.end();
         });
     }
+    fetchText(url, timeoutMs, maxBytes, signal) {
+        if (signal.aborted)
+            return Promise.reject(new InterruptedError("core.error.interrupted"));
+        return new Promise((resolve, reject) => {
+            const started = performance.now();
+            const elapsed = () => Math.round(performance.now() - started);
+            const target = new URL(url);
+            const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+            const outgoing = send(target, {
+                method: "GET",
+                headers: { "user-agent": "kiriya", accept: "application/json" },
+            });
+            let settled = false;
+            const settle = (outcome) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener("abort", onAbort);
+                outgoing.destroy();
+                if (outcome === null)
+                    reject(new InterruptedError("core.error.interrupted"));
+                else
+                    resolve(outcome);
+            };
+            const onAbort = () => settle(null);
+            const timer = setTimeout(() => settle({ ok: false, failure: "timeout", status: null, code: null, ms: elapsed() }), timeoutMs);
+            signal.addEventListener("abort", onAbort, { once: true });
+            outgoing.once("response", (response) => {
+                const status = response.statusCode ?? 0;
+                const chunks = [];
+                let size = 0;
+                response.on("data", (chunk) => {
+                    size += chunk.length;
+                    // Stop at the limit instead of holding whatever the other end decides to send.
+                    if (size > maxBytes) {
+                        response.destroy();
+                        settle({ ok: false, failure: "too-large", status, code: null, ms: elapsed() });
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                response.once("end", () => settle({ ok: true, status, body: Buffer.concat(chunks).toString("utf8"), ms: elapsed() }));
+                response.once("error", (error) => {
+                    const code = errorCode(error);
+                    settle({ ok: false, failure: httpFailure(code), status, code, ms: elapsed() });
+                });
+            });
+            outgoing.on("error", (error) => {
+                const code = errorCode(error);
+                settle({ ok: false, failure: httpFailure(code), status: null, code, ms: elapsed() });
+            });
+            outgoing.end();
+        });
+    }
     async lookup(name) {
         try {
             const found = await systemLookup(name, { all: true });

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

@@ -85,7 +85,8 @@ function wordmark(context) {
 }
 /** `-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 named = spec.valueName ?? (spec.choices === undefined ? "<value>" : `<${spec.choices.join("|")}>`);
+    const value = spec.type === "string" ? ` ${named}` : "";
     const short = spec.short === undefined ? "" : `-${spec.short}, `;
     return `${short}--${name}${value}`;
 }

package/dist/src/core/presentation/mcp/tool-definitions.js

@@ -65,13 +65,15 @@ export function inputSchemaOf(commandId, input, translator, access = READING) {
     }
     for (const [name, option] of toolOptions(input, access)) {
         const text = translator.text(message(option.description));
+        // Choices belong in the enum, where a client can act on them, rather than in prose it must read.
         const description = option.valueName === undefined ? text : `${text} ${option.valueName}`;
+        const choices = option.choices === undefined ? {} : { enum: [...option.choices] };
         if (option.type === "boolean")
             claim(name, { type: "boolean", description });
         else if (option.multiple === true)
-            claim(name, { type: "array", items: { type: "string" }, description });
+            claim(name, { type: "array", items: { type: "string", ...choices }, description });
         else
-            claim(name, { type: "string", description });
+            claim(name, { type: "string", ...choices, description });
     }
     return { type: "object", properties, ...(required.length > 0 ? { required } : {}), additionalProperties: false };
 }

package/dist/src/i18n/locales/en.js

@@ -390,6 +390,7 @@ export const en = {
     "doctor.status.warn": "warn",
     "doctor.status.fail": "fail",
     "doctor.check.kiriya": "{version}",
+    "doctor.newer": "doctor asks no network. Run kiriya self-update to see whether a newer version is out.",
     "doctor.check.node": "{version}",
     "doctor.check.node-old": "Node.js {version} is older than {minimum}, the oldest release kiriya supports",
     "doctor.check.os": "{os}",
@@ -666,6 +667,24 @@ export const en = {
     "wait.file.gone": "{path} is gone, after {seconds} s",
     "wait.file.timed-out": "{path} did not appear within {seconds} s",
     "wait.file.still-there": "{path} was still there after {seconds} s",
+    "self-update.summary": "Ask the registry whether a newer kiriya exists, and install it with --apply",
+    "self-update.about": "Asks npm's registry which version it serves as latest and compares it with this one. " +
+        "Without --apply it changes nothing, so it is safe to run just to find out. With --apply " +
+        "it installs the newer version with npm, and refuses when npm was not what installed " +
+        "kiriya in the first place. This is the only command that reaches the network for a " +
+        "reason other than the one you asked for, which is why it has to be run on purpose: " +
+        "nothing in kiriya checks for updates by itself. A prerelease is never offered.",
+    "self-update.option.apply": "Install the newer version; without it nothing changes",
+    "self-update.current": "kiriya {version} is the newest version",
+    "self-update.available": "kiriya {latest} is out; this is {installed}",
+    "self-update.how-apply": "Run kiriya self-update --apply to install it.",
+    "self-update.how-elsewhere": "npm did not install this kiriya, so update it the way you installed it, to {latest}.",
+    "self-update.applied": "Updated to kiriya {version}",
+    "self-update.unreachable": "The registry could not be reached ({failure}), so the newest version is unknown",
+    "self-update.unreadable": "The registry answered {status}, which does not say which version is latest",
+    "self-update.not-npm": "kiriya {latest} is out, but npm did not install this one, so npm will not replace it",
+    "self-update.no-npm": "npm is not on PATH, so the newer version cannot be installed",
+    "self-update.failed": "npm could not install the newer version (exit code {code}): {detail}",
     "core.processes.failed": "{program} could not list processes (exit code {code}): {detail}",
     "core.processes.unreadable": "Processes could not be read from {source}: {detail}",
     "core.ports.failed": "{program} could not list listening ports (exit code {code}): {detail}",

package/dist/src/main.js

@@ -5,6 +5,7 @@
  */
 import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { BUILT_IN_MODULES } from "./config/modules.js";
 import { CommandRegistry } from "./core/application/command-registry.js";
 import { pluginEntries } from "./core/application/config-values.js";
@@ -124,7 +125,12 @@ const ports = {
     protectedPaths: new PathGuard(environment),
     config,
     plugins,
-    runtime: { kiriyaVersion: version, nodeVersion: process.version },
+    runtime: {
+        kiriyaVersion: version,
+        nodeVersion: process.version,
+        // dist/src/main.js, so two levels up is the folder holding package.json.
+        installDirectory: fileURLToPath(new URL("../../", import.meta.url)),
+    },
 };
 for (const module of BUILT_IN_MODULES)
     registry.register(module, ports);

package/dist/src/modules/completion/domain/suggest.js

@@ -1,7 +1,11 @@
-/** The values an option lists in its value name, such as `<hex|base64|base64url>`. */
+/**
+ * The values an option takes, when it takes only a list of them. It reads the list the
+ * command declares, rather than parsing the value name it is displayed under, so an option
+ * whose value name merely looks like a list — `--tail <n|all>`, a number or a word — offers
+ * nothing instead of offering `n`.
+ */
 export function optionChoices(option) {
-    const match = /^<([a-z0-9-]+(?:\|[a-z0-9-]+)+)>$/.exec(option.valueName ?? "");
-    return match?.[1]?.split("|") ?? [];
+    return option.choices === undefined ? [] : [...option.choices];
 }
 function ownCommand(module) {
     return module.commands.find((command) => command.verb === "");

package/dist/src/modules/convert/application/convert-case.use-case.js

@@ -11,7 +11,7 @@ export const caseSpec = {
     input: {
         positionals: [valuePositional],
         options: {
-            to: { type: "string", description: "convert.case.option.to", valueName: `<${TEXT_CASES.join("|")}>` },
+            to: { type: "string", description: "convert.case.option.to", choices: TEXT_CASES },
             file: fileOption,
         },
         parse(raw) {

package/dist/src/modules/convert/application/convert-time.use-case.js

@@ -16,7 +16,7 @@ export const timeSpec = {
     idempotent: false,
     input: {
         positionals: [{ name: "value", description: "convert.time.arg.value", required: false, variadic: false }],
-        options: { unit: { type: "string", description: "convert.time.option.unit", valueName: "<auto|seconds|ms>" } },
+        options: { unit: { type: "string", description: "convert.time.option.unit", choices: EPOCH_UNITS } },
         parse(raw) {
             const reader = new RawReader(raw);
             return { value: reader.positional(0), unit: reader.choice("unit", EPOCH_UNITS, "auto") };

package/dist/src/modules/doctor/presentation/doctor.view.js

@@ -16,6 +16,9 @@ export const doctorView = (output, format) => {
         const status = format.text(message(STATUS_KEYS[check.status])).padEnd(statusWidth);
         return `  ${paint(check.status, status, format)}  ${check.name.padEnd(nameWidth)}  ${format.text(check.detail)}`;
     });
+    // doctor reaches no network, so it cannot know whether this version is behind. It says where
+    // to find out instead, because nothing else told anyone that a newer kiriya exists.
+    lines.push("", format.dim(format.text(message("doctor.newer"))));
     if (output.plugins.length > 0) {
         lines.push("", format.bold(format.text(message("doctor.plugins"))));
         const idWidth = Math.max(...output.plugins.map((plugin) => plugin.id.length));

package/dist/src/modules/files/application/find-files.use-case.js

@@ -26,7 +26,7 @@ export const findSpec = {
         options: {
             name: { type: "string", description: "files.find.option.name", valueName: "<glob>" },
             ext: { type: "string", description: "files.find.option.ext", valueName: "<extensions>", multiple: true },
-            type: { type: "string", description: "files.find.option.type", valueName: "<file|dir>" },
+            type: { type: "string", description: "files.find.option.type", choices: FIND_TYPES },
             larger: { type: "string", description: "files.find.option.larger", valueName: "<size>" },
             smaller: { type: "string", description: "files.find.option.smaller", valueName: "<size>" },
             newer: { type: "string", description: "files.find.option.newer", valueName: "<time>" },

package/dist/src/modules/files/application/hash-files.use-case.js

@@ -19,7 +19,7 @@ export const hashSpec = {
     input: {
         positionals: [{ name: "paths", description: "files.hash.arg.paths", required: true, variadic: true, path: true }],
         options: {
-            algo: { type: "string", description: "files.hash.option.algo", valueName: `<${HASH_ALGORITHMS.join("|")}>` },
+            algo: { type: "string", description: "files.hash.option.algo", choices: HASH_ALGORITHMS },
             check: { type: "string", description: "files.hash.option.check", valueName: "<hex>" },
         },
         parse(raw) {

package/dist/src/modules/files/application/list-entries.use-case.js

@@ -16,7 +16,7 @@ export const listSpec = {
         positionals: [{ name: "path", description: "files.list.arg.path", required: false, variadic: false, path: true }],
         options: {
             all: { type: "boolean", description: "files.option.all" },
-            sort: { type: "string", description: "files.list.option.sort", valueName: "<name|size|time>" },
+            sort: { type: "string", description: "files.list.option.sort", choices: LIST_SORTS },
             reverse: { type: "boolean", description: "files.list.option.reverse" },
         },
         parse(raw) {

package/dist/src/modules/files/application/rename-paths.use-case.js

@@ -27,11 +27,11 @@ export const renameSpec = {
             { name: "paths", description: "files.rename.arg.paths", required: false, variadic: true, path: true },
         ],
         options: {
-            case: { type: "string", description: "files.rename.option.case", valueName: `<${CASE_STYLES.join("|")}>` },
+            case: { type: "string", description: "files.rename.option.case", choices: CASE_STYLES },
             find: { type: "string", description: "files.rename.option.find", valueName: "<text>" },
             with: { type: "string", description: "files.rename.option.with", valueName: "<text>" },
             recursive: { type: "boolean", description: "files.rename.option.recursive" },
-            only: { type: "string", description: "files.rename.option.only", valueName: "<files|dirs>" },
+            only: { type: "string", description: "files.rename.option.only", choices: ONLY },
             apply: { type: "boolean", description: "files.rename.option.apply" },
             yes: { type: "boolean", description: "files.rename.option.yes", short: "y", terminalOnly: true },
         },

package/dist/src/modules/files/application/show-info.use-case.js

@@ -28,7 +28,7 @@ export const infoSpec = {
     input: {
         positionals: [{ name: "paths", description: "files.info.arg.paths", required: true, variadic: true, path: true }],
         options: {
-            hash: { type: "string", description: "files.info.option.hash", valueName: `<${HASH_ALGORITHMS.join("|")}>` },
+            hash: { type: "string", description: "files.info.option.hash", choices: HASH_ALGORITHMS },
         },
         parse(raw) {
             const reader = new RawReader(raw);

package/dist/src/modules/gen/application/generate-tokens.use-case.js

@@ -11,7 +11,7 @@ export const tokenSpec = {
         positionals: [],
         options: {
             bytes: { type: "string", description: "gen.token.option.bytes", valueName: "<n>" },
-            format: { type: "string", description: "gen.token.option.format", valueName: "<hex|base64|base64url>" },
+            format: { type: "string", description: "gen.token.option.format", choices: TOKEN_FORMATS },
             count: countOption,
         },
         parse(raw) {

package/dist/src/modules/net/application/lookup-name.use-case.js

@@ -16,7 +16,7 @@ export const dnsSpec = {
     input: {
         positionals: [{ name: "name", description: "net.dns.arg.name", required: true, variadic: false }],
         options: {
-            type: { type: "string", description: "net.dns.option.type", valueName: `<${LOOKUP_TYPES.join("|")}>` },
+            type: { type: "string", description: "net.dns.option.type", choices: LOOKUP_TYPES },
         },
         parse(raw) {
             const reader = new RawReader(raw);

package/dist/src/modules/self-update/application/update-self.use-case.js

@@ -0,0 +1,86 @@
+import { done } from "../../../core/domain/command.js";
+import { CapabilityUnavailableError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { installSource } from "../domain/install-source.js";
+import { compareVersions, parseVersion, readLatestVersion } from "../domain/versions.js";
+/** The registry entry for the version npm serves as `latest`. */
+export const LATEST_URL = "https://registry.npmjs.org/kiriya/latest";
+/** Long enough for a slow network, short enough that nobody waits on a broken one. */
+export const ASK_TIMEOUT_MS = 10_000;
+/** That endpoint answers a few kilobytes; a body past this is something else. */
+export const MAX_BODY_BYTES = 262_144;
+/** An npm install over a slow network outlasts the runner's default minute. */
+export const INSTALL_TIMEOUT_MS = 300_000;
+export const selfUpdateSpec = {
+    id: "self-update",
+    summary: "self-update.summary",
+    examples: ["kiriya self-update", "kiriya self-update --apply", "kiriya self-update --json"],
+    // It replaces an installed program, which a reinstall puts back.
+    safety: "write",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    // An agent must never upgrade, mid-session, the tool it is calling.
+    terminalOnly: true,
+    input: {
+        positionals: [],
+        options: {
+            apply: { type: "boolean", description: "self-update.option.apply" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { apply: reader.flag("apply") };
+        },
+    },
+};
+export class UpdateSelf {
+    network;
+    processRunner;
+    runtime;
+    spec = selfUpdateSpec;
+    constructor(network, processRunner, runtime) {
+        this.network = network;
+        this.processRunner = processRunner;
+        this.runtime = runtime;
+    }
+    async execute(input, context) {
+        const installed = this.runtime.kiriyaVersion;
+        const source = installSource(this.runtime.installDirectory);
+        const outcome = await this.network.fetchText(LATEST_URL, ASK_TIMEOUT_MS, MAX_BODY_BYTES, context.signal);
+        if (!outcome.ok) {
+            const data = { installed, latest: null, newer: false, source, applied: false };
+            return done(data, { failures: [message("self-update.unreachable", { failure: outcome.failure })] });
+        }
+        const latest = outcome.status === 200 ? readLatestVersion(outcome.body) : null;
+        if (latest === null) {
+            const data = { installed, latest: null, newer: false, source, applied: false };
+            return done(data, { failures: [message("self-update.unreadable", { status: outcome.status })] });
+        }
+        const here = parseVersion(installed);
+        const there = parseVersion(latest);
+        const newer = here !== null && there !== null && compareVersions(there, here) > 0;
+        const base = { installed, latest, newer, source };
+        if (!newer || !input.apply)
+            return done({ ...base, applied: false });
+        // Only npm put kiriya here, so only npm is asked to replace it.
+        if (source !== "npm") {
+            return done({ ...base, applied: false }, { failures: [message("self-update.not-npm", { latest })] });
+        }
+        const npm = await this.processRunner.find("npm");
+        if (npm === null)
+            throw new CapabilityUnavailableError("self-update.no-npm");
+        const result = await this.processRunner.run(npm, ["install", "--global", `kiriya@${latest}`], {
+            signal: context.signal,
+            // An install over a slow network outlasts the default minute.
+            timeoutMs: INSTALL_TIMEOUT_MS,
+            // Shown as it arrives, because this is the one command that can take a while.
+            onOutput: (text, stream) => context.passthrough.write(text, stream),
+        });
+        if (result.code !== 0) {
+            return done({ ...base, applied: false }, { failures: [message("self-update.failed", { code: result.code, detail: result.stderr.trim() })] });
+        }
+        return done({ ...base, applied: true });
+    }
+}
+//# sourceMappingURL=update-self.use-case.js.map

package/dist/src/modules/self-update/domain/install-source.js

@@ -0,0 +1,17 @@
+/** How this kiriya got onto the machine, which decides whether it may run a package manager. */
+export const INSTALL_SOURCES = ["npm", "elsewhere"];
+/**
+ * `npm` when kiriya's own files sit inside a `node_modules/kiriya` folder, which is where npm
+ * puts a package and nowhere else puts anything. A source checkout linked with `npm link`
+ * resolves to the repository instead, and a future Homebrew tap or single file would too, so
+ * both read as `elsewhere` and self-update refuses to run npm over them.
+ */
+export function installSource(installDirectory) {
+    const parts = installDirectory.replace(/\\/g, "/").split("/").filter(Boolean);
+    for (let index = 0; index + 1 < parts.length; index += 1) {
+        if (parts[index] === "node_modules" && parts[index + 1] === "kiriya")
+            return "npm";
+    }
+    return "elsewhere";
+}
+//# sourceMappingURL=install-source.js.map

package/dist/src/modules/self-update/domain/versions.js

@@ -0,0 +1,52 @@
+/** Comparing two released versions, and reading the newest one out of what a registry answers. */
+const PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+export function parseVersion(text) {
+    const match = PATTERN.exec(text.trim());
+    if (match === null)
+        return null;
+    const [, major, minor, patch, prerelease] = match;
+    return {
+        major: Number(major),
+        minor: Number(minor),
+        patch: Number(patch),
+        prerelease: prerelease ?? null,
+    };
+}
+/**
+ * Negative when `a` is older, positive when newer, zero when the same. A prerelease is older
+ * than the release it leads to, which is all kiriya needs: it never offers one as an upgrade.
+ */
+export function compareVersions(a, b) {
+    for (const part of ["major", "minor", "patch"]) {
+        if (a[part] !== b[part])
+            return a[part] - b[part];
+    }
+    if (a.prerelease === b.prerelease)
+        return 0;
+    if (a.prerelease === null)
+        return 1;
+    if (b.prerelease === null)
+        return -1;
+    return a.prerelease < b.prerelease ? -1 : 1;
+}
+/**
+ * The version the registry calls `latest`, from the body of
+ * `https://registry.npmjs.org/<name>/latest`. null when the body is not what that endpoint
+ * answers, so a proxy returning a login page is a failure rather than a version.
+ */
+export function readLatestVersion(body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return null;
+    const version = parsed.version;
+    if (typeof version !== "string")
+        return null;
+    return parseVersion(version) === null ? null : version;
+}
+//# sourceMappingURL=versions.js.map

package/dist/src/modules/self-update/presentation/self-update.view.js

@@ -0,0 +1,19 @@
+import { message } from "../../../core/domain/message.js";
+/** A version that could not be read arrives as a failure, so this prints nothing for it. */
+export const selfUpdateView = (output, format) => {
+    if (output.latest === null)
+        return [];
+    if (output.applied) {
+        return [format.green(format.text(message("self-update.applied", { version: output.latest })))];
+    }
+    if (!output.newer) {
+        return [format.text(message("self-update.current", { version: output.installed }))];
+    }
+    const found = format.text(message("self-update.available", { installed: output.installed, latest: output.latest }));
+    // Say what to type next, because finding out is the whole point of running this.
+    const next = output.source === "npm"
+        ? message("self-update.how-apply")
+        : message("self-update.how-elsewhere", { latest: output.latest });
+    return [format.green(found), format.dim(format.text(next))];
+};
+//# sourceMappingURL=self-update.view.js.map

package/dist/src/modules/self-update/self-update.module.js

@@ -0,0 +1,13 @@
+import { UpdateSelf } from "./application/update-self.use-case.js";
+import { selfUpdateView } from "./presentation/self-update.view.js";
+export const selfUpdateModule = {
+    id: "self-update",
+    summary: "self-update.summary",
+    about: "self-update.about",
+    // A module that is one command shows that command's examples, as doctor does.
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/self-update.md",
+    register(registrar, ports) {
+        registrar.add(new UpdateSelf(ports.network, ports.processRunner, ports.runtime), selfUpdateView);
+    },
+};
+//# sourceMappingURL=self-update.module.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiriya",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "One command-line toolbox for everyday developer work that behaves the same on Windows, Linux and macOS.",
   "mcpName": "io.github.SatPaingOo/kiriya",
   "license": "MIT",