jsmdcui 0.7.0 → 0.9.0

package/src/lua/engine.js

@@ -2,7 +2,6 @@ import { existsSync } from "node:fs";
 import { readInternalAssetBytes } from "../runtime/assets.js";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { isCompiledBinary, resolveCompiledBaseDir } from "../runtime/compiled.js";
 import { REPO_ROOT } from "../../single-exe/compiled.js";
 
 export async function createLuaEngine() {
@@ -44,9 +43,7 @@ async function resolveLuaWasmLocation() {
     }
   }
 
-  const fallbackPath = isCompiledBinary(process.argv)
-    ? join(resolveCompiledBaseDir({ argv: process.argv }), wasmAssetPath)
-    : join(REPO_ROOT, wasmAssetPath);
+  const fallbackPath = join(REPO_ROOT, wasmAssetPath);
 
   return existsSync(fallbackPath) ? fallbackPath : undefined;
 }

package/src/platform/terminal.js

@@ -0,0 +1,5 @@
+import process from "node:process";
+
+export function controllingTerminalInputPath(platform = process.platform) {
+  return platform === "win32" ? "CONIN$" : "/dev/tty";
+}

package/src/plugins/js-bridge.js

@@ -4,6 +4,7 @@ import { dirname, join, basename, extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import { tmpdir } from "node:os";
 import { assetPath, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetBytes } from "../runtime/assets.js";
+import { isMdcuiEncoding } from "../runtime/encodings.js";
 import { newMessage, newMessageAtLine, MTError, MTWarning, MTInfo } from "../buffer/message.js";
 import { Loc } from "../buffer/loc.js";
 
@@ -752,6 +753,56 @@ function _findBlock(lines, selector) {
   return null;
 }
 
+export function findTuiBlockAtLine(lines, lineIndex) {
+  return findTuiBlockInIndex(buildTuiBlockIndex(lines), lineIndex);
+}
+
+export function buildTuiBlockIndex(lines, declarations = null) {
+  const blocks = [];
+  for (let start = 0; start < lines.length; start++) {
+    const header = _blockHeader(lines[start]);
+    if (!header) continue;
+    let end = lines.length;
+    for (let y = start + 1; y < lines.length; y++) {
+      const line = String(lines[y] ?? "");
+      const rest = line.startsWith(header.indent)
+        ? line.slice(header.indent.length)
+        : line;
+      if (header.kind === "fenced") {
+        const closing = rest.match(/^(`{3,})\s*$/);
+        if (!closing || closing[1].length < header.fenceLength) continue;
+      } else if (!/^(?:└─|╰─|\+-)\s*$/.test(rest)) {
+        continue;
+      }
+      end = y;
+      break;
+    }
+    const declaration = header.id ? declarations?.get(header.id) : null;
+    if (
+      declarations == null
+      || (
+        declaration?.tag === header.tag
+        && declaration.events?.size > 0
+      )
+    ) blocks.push({ start, end, header });
+    start = Math.max(start, end);
+  }
+  return blocks;
+}
+
+export function findTuiBlockInIndex(blocks, lineIndex) {
+  let low = 0;
+  let high = blocks.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const block = blocks[middle];
+    if (lineIndex <= block.start) high = middle - 1;
+    else if (lineIndex >= block.end) low = middle + 1;
+    else return block;
+  }
+  return null;
+}
+
 function _blockValue(lines, selector) {
   const block = _findBlock(lines, selector);
   if (!block) return undefined;
@@ -983,7 +1034,7 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
         buffer._mdcuiHeadingTaskListAnchors = new Map();
       buffer._mdcuiHeadingTaskListAnchors.set(heading.ordinal, { index: start, indent: list.indent });
     }
-    _spliceBufferLines(buffer, start, end - start, replacement.lines, {
+    spliceTuiBufferLines(buffer, start, end - start, replacement.lines, {
       styles: replacement.styles,
       ansi: replacement.ansi,
     });
@@ -1003,14 +1054,14 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
         indent: list.indent,
       });
     }
-    _spliceBufferLines(buffer, item.start, item.end - item.start, []);
+    spliceTuiBufferLines(buffer, item.start, item.end - item.start, []);
     return item.value;
   }
 
   const replacement = _tuiTaskItemReplacement(list.indent, args);
   if (replacement.lines.length === 0) return list.items.length;
   const start = method === "push" ? list.end : list.first;
-  _spliceBufferLines(buffer, start, 0, replacement.lines, {
+  spliceTuiBufferLines(buffer, start, 0, replacement.lines, {
     styles: replacement.styles,
     ansi: replacement.ansi,
   });
@@ -1018,8 +1069,10 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
   return list.items.length + replacement.lines.length;
 }
 
-function _spliceBufferLines(buffer, start, deleteCount, replacement, replacementMeta = {}) {
+export function spliceTuiBufferLines(buffer, start, deleteCount, replacement, replacementMeta = {}) {
   const oldCursor = buffer.cursor ? { ...buffer.cursor } : null;
+  buffer._mdcuiFenceBlockIndex = null;
+  buffer._mdcuiControlBlockIndex = null;
   buffer.lines.splice(start, deleteCount, ...replacement);
 
   if (Array.isArray(buffer._ansiStyleLines)) {
@@ -1065,24 +1118,70 @@ function _spliceBufferLines(buffer, start, deleteCount, replacement, replacement
   buffer.ensureCursor?.();
 }
 
+export function insertTuiTextareaNewline(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  const left = line.slice(0, buffer.cursor.x);
+  const right = line.slice(buffer.cursor.x);
+  buffer.lines[buffer.cursor.y] = left;
+  spliceTuiBufferLines(buffer, buffer.cursor.y + 1, 0, [prefix + right]);
+  buffer.cursor.y++;
+  buffer.cursor.x = prefix.length;
+  buffer.ensureCursor?.();
+  return true;
+}
+
+export function mergeTuiTextareaBackward(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  if (buffer.cursor.x > prefix.length || buffer.cursor.y <= block.start + 1) return false;
+  const previousY = buffer.cursor.y - 1;
+  const previousLength = String(buffer.lines?.[previousY] ?? "").length;
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  const body = line.startsWith(prefix) ? line.slice(prefix.length) : line;
+  buffer.lines[previousY] += body;
+  spliceTuiBufferLines(buffer, buffer.cursor.y, 1, []);
+  buffer.cursor.y = previousY;
+  buffer.cursor.x = previousLength;
+  buffer.ensureCursor?.();
+  return true;
+}
+
+export function mergeTuiTextareaForward(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  if (buffer.cursor.x < line.length || buffer.cursor.y >= block.end - 1) return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  const nextLine = String(buffer.lines?.[buffer.cursor.y + 1] ?? "");
+  const body = nextLine.startsWith(prefix) ? nextLine.slice(prefix.length) : nextLine;
+  buffer.lines[buffer.cursor.y] += body;
+  spliceTuiBufferLines(buffer, buffer.cursor.y + 1, 1, []);
+  buffer.ensureCursor?.();
+  return true;
+}
+
 function _setBlockValue(buffer, selector, value) {
   const lines = buffer.lines;
   const block = _findBlock(lines, selector);
   if (!block) return false;
 
-  const values = String(value ?? "").replace(/\r\n?/g, "\n").split("\n");
+  const normalizedValue = String(value ?? "").replace(/\r\n?/g, "\n");
+  if ((_blockValue(lines, selector) ?? "") === normalizedValue) return true;
+  buffer.pushUndo?.(true);
+  const values = normalizedValue.split("\n");
   const contentStart = block.start + 1;
   const capacity = Math.max(0, block.end - contentStart);
 
   if (block.header.kind === "fenced") {
     const replacement = values.map((line) => block.header.indent + line);
-    _spliceBufferLines(buffer, contentStart, capacity, replacement);
+    spliceTuiBufferLines(buffer, contentStart, capacity, replacement);
     return true;
   }
 
   const rowPrefix = block.header.indent + block.header.bodyMarker + " ";
   const replacement = values.map((line) => rowPrefix + line);
-  _spliceBufferLines(buffer, contentStart, capacity, replacement);
+  spliceTuiBufferLines(buffer, contentStart, capacity, replacement);
   return true;
 }
 
@@ -1229,7 +1328,12 @@ export function buildMicroGlobal(jsManager) {
     // ── Messaging ─────────────────────────────────────────────────
     Log:         (...args) => console.log(...args),
     TermMessage: (msg) => { const app = getApp(); if (app) { app.message = String(msg); if (app._started) app.render?.(); } },
-    alert: async (msg) => { const app = getApp(); if (app) await app.runAlert(msg); else console.log(String(msg)); },
+    alert: (msg) => { const app = getApp(); return app ? app.protectedAlert(msg) : console.log(String(msg)); },
+    confirm: (msg) => { const app = getApp(); return app ? app.protectedConfirm(msg) : false; },
+    prompt: (msg, defaultValue = "") => {
+      const app = getApp();
+      return app ? app.protectedPrompt(msg, defaultValue) : defaultValue;
+    },
 
     // ── Buffer line access (1-based line numbers; omit → cursor line) ─
 
@@ -1250,6 +1354,7 @@ export function buildMicroGlobal(jsManager) {
       const y = lineNumber != null ? Number(lineNumber) - 1 : buf.cursor.y;
       if (y < 0 || y >= buf.lines.length) return;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       const parts = String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
       buf.lines.splice(y, 1, ...parts);
       buf.invalidateHighlightFrom?.(y, { force: parts.length > 1 });
@@ -1266,6 +1371,7 @@ export function buildMicroGlobal(jsManager) {
       const y = lineNumber != null ? Number(lineNumber) - 1 : buf.cursor.y;
       if (y < 0 || y >= buf.lines.length) return;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       if (buf.lines.length === 1) {
         buf.lines[0] = "";
       } else {
@@ -1300,12 +1406,55 @@ export function buildMicroGlobal(jsManager) {
       return app?.buffer?.lines.join("\n") ?? "";
     },
 
+    // Returns the rendered ANSI document when available, otherwise plain text.
+    getAllAnsiText() {
+      const buffer = getApp()?.buffer;
+      return typeof buffer?._mdcuiAnsiText === "string"
+        ? buffer._mdcuiAnsiText
+        : buffer?.lines.join("\n") ?? "";
+    },
+
+    // Activates a 1-based rendered-buffer cell in MDCUI; otherwise falls back to goto.
+    async clickBufferCell(column = 1, line = 1) {
+      const app = getApp();
+      const buffer = app?.buffer;
+      if (!app || !buffer) return false;
+
+      const targetLine = Math.max(1, Math.trunc(Number(line)) || 1);
+      const targetColumn = Math.max(1, Math.trunc(Number(column)) || 1);
+      if (!isMdcuiEncoding(buffer.encoding ?? buffer.Settings?.encoding)) {
+        await app.handleCommand(`goto ${targetLine}:${targetColumn}`);
+        app.render?.();
+        return true;
+      }
+
+      const y = Math.min(targetLine - 1, Math.max(0, buffer.lines.length - 1));
+      const x = Math.min(targetColumn - 1, String(buffer.lines[y] ?? "").length);
+      buffer.cursor = { x, y };
+      const handled = await app.handleMdcuiCellCallback(buffer, y, x, "mouse");
+      app.render?.();
+      return handled;
+    },
+
+    // Sends terminal input through the App's normal parser and event pipeline.
+    async _dispatchRawInput(raw) {
+      const app = getApp();
+      if (!app) return false;
+      const bytes = typeof raw === "string"
+        ? new TextEncoder().encode(raw)
+        : raw;
+      await app._dispatchInput(bytes);
+      app.render?.();
+      return true;
+    },
+
     // Replaces the entire buffer content with text (may contain newlines).
     putAllText(text) {
       const app = getApp();
       if (!app?.buffer) return;
       const buf = app.buffer;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       buf.lines = String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
       if (buf.lines.length === 0) buf.lines = [""];
       buf.invalidateHighlightFrom?.(0, { force: true });

package/tests/compiled-runtime.test.js

@@ -0,0 +1,8 @@
+import { expect, test } from "bun:test";
+import { isCompiledBinary as isSingleExeCompiled } from "../single-exe/compiled.js";
+
+test("single-exe recognizes Bun compiled virtual paths", () => {
+  expect(isSingleExeCompiled(["bun", "/$bunfs/root/app.js"])).toBe(true);
+  expect(isSingleExeCompiled(["bun", "B:/~BUN/root/app.js"])).toBe(true);
+  expect(isSingleExeCompiled(["bun", "/project/src/index.js"])).toBe(false);
+});

package/tests/demo.test.js

@@ -21,6 +21,7 @@ test("--help describes the non-overwriting demo behavior", () => {
   expect(output.match(/Open it in the TUI and write 5 generated files beside it/g)?.length).toBe(2);
   expect(output).toContain("--demo-imgtool");
   expect(output).toContain("--demo-imgtool-zh");
+  expect(output).toContain("--cdp-maze");
 });
 
 test("--demo-list lists root and automatically discovered demos", () => {
@@ -38,6 +39,27 @@ test("--demo-list lists root and automatically discovered demos", () => {
   expect(output).toContain("--demo-imgtool     --demo-image-processor");
 });
 
+test("--export-cdp-maze writes and overwrites the bundled solver", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-export-cdp-maze-"));
+  const outputPath = join(dir, "cdp-maze.js");
+  try {
+    await writeFile(outputPath, "old solver\n");
+    const result = Bun.spawnSync([bunBin, tui, "--export-cdp-maze"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toContain(`Wrote ${outputPath}`);
+    const exported = await readFile(outputPath, "utf8");
+    expect(exported).toContain("export async function runCdpMaze");
+    expect(exported).not.toContain("old solver");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("--demo writes bundled testapp.md to cwd before opening it", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-"));
   try {
@@ -94,6 +116,24 @@ test("--demo-<filename> automatically loads a matching demos file", async () =>
   }
 });
 
+test("--cdp-maze loads the maze demo", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-cdp-maze-"));
+  try {
+    const result = Bun.spawnSync([bunBin, tui, "--cdp-maze", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    const written = await readFile(join(dir, "maze.md"), "utf8");
+    expect(written).toContain("Put the cursor here");
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("Put the cursor here");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 test("--demo-<filename> preserves an existing local copy", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-generic-existing-"));
   const existing = "# Keep my selector demo\n";