bunmicro 0.9.19 → 0.9.21

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.9.21] - 2026-06-09
+- Prompt mouse click repositions cursor (command and shell prompt)
+- Clicking > or $ label toggles between command/shell prompt, preserving input
+- Prompt mouse double click: left=key-down, middle=key-up, right=key-enter (command and shell prompt)
+- js and eval js/py/sh commands
+
+## [0.9.20] - 2026-06-07
+- Added cursor shape option
+- Fixed selection hide cursor
+
 ## [0.9.19] - 2026-06-06
 - Fixed Windows clipboard
 - Fixed cli encoding help readme

package/README.md

@@ -24,12 +24,13 @@
 - Alt-s to enter selection mode
 - Useful without a mouse on Android
 - Also available: Ctrl-E act SelectRight
-## js plugin
+## js plugin / command
 - Instead of writing Lua, use your familiar JavaScript to extend functionalities
 - runtime/jsplugins/`name`/`name`.js
 - a full documentation in example.js
 - an example plugin named chapter for turning to the next/prev page by number. 
 - It registers 2 commands: next/prevchapter
+- js and eval js command explained at the bottom
 ## Output highlighted text to terminal
 - Works like bat ccat glow
 - bunmicro -bat file
@@ -179,16 +180,51 @@ bun x bunmicro
 - Encoding: Reopen with a specific encoding. 
   * Show supported encodings by bunmicro --version
 - Alt-G: Show nano-like key bindings menu 
+- Command/Shell Prompt row:
+  * See the next section
 
 # Command/Shell Prompts
 ## Command
 - Internal commands for automating / tuning bunmicro
 - Press Tab for available commands, arrow keys for selection
 - In this Bun version, I added more commands like
-  * js to eval JavaScript
   * act/action to do automation actions.
   * Press tab after act to get a list of them
   * or use help actions to show the list
+
+## eval — run code in py/js/sh
+- Executed in a separate processs
+- `eval js` — run selected text as JavaScript (via Bun)
+- `eval py` — run selected text as Python (python3 / python on Windows)
+- `eval sh` — run selected text as shell script (/bin/sh, or Bun shell on Windows)
+- If no text is selected, append code inline:
+  * `eval js console.log("hi")`
+  * `eval py print("hi")`
+  * `eval sh echo hi`
+- Code after the language name is taken literally (no shell quoting)
+- Output is shown in the terminal (same as Ctrl-B shell mode)
+- Runs via a temp file (`bunmicro-tmpXXXXXXXX.js/py/sh`), deleted after execution
+
+## js — eval JavaScript inline
+- Executed inside bunmicro's jsplugin context, 
+- `js <expression or code>`
+- Code is passed raw to await eval (bypass shell quoting), result shown via alert
+- Examples: 
+- `js new Date().toISOString()`
+- `js let ln=micro.getLine(); ln`
+- Implemented in `runtime/jsplugins/example/example.js` as a demo of `micro.MakeCommand`
 ## Shell
 - Executes a given shell command like sh -c
 - Outputs the result to the original terminal before entering bunmicro
+## Prompt mouse gestures
+- Click anywhere: move cursor to that position
+- Click `>` or `$` label: toggle between Command and Shell mode (input is preserved)
+- Double click left ⅓ of row: newer history (same as ↓ key)
+- Double click middle ⅓ of row: older history (same as ↑ key)
+- Double click right ⅓ of row: execute the current input (same as Enter)
+## Prompt keyboard shortcuts
+- `Ctrl-U`: delete everything before cursor
+- `Ctrl-K`: delete everything after cursor
+- `Ctrl-A` / `Home`: move cursor to start
+- `Ctrl-E` / `End`: move cursor to end 
+- `↑` / `↓`: navigate command history

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmicro",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "Bun JavaScript rewrite of the micro editor originally in Golang",
   "type": "module",
   "main": "./src/index.js",

package/runtime/help/options.md

@@ -94,6 +94,13 @@ Here are the available options:
 
     default value: `true`
 
