bunmicro 0.9.10 → 0.9.20

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [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
+- Added cli clean config dir
+- Added softwrap subrow line number
+  * goto line
+  * show subrow line number in showpath
+  * pageup/down respects softwrap
+- Fixed CRLF being overwritten
+- Added primary clipboard 
+- Fixed clipboard cmd / action
+  * Ctrl+K should accumulate
+- Clipboard backend priority
+- Added OSC 52 clipboard copy
+  * Use by set clipboard terminal
+
 ## [0.9.10] - 2026-06-04
 - Up/Down key auto-complete selection in editor
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmicro",
-  "version": "0.9.10",
+  "version": "0.9.20",
   "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

@@ -61,7 +61,9 @@ micro.on("init", () => {
     //micro.TermMessage("Hello from JS plugin! Args: " + args.join(", "));
 
     //await micro.alert(micro.getLine())
-    await micro.alert(bp?.Buf?.Path || "(no path)")
+    const path = bp?.Buf?.Path || "(no path)";
+    const loc = bp?.CursorLocation?.() || "+1.0:1";
+    await micro.alert(`${path}\n${loc}`)
     
   });
   

package/src/config/clean.js

@@ -0,0 +1,172 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { defaultAllSettings, LOCAL_SETTINGS } from "./defaults.js";
+
+function settingsEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+async function createCleanPrompt() {
+  if (process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+      ask: async () => {
+        const text = (await rl.question("Continue [Y/n]: ")).trim();
+        return text.length === 0 || text.toLowerCase().startsWith("y");
+      },
+      close: () => rl.close(),
+    };
+  }
+
+  const answers = (await Bun.stdin.text()).split(/\r?\n/);
+  let index = 0;
+  return {
+    ask: async () => {
+      process.stdout.write("Continue [Y/n]: ");
+      const text = (answers[index++] ?? "").trim();
+      return text.length === 0 || text.toLowerCase().startsWith("y");
+    },
+    close: () => {},
+  };
+}
+
+function cleanDefaultSettings(config) {
+  const defaults = defaultAllSettings();
+  const cleaned = { ...config.parsedSettings };
+  for (const [key, value] of Object.entries(cleaned)) {
+    if (LOCAL_SETTINGS.has(key)) {
+      delete cleaned[key];
+      continue;
+    }
+    if (key in defaults && settingsEqual(config.globalSettings[key], defaults[key]) && settingsEqual(value, defaults[key])) {
+      delete cleaned[key];
+    }
+  }
+  return cleaned;
+}
+
+function findUnusedOptions(settings, pluginNames) {
+  const defaults = defaultAllSettings();
+  const unused = [];
+  for (const key of Object.keys(settings)) {
+    if (key.startsWith("ft:") || key.startsWith("glob:")) continue;
+    if (key in defaults) continue;
+    let valid = false;
+    for (const name of pluginNames) {
+      if (key === name || key.startsWith(`${name}.`)) {
+        valid = true;
+        break;
+      }
+    }
+    if (!valid) unused.push(key);
+  }
+  return unused.sort();
+}
+
+async function writeCleanSettings(config, settings) {
+  const settingsFile = join(config.configDir, "settings.json");
+  await Bun.write(settingsFile, JSON.stringify(settings, null, "    ") + "\n");
+}
+
+function invalidBunBufferStateFile(path, name) {
+  if (name !== "history.json" && name !== "cursor_state.json") return false;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return !parsed || typeof parsed !== "object" || Array.isArray(parsed);
+  } catch {
+    return true;
+  }
+}
+
+export async function cleanConfig(config, plugins) {
+  const prompt = await createCleanPrompt();
+  try {
+    console.log("Cleaning your configuration directory at", config.configDir);
+    console.log(`Please consider backing up ${config.configDir} before continuing`);
+
+    if (!(await prompt.ask())) {
+      console.log("Stopping early");
+      return;
+    }
+
+    console.log("Cleaning default settings");
+    let cleanedSettings = cleanDefaultSettings(config);
+    try {
+      await writeCleanSettings(config, cleanedSettings);
+    } catch (err) {
+      console.log(`Error writing settings.json file: ${err.message}`);
+    }
+
+    const pluginNames = new Set(plugins.list().map((plugin) => plugin.name));
+    const unusedOptions = findUnusedOptions(cleanedSettings, pluginNames);
+    if (unusedOptions.length > 0) {
+      const settingsFile = join(config.configDir, "settings.json");
+      console.log("The following options are unused:");
+      for (const option of unusedOptions) console.log(`${option} (value: ${JSON.stringify(cleanedSettings[option])})`);
+      console.log(`These options will be removed from ${settingsFile}`);
+
+      if (await prompt.ask()) {
+        for (const option of unusedOptions) delete cleanedSettings[option];
+        try {
+          await writeCleanSettings(config, cleanedSettings);
+          console.log("Removed unused options");
+          console.log("\n");
+        } catch (err) {
+          console.log(`Error overwriting settings.json file: ${err.message}`);
+        }
+      }
+    }
+
+    const buffersPath = join(config.configDir, "buffers");
+    if (existsSync(buffersPath)) {
+      const badFiles = [];
+      for (const entry of readdirSync(buffersPath, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        const path = join(buffersPath, entry.name);
+        if (invalidBunBufferStateFile(path, entry.name)) badFiles.push(path);
+      }
+      if (badFiles.length > 0) {
+        console.log(`Detected ${badFiles.length} files with an invalid format in ${buffersPath}`);
+        console.log("These files store cursor and undo history.");
+        console.log(`Removing badly formatted files in ${buffersPath}`);
+
+        if (await prompt.ask()) {
+          let removed = 0;
+          for (const file of badFiles) {
+            try {
+              await rm(file);
+              removed++;
+            } catch (err) {
+              console.log(err.message);
+            }
+          }
+          if (removed === 0) console.log("Failed to remove files");
+          else console.log(`Removed ${removed} badly formatted files`);
+          console.log("\n");
+        }
+      }
+    }
+
+    const oldPluginsDir = join(config.configDir, "plugins");
+    if (existsSync(oldPluginsDir) && statSync(oldPluginsDir).isDirectory()) {
+      console.log(`Found directory ${oldPluginsDir}`);
+      console.log(`Plugins should now be stored in ${join(config.configDir, "plug")}`);
+      console.log(`Removing ${oldPluginsDir}`);
+
+      if (await prompt.ask()) {
+        try {
+          await rm(oldPluginsDir, { recursive: true, force: true });
+        } catch (err) {
+          console.log(err.message);
+        }
+      }
+      console.log("\n");
+    }
+
+    console.log("Done cleaning");
+  } finally {
+    prompt.close();
+  }
+}

package/src/config/config.js

@@ -104,7 +104,9 @@ function normalizeSetting(key, value) {
 
 function validateOption(option, value) {
   if (option === "encoding") {
-    try { new TextDecoder(String(value || "utf-8")); }
+    const encoding = String(value || "utf-8");
+    if (encoding === "hex3") return;
+    try { new TextDecoder(encoding); }
     catch { throw new Error(`Invalid encoding: ${value}`); }
   }
   const choices = OPTION_CHOICES[option];

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"],
@@ -91,7 +98,7 @@ export const OPTION_CHOICES = {
 
 // Settings that are buffer-local only and must never be written to the global config file.
 // Mirrors Go micro's config.LocalSettings.
-export const LOCAL_SETTINGS = new Set(["readonly", "filetype"]);
+export const LOCAL_SETTINGS = new Set(["readonly", "filetype", "fileformat"]);
 
 export function defaultAllSettings() {
   return { ...DEFAULT_COMMON_SETTINGS, ...DEFAULT_GLOBAL_ONLY_SETTINGS };