@nanhara/hara 0.53.0 → 0.62.0

package/dist/tui/vim.js

@@ -0,0 +1,115 @@
+const isSpace = (ch) => ch === " " || ch === "\t";
+const clamp = (c, n) => Math.max(0, Math.min(n, c));
+/** Start of the next word (run of non-space), vim `w`. */
+function nextWord(v, c) {
+    const n = v.length;
+    let i = c;
+    if (i < n && !isSpace(v[i]))
+        while (i < n && !isSpace(v[i]))
+            i++;
+    while (i < n && isSpace(v[i]))
+        i++;
+    return i;
+}
+/** Start of the previous word, vim `b`. */
+function prevWord(v, c) {
+    let i = c - 1;
+    while (i > 0 && isSpace(v[i]))
+        i--;
+    while (i > 0 && !isSpace(v[i - 1]))
+        i--;
+    return Math.max(0, i);
+}
+/** End index of the current/next word, vim `e`. */
+function wordEnd(v, c) {
+    const n = v.length;
+    let i = c + 1;
+    while (i < n && isSpace(v[i]))
+        i++;
+    while (i < n - 1 && !isSpace(v[i + 1]))
+        i++;
+    return Math.min(n, i);
+}
+/** Apply one printable key in NORMAL mode, returning the next state. Special keys (Esc/Enter/arrows/
+ *  backspace) are handled by the caller. Unknown keys are no-ops. */
+export function vimNormal(st, input) {
+    const { value, cursor } = st;
+    const n = value.length;
+    const move = (c) => ({ ...st, cursor: clamp(c, n), pending: "" });
+    const toInsert = (v, c, register = st.register) => ({ value: v, cursor: clamp(c, v.length), mode: "insert", pending: "", register });
+    const toNormal = (patch) => ({ ...st, pending: "", ...patch });
+    // operator-pending: d{motion} / c{motion}
+    if (st.pending === "d" || st.pending === "c") {
+        const op = st.pending;
+        if (input === op)
+            return op === "c" ? toInsert("", 0, value) : toNormal({ value: "", cursor: 0, register: value }); // dd / cc
+        const ranges = {
+            w: [cursor, nextWord(value, cursor)],
+            e: [cursor, Math.min(n, wordEnd(value, cursor) + 1)],
+            b: [prevWord(value, cursor), cursor],
+            $: [cursor, n],
+            "0": [0, cursor],
+        };
+        const r = ranges[op === "c" && input === "w" ? "e" : input]; // cw acts like ce (vim quirk)
+        if (!r)
+            return toNormal({}); // unknown motion → cancel the operator
+        const [from, to] = r;
+        const deleted = value.slice(from, to);
+        const next = value.slice(0, from) + value.slice(to);
+        return op === "c" ? toInsert(next, from, deleted) : toNormal({ value: next, cursor: clamp(from, next.length), register: deleted });
+    }
+    if (st.pending === "g")
+        return input === "g" ? move(0) : toNormal({});
+    switch (input) {
+        // motions
+        case "h":
+            return move(cursor - 1);
+        case "l":
+            return move(cursor + 1);
+        case "0":
+            return move(0);
+        case "$":
+            return move(n);
+        case "w":
+            return move(nextWord(value, cursor));
+        case "b":
+            return move(prevWord(value, cursor));
+        case "e":
+            return move(wordEnd(value, cursor));
+        case "G":
+            return move(n);
+        // enter insert mode
+        case "i":
+            return toInsert(value, cursor);
+        case "a":
+            return toInsert(value, cursor + 1);
+        case "I":
+            return toInsert(value, value.length - value.trimStart().length);
+        case "A":
+        case "o": // single-line: open ≈ append at end
+            return toInsert(value, n);
+        // edits
+        case "x": {
+            if (!n)
+                return toNormal({});
+            return toNormal({ value: value.slice(0, cursor) + value.slice(cursor + 1), cursor: clamp(cursor, n - 1), register: value[cursor] ?? "" });
+        }
+        case "D":
+            return toNormal({ value: value.slice(0, cursor), cursor: clamp(cursor, cursor), register: value.slice(cursor) });
+        case "C":
+            return toInsert(value.slice(0, cursor), cursor, value.slice(cursor));
+        case "p":
+            return toNormal({ value: value.slice(0, cursor + 1) + st.register + value.slice(cursor + 1), cursor: cursor + st.register.length });
+        case "P":
+            return toNormal({ value: value.slice(0, cursor) + st.register + value.slice(cursor), cursor: cursor + Math.max(0, st.register.length - 1) });
+        // operators
+        case "d":
+            return { ...st, pending: "d" };
+        case "c":
+            return { ...st, pending: "c" };
+        case "g":
+            return { ...st, pending: "g" };
+        default:
+            return toNormal({}); // ignore everything else (printable keys don't insert in normal mode)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.53.0",
+  "version": "0.62.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"
@@ -8,8 +8,10 @@
   "type": "module",
   "files": [
     "dist",
+    "!dist/bin",
     "README.md",
     "CHANGELOG.md",
+    "SECURITY.md",
     "LICENSE",
     "CLA.md",
     "plugins"
@@ -40,7 +42,9 @@
     "prepare": "tsc",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "test": "tsc && node --test test/*.test.mjs"
+    "test": "tsc && node --test test/*.test.mjs",
+    "build:binary": "tsc && bun scripts/build-binary.ts dist/bin/hara",
+    "build:binaries": "tsc && bun scripts/build-binary.ts dist/bin/hara-darwin-arm64 bun-darwin-arm64 && bun scripts/build-binary.ts dist/bin/hara-darwin-x64 bun-darwin-x64 && bun scripts/build-binary.ts dist/bin/hara-linux-x64 bun-linux-x64 && bun scripts/build-binary.ts dist/bin/hara-linux-arm64 bun-linux-arm64"
   },
   "publishConfig": {
     "access": "public"