+* `cursorshape`: sets the editor cursor shape using the terminal's DECSCUSR
+   support. This setting is `global only`. Supported values are `default`,
+   `block`, `underline`, `bar`, and their `blinking-` variants. The plain
+   shape names use a steady cursor.
+
+    default value: `block`
+
 * `detectlimit`: if this is not set to 0, it will limit the amount of first
    lines in a file that are matched to determine the filetype.
    A higher limit means better accuracy of guessing the filetype, but also
@@ -566,6 +573,7 @@ so that you can see what the formatting should look like.
     "colorscheme": "default",
     "comment": true,
     "cursorline": true,
+    "cursorshape": "block",
     "detectlimit": 100,
     "diff": true,
     "diffgutter": false,

package/runtime/jsplugins/example/example.js

@@ -41,6 +41,8 @@ Flat buffer helpers (all 1-based line numbers, omit → cursor line):
 Other micro APIs:
   micro.CurPane()              — returns pane adapter for active pane
   micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
+                                 args.raw = full original input string (bypass shellSplit)
+                                 e.g. for command "js 1+1": args.raw = "js 1+1", args.raw.slice(3) = "1+1"
   micro.RegisterAction(name, fn) — register bindable action
   micro.TermMessage(msg)       — show msg in editor status row
   micro.alert(msg)             — suspend editor, print msg, wait for Enter
