@nanhara/hara 0.120.0 → 0.121.1

package/dist/tui/InputBox.js

@@ -14,10 +14,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 //      of leaning on ink's soft-wrap of a single <Text>, which mis-aligns wrapped rows against the
 //      "› " prompt gutter and reflows unpredictably as you type.
 import { Box, Text, useInput, useStdout } from "ink";
-import { memo, useMemo, useState } from "react";
+import { memo, useMemo, useRef, useState } from "react";
 import { fileCandidates } from "../context/mentions.js";
 import { imagePathFromPaste } from "../images.js";
 import { vimNormal } from "./vim.js";
+import { ComposerHistory, moveCursorLine, nextGraphemeIndex, previousGraphemeIndex, previousWordIndex, } from "./input-history.js";
 export const MODES = ["suggest", "auto-edit", "full-auto", "plan"];
 export const nextMode = (m) => MODES[(MODES.indexOf(m) + 1) % MODES.length];
 const tok = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
@@ -312,15 +313,30 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const [mode, setMode] = useState("insert"); // vim only
     const [pending, setPending] = useState(""); // vim operator-pending (d/c/g)
     const [register, setRegister] = useState(""); // vim yank/delete register
+    const historyRef = useRef(null);
+    if (!historyRef.current)
+        historyRef.current = new ComposerHistory();
+    const inputHistory = historyRef.current;
     const set = (v, c) => {
+        inputHistory.abandonNavigation();
         setValue(v);
         setCursor(c);
         setSel(0);
         setDismissed(false);
     };
