kritya 0.8.26-beta → 0.8.28-beta

package/dist/ui/Spinner.js

@@ -1,12 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
-import { Text } from "ink";
+import { Text, useAnimation } from "ink";
 const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Milliseconds between frames — the spinner's twelve-frames-a-second beat. */
+const FRAME_INTERVAL_MS = 80;
+/**
+ * The spinner that turns beside the working… label. Ink drives this from one
+ * animation timer shared by the whole app — no private `setInterval` to own or
+ * clean up, and the beat comes from elapsed time, so a busy machine skips a
+ * frame instead of drifting late.
+ */
 export function Spinner({ label }) {
-    const [frame, setFrame] = useState(0);
-    useEffect(() => {
-        const timer = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), 80);
-        return () => clearInterval(timer);
-    }, []);
-    return (_jsxs(Text, { color: "yellow", children: [FRAMES[frame], " ", _jsx(Text, { dimColor: true, children: label })] }));
+    const { frame } = useAnimation({ interval: FRAME_INTERVAL_MS });
+    // `frame` counts up forever; the glyph list is what wraps it back around.
+    return (_jsxs(Text, { color: "yellow", children: [FRAMES[frame % FRAMES.length], " ", _jsx(Text, { dimColor: true, children: label })] }));
 }

package/dist/ui/StatusLine.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from "ink";
 import { displayModelId } from "../config/models.js";
 /**

package/dist/ui/StreamViewport.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "ink";
+import { streamRows } from "./viewport.js";
+/**
+ * Holds a streaming answer to the rows left under the live region, scrolling
+ * to its tail as it grows.
+ *
+ * Ink erases its live region by rewinding a line count, which can only reach
+ * what is still on screen. Let the streaming text grow past the terminal's
+ * height and the erase silently comes up short, stranding a partial copy in
+ * the scrollback — then the finished message prints below it and the answer
+ * appears twice. Capping the live region keeps the erase exact; the whole
+ * answer is printed once when the turn ends.
+ *
+ * This used to be done by hand: word-wrap every line to estimate the rows it
+ * would render at, then slice off the tail that didn't fit. Ink 8 renders
+ * `maxHeight` and `overflow="hidden"` natively, so the box does the capping.
+ *
+ * `justifyContent="flex-end"` is what pins the view to the tail: a column
+ * whose content overflows a capped height lines up against its end, keeping
+ * the newest text visible. It costs nothing while the answer still fits — the
+ * box is then only as tall as its content and the text grows downward as you
+ * would expect. `flexShrink={0}` on the content is what makes that work: Yoga
+ * would otherwise shrink the child back down to the cap, leaving the top on
+ * screen and the tail cut off.
+ */
+export function StreamViewport({ rows, children }) {
+    return (_jsx(Box, { flexDirection: "column", maxHeight: streamRows(rows), overflow: "hidden", justifyContent: "flex-end", marginBottom: 1, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, children: children }) }));
+}

