bunmicro 0.8.0

package/runtime/jsplugins/chapter/chapter.js

@@ -0,0 +1,108 @@
+// example.js — demonstrates the micro JS plugin API
+// No imports needed: `micro` is available as a global.
+
+/*
+
+# JS Plugin Documentation
+
+Available hooks (register with micro.on(hookName, fn)):
+
+  Lifecycle (no args):
+    "preinit"           — before plugins load
+    "init"              — main plugin setup, register commands/actions here
+    "postinit"          — after all plugins loaded
+
+  Buffer events:
+    "onBufferOpen"  (buffer)      — buffer opened (raw BufferModel, not pane adapter)
+    "onBufferClose" (buffer)      — buffer closed (raw BufferModel)
+    "onSetActive"   (bp)          — pane became active (tab switch, close, etc.)
+    "onSave"        (bp)          — buffer saved
+
+  Input events:
+    "onRune"           (bp, ch)   — printable character inserted (ch is the string)
+
+  Cancellable hooks (return false to cancel the action):
+    "preBackspace"     (bp)       — before backspace; return false to block
+    "preInsertNewline" (bp)       — before Enter/newline; return false to block
+
+bp is a pane adapter with:
+  bp.Buf.Line(n)  bp.Buf.LinesNum()  bp.Buf.FileType()
+  bp.Buf.Insert(loc, text)  bp.Buf.Replace(s, e, text)
+  bp.Cursor.X  bp.Cursor.Y  bp.Cursor.Loc  bp.Cursor.HasSelection()
+  bp.Save()  bp.Backspace()  bp.CursorLeft/Right()  bp.InsertNewline()
+
+Flat buffer helpers (all 1-based line numbers, omit → cursor line):
+  micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
+  micro.getLines(from?, to?)   micro.getLinesCount()
+  micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.putAllText(text)       — replace entire buffer content; pushes undo
+  micro.getSelection()         micro.putSelection(text)
+
+Other micro APIs:
+  micro.CurPane()              — returns pane adapter for active pane
+  micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
+  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
+  micro.Log(...args)           — console.log passthrough
+  micro.GetOption(name)        micro.SetOption(name, value)
+  micro.cmd.save()             — call any editor command via proxy
+  micro.action.CursorUp()      — run any registered action via proxy
+  micro.shell.CMD(...args)     — run CMD interactively (same as Ctrl-B); async
+                                 e.g. await micro.shell.ls('-l')
+                                      await micro.shell.git('diff', '--stat')
+
+*/
+
+micro.on("init", () => {
+  // Register a custom Ctrl+E command
+
+  
+  micro.MakeCommand("nextchapter", async (bp, args) =>
+  {
+     let fp=bp?.Buf?.Path
+     let i1=fp.lastIndexOf('/')- -1
+     let i2=fp.lastIndexOf('.')
+     let nb=fp.slice(i1,i2)
+     let nfp=fp.slice(0,i1)+(nb- -1)+fp.slice(i2)
+
+     await micro.cmd.open('-f',nfp)
+     
+     /*
+     await micro.cmd.replaceall('曰','日')
+     await micro.cmd.replaceall('修土','修士')
+     await micro.cmd.replaceall('<p>','\n')
+     await micro.cmd.replaceall('</p>','\n')
+     await micro.cmd.goto(48)
+     
+
+     micro.cmd.tts()
+     */
+
+  });
+
+  micro.MakeCommand("prevchapter", async (bp, args) =>
+  {
+     let fp=bp?.Buf?.Path
+     let i1=fp.lastIndexOf('/')- -1
+     let i2=fp.lastIndexOf('.')
+     let nb=fp.slice(i1,i2)
+     let nfp=fp.slice(0,i1)+(nb-1)+fp.slice(i2)
+
+     await micro.cmd.open('-f',nfp)
+     
+     /*
+     await micro.cmd.replaceall('曰','日')
+     await micro.cmd.replaceall('修土','修士')
+     await micro.cmd.replaceall('<p>','\n')
+     await micro.cmd.replaceall('</p>','\n')
+     await micro.cmd.goto(48)
+
+     micro.cmd.tts()
+     */
+
+  });
+
+});
+
+

package/runtime/jsplugins/diff/diff.js