@@ -70,12 +72,10 @@ micro.on("init", () => {
 
   micro.MakeCommand("js", async (bp, args) =>
   {
-    let scriptText=args.join("\n");
-
-    await micro.alert(
-      await eval(scriptText)
-    )
-    
+    // args.raw is the full original input string, e.g. "js console.log('hi')"
+    // slice(3) skips the "js " prefix (2-char name + 1 space)
+    const scriptText = args.raw?.slice(3) ?? args.join(" ");
+    await micro.alert(await eval(scriptText));
   });
   
 

package/src/config/defaults.js

@@ -57,6 +57,7 @@ export const DEFAULT_GLOBAL_ONLY_SETTINGS = {
   autosave: 0,
   clipboard: "external",
   colorscheme: "default",
+  cursorshape: "block",
   savehistory: true,
   divchars: "|-",
   divreverse: true,
@@ -81,6 +82,12 @@ export const DEFAULT_GLOBAL_ONLY_SETTINGS = {
 
 export const OPTION_CHOICES = {
   clipboard: ["internal", "external", "terminal"],
+  cursorshape: [
+    "default",
+    "block", "blinking-block",
+    "underline", "blinking-underline",
+    "bar", "blinking-bar",
+  ],
   fileformat: ["unix", "dos"],
   helpsplit: ["hsplit", "vsplit"],
   matchbracestyle: ["underline", "highlight"],

package/src/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 import child_process from "node:child_process"
-import { accessSync, constants, existsSync, readdirSync, statSync } from "node:fs";
+import { accessSync, constants, existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname, basename, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -81,6 +81,7 @@ const DEFAULT_SETTINGS = {
   tabsize: 4,
   tabstospaces: false,
   autosave: 0,
+  cursorshape: "block",
   cursorline: true,
   diffgutter: false,
   eofnewline: true,
@@ -1249,6 +1250,9 @@ class BufferModel {
   SetOption(option, value) {
     const oldValue = this.Settings[option];
     const parsed = parseOptionValue(value);
+    if (option === "cursorshape" && !OPTION_CHOICES.cursorshape.includes(String(parsed))) {
+      throw new Error(`Invalid value for cursorshape: ${parsed}`);
+    }
     if (option === "fileformat" && !OPTION_CHOICES.fileformat.includes(String(parsed))) {
       throw new Error(`Invalid value for fileformat: ${parsed}`);
     }
@@ -1263,6 +1267,9 @@ class BufferModel {
 
   DoSetOptionNative(option, value) {
     const oldValue = this.Settings[option];
+    if (option === "cursorshape" && !OPTION_CHOICES.cursorshape.includes(String(value))) {
+      throw new Error(`Invalid value for cursorshape: ${value}`);
+    }
     if (option === "fileformat" && !OPTION_CHOICES.fileformat.includes(String(value))) {
       throw new Error(`Invalid value for fileformat: ${value}`);
     }
@@ -1928,7 +1935,11 @@ class App {
       const totalText = this.prompt.label + this.prompt.value;
       const labelW = displayWidth(this.prompt.label);
       const cursorInTotal = labelW + displayWidth(this.prompt.value.slice(0, this.prompt.cursor));
-      const scrollX = Math.max(0, cursorInTotal - (this.cols - 1));
+      let scrollX = this._promptScrollX ?? 0;
+      if (cursorInTotal > scrollX + this.cols - 1) scrollX = cursorInTotal - (this.cols - 1);
+      if (cursorInTotal < scrollX) scrollX = cursorInTotal;
+      scrollX = Math.max(0, scrollX);
+      this._promptScrollX = scrollX;
       const startIdx = scrollX > 0 ? visualColToCharIdx(totalText, 0, scrollX) : 0;
       putText(this.screen, 0, promptRow, totalText.slice(startIdx), promptStyle, this.cols);
       this.screen.setCursor(cursorInTotal - scrollX, promptRow, true, "bar");
@@ -1966,8 +1977,19 @@ class App {
         cursorCol = p.x + gutterW + displayWidth(line.slice(buf.scroll.x, cursorX));
       }
 
-      const cursorVisible = cursorRow >= p.y && cursorRow < p.y + p.h && cursorCol >= p.x && cursorCol < p.x + p.w;
-      this.screen.setCursor(clamp(cursorCol, 0, this.cols - 1), clamp(cursorRow, 0, this.rows - 1), cursorVisible, "steady-block");
+      // Go micro hides the terminal cursor while a non-empty selection is
+      // active. Otherwise its block cursor makes the exclusive selection end
+      // look selected even though copy/cut correctly omit that character.
+      const hasSelection = p.selection && !sameLoc(p.selection.start, p.selection.end);
+      const cursorVisible = !hasSelection &&
+        cursorRow >= p.y && cursorRow < p.y + p.h &&
+        cursorCol >= p.x && cursorCol < p.x + p.w;
+      this.screen.setCursor(
+        clamp(cursorCol, 0, this.cols - 1),
+        clamp(cursorRow, 0, this.rows - 1),
+        cursorVisible,
+        DEFAULT_SETTINGS.cursorshape,
+      );
     } else if (!this.prompt && activePaneObj?.type !== "term") {
       this.screen.setCursor(0, 0, false);
     }
@@ -3173,6 +3195,61 @@ class App {
       this._suppressMouseUntilUp = false;
     }
 
+    // Prompt row click: reposition cursor, toggle shell/command mode, or zone double-click
+    if (this.prompt && event.y === this.rows - 1) {
+      if ((event.action === "down" || event.action === "drag") && event.button === "left") {
+        const totalText = this.prompt.label + this.prompt.value;
+        const scrollX = this._promptScrollX ?? 0;
+        const startIdx = scrollX > 0 ? visualColToCharIdx(totalText, 0, scrollX) : 0;
+        const clickedCharIdx = visualColToCharIdx(totalText, startIdx, event.x);
+
+        if (event.action === "down") {
+          // Double-click zone: divide prompt row into thirds
+          const third = Math.floor(this.cols / 3);
+          const zone = event.x < third ? "left" : event.x < third * 2 ? "middle" : "right";
+          const now = Date.now();
+          const isDoubleClick = this._lastPromptClickZone === zone &&
+                                now - (this._lastPromptClickTime ?? 0) < 400;
+          this._lastPromptClickTime = now;
+          this._lastPromptClickZone = zone;
+
+          if (isDoubleClick && !this.prompt.yn) {
+            if (zone === "left") {
+              this.prompt.historyDown();
+            } else if (zone === "middle") {
+              this.prompt.historyUp();
+            } else {
+              const prompt = this.prompt;
+              this.prompt = null;
+              prompt.commit();
+              await prompt.callback(prompt.value);
+            }
+            this.render();
+            return;
+          }
+
+          // Single click on label (> or $): toggle Command ↔ Shell
+          if (clickedCharIdx < this.prompt.label.length &&
+              (this.prompt.type === "Command" || this.prompt.type === "Shell")) {
+            const val = this.prompt.value;
+            if (this.prompt.type === "Command") {
+              this.openShellMode();
+              this.prompt.value = val;
+              this.prompt.cursor = val.length;
+            } else {
+              this.openCommandMode(val);
+            }
+            this.render();
+            return;
+          }
+        }
+
+        this.prompt.cursor = Math.max(0, Math.min(clickedCharIdx - this.prompt.label.length, this.prompt.value.length));
+        this.render();
+      }
+      return;
+    }
+
     if (this.handleSuggestionMouse(event)) {
       this.render();
       return;
@@ -3593,6 +3670,19 @@ class App {
       this.prompt.cursor = 0;
     } else if (key === "end" || key === "ctrl-e") {
       this.prompt.cursor = this.prompt.value.length;
+    } else if (key === "ctrl-u") {
+      const prompt = this.prompt;
+      prompt.value = prompt.value.slice(prompt.cursor);
+      prompt.cursor = 0;
+      prompt.resetCompletion();
+      this.message = "";
+      prompt.onDelta?.(prompt.value);
+    } else if (key === "ctrl-k") {
+      const prompt = this.prompt;
+      prompt.value = prompt.value.slice(0, prompt.cursor);
+      prompt.resetCompletion();
+      this.message = "";
+      prompt.onDelta?.(prompt.value);
     } else if (key === "backspace") {
       const prompt = this.prompt;
       if (prompt.cursor > 0) {
@@ -3656,6 +3746,7 @@ class App {
 
   openPrompt(label, callback, options = {}) {
     this.prompt = new Prompt(label, callback, options);
+    this._promptScrollX = 0;
   }
 
   openYNPrompt(label, callback, { onCancel = null } = {}) {
@@ -4536,9 +4627,53 @@ class App {
         this.message = toSpaces ? "Retabbed to spaces" : "Retabbed to tabs";
         break;
       }
-      case "eval":
-        this.message = "Eval unsupported";
+      case "eval": {
+        const lang = cmdArgs[0];
+        if (!lang) { this.message = "Usage: eval js|py|sh [code]"; break; }
+        if (lang !== "js" && lang !== "py" && lang !== "sh") {
+          this.message = `eval: unknown language '${lang}' — use js, py, or sh`;
+          break;
+        }
+        // Code source: inline (raw, bypass shell quoting) or selection
+        let evalCode;
+        const inlineMatch = /^\s*eval\s+(?:js|py|sh)\s+(.+)$/s.exec(input);
+        if (inlineMatch) {
+          evalCode = inlineMatch[1];
+        } else {
+          const sel = this.pane?.selection;
+          evalCode = (sel && !sameLoc(sel.start, sel.end)) ? getSelectionText(buf, sel) : null;
+          if (!evalCode) { this.message = `eval ${lang}: select text, or use: eval ${lang} <code>`; break; }
+        }
+        // Build temp file
+        const { tmpdir } = await import("node:os");
+        const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+        let ext, execArgs, fileContent = evalCode;
+        if (lang === "js") {
+          ext = "js";
+          execArgs = [Bun.which("bun") ?? "bun"];
+        } else if (lang === "py") {
+          ext = "py";
+          const pyBin = process.platform === "win32" ? "python" : "python3";
+          execArgs = [Bun.which(pyBin) ?? pyBin];
+        } else { // sh
+          if (existsSync("/bin/sh")) {
+            ext = "sh";
+            execArgs = ["/bin/sh"];
+          } else {
+            ext = "js";
+            fileContent = `import { $ } from "bun";\nawait $\`\n${evalCode}\n\`;\n`;
+            execArgs = [Bun.which("bun") ?? "bun"];
+          }
+        }
+        const evalTmpFile = join(tmpdir(), `bunmicro-tmp${suffix}.${ext}`);
+        await Bun.write(evalTmpFile, fileContent);
+        try {
+          await this.runInteractiveShell([...execArgs, evalTmpFile]);
+        } finally {
+          try { unlinkSync(evalTmpFile); } catch {}
+        }
         break;
+      }
       case "bind":
       case "unbind":
         this.message = `${cmd}: keybinding system not yet implemented`;
@@ -4642,6 +4777,7 @@ class App {
         const pluginCmd = this.context.plugins?.commands?.get(cmd);
         if (pluginCmd) {
           try {
+            cmdArgs.raw = input;
             await pluginCmd(makePaneAdapter(this.buffer, this), cmdArgs);
           } catch (e) {
             this.message = String(e.message ?? e);

package/src/screen/screen.js

@@ -3,6 +3,20 @@ import { styleToAnsi } from "../display/ansi-style.js";
 import { CellBuffer } from "./cell-buffer.js";
 import { DISABLE_MOUSE, DISABLE_PASTE, ENABLE_MOUSE, ENABLE_PASTE, ResizeEvent } from "./events.js";
 
+const CURSOR_SHAPE_SEQUENCE = {
+  default: "\x1b[0 q",
+  "blinking-block": "\x1b[1 q",
+  block: "\x1b[2 q",
+  "blinking-underline": "\x1b[3 q",
+  underline: "\x1b[4 q",
+  "blinking-bar": "\x1b[5 q",
+  bar: "\x1b[6 q",
+};
+
+export function cursorShapeSequence(shape) {
+  return CURSOR_SHAPE_SEQUENCE[shape] ?? CURSOR_SHAPE_SEQUENCE.block;
+}
+
 export class Screen {
   constructor({ mouse = true } = {}) {
     this.mouse = mouse;
@@ -23,7 +37,7 @@ export class Screen {
   fini() {
     if (this.mouse) this.write(DISABLE_MOUSE);
     this.write(DISABLE_PASTE);
-    this.write("\x1b[?25h\x1b[?1049l\x1b[0m");
+    this.write("\x1b[0 q\x1b[?25h\x1b[?1049l\x1b[0m");
   }
 
   SetContent(x, y, ch, combining = [], style = null) {
@@ -81,9 +95,7 @@ export class Screen {
     }
     out += "\x1b[0m";
     if (this.cursor && this.cursorVisible) {
-      // cursor shape: 1/2=block, 3/4=underline, 5/6=bar; odd=blink even=steady
-      const shape = this.cursor.shape === "bar" ? "\x1b[5 q" : this.cursor.shape === "steady-block" ? "\x1b[2 q" : "\x1b[1 q";
-      out += shape + this.move(this.cursor.y + 1, this.cursor.x + 1) + "\x1b[?25h";
+      out += cursorShapeSequence(this.cursor.shape) + this.move(this.cursor.y + 1, this.cursor.x + 1) + "\x1b[?25h";
     } else out += "\x1b[?25l";
     this.write(out);
     this.previous = this.cells.clone();

package/todo.txt

@@ -15,6 +15,7 @@ Current handoff notes
     - Always emits ANSI codes regardless of TTY state.
     - -profile removed from usage (flag parsed but never implemented in Go either; -debug kept for future log.txt work).
 [x] Recent editor UX parity implemented:
+    - Global cursorshape option supports common DECSCUSR cursor shapes: default, steady/blinking block, underline, and bar, with command completion.
     - Tab autocomplete candidate row cycles highlight correctly and only highlights the selected candidate text.
     - Tab autocomplete single-match case fixed: was silently no-op due to acHas=false; now inserts suffix directly.
     - Mouse click on autocomplete candidates no longer moves the editor cursor to the click location.