+    const snapshot = () => ({ value, attachments: images, pastes });
+    const restore = (draft) => {
+        setValue(draft.value);
+        setCursor(draft.value.length);
+        setImages(draft.attachments);
+        setPastes(draft.pastes);
+        setSel(0);
+        setDismissed(false);
+    };
     // Attach an image: drop a highlighted `[Image #N]` token inline at the cursor and track the file
     // (codex / Claude-Code style). Backspace over the token removes both.
     const addImage = (img) => {
+        inputHistory.abandonNavigation();
         const tok = `[Image #${images.length + 1}]`;
         const before = value.slice(0, cursor);
         const ins = (before && !/\s$/.test(before) ? " " : "") + tok + " ";
@@ -334,6 +350,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     // the box: typing stays smooth (the VALUE stays short), the box stays small, and a multi-line paste
     // can no longer fire the newline-submit path mid-paste. Expanded back to the full text on submit.
     const addPaste = (text) => {
+        inputHistory.abandonNavigation();
         const lines = text.split("\n").length;
         const tok = `[Paste #${pastes.length + 1} +${lines} lines]`;
         const before = value.slice(0, cursor);
@@ -348,6 +365,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const submit = (text) => {
         if (!text.trim() && images.length === 0)
             return; // nothing to send
+        inputHistory.record(snapshot());
         onSubmit?.(expandPastes(text), images.length ? images : undefined);
         set("", 0);
         setImages([]);
@@ -365,6 +383,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const complete = (cand) => {
         if (!mention)
             return;
+        inputHistory.abandonNavigation();
         const before = value.slice(0, mention.start); // includes the leading '@'
         const after = value.slice(cursor);
         const insert = cand.endsWith("/") ? cand : cand + " "; // dirs keep drilling; files end the mention
@@ -406,6 +425,8 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 return setCursor((c) => Math.max(0, c - 1));
             if (input && !key.ctrl && !key.meta) {
                 const st = vimNormal({ value, cursor, mode, pending, register }, input);
+                if (st.value !== value)
+                    inputHistory.abandonNavigation();
                 setValue(st.value);
                 setCursor(st.cursor);
                 setMode(st.mode);
@@ -416,20 +437,54 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
             }
             return;
         }
+        if (key.upArrow) {
+            const onFirstLine = cursor === 0 || value.lastIndexOf("\n", cursor - 1) < 0;
+            if (onFirstLine) {
+                const draft = inputHistory.older(snapshot());
+                if (draft)
+                    restore(draft);
+            }
+            else {
+                setCursor(moveCursorLine(value, cursor, -1));
+            }
+            return;
+        }
+        if (key.downArrow) {
+            const onLastLine = value.indexOf("\n", cursor) < 0;
+            if (onLastLine) {
+                const draft = inputHistory.newer();
+                if (draft)
+                    restore(draft);
+            }
+            else {
+                setCursor(moveCursorLine(value, cursor, 1));
+            }
+            return;
+        }
         if (key.return) {
+            if (key.shift || key.meta) {
+                set(value.slice(0, cursor) + "\n" + value.slice(cursor), cursor + 1);
+                return;
+            }
             submit(value);
             return;
         }
         if (key.leftArrow)
-            return setCursor((c) => Math.max(0, c - 1));
+            return setCursor((c) => previousGraphemeIndex(value, c));
         if (key.rightArrow)
-            return setCursor((c) => Math.min(value.length, c + 1));
+            return setCursor((c) => nextGraphemeIndex(value, c));
         if (key.ctrl && input === "a")
             return setCursor(0);
         if (key.ctrl && input === "e")
             return setCursor(value.length);
         if (key.ctrl && input === "u")
             return set(value.slice(cursor), 0);
+        if (key.ctrl && input === "w") {
+            const start = previousWordIndex(value, cursor);
+            return set(value.slice(0, start) + value.slice(cursor), start);
+        }
+        if (key.ctrl && input === "k")
+            return set(value.slice(0, cursor), cursor);
         if (key.ctrl && input === "v") {
             // paste a screenshot / image from the OS clipboard
             const img = onClipboardImage?.();
@@ -442,6 +497,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 const head = value.slice(0, cursor);
                 const pm = /\[Paste #(\d+) \+\d+ lines\]\s?$/.exec(head); // paste token deletes whole + renumbers
                 if (pm) {
+                    inputHistory.abandonNavigation();
                     const n = Number(pm[1]);
                     const kept = head.slice(0, pm.index) + value.slice(cursor);
                     const renumbered = kept.replace(/\[Paste #(\d+)( \+\d+ lines\])/g, (m2, d, tail) => (Number(d) > n ? `[Paste #${Number(d) - 1}${tail}` : m2));
@@ -454,6 +510,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 }
                 const tm = /\[Image #(\d+)\]\s?$/.exec(head); // backspacing over an attachment token removes it whole
                 if (tm) {
+                    inputHistory.abandonNavigation();
                     const n = Number(tm[1]);
                     const kept = head.slice(0, tm.index) + value.slice(cursor);
                     const renumbered = kept.replace(/\[Image #(\d+)\]/g, (m2, d) => (Number(d) > n ? `[Image #${Number(d) - 1}]` : m2));
@@ -464,7 +521,8 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                     setDismissed(false);
                     return;
                 }
-                set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+                const previous = previousGraphemeIndex(value, cursor);
+                set(value.slice(0, previous) + value.slice(cursor), previous);
             }
             return;
         }

package/dist/tui/input-history.js

@@ -0,0 +1,167 @@
+// Pure composer state: bounded shell-style history plus Unicode-safe cursor helpers. Keeping this out
+// of the Ink component makes navigation deterministic and avoids copying a growing history on each key.
+const cloneDraft = (draft) => ({
+    value: draft.value,
+    attachments: [...draft.attachments],
+    pastes: [...draft.pastes],
+});
+const draftChars = (draft) => draft.value.length + draft.pastes.reduce((sum, paste) => sum + paste.length, 0) + draft.attachments.length * 128;
+/** Bounded in-process history. The draft that existed before Up is restored after navigating Down. */
+export class ComposerHistory {
+    maxEntries;
+    maxChars;
+    entries = [];
+    cursor = null;
+    scratch = null;
+    totalChars = 0;
+    constructor(maxEntries = 100, maxChars = 2_000_000) {
+        this.maxEntries = maxEntries;
+        this.maxChars = maxChars;
+    }
+    get browsing() {
+        return this.cursor !== null;
+    }
+    get length() {
+        return this.entries.length;
+    }
+    record(draft) {
+        this.abandonNavigation();
+        const chars = draftChars(draft);
+        // A giant paste is already retained by the conversation history. Do not duplicate an entry larger
+        // than the entire composer-history budget just to support Up-arrow recall.
+        if (chars > this.maxChars || this.maxEntries <= 0)
+            return;
+        this.entries.push({ draft: cloneDraft(draft), chars });
+        this.totalChars += chars;
+        while (this.entries.length > this.maxEntries || this.totalChars > this.maxChars) {
+            this.totalChars -= this.entries.shift().chars;
+        }
+    }
+    older(current) {
+        if (!this.entries.length)
+            return null;
+        if (this.cursor === null) {
+            this.scratch = cloneDraft(current);
+            this.cursor = this.entries.length - 1;
+        }
+        else if (this.cursor > 0) {
+            this.cursor--;
+        }
+        return cloneDraft(this.entries[this.cursor].draft);
+    }
+    newer() {
+        if (this.cursor === null)
+            return null;
+        if (this.cursor < this.entries.length - 1) {
+            this.cursor++;
+            return cloneDraft(this.entries[this.cursor].draft);
+        }
+        const draft = this.scratch ?? { value: "", attachments: [], pastes: [] };
+        this.cursor = null;
+        this.scratch = null;
+        return cloneDraft(draft);
+    }
+    abandonNavigation() {
+        this.cursor = null;
+        this.scratch = null;
+    }
+}
+let segmenter;
+function graphemeSegmenter() {
+    // Constructing Intl.Segmenter loads ICU data. Defer that cost until the first actual cursor edit so
+    // lightweight commands such as `hara --version` do not pay for TUI Unicode support.
+    if (segmenter === undefined)
+        segmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(undefined, { granularity: "grapheme" }) : null;
+    return segmenter;
+}
+/** Previous user-perceived character boundary (keeps emoji ZWJ sequences/combining marks intact). */
+export function previousGraphemeIndex(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at === 0)
+        return 0;
+    const segments = graphemeSegmenter();
+    if (!segments) {
+        const low = value.charCodeAt(at - 1);
+        const paired = low >= 0xdc00 && low <= 0xdfff && at > 1 && value.charCodeAt(at - 2) >= 0xd800 && value.charCodeAt(at - 2) <= 0xdbff;
+        return Math.max(0, at - (paired ? 2 : 1));
+    }
+    let previous = 0;
+    for (const part of segments.segment(value)) {
+        if (part.index >= at)
+            break;
+        previous = part.index;
+    }
+    return previous;
+}
+/** Next user-perceived character boundary. */
+export function nextGraphemeIndex(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at >= value.length)
+        return value.length;
+    const segments = graphemeSegmenter();
+    if (!segments) {
+        const cp = value.codePointAt(at);
+        return Math.min(value.length, at + (cp !== undefined && cp > 0xffff ? 2 : 1));
+    }
+    for (const part of segments.segment(value)) {
+        const end = part.index + part.segment.length;
+        if (end > at)
+            return end;
+    }
+    return value.length;
+}
+/** Start of the previous shell-style word, used by Ctrl+W. */
+export function previousWordIndex(value, cursor) {
+    let at = Math.max(0, Math.min(value.length, cursor));
+    while (at > 0) {
+        const previous = previousGraphemeIndex(value, at);
+        if (!/\s/u.test(value.slice(previous, at)))
+            break;
+        at = previous;
+    }
+    while (at > 0) {
+        const previous = previousGraphemeIndex(value, at);
+        if (/\s/u.test(value.slice(previous, at)))
+            break;
+        at = previous;
+    }
+    return at;
+}
+function graphemeFloor(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at === value.length)
+        return at;
+    const segments = graphemeSegmenter();
+    if (!segments)
+        return at > 0 && /[\uDC00-\uDFFF]/.test(value[at]) ? at - 1 : at;
+    let floor = 0;
+    for (const part of segments.segment(value)) {
+        if (part.index > at)
+            break;
+        floor = part.index;
+        if (part.index + part.segment.length === at)
+            return at;
+    }
+    return floor;
+}
+/** Move between logical pasted/typed lines while retaining the closest possible column. */
+export function moveCursorLine(value, cursor, direction) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    const lineStart = (at === 0 ? -1 : value.lastIndexOf("\n", at - 1)) + 1;
+    const lineEndAt = value.indexOf("\n", at);
+    const lineEnd = lineEndAt < 0 ? value.length : lineEndAt;
+    const column = Math.min(at - lineStart, lineEnd - lineStart);
+    if (direction < 0) {
+        if (lineStart === 0)
+            return at;
+        const previousEnd = lineStart - 1;
+        const previousStart = value.lastIndexOf("\n", Math.max(0, previousEnd - 1)) + 1;
+        return graphemeFloor(value, previousStart + Math.min(column, previousEnd - previousStart));
+    }
+    if (lineEnd === value.length)
+        return at;
+    const nextStart = lineEnd + 1;
+    const nextEndAt = value.indexOf("\n", nextStart);
+    const nextEnd = nextEndAt < 0 ? value.length : nextEndAt;
+    return graphemeFloor(value, nextStart + Math.min(column, nextEnd - nextStart));
+}

package/dist/tui/run.js

@@ -4,36 +4,39 @@
 import { render, Box, Text, useApp, useInput } from "ink";
 import { createElement } from "react";
 import { App } from "./App.js";
-export async function runTui(props) {
-    const instance = render(createElement(App, props));
-    // Resize repaint fix. ink 6.8's own resize handler only clears the screen when the terminal gets
-    // NARROWER; on a WIDEN (or a resize it doesn't classify as narrowing) it just re-renders, so the old
-    // frame — reflowed at the new width — is never erased, and the ~125ms spinner tick stacks a fresh copy
-    // each time (the "moved the window and the UI stacked up" garble). We complement it: on ANY resize,
-    // clear ink's tracked output so the next render starts clean. Debounced by a microtask so a burst of
-    // resize events during a window drag collapses to one clear.
-    const out = process.stdout;
-    let pending = false;
+/** Ink 6.8 clears before repainting when a terminal gets narrower, but not when it gets wider. Install a
+ *  complementary WIDTH-only clear ahead of Ink's own resize listener so Ink's normal layout pass redraws
+ *  the frame immediately afterwards. Never clear on a rows-only resize: `instance.clear()` erases the
+ *  dynamic region without scheduling a React render, which made an idle input box disappear when a user
+ *  dragged only the top/bottom edge of the terminal window. Exported for a small ordering regression test. */
+export function installResizeRepaint(out, instance) {
+    let lastColumns = out.columns;
     const onResize = () => {
-        if (pending)
+        const columns = out.columns;
+        if (!columns || columns === lastColumns)
             return;
-        pending = true;
-        queueMicrotask(() => {
-            pending = false;
-            try {
-                instance.clear();
-            }
-            catch {
-                /* best-effort — never let a repaint fix crash the session */
-            }
-        });
+        lastColumns = columns;
+        try {
+            instance.clear();
+        }
+        catch {
+            /* best-effort — never let a repaint fix crash the session */
+        }
     };
-    out.on("resize", onResize);
+    // Ink registered its listener inside render() already. Prepending is essential: clearing AFTER Ink's
+    // repaint is precisely what leaves the prompt blank until some unrelated state update happens.
+    out.prependListener("resize", onResize);
+    return () => out.off("resize", onResize);
+}
+export async function runTui(props) {
+    const instance = render(createElement(App, props));
+    const out = process.stdout;
+    const removeResizeRepaint = installResizeRepaint(out, instance);
     try {
         await instance.waitUntilExit();
     }
     finally {
-        out.off("resize", onResize);
+        removeResizeRepaint();
     }
 }
 // A tiny ink yes/no prompt for pre-TUI confirms (e.g. the first-run "create AGENTS.md?" offer).

package/dist/undo.js

@@ -1,7 +1,8 @@
 // In-session undo stack for file changes. Each edit tool records the prior state of the files it
 // touched; `/undo` pops the last group and restores it. Process-scoped (one REPL session).
-import { writeFile, unlink, mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
+import { unlink } from "node:fs/promises";
+import { atomicWriteText } from "./fs-write.js";
+import { invalidateFileCandidates } from "./context/mentions.js";
 const stack = [];
 const MAX = 50;
 /** Record a group of file changes (one tool call = one undo step). */
@@ -27,8 +28,7 @@ export async function undoLast() {
                 await unlink(s.absPath).catch(() => { }); // was newly created → remove
             }
             else {
-                await mkdir(dirname(s.absPath), { recursive: true });
-                await writeFile(s.absPath, s.before, "utf8");
+                await atomicWriteText(s.absPath, s.before);
             }
             files.push(s.path);
         }
@@ -36,5 +36,7 @@ export async function undoLast() {
             /* skip a file we can't restore */
         }
     }
+    if (files.length)
+        invalidateFileCandidates();
     return { files };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.120.0",
+  "version": "0.121.1",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"
@@ -70,5 +70,10 @@
   "optionalDependencies": {
     "@zvec/zvec": "^0.5.0",
     "qrcode-terminal": "^0.12.0"
+  },
+  "overrides": {
+    "@larksuiteoapi/node-sdk": {
+      "axios": "1.18.1"
+    }
   }
 }