@@ -0,0 +1,46 @@
+// diff.js — JS port of the Lua diff plugin (Go parity)
+// When diffgutter is enabled, fetches git HEAD content and sets it as the
+// diff base so the editor can show added/modified/removed gutter markers.
+//
+// Go behavior (diff.lua):
+//   1. Skip scratch buffers or buffers with no path.
+//   2. Check the file exists on disk; skip if not.
+//   3. Run: git -C <dir> show HEAD:./<file>
+//   4. On git failure (not tracked / no commits): set diffBase = current file
+//      content — this produces no gutter markers (base == current).
+//   5. On success: set diffBase = git HEAD content.
+
+import { dirname, basename } from "node:path";
+import { existsSync } from "node:fs";
+
+const _hasGit = await Bun.which("git") !== null;
+
+micro.on("onBufferOpen", async (buffer) => {
+  if (!_hasGit) return;
+  if (!buffer.Settings?.diffgutter) return;
+  if (buffer.Type?.Scratch) return;
+  const absPath = buffer.AbsPath || buffer.Path;
+  if (!absPath) return;
+
+  // Go: os.Stat check — only proceed if the file exists on disk
+  try { if (!existsSync(absPath)) return; } catch { return; }
+
+  const dir = dirname(absPath);
+  const file = basename(absPath);
+  try {
+    const proc = Bun.spawn(["git", "-C", dir, "show", `HEAD:./${file}`], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const exitCode = await proc.exited;
+    if (exitCode === 0) {
+      const text = await new Response(proc.stdout).text();
+      buffer.SetDiffBase(text);
+    } else {
+      // Go: on git failure set diffBase = current content (no markers shown)
+      buffer.SetDiffBase(buffer.Bytes ? buffer.Bytes() : "");
+    }
+  } catch (e) {
+    // Go: on error set diffBase = current content (no markers shown)
+    buffer.SetDiffBase(buffer.Bytes ? buffer.Bytes() : "");
+  }
+});

package/runtime/jsplugins/example/example.js

@@ -0,0 +1,108 @@
+// example.js — demonstrates the micro JS plugin API
+// No imports needed: `micro` is available as a global.
+
+/*
+
+# JS Plugin Documentation
+
+Available hooks (register with micro.on(hookName, fn)):
+
+  Lifecycle (no args):
+    "preinit"           — before plugins load
+    "init"              — main plugin setup, register commands/actions here
+    "postinit"          — after all plugins loaded
+
+  Buffer events:
+    "onBufferOpen"  (buffer)      — buffer opened (raw BufferModel, not pane adapter)
+    "onBufferClose" (buffer)      — buffer closed (raw BufferModel)
+    "onSetActive"   (bp)          — pane became active (tab switch, close, etc.)
+    "onSave"        (bp)          — buffer saved
+
+  Input events:
+    "onRune"           (bp, ch)   — printable character inserted (ch is the string)
+
+  Cancellable hooks (return false to cancel the action):
+    "preBackspace"     (bp)       — before backspace; return false to block
+    "preInsertNewline" (bp)       — before Enter/newline; return false to block
+
+bp is a pane adapter with:
+  bp.Buf.Line(n)  bp.Buf.LinesNum()  bp.Buf.FileType()
+  bp.Buf.Insert(loc, text)  bp.Buf.Replace(s, e, text)
+  bp.Cursor.X  bp.Cursor.Y  bp.Cursor.Loc  bp.Cursor.HasSelection()
+  bp.Save()  bp.Backspace()  bp.CursorLeft/Right()  bp.InsertNewline()
+
+Flat buffer helpers (all 1-based line numbers, omit → cursor line):
+  micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
+  micro.getLines(from?, to?)   micro.getLinesCount()
+  micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.putAllText(text)       — replace entire buffer content; pushes undo
+  micro.getSelection()         micro.putSelection(text)
+
+Other micro APIs:
+  micro.CurPane()              — returns pane adapter for active pane
+  micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
+  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
+  micro.Log(...args)           — console.log passthrough
+  micro.GetOption(name)        micro.SetOption(name, value)
+  micro.cmd.save()             — call any editor command via proxy
+  micro.action.CursorUp()      — run any registered action via proxy
+  micro.shell.CMD(...args)     — run CMD interactively (same as Ctrl-B); async
+                                 e.g. await micro.shell.ls('-l')
+                                      await micro.shell.git('diff', '--stat')
+
+*/
+
+micro.on("init", () => {
+  // Register a custom Ctrl+E command
+  micro.MakeCommand("showpath", async (bp, args) =>
+  {
+    //micro.TermMessage("Hello from JS plugin! Args: " + args.join(", "));
+
+    //await micro.alert(micro.getLine())
+    await micro.alert(bp?.Buf?.Path || "(no path)")
+    
+  });
+  
+
+  micro.MakeCommand("js", async (bp, args) =>
+  {
+    let scriptText=args.join("\n");
+
+    await micro.alert(
+      await eval(scriptText)
+    )
+    
+  });
+  
+
+  // greet: shows a message via micro.alert (leaves editor, shows text, Enter returns)
+  micro.MakeCommand("greet", async (bp, args) => 
+  {
+    const name = args.length ? 
+               args.join(" ") : "world";
+               
+    let s=Bun.markdown.ansi(
+      '# Hello\n- '+name
+    );
+    
+    await micro.alert(s);
+  });
+
+  // Register a custom action (can be bound to a key in keybindings.json)
+  micro.RegisterAction("ExampleDuplicateAndComment", async () => 
+  {
+    await micro.action.DuplicateLine();
+    await micro.action.ToggleComment();
+  });
+});
+
+micro.on("onSave", (bp) => 
+{
+  // bp is the BufPane adapter 
+  // (same as Lua's bp arg)
+  
+  const path = bp?.Buf?.Path || "(no path)";
+  //micro.Log("[example] saved:", path);
+});

package/runtime/jsplugins/linter/linter.js

@@ -0,0 +1,281 @@
+// linter.js — JS port of linter.lua
+// Runs linters on save, adds gutter messages via bp.Buf.AddMessage.
+// micro global is available as globalThis.micro.
+
+import { basename, dirname } from "node:path";
+
+const GOOS = process.platform === "win32" ? "windows" : process.platform;
+const devnull = GOOS === "windows" ? "NUL" : "/dev/null";
+
+// ── Linter registry ───────────────────────────────────────────────────────────
+
+const linters = new Map();
+
+function makeLinter(name, filetype, cmd, args, errorformat, {
+  os: osList = [], whitelist = false, domatch = false, loffset = 0, coffset = 0,
+} = {}) {
+  linters.set(name, { filetype, cmd, args, errorformat, osList, whitelist, domatch, loffset, coffset });
+}
+
+function removeLinter(name) { linters.delete(name); }
+
+// ── Registrations (mirrors linter.lua preinit) ────────────────────────────────
+
+makeLinter("gcc",         "c",           "gcc",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("g++",         "c++",         "g++",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("dmd",         "d",           "dmd",        ["-color=off", "-o-", "-w", "-wi", "-c", "%f"],                 "%f%(%l%):.+: %m");
+makeLinter("ldc2",        "d",           "ldc2",       ["--o-", "--vcolumns", "-w", "-c", "%f"],                       "%f%(%l,%c%):[^:]+: %m");
+makeLinter("gdc",         "d",           "gdc",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("eslint",      "javascript",  "eslint",     ["-f", "json", "--no-ignore", "%f"],                            null);  // JSON parsing
+makeLinter("gobuild",     "go",          "go",         ["build", "-o", devnull, "%d"],                                 "%f:%l:%c:? %m");
+makeLinter("govet",       "go",          "go",         ["vet"],                                                        "%f:%l:%c: %m");
+makeLinter("clippy",      "rust",        "cargo",      ["clippy", "--message-format", "short"],                        "%f:%l:%c: %m");
+makeLinter("hlint",       "haskell",     "hlint",      ["%f"],                                                         "%f:%(?%l[,:]%c%)?.-: %m");
+makeLinter("javac",       "java",        "javac",      ["-d", "%d", "%f"],                                             "%f:%l: error: %m");
+makeLinter("jshint",      "javascript",  "jshint",     ["%f"],                                                         "%f: line %l,.+, %m");
+makeLinter("literate",    "literate",    "lit",        ["-c", "%f"],                                                   "%f:%l:%m",   { domatch: true });
+makeLinter("luacheck",    "lua",         "luacheck",   ["--no-color", "%f"],                                           "%f:%l:%c: %m");
+makeLinter("nim",         "nim",         "nim",        ["check", "--listFullPaths", "--stdout", "--hints:off", "%f"],   "%f.%l, %c. %m");
+makeLinter("clang",       "objective-c", "xcrun",      ["clang", "-fsyntax-only", "-Wall", "-Wextra", "%f"],           "%f:%l:%c:.+: %m");
+makeLinter("pyflakes",    "python",      "pyflakes",   ["%f"],                                                         "%f:%l:.-:? %m");
+makeLinter("mypy",        "python",      "mypy",       ["%f"],                                                         "%f:%l: %m");
+makeLinter("pylint",      "python",      "pylint",     ["--output-format=parseable", "--reports=no", "%f"],            "%f:%l: %m");
+makeLinter("ruff",        "python",      "ruff",       ["check", "--output-format=concise", "%f"],                     "%f:%l:%c: %m");
+makeLinter("flake8",      "python",      "flake8",     ["%f"],                                                         "%f:%l:%c: %m");
+makeLinter("shfmt",       "shell",       "shfmt",      ["%f"],                                                         "%f:%l:%c: %m");
+makeLinter("shellcheck",  "shell",       "shellcheck", ["-f", "gcc", "%f"],                                            "%f:%l:%c:.+: %m");
+makeLinter("swiftc",      "swift",       "xcrun",      ["swiftc", "%f"],                                               "%f:%l:%c:.+: %m", { os: ["darwin"], whitelist: true });
+makeLinter("swiftc-linux","swift",       "swiftc",     ["%f"],                                                         "%f:%l:%c:.+: %m", { os: ["linux"],  whitelist: true });
+makeLinter("yaml",        "yaml",        "yamllint",   ["--format", "parsable", "%f"],                                 "%f:%l:%c:.+ %m");
+makeLinter("nix-linter",  "nix",         "nix-linter", ["%f"],                                                        "%m at %f:%l:%c",   { os: ["linux"],  whitelist: true });
+
+// ── Errorformat → JS regex ────────────────────────────────────────────────────
+
+function parseErrorformat(ef) {
+  const captures = [];
+  let out = "";
+  let i = 0;
+
+  while (i < ef.length) {
+    if (ef[i] === "%") {
+      const next = ef[i + 1] ?? "";
+      i += 2;
+      switch (next) {
+        case "f": captures.push("f"); out += "(.+?)"; break;
+        case "l": captures.push("l"); out += "(\\d+)"; break;
+        case "c": captures.push("c"); out += "(\\d+)"; break;
+        case "m": captures.push("m"); out += "(.+)";  break;
+        case "%": out += "%"; break;
+        case "d": out += "\\d"; break;
+        case "D": out += "\\D"; break;
+        case "s": out += "\\s"; break;
+        case "S": out += "\\S"; break;
+        case "w": out += "\\w"; break;
+        case "W": out += "\\W"; break;
+        case "a": out += "[a-zA-Z]"; break;
+        default:
+          // Lua punctuation escape → literal, JS-escaped
+          out += next.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+          break;
+      }
+      continue;
+    }
+
+    if (ef[i] === "[") {
+      let cls = "[";
+      i++;
+      while (i < ef.length && ef[i] !== "]") {
+        if (ef[i] === "%") {
+          const nc = ef[i + 1] ?? "";
+          i += 2;
+          if (nc === "s") cls += "\\s";
+          else if (nc === "S") cls += "\\S";
+          else if (nc === "d") cls += "\\d";
+          else if (nc === "w") cls += "\\w";
+          else if (nc === "%") cls += "%";
+          else cls += nc;
+        } else {
+          cls += ef[i++];
+        }
+      }
+      cls += "]";
+      if (ef[i] === "]") i++;
+      out += cls;
+      continue;
+    }
+
+    // Lua `.-` (lazy any) → JS `.*?`
+    if (ef[i] === "." && ef[i + 1] === "-") {
+      out += ".*?";
+      i += 2;
+      continue;
+    }
+
+    // `|` is literal in Lua patterns but special in JS regex
+    if (ef[i] === "|" || ef[i] === "{" || ef[i] === "}") {
+      out += "\\" + ef[i++];
+      continue;
+    }
+
+    out += ef[i++];
+  }
+
+  return { regex: new RegExp(out), captures };
+}
+
+const _parsedCache = new Map();
+function getParsed(ef) {
+  if (!_parsedCache.has(ef)) _parsedCache.set(ef, parseErrorformat(ef));
+  return _parsedCache.get(ef);
+}
+
+// ── eslint JSON output parsing ────────────────────────────────────────────────
+
+function parseEslintJson(output, bufPath) {
+  let results;
+  try { results = JSON.parse(output); } catch { return null; }
+  if (!Array.isArray(results)) return null;
+
+  const msgs = [];
+  const bufBase = basename(bufPath);
+  for (const file of results) {
+    if (!file?.messages || basename(file.filePath ?? "") !== bufBase) continue;
+    for (const m of file.messages) {
+      msgs.push({
+        line: m.line ?? 1,
+        col: m.column ?? 1,
+        msg: m.message ?? "",
+        severity: (m.severity ?? 2) >= 2 ? micro.buffer.MTError : micro.buffer.MTWarning,
+      });
+    }
+  }
+  return msgs;
+}
+
+// ── OS filter ─────────────────────────────────────────────────────────────────
+
+function checkFtMatch(ft, v) {
+  let ftmatch = v.domatch ? new RegExp(v.filetype).test(ft) : ft === v.filetype;
+  if (!ftmatch) return false;
+  const hasOS = v.osList.includes(GOOS);
+  if (!hasOS && v.whitelist) return false;
+  if (hasOS && !v.whitelist) return false;
+  return true;
+}
+
+// ── Spawn + parse ─────────────────────────────────────────────────────────────
+
+async function spawnAndCollect(argv) {
+  let proc;
+  try {
+    proc = Bun.spawn(argv, { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+  } catch (err) {
+    micro.pushLintLog(`[linter:${argv[0]}] spawn failed: ${err.message}`);
+    return null;
+  }
+  const dec = new TextDecoder();
+  const readAll = async (stream) => {
+    const chunks = [];
+    if (!stream) return "";
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(dec.decode(value, { stream: true }));
+    }
+    return chunks.join("");
+  };
+  try {
+    const [out, err] = await Promise.all([readAll(proc.stdout), readAll(proc.stderr)]);
+    await proc.exited;
+    return out + err;
+  } catch (err) {
+    micro.pushLintLog(`[linter:${argv[0]}] read failed: ${err.message}`);
+    return null;
+  }
+}
+
+async function lint(bufAdapter, linterName, v) {
+  const file = bufAdapter.Path ?? bufAdapter.path ?? "";
+  const dir = dirname(file) || ".";
+
+  const argv = [v.cmd, ...v.args.map(a => a.replace(/%f/g, file).replace(/%d/g, dir))];
+  const output = await spawnAndCollect(argv);
+  if (output == null) return;
+
+  bufAdapter.ClearMessages(linterName);
+
+  // eslint: JSON path
+  if (v.errorformat === null) {
+    const msgs = parseEslintJson(output, file);
+    if (!msgs) {
+      if (output.trim()) micro.pushLintLog(`[linter:${linterName}]\n${output.trim()}`);
+      return;
+    }
+    for (const { line, col, msg, severity } of msgs) {
+      const start = micro.buffer.Loc(col - 1 + v.coffset, line - 1 + v.loffset);
+      const end   = micro.buffer.Loc(col     + v.coffset, line - 1 + v.loffset);
+      bufAdapter.AddMessage(micro.buffer.newMessage(linterName, msg, start, end, severity));
+    }
+    micro.render();
+    return;
+  }
+
+  // Generic errorformat path
+  const { regex, captures } = getParsed(v.errorformat);
+  const hasCol = captures.includes("c");
+  const bufBase = basename(file);
+
+  for (let rawLine of output.split("\n")) {
+    rawLine = rawLine.replace(/^\s+|\s+$/g, "");
+    if (!rawLine) continue;
+    const m = regex.exec(rawLine);
+    if (!m) continue;
+
+    const capMap = {};
+    captures.forEach((k, idx) => { capMap[k] = m[idx + 1]; });
+
+    if (!capMap.f || basename(capMap.f) !== bufBase) continue;
+
+    const lineNum = Number(capMap.l ?? 1);
+    const colNum  = Number(capMap.c ?? 1);
+    const msg     = capMap.m ?? "";
+
+    let bmsg;
+    if (hasCol && capMap.c != null) {
+      const start = micro.buffer.Loc(colNum - 1 + v.coffset, lineNum - 1 + v.loffset);
+      const end   = micro.buffer.Loc(colNum     + v.coffset, lineNum - 1 + v.loffset);
+      bmsg = micro.buffer.newMessage(linterName, msg, start, end, micro.buffer.MTError);
+    } else {
+      bmsg = micro.buffer.newMessageAtLine(linterName, msg, lineNum + v.loffset, micro.buffer.MTError);
+    }
+    bufAdapter.AddMessage(bmsg);
+  }
+  micro.render();
+}
+
+async function runLinter(bp) {
+  const ft   = bp.Buf.FileType();
+  const buf  = bp.Buf;
+
+  for (const [name, v] of linters) {
+    if (!checkFtMatch(ft, v)) continue;
+    lint(buf, name, v).catch(e => micro.pushLintLog(`[linter:${name}] ${e.message}`));
+  }
+}
+
+// ── Hook registration ─────────────────────────────────────────────────────────
+
+micro.on("init", () => {
+  micro.MakeCommand("lint", async (bp) => {
+    await bp.Save();
+    await runLinter(bp);
+  });
+});
+
+micro.on("onSave", (bp) => {
+  runLinter(bp).catch(e => micro.pushLintLog(`[linter:onSave] ${e.message}`));
+});
+
+// Expose API for user init.js to override linter definitions
+globalThis.linter = { makeLinter, removeLinter, linters };

package/runtime/plugins/autoclose/autoclose.lua

@@ -0,0 +1,75 @@
+VERSION = "1.0.0"
+
+local uutil = import("micro/util")
+local utf8 = import("utf8")
+local autoclosePairs = {"\"\"", "''", "``", "()", "{}", "[]"}
+local autoNewlinePairs = {"()", "{}", "[]"}
+
+function charAt(str, i)
+    -- lua indexing is one off from go
+    return uutil.RuneAt(str, i-1)
+end
+
+function onRune(bp, r)
+    for i = 1, #autoclosePairs do
+        if r == charAt(autoclosePairs[i], 2) then
+            local curLine = bp.Buf:Line(bp.Cursor.Y)
+
+            if charAt(curLine, bp.Cursor.X+1) == charAt(autoclosePairs[i], 2) then
+                bp:Backspace()
+                bp:CursorRight()
+                break
+            end
+
+            if bp.Cursor.X > 1 and (uutil.IsWordChar(charAt(curLine, bp.Cursor.X-1)) or charAt(curLine, bp.Cursor.X-1) == charAt(autoclosePairs[i], 1)) then
+                break
+            end
+        end
+        if r == charAt(autoclosePairs[i], 1) then
+            local curLine = bp.Buf:Line(bp.Cursor.Y)
+
+            if bp.Cursor.X == uutil.CharacterCountInString(curLine) or not uutil.IsWordChar(charAt(curLine, bp.Cursor.X+1)) then
+                -- the '-' here is to derefence the pointer to bp.Cursor.Loc which is automatically made
+                -- when converting go structs to lua
+                -- It needs to be dereferenced because the function expects a non pointer struct
+                bp.Buf:Insert(-bp.Cursor.Loc, charAt(autoclosePairs[i], 2))
+                bp:CursorLeft()
+                break
+            end
+        end
+    end
+    return true
+end
+
+function preInsertNewline(bp)
+    local curLine = bp.Buf:Line(bp.Cursor.Y)
+    local curRune = charAt(curLine, bp.Cursor.X)
+    local nextRune = charAt(curLine, bp.Cursor.X+1)
+    local ws = uutil.GetLeadingWhitespace(curLine)
+
+    for i = 1, #autoNewlinePairs do
+        if curRune == charAt(autoNewlinePairs[i], 1) then
+            if nextRune == charAt(autoNewlinePairs[i], 2) then
+                bp.Buf:Insert(-bp.Cursor.Loc, "\n" .. ws)
+                bp:StartOfLine()
+                bp:CursorLeft()
+                bp:InsertNewline()
+                bp:InsertTab()
+                return false
+            end
+        end
+    end
+
+    return true
+end
+
+function preBackspace(bp)
+    for i = 1, #autoclosePairs do
+        local curLine = bp.Buf:Line(bp.Cursor.Y)
+        if charAt(curLine, bp.Cursor.X+1) == charAt(autoclosePairs[i], 2) and charAt(curLine, bp.Cursor.X) == charAt(autoclosePairs[i], 1) then
+            bp:Delete()
+        end
+    end
+
+    return true
+end

package/runtime/plugins/ftoptions/ftoptions.lua

@@ -0,0 +1,17 @@
+VERSION = "1.0.0"
+
+function onBufferOpen(b)
+    local ft = b:FileType()
+
+    if ft == "go" or
+    ft == "makefile" then
+        b:SetOption("tabstospaces", "off")
+    elseif ft == "fish" or
+           ft == "python" or
+           ft == "python2" or
+           ft == "python3" or
+           ft == "yaml" or
+           ft == "nim" then
+        b:SetOption("tabstospaces", "on")
+    end
+end

package/runtime/plugins/literate/README.md

@@ -0,0 +1,5 @@
+# Literate Micro
+
+Support for reading `.lit` files from [zyedidia/Literate](https://github.com/zyedidia/Literate).
+
+This plugin will automatically detect the filetype and highlight the correct language inside the code blocks.