package/dist/ui/TextInput.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef, useState } from "react";
+import { Box, Text, measureElement, useCursor, useInput, usePaste } from "ink";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+/**
+ * Where the caret lands in already-rendered text: the row and column the
+ * terminal cursor has to sit on once the text wraps.
+ *
+ * Wrapped with the very same call ink makes when it lays the text out
+ * (`wrapText` → `wrapAnsi(text, width, { trim: false, hard: true })`), so the
+ * two can't disagree about where a line breaks. Re-deriving the break point by
+ * dividing the column count would: `wrapAnsi` leaves the space that ends a
+ * wrapped line on that line, so a greedy wrapper lands the next line one column
+ * to the left and the caret drifts a cell per wrap.
+ *
+ * One deliberate approximation: a line that fills the width exactly reports
+ * `col === width`, i.e. the column just past its last character. That is where
+ * the terminal's own pending-wrap cursor sits, and the alternative — jumping to
+ * column 0 of the following row — is just as defensible and just as wrong the
+ * other half of the time.
+ */
+export function caretAt(before, width) {
+    const lines = wrapAnsi(before, Math.max(1, width), { trim: false, hard: true }).split("\n");
+    const last = lines[lines.length - 1] ?? "";
+    return { row: lines.length - 1, col: stringWidth(last) };
+}
+/**
+ * The prompt's text field.
+ *
+ * Hand-rolled rather than borrowed from ink-text-input, for two reasons that
+ * both come down to ink 8 finally exposing the terminal cursor. `useCursor`
+ * puts the *real* cursor at the caret, which is what an IME needs to place its
+ * composition popup — ink-text-input fakes the cursor with a reverse-video
+ * character, so typing Chinese, Japanese or Korean puts the popup in the wrong
+ * place. And `usePaste` turns on bracketed paste, so a pasted block arrives as
+ * one marked string we can normalize, instead of a run of raw keystrokes whose
+ * carriage returns survive into the prompt and into the message sent to the
+ * model.
+ */
+export function TextInput({ value, onChange, onSubmit, placeholder, mask, isActive = true, }) {
+    const [cursor, setCursorOffset] = useState(value.length);
+    const [origin, setOrigin] = useState(null);
+    const boxRef = useRef(null);
+    const { setCursorPosition } = useCursor();
+    // The caller owns the value, so it can move under us — cleared on submit,
+    // replaced by history recall. Clamping during render rather than in an effect
+    // keeps the caret correct in the same pass.
+    const offset = Math.min(cursor, value.length);
+    const display = mask ? mask.repeat(value.length) : value;
+    const beforeCaret = mask ? mask.repeat(offset) : display.slice(0, offset);
+    // Re-measure after every commit; setOrigin bails out when nothing moved, so
+    // a steady prompt re-renders zero extra times. Ink computes layout in
+    // resetAfterCommit, which runs *before* layout effects, so the first pass
+    // already sees a real layout. The zero check is belt and braces: a Box that
+    // genuinely has no room yet should leave the cursor hidden rather than pin it
+    // to the terminal origin.
+    useLayoutEffect(() => {
+        const node = boxRef.current;
+        if (!node)
+            return;
+        const { x, y, clientWidth } = measureElement(node);
+        if (clientWidth === 0)
+            return;
+        setOrigin((prev) => prev && prev.x === x && prev.y === y && prev.width === clientWidth
+            ? prev
+            : { x, y, width: clientWidth });
+    });
+    // Publishing the caret has to happen during render. useCursor() forwards it
+    // from an insertion effect, which runs *before* layout effects, so a position
+    // set from an effect would always reach the terminal one render late — and a
+    // cursor that trails the caret by a keystroke is worse than none for an IME.
+    if (isActive && origin) {
+        const { row, col } = caretAt(beforeCaret, Math.max(1, origin.width));
+        setCursorPosition({ x: origin.x + col, y: origin.y + row });
+    }
+    else {
+        setCursorPosition(undefined);
+    }
+    useInput((input, key) => {
+        // Ctrl/meta chords are the app's shortcuts (Ctrl+K kill switch, Ctrl+O
+        // verbose), never text. Swallowing them here is what stops them being
+        // typed into the box as a bare letter.
+        if (key.ctrl || key.meta)
+            return;
+        // Keys the surrounding app owns: up/down drive suggestions and history,
+        // Tab completes, Escape cancels.
+        if (key.upArrow || key.downArrow || key.tab || key.escape)
+            return;
+        if (key.return) {
+            onSubmit?.(value);
+            return;
+        }
+        if (key.leftArrow) {
+            setCursorOffset(Math.max(0, offset - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorOffset(Math.min(value.length, offset + 1));
+            return;
+        }
+        if (key.home) {
+            setCursorOffset(0);
+            return;
+        }
+        if (key.end) {
+            setCursorOffset(value.length);
+            return;
+        }
+        // Ink reports these separately — backspace is DEL, forward-delete is
+        // CSI 3~ — so they delete on opposite sides of the caret.
+        if (key.backspace) {
+            if (offset === 0)
+                return;
+            onChange(value.slice(0, offset - 1) + value.slice(offset));
+            setCursorOffset(offset - 1);
+            return;
+        }
+        if (key.delete) {
+            if (offset >= value.length)
+                return;
+            onChange(value.slice(0, offset) + value.slice(offset + 1));
+            return;
+        }
+        if (!input)
+            return;
+        // Bracketed paste normally routes to usePaste below. A terminal without
+        // it still delivers the block here, so normalize on both paths.
+        const inserted = input.replace(/\r\n?/g, "\n");
+        onChange(value.slice(0, offset) + inserted + value.slice(offset));
+        setCursorOffset(offset + inserted.length);
+    }, { isActive });
+    usePaste((text) => {
+        const inserted = text.replace(/\r\n?/g, "\n");
+        onChange(value.slice(0, offset) + inserted + value.slice(offset));
+        setCursorOffset(offset + inserted.length);
+    }, { isActive });
+    return (_jsx(Box, { ref: boxRef, flexGrow: 1, children: value.length === 0 && placeholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : (_jsx(Text, { children: display })) }));
+}

package/dist/ui/TranscriptItem.js

@@ -1,12 +1,13 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { Banner } from "./Banner.js";
 import { Markdown } from "./Markdown.js";
 import { toolOutputPreview } from "./toolOutputPreview.js";
-import { terminalColumns } from "./viewport.js";
+/** Indent tool output is printed under (see the `    ` prefix below). */
+const TOOL_INDENT = 4;
 /** Renders one line of the transcript — a user message, assistant reply, tool call, info line, or banner. */
-export function TranscriptItem({ item, verbose, stdout }) {
-    return (_jsxs(Box, { marginBottom: item.kind === "tool" ? 0 : 1, flexDirection: "column", children: [item.kind === "user" && (_jsxs(Text, { children: [_jsxs(Text, { bold: true, color: "green", children: ["\u276F", " "] }), item.text] })), item.kind === "assistant" && _jsx(Markdown, { text: item.text }), item.kind === "tool" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [item.error ? _jsx(Text, { color: "red", children: "\u2717" }) : _jsx(Text, { color: "green", children: "\u2713" }), " ", item.summary, item.resultSummary && !verbose ? ` — ${item.resultSummary}` : ""] }), item.output && item.output.trim() && (item.resultSummary === undefined || verbose) && (_jsx(Text, { dimColor: true, children: toolOutputPreview(item.output, verbose, Math.max(20, terminalColumns(stdout) - 6), item.error)
+export function TranscriptItem({ item, verbose, contentWidth }) {
+    return (_jsxs(Box, { marginBottom: item.kind === "tool" ? 0 : 1, flexDirection: "column", children: [item.kind === "user" && (_jsxs(Text, { children: [_jsxs(Text, { bold: true, color: "green", children: ["\u276F", " "] }), item.text] })), item.kind === "assistant" && _jsx(Markdown, { text: item.text, width: contentWidth }), item.kind === "tool" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [item.error ? _jsx(Text, { color: "red", children: "\u2717" }) : _jsx(Text, { color: "green", children: "\u2713" }), " ", item.summary, item.resultSummary && !verbose ? ` — ${item.resultSummary}` : ""] }), item.output && item.output.trim() && (item.resultSummary === undefined || verbose) && (_jsx(Text, { dimColor: true, children: toolOutputPreview(item.output, verbose, Math.max(20, contentWidth - TOOL_INDENT), item.error)
                             .split("\n")
                             .map((l) => `    ${l}`)
                             .join("\n") }))] })), item.kind === "info" && _jsx(Text, { dimColor: true, children: item.text }), item.kind === "banner" && _jsx(Banner, { subtitle: item.subtitle, compact: item.compact }), item.kind === "summary" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "\u2713 Completed" }), item.files.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Changed:" }), item.files.map((f) => (_jsxs(Text, { children: [" ", f] }, f)))] })) : (_jsx(Text, { dimColor: true, children: "No files changed." })), _jsxs(Text, { dimColor: true, children: ["Next: ", item.nextStep] })] }))] }));

package/dist/ui/openInEditor.js

@@ -0,0 +1,34 @@
+import { spawn } from "node:child_process";
+/**
+ * Opens a file in the user's editor, handing the terminal over while it runs.
+ *
+ * Ink's `suspendTerminal` stops rendering, stops consuming input, and puts
+ * the terminal back in the mode an interactive child expects (raw mode off,
+ * cursor visible, bracketed paste off). When the editor exits, Ink reapplies
+ * its own terminal state and repaints the whole UI from scratch, so the
+ * session continues exactly where it left off.
+ *
+ * If the user changed the file, the undo stack's existing file watcher
+ * reports it through `onExternalEdit` like any other outside edit — no
+ * extra change detection needed here.
+ */
+export async function openInEditor(suspendTerminal, absPath) {
+    await suspendTerminal(async () => {
+        const editor = process.env.VISUAL || process.env.EDITOR || "vi";
+        await new Promise((resolve) => {
+            let child;
+            try {
+                child = spawn(editor, [absPath], { stdio: "inherit" });
+            }
+            catch {
+                // Bad editor path — resolve instead of hanging the session.
+                resolve();
+                return;
+            }
+            // 'error' fires when the binary can't be launched at all.
+            child.on("error", () => resolve());
+            child.on("exit", () => resolve());
+        });
+    });
+    // Ink has restored the terminal and repainted by the time this resolves.
+}

package/dist/ui/viewport.js

@@ -1,38 +1,12 @@
-import { wrapInline } from "./inline.js";
-/** Rows below the streaming region: prompt, status line, spinner, breathing room. */
+/**
+ * Rows the live region below the streaming answer needs: the prompt box, the
+ * spinner and steer input, the status line, and a little breathing room. The
+ * live answer is clipped to what is left, so the prompt stays on screen while
+ * it streams.
+ */
 const RESERVED_ROWS = 8;
 /** Never collapse the live view to nothing, however short the terminal. */
 const MIN_ROWS = 4;
-/**
- * Rows held back against an estimate that comes in low. Underestimating by
- * even one row brings back the bug this file exists to prevent, and the only
- * cost of overestimating is showing slightly less of the live text.
- */
-const SAFETY_ROWS = 4;
-/** Columns the renderer itself works in: the terminal, less its padding. */
-const RENDER_INSET = 2;
-/** A table row wraps its cells; assume the worst rather than guess low. */
-const TABLE_ROW_HEIGHT = 3;
-/**
- * Terminal rows a line will occupy once rendered. Measured with the same
- * word-wrapping the renderer uses — dividing width by columns assumes words
- * can be split mid-word, which under-counts every wrapped paragraph.
- */
-function rowsFor(line, columns) {
-    const width = Math.max(1, columns - RENDER_INSET);
-    const wrapped = wrapInline(line, width).length;
-    return line.includes("|") ? Math.max(wrapped, TABLE_ROW_HEIGHT) : Math.max(1, wrapped);
-}
-/**
- * The tail of a streaming answer that fits the viewport.
- *
- * Ink erases its live region by rewinding a line count, which can only reach
- * what is still on screen. Let the streaming text grow past the terminal's
- * height and the erase silently comes up short, stranding a partial copy in
- * the scrollback — then the finished message prints below it and the answer
- * appears twice. Showing only what fits keeps the erase exact; the whole
- * answer is printed once when the turn ends.
- */
 /**
  * The terminal's size, falling back to 80x24 when it isn't known.
  *
@@ -50,22 +24,15 @@ export function terminalColumns(stdout) {
 export function terminalRows(stdout) {
     return stdout?.rows || 24;
 }
-export function tailForViewport(text, columns, rows) {
-    const budget = Math.max(MIN_ROWS, rows - RESERVED_ROWS - SAFETY_ROWS);
-    const lines = text.split("\n");
-    let used = 0;
-    let start = lines.length;
-    while (start > 0) {
-        const next = used + rowsFor(lines[start - 1], columns);
-        if (next > budget)
-            break;
-        used = next;
-        start--;
-    }
-    if (start === 0)
-        return text;
-    const tail = lines.slice(start);
-    // Reopen a fence the cut landed inside, so the tail doesn't render as prose.
-    const fencesDropped = lines.slice(0, start).filter((l) => l.trimStart().startsWith("```")).length;
-    return fencesDropped % 2 === 1 ? `\`\`\`\n${tail.join("\n")}` : tail.join("\n");
+/**
+ * Rows the streaming answer may occupy: the terminal, less the live region
+ * that has to stay visible below it.
+ *
+ * This used to be the budget for slicing the answer by hand — wrapping every
+ * line to estimate the rows it would render at, then keeping the tail that
+ * fit. Ink 8 clips a `<Box>` natively (see StreamViewport.tsx), so the only
+ * thing left to decide is how much room the live region gets.
+ */
+export function streamRows(rows) {
+    return Math.max(MIN_ROWS, rows - RESERVED_ROWS);
 }

package/dist/undo/undo.js

@@ -25,6 +25,8 @@ export class UndoStack {
     entries = [];
     redoStack = [];
     turn = 0;
+    /** The file most recently snapshotted — i.e. last touched by the agent. */
+    lastTouched = null;
     // File-watcher checkpointing. Scoped to files kritya has itself snapshotted
     // this session — never a whole-repo recursive watch — so this can't pick up
     // noise from build output, node_modules, or unrelated files, and can't leak
@@ -43,6 +45,7 @@ export class UndoStack {
     }
     /** Capture the current state of a file before it is modified. */
     snapshot(absPath, relPath) {
+        this.lastTouched = { absPath, relPath };
         this.entries.push({ relPath, absPath, content: readOrNull(absPath), turn: this.turn });
         this.evictOldestTurnsOverCap();
         // A fresh change invalidates any redo history.
@@ -51,6 +54,14 @@ export class UndoStack {
         this.watchForExternalEdits(absPath, relPath);
         this.scheduleOwnWriteSync(absPath);
     }
+    /**
+     * The file the agent touched most recently this session, if any. Used by
+     * the Ctrl+E "open in $EDITOR" flow so there is always a sensible default
+     * target without the user naming a path.
+     */
+    lastTouchedFile() {
+        return this.lastTouched;
+    }
     /**
      * Re-read the file once the own-write grace window closes, and record that
      * as what we believe is on disk.

package/dist/update/check.js

@@ -0,0 +1,189 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR } from "../config/config.js";
+import { debugLog } from "../config/debug.js";
+import { writeFileAtomicSync } from "../atomicWrite.js";
+import { VERSION } from "../version.js";
+/**
+ * "Is a newer kritya out?" — a courtesy notice, so every path here is
+ * best-effort by design: it never throws, never blocks for long, and never
+ * runs when it would be in the way (see `updateCheckDisabled` and the TTY gate
+ * at the call sites). A version check that can break `kritya --version` or
+ * stall startup would be a worse bug than the staleness it reports.
+ */
+export const UPDATE_CHECK_DISABLED_ENV = "KRITYA_NO_UPDATE_CHECK";
+const CACHE_FILE = path.join(CONFIG_DIR, "update-check.json");
+/** How long a cached answer stays good. One registry hit per day, per machine. */
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** Kept short: this is a nicety, and it sits in front of a user's shell prompt. */
+const REQUEST_TIMEOUT_MS = 2_000;
+const REGISTRY_URL = "https://registry.npmjs.org/kritya";
+/** npm's abbreviated packument — a fraction of the full document's size. */
+const PACKUMENT_ACCEPT = "application/vnd.npm.install-v1+json";
+export function updateCheckDisabled() {
+    const value = process.env[UPDATE_CHECK_DISABLED_ENV];
+    return value !== undefined && /^(1|true|yes|on)$/i.test(value.trim());
+}
+/**
+ * Semver precedence: -1 if a < b, 0 if equal, 1 if a > b.
+ *
+ * Hand-rolled rather than pulled from a dependency because the only shapes
+ * this ever sees are our own release tags (`0.8.27-beta`), and a full semver
+ * implementation would be more code than it saves. Follows §11 where it
+ * matters: a release outranks any prerelease of the same core, and numeric
+ * prerelease identifiers rank below alphanumeric ones.
+ */
+export function compareVersions(a, b) {
+    const parse = (value) => {
+        const [core, ...rest] = value.trim().replace(/^v/, "").split("-");
+        return { nums: core.split(".").map((n) => Number(n) || 0), pre: rest.join("-") };
+    };
+    const left = parse(a);
+    const right = parse(b);
+    for (let i = 0; i < 3; i += 1) {
+        const x = left.nums[i] ?? 0;
+        const y = right.nums[i] ?? 0;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    if (left.pre === right.pre)
+        return 0;
+    if (!left.pre)
+        return 1;
+    if (!right.pre)
+        return -1;
+    const li = left.pre.split(".");
+    const ri = right.pre.split(".");
+    for (let i = 0; i < Math.max(li.length, ri.length); i += 1) {
+        const x = li[i];
+        const y = ri[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const xNum = /^\d+$/.test(x);
+        const yNum = /^\d+$/.test(y);
+        if (xNum && yNum) {
+            const dx = Number(x);
+            const dy = Number(y);
+            if (dx !== dy)
+                return dx < dy ? -1 : 1;
+        }
+        else if (xNum !== yNum) {
+            return xNum ? -1 : 1;
+        }
+        else if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/**
+ * The newest version across a packument's dist-tags.
+ *
+ * Deliberately the maximum of *all* tags rather than a single channel: this
+ * package currently only publishes prereleases under `beta`, while `latest`
+ * lags behind by design (it is moved by hand — see publish.yml). Reading only
+ * `latest` would mean the notice never fires for the people actually running
+ * betas.
+ */
+export function newestVersion(distTags) {
+    let newest = null;
+    for (const version of Object.values(distTags ?? {})) {
+        if (typeof version !== "string" || !version)
+            continue;
+        if (!newest || compareVersions(version, newest) > 0)
+            newest = version;
+    }
+    return newest;
+}
+export function isOutdated(current, latest) {
+    return latest !== null && compareVersions(latest, current) > 0;
+}
+/** The user-facing notice, or null when there's nothing worth saying. */
+export function updateNotice(current, latest) {
+    if (!isOutdated(current, latest))
+        return null;
+    return (`A newer version of kritya is available: ${current} → ${latest}\n` +
+        `  npm install -g kritya@${latest}`);
+}
+function readCache(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (typeof parsed.checkedAt !== "number" || typeof parsed.latest !== "string")
+            return null;
+        return { checkedAt: parsed.checkedAt, latest: parsed.latest };
+    }
+    catch (err) {
+        // Missing on first run, or corrupt — either way, just check the registry.
+        debugLog(`readUpdateCache(${file})`, err);
+        return null;
+    }
+}
+function writeCache(file, entry) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        writeFileAtomicSync(file, `${JSON.stringify(entry, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch (err) {
+        // Not being able to remember the answer only costs one extra request.
+        debugLog(`writeUpdateCache(${file})`, err);
+    }
+}
+/**
+ * Resolve whether a newer version exists. Never rejects.
+ *
+ * A cached answer younger than the TTL is returned as-is; otherwise the
+ * registry is asked with a hard 2s timeout and the result is cached. Any
+ * failure resolves to `source: "unavailable"` — being offline is not an error
+ * worth showing anyone.
+ */
+export async function checkForUpdate(options = {}) {
+    const current = VERSION;
+    if (updateCheckDisabled()) {
+        return { current, latest: null, outdated: false, source: "disabled" };
+    }
+    const now = options.now ?? Date.now();
+    const cacheFile = options.cacheFile ?? CACHE_FILE;
+    if (!options.force) {
+        const cached = readCache(cacheFile);
+        if (cached && now - cached.checkedAt < CACHE_TTL_MS) {
+            return {
+                current,
+                latest: cached.latest,
+                outdated: isOutdated(current, cached.latest),
+                source: "cache",
+            };
+        }
+    }
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const response = await fetchImpl(REGISTRY_URL, {
+            headers: { accept: PACKUMENT_ACCEPT },
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            throw new Error(`registry returned HTTP ${response.status}`);
+        const doc = (await response.json());
+        const latest = newestVersion(doc["dist-tags"]);
+        if (!latest)
+            throw new Error("registry response contained no dist-tags");
+        writeCache(cacheFile, { checkedAt: now, latest });
+        return { current, latest, outdated: isOutdated(current, latest), source: "registry" };
+    }
+    catch (err) {
+        debugLog(`checkForUpdate(${REGISTRY_URL})`, err);
+        return {
+            current,
+            latest: null,
+            outdated: false,
+            source: "unavailable",
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** The notice to print for a user, or null. Never throws. */
+export async function updateNoticeForUser(options = {}) {
+    const status = await checkForUpdate(options);
+    return updateNotice(status.current, status.latest);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.26-beta",
+  "version": "0.8.28-beta",
   "description": "Kritya — a lean, provider-agnostic terminal coding agent (NVIDIA, OpenAI, OpenRouter, Groq, Ollama, and more)",
   "type": "module",
   "publishConfig": {
@@ -24,7 +24,7 @@
     "!dist/electron/**"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=22.19.0"
   },
   "scripts": {
     "build": "tsc",
@@ -37,8 +37,12 @@
     "format:check": "prettier --check .",
     "check:audit": "node scripts/check-audit.mjs",
     "check:install-scripts": "node scripts/check-install-scripts.mjs",
+    "check:package": "node scripts/check-package.mjs",
+    "check:release": "node scripts/check-release.mjs",
+    "check:smoke": "node scripts/smoke-install.mjs",
+    "check:typescript-setup": "node scripts/check-typescript-setup.mjs",
     "link": "npm run build && npm link",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run build && npm run check:package && npm run check:smoke",
     "prepare": "husky",
     "electron:dev": "npm run build && electron .",
     "electron:build": "npm run build && electron-builder"
@@ -57,9 +61,7 @@
   "dependencies": {
     "docx": "^9.7.1",
     "exceljs": "^4.4.0",
-    "fast-glob": "^3.3.3",
-    "ink": "^7.1.1",
-    "ink-text-input": "^6.0.0",
+    "ink": "^8.0.0",
     "jszip": "^3.10.1",
     "mammoth": "^1.12.2",
     "openai": "^7.10.0",
@@ -68,7 +70,9 @@
     "pptxgenjs": "^4.0.1",
     "react": "^19.2.8",
     "string-width": "^8.2.2",
-    "undici": "^7.29.0"
+    "tinyglobby": "^0.2.17",
+    "undici": "^8.11.2",
+    "wrap-ansi": "^10.0.2"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -82,14 +86,15 @@
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
     "lint-staged": "^17.4.1",
-    "prettier": "^3.3.0",
+    "prettier": "^3.9.0",
     "tsx": "^4.23.13",
-    "typescript": "^6.0.3",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "@typescript/native": "npm:typescript@^7.0.2",
     "typescript-eslint": "^8.69.0"
   },
   "overrides": {
-    "brace-expansion": "^5.0.8",
-    "fast-uri": "^3.1.7",
+    "brace-expansion": "^5.0.12",
+    "fast-uri": "^3.1.8",
     "exceljs": {
       "uuid": "^11.1.1",
       "unzipper": "^0.12.3",
@@ -118,10 +123,7 @@
     "publish": null,
     "files": [
       "dist/**/*",
-      "electron/**/*",
-      "package.json",
-      "!src/**/*",
-      "!scripts/**/*"
+      "electron/**/*"
     ],
     "win": {
       "target": "nsis"