march-cli 0.1.29 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/cli/commands/help-command.mjs

@@ -1,6 +1,6 @@
 export function formatHelpLines() {
   return [
-    "Commands: /new, /exit, /help, /hotkeys, /templates, /export jsonl, /export html, /export gist <jsonl|html>, /settings, /extensions, /providers, /providers <name>, /model, /models, /session, /status, /shell, /shell spawn [name], /save, /name, /copy, /mouse",
+    "Commands: /new, /exit, /help, /hotkeys, /templates, /export jsonl, /export html, /export gist <jsonl|html>, /settings, /extensions, /providers, /providers <name>, /model, /models, /session, /status, /shell, /shell spawn [name], /save, /name, /copy",
     "Sessions: /session opens previous sessions and restores the selected one.",
     "Shortcuts: Tab = toggle Do/Discuss, Esc = abort turn, Ctrl+C = abort turn / press twice to exit when idle, Ctrl+O = toggle tool output, Alt+S = shell pane, Alt+N = next shell, Alt+K/J = shell scroll, PageUp/PageDown = output scroll, Ctrl+G = external editor, Shift+Tab = thinking selector, Ctrl+T = thinking selector, Ctrl+L = model selector",
   ];

package/src/cli/fallback-ui.mjs

@@ -58,7 +58,6 @@ export function createJsonUI() {
     getInputText: () => "",
     insertTextAtCursor: () => {},
     openExternalEditor: () => {},
-    toggleMouse: () => false,
     toggleToolOutput: () => false,
     requestExit: () => {},
     close: () => {},
@@ -148,7 +147,6 @@ export function createPlainUI() {
     getInputText: () => "",
     insertTextAtCursor: () => {},
     openExternalEditor: () => {},
-    toggleMouse: () => false,
     toggleToolOutput: () => false,
     requestExit: () => {},
     close: () => {},

package/src/cli/input/autocomplete.mjs

@@ -14,7 +14,6 @@ const MARCH_COMMANDS = [
   { name: "copy", description: "Copy last assistant response to clipboard" },
   { name: "thinking", description: "Open thinking selector" },
   { name: "thinking list", description: "List available thinking levels" },
-  { name: "mouse", description: "Toggle mouse wheel and TUI selection copy" },
   { name: "hotkeys", description: "Show keyboard shortcuts and input prefixes" },
   { name: "templates", description: "List project prompt templates" },
   { name: "export jsonl", description: "Export current session turns as JSONL" },

package/src/cli/slash-commands.mjs

@@ -105,12 +105,6 @@ export async function handleSlashCommand(trimmed, {
     return { handled: true };
   }
 
-  if (trimmed === "/mouse") {
-    const on = ui.toggleMouse();
-    ui.writeln(on ? "Mouse tracking: ON (wheel scroll and TUI selection copy enabled)" : "Mouse tracking: OFF (native terminal selection enabled)");
-    return { handled: true };
-  }
-
   if (trimmed === "/status") {
     for (const line of statusCommand({
       runner,
@@ -145,6 +139,11 @@ export async function handleSlashCommand(trimmed, {
     return { handled: true };
   }
 
+  if (trimmed === "/mouse") {
+    ui.writeln("Mouse selection is always enabled.");
+    return { handled: true };
+  }
+
   const sessionSourceCommand = await handleSessionSourceCommand(trimmed, {
     ui,
     runner,

package/src/cli/tui/input/mouse-selection-controller.mjs

@@ -44,8 +44,7 @@ export function createMouseSelectionController({
   }
 
   return {
-    handleMouseInput(data, mouseOn) {
-      if (!mouseOn) return undefined;
+    handleMouseInput(data) {
       const mouse = parseMouseEvent(data);
       if (mouse?.type === "scroll") {
         if (shellDrawer.isVisible?.() && mouse.col > Math.floor((terminal.columns || 80) * 0.64)) {
@@ -76,7 +75,7 @@ export function createMouseSelectionController({
 
     handleCopyKey(data) {
       if (data !== "\x03") return undefined;
-      const text = selection.text();
+      const text = selection.copyText?.() ?? selection.text();
       if (!text) return undefined;
       selection.clear();
       copySelectionText(text);

package/src/cli/tui/layout/main-pane-layout.mjs

@@ -18,11 +18,12 @@ export class MainPaneLayout {
     const fixedHeight = statusTopLines.length + editorLines.length + statusBottomLines.length;
     const viewportHeight = Math.max(1, (this.terminal?.rows || 30) - fixedHeight);
     this.output.setViewportHeight(viewportHeight);
-    const outputLines = this.output.render(safeWidth);
+    const outputView = this.output.renderSelectable?.(safeWidth) ?? { lines: this.output.render(safeWidth), copyText: null };
+    const outputLines = outputView.lines;
     const outputTop = Math.max(0, viewportHeight - outputLines.length);
     const editorTop = viewportHeight + statusTopLines.length;
     this.selection?.setRegions?.([
-      { id: "output", topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines },
+      { id: "output", topRow: outputTop, leftCol: 0, width: safeWidth, lines: outputLines, copyText: outputView.copyText },
       { id: "editor", topRow: editorTop, leftCol: 0, width: safeWidth, lines: editorLines },
     ]);
     const selectedOutputLines = this.selection?.applyRegion?.("output", outputLines) ?? outputLines;

package/src/cli/tui/output/selectable-copy.mjs

@@ -0,0 +1,107 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { marked } from "marked";
+import { renderMarkdown } from "../markdown-renderer.mjs";
+
+export function appendSelectableEntries(entries, block, lines, width) {
+  if (block.type !== "markdown") {
+    for (const line of lines) entries.push({ line, source: null, codeSource: null, baseRow: entries.length });
+    return;
+  }
+  const source = { kind: "markdown", text: block.text, startRow: entries.length, endRow: entries.length + lines.length - 1 };
+  const fragmentRanges = renderedFragmentRanges(block.text, width, entries.length);
+  for (const line of lines) {
+    const baseRow = entries.length;
+    const fragmentSource = fragmentRanges.find((range) => baseRow >= range.startRow && baseRow <= range.endRow) ?? null;
+    const codeSource = fragmentSource?.kind === "code" ? fragmentSource : null;
+    entries.push({ line, source, codeSource, fragmentSource, baseRow });
+  }
+}
+
+export function sliceEntriesWithTail(baseEntries, tailLine, range) {
+  if (!range) return tailLine == null ? baseEntries : [...baseEntries, { line: tailLine, source: null, codeSource: null, baseRow: baseEntries.length }];
+  const { start, end } = range;
+  const visible = baseEntries.slice(start, Math.min(end, baseEntries.length));
+  if (tailLine != null && end > baseEntries.length) visible.push({ line: tailLine, source: null, codeSource: null, baseRow: baseEntries.length });
+  return visible;
+}
+
+export function copySourceTextForRange(entries, range) {
+  if (!range) return "";
+  const selected = trimEmptyBoundaryEntries(entries.slice(range.start.row, range.end.row + 1));
+  const codeText = copyCompleteCodeSource(selected, entries, range);
+  if (codeText) return codeText;
+  const fragmentText = copyCompleteFragmentSource(selected, entries, range);
+  if (fragmentText) return fragmentText;
+  if (!selected.length || selected.some((entry) => !entry.source)) return "";
+  const sources = uniqueSources(selected, "source");
+  if (!sources.length || !sources.every((source) => sourceIsFullySelected(source, entries, range, "source"))) return "";
+  return sources.map((source) => source.text).join("\n\n");
+}
+
+function trimEmptyBoundaryEntries(entries) {
+  let start = 0;
+  let end = entries.length;
+  while (start < end && !entries[start].source && stripAnsi(entries[start].line).trim() === "") start += 1;
+  while (end > start && !entries[end - 1].source && stripAnsi(entries[end - 1].line).trim() === "") end -= 1;
+  return entries.slice(start, end);
+}
+
+function uniqueSources(entries, key) {
+  const result = [];
+  for (const entry of entries) {
+    const source = entry[key];
+    if (!source || result.includes(source)) continue;
+    result.push(source);
+  }
+  return result;
+}
+
+function copyCompleteCodeSource(selected, entries, range) {
+  if (!selected.length || selected.some((entry) => !entry.codeSource)) return "";
+  const sources = uniqueSources(selected, "codeSource");
+  if (sources.length !== 1 || !sourceIsFullySelected(sources[0], entries, range, "codeSource")) return "";
+  return sources[0].text;
+}
+
+function copyCompleteFragmentSource(selected, entries, range) {
+  if (!selected.length || selected.some((entry) => !entry.fragmentSource)) return "";
+  const sources = uniqueSources(selected, "fragmentSource");
+  if (sources.length !== 1 || !sourceIsFullySelected(sources[0], entries, range, "fragmentSource")) return "";
+  return sources[0].text;
+}
+
+function sourceIsFullySelected(source, entries, range, key) {
+  const startIndex = entries.findIndex((entry) => entry[key] === source && entry.baseRow === source.startRow);
+  const endIndex = entries.findLastIndex((entry) => entry[key] === source && entry.baseRow === source.endRow);
+  if (startIndex < 0 || endIndex < 0) return false;
+  if (range.start.row > startIndex || range.end.row < endIndex) return false;
+  const lastLine = stripAnsi(entries[endIndex]?.line ?? "");
+  const coversStart = range.start.row < startIndex || range.start.col <= 0;
+  const coversEnd = range.end.row > endIndex || range.end.col >= visibleWidth(lastLine);
+  return coversStart && coversEnd;
+}
+
+function renderedFragmentRanges(markdown, width, baseRow) {
+  let tokens = [];
+  try { tokens = marked.lexer(String(markdown ?? "")); } catch { return []; }
+  let row = baseRow;
+  const ranges = [];
+  for (const token of tokens) {
+    const raw = token.raw ?? token.text ?? "";
+    const lineCount = renderMarkdown(raw, width).length;
+    const range = sourceRangeForToken(token, raw, row, lineCount);
+    if (range) ranges.push(range);
+    row += lineCount;
+  }
+  return ranges;
+}
+
+function sourceRangeForToken(token, raw, row, lineCount) {
+  if (token.type === "code") return { kind: "code", text: String(token.text ?? ""), startRow: row, endRow: row + lineCount - 1 };
+  if (token.type === "table") return { kind: "table", text: String(raw).trimEnd(), startRow: row, endRow: row + lineCount - 1 };
+  return null;
+}
+
+function stripAnsi(text) {
+  return String(text ?? "").replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g, "");
+}

package/src/cli/tui/output-buffer.mjs

@@ -4,12 +4,9 @@ import { renderMarkdown, renderStreamingMarkdown } from "./markdown-renderer.mjs
 import { renderEditDiffBlock } from "./tui-diff-rendering.mjs";
 import { OutputScrollState } from "./output/scroll-state.mjs";
 import { appendTextLines, wrapLine } from "./output/text-line-renderer.mjs";
-import { sliceLinesWithTail } from "./output/visible-lines.mjs";
+import { appendSelectableEntries, copySourceTextForRange, sliceEntriesWithTail } from "./output/selectable-copy.mjs";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-
-
 function currentTextToBlocks(textLines, sealed, cache = null) {
   const blocks = [];
   for (let i = 0; i < textLines.length;) {
@@ -72,13 +69,11 @@ export class OutputBuffer {
     this._activeThinking = null;
     this.overlayStatus = null;
     this.scrollState = new OutputScrollState();
-    this._segmentLinesCache = new Map();
     this._baseLinesCache = new Map();
+    this._baseEntriesCache = new Map();
   }
 
-  get scrollOffset() {
-    return this.scrollState.offset;
-  }
+  get scrollOffset() { return this.scrollState.offset; }
 
   clear() {
     this.segments = [];
@@ -90,27 +85,19 @@ export class OutputBuffer {
     this._activeThinking = null;
     this.overlayStatus = null;
     this.scrollState.clear();
-    this._segmentLinesCache = new Map();
     this._baseLinesCache = new Map();
+    this._baseEntriesCache = new Map();
   }
 
-  write(text) {
-    this._writeText(text, false);
-  }
-
-  writeMarkdown(text) {
-    this._writeText(text, true);
-  }
+  write(text) { this._writeText(text, false); }
+  writeMarkdown(text) { this._writeText(text, true); }
 
   _writeText(text, markdown) {
     this.overlayStatus = null;
     this._invalidateBaseLines();
     const current = this.currentText.at(-1);
-    if (current.markdown !== markdown && current.text !== "") {
-      this.currentText.push({ text: "", markdown });
-    } else {
-      current.markdown = markdown;
-    }
+    if (current.markdown !== markdown && current.text !== "") this.currentText.push({ text: "", markdown });
+    else current.markdown = markdown;
     const parts = text.split("\n");
     this.currentText[this.currentText.length - 1].text += parts[0];
     for (let i = 1; i < parts.length; i++) this.currentText.push({ text: parts[i], markdown });
@@ -134,10 +121,9 @@ export class OutputBuffer {
   startThinking() {
     this.overlayStatus = null;
     this._flushText();
-    const seg = { type: "thinking", tokens: 0, content: [] };
-    this.segments.push(seg);
-    this._invalidateSegmentLines();
-    this._activeThinking = seg;
+    this._activeThinking = { type: "thinking", tokens: 0, content: [] };
+    this.segments.push(this._activeThinking);
+    this._invalidateBaseLines();
   }
 
   appendThinking(text) {
@@ -151,25 +137,24 @@ export class OutputBuffer {
   }
 
   endThinking(tokens) {
-    if (this._activeThinking) {
-      this._activeThinking.tokens = tokens;
-      this._activeThinking = null;
-      this._invalidateSegmentLines();
-    }
+    if (!this._activeThinking) return;
+    this._activeThinking.tokens = tokens;
+    this._activeThinking = null;
+    this._invalidateBaseLines();
   }
 
   addThinkingBlock(tokens, content) {
     this.overlayStatus = null;
     this._flushText();
     this.segments.push({ type: "thinking", tokens, content: content.split("\n") });
-    this._invalidateSegmentLines();
+    this._invalidateBaseLines();
   }
 
   addBlock(block) {
     this.overlayStatus = null;
     this._flushText();
     this.segments.push(block);
-    this._invalidateSegmentLines();
+    this._invalidateBaseLines();
   }
 
   setOverlayStatus(lines) {
@@ -182,14 +167,12 @@ export class OutputBuffer {
     this._invalidateBaseLines();
   }
 
-  sealCurrentText() {
-    return this._flushText();
-  }
+  sealCurrentText() { return this._flushText(); }
 
   _flushText() {
     if (this.currentText.length <= 1 && this.currentText[0].text === "") return false;
     this.segments.push(...currentTextToBlocks(this.currentText, true));
-    this._invalidateSegmentLines();
+    this._invalidateBaseLines();
     this.currentText = [{ text: "", markdown: false }];
     this.currentTextCache = new Map();
     return true;
@@ -200,60 +183,44 @@ export class OutputBuffer {
     if (text !== undefined) this.spinnerText = text;
   }
 
-  tick() {
-    this.spinnerIdx = (this.spinnerIdx + 1) % SPINNER_FRAMES.length;
-  }
-
-  scroll(delta, options) {
-    return this.scrollState.scroll(delta, options);
-  }
-
-  getScrollStep() {
-    return this.scrollState.getStep();
-  }
-
-  getMaxScrollOffset() {
-    return this.scrollState.getMaxOffset();
-  }
-
-  setViewportHeight(height) {
-    this.scrollState.setViewportHeight(height);
-  }
-
-  resetScroll() {
-    this.scrollState.reset();
-  }
+  tick() { this.spinnerIdx = (this.spinnerIdx + 1) % SPINNER_FRAMES.length; }
+  scroll(delta, options) { return this.scrollState.scroll(delta, options); }
+  getScrollStep() { return this.scrollState.getStep(); }
+  getMaxScrollOffset() { return this.scrollState.getMaxOffset(); }
+  setViewportHeight(height) { this.scrollState.setViewportHeight(height); }
+  resetScroll() { this.scrollState.reset(); }
 
   setToolCardsExpanded(expanded) {
     let changed = false;
     for (const seg of this.segments) {
-      if (seg.type !== "tool-card") continue;
-      if (seg.expanded === expanded) continue;
+      if (seg.type !== "tool-card" || seg.expanded === expanded) continue;
       seg.expanded = expanded;
       changed = true;
     }
-    if (changed) this._invalidateSegmentLines();
+    if (changed) this._invalidateBaseLines();
     return changed;
   }
 
-  invalidate() {
-    this._invalidateSegmentLines();
-  }
-
-  _invalidateSegmentLines() {
-    this._segmentLinesCache.clear();
-    this._invalidateBaseLines();
-  }
+  invalidate() { this._invalidateBaseLines(); }
 
   _invalidateBaseLines() {
     this._baseLinesCache.clear();
+    this._baseEntriesCache.clear();
   }
 
   render(width) {
-    const baseLines = this._renderBaseLines(width);
+    return this.renderSelectable(width).lines;
+  }
+
+  renderSelectable(width) {
+    const baseEntries = this._renderBaseEntries(width);
     const tailLine = this.spinning ? this._spinnerLine() : null;
-    this.scrollState.setTotalLines(baseLines.length + (tailLine == null ? 0 : 1));
-    return sliceLinesWithTail(baseLines, tailLine, this.scrollState.sliceRange());
+    this.scrollState.setTotalLines(baseEntries.length + (tailLine == null ? 0 : 1));
+    const entries = sliceEntriesWithTail(baseEntries, tailLine, this.scrollState.sliceRange());
+    return {
+      lines: entries.map((entry) => entry.line),
+      copyText: (range) => copySourceTextForRange(entries, range),
+    };
   }
 
   _spinnerLine() {
@@ -263,31 +230,28 @@ export class OutputBuffer {
   _renderBaseLines(width) {
     const cached = this._baseLinesCache.get(width);
     if (cached) return cached;
-    const lines = [...this._renderCachedSegmentLines(width)];
-    const dynamicStart = this._cachedSegmentPrefixCount();
-    for (const seg of this.segments.slice(dynamicStart)) for (const line of renderBlock(seg, width)) lines.push(line);
-    for (const block of currentTextToBlocks(this.currentText, false, this.currentTextCache)) for (const line of renderBlock(block, width)) lines.push(line);
-    if (this.overlayStatus) for (const line of renderBlock(this.overlayStatus, width)) lines.push(line);
+    const lines = this._renderBaseEntries(width).map((entry) => entry.line);
     this._baseLinesCache.set(width, lines);
     return lines;
   }
 
-  _renderCachedSegmentLines(width) {
-    const prefixCount = this._cachedSegmentPrefixCount();
-    const cached = this._segmentLinesCache.get(width);
-    if (cached?.prefixCount === prefixCount) return cached.lines;
-
-    const lines = [];
-    for (let i = 0; i < prefixCount; i += 1) {
-      for (const line of renderBlock(this.segments[i], width)) lines.push(line);
-    }
-    this._segmentLinesCache.set(width, { prefixCount, lines });
-    return lines;
+  _renderBaseEntries(width) {
+    const cached = this._baseEntriesCache.get(width);
+    if (cached) return cached;
+    const entries = [];
+    for (const block of this._blocksForRender()) appendBlockEntries(entries, block, width);
+    this._baseEntriesCache.set(width, entries);
+    return entries;
   }
 
-  _cachedSegmentPrefixCount() {
-    if (!this._activeThinking) return this.segments.length;
-    const index = this.segments.indexOf(this._activeThinking);
-    return index < 0 ? this.segments.length : index;
+  _blocksForRender() {
+    const blocks = [...this.segments];
+    blocks.push(...currentTextToBlocks(this.currentText, false, this.currentTextCache));
+    if (this.overlayStatus) blocks.push(this.overlayStatus);
+    return blocks;
   }
 }
+
+function appendBlockEntries(entries, block, width) {
+  appendSelectableEntries(entries, block, renderBlock(block, width), width);
+}

package/src/cli/tui/selection-screen.mjs

@@ -73,6 +73,19 @@ export class ScreenSelection {
     return hadSelection;
   }
 
+  copyText() {
+    const sourceText = this.sourceText();
+    return sourceText || this.text();
+  }
+
+  sourceText() {
+    const range = this.range();
+    if (!range) return "";
+    const region = this._singleRegionForRange(range);
+    if (!region?.copyText) return "";
+    return region.copyText(localRange(range, region)) || "";
+  }
+
   text() {
     const range = this.range();
     if (!range) return "";
@@ -110,6 +123,15 @@ export class ScreenSelection {
     return this._plainLines.get(row);
   }
 
+  _singleRegionForRange(range) {
+    const matches = this.regions.filter((region) => {
+      const start = region.docStart;
+      const end = region.docStart + region.lines.length - 1;
+      return range.start.row >= start && range.end.row <= end;
+    });
+    return matches.length === 1 ? matches[0] : null;
+  }
+
   range() {
     if (!this.anchor || !this.focus) return null;
     const [start, end] = comparePoints(this.anchor, this.focus) <= 0
@@ -133,6 +155,14 @@ function normalizeRegion(region, index) {
     topRow: Math.max(0, Math.trunc(region.topRow ?? 0)),
     leftCol: Math.max(0, Math.trunc(region.leftCol ?? 0)),
     width,
+    copyText: typeof region.copyText === "function" ? region.copyText : null,
+  };
+}
+
+function localRange(range, region) {
+  return {
+    start: { row: range.start.row - region.docStart, col: range.start.col },
+    end: { row: range.end.row - region.docStart, col: range.end.col },
   };
 }
 

package/src/cli/ui.mjs

@@ -58,7 +58,6 @@ export function createTuiUI({
   tui.setFocus(editor);
 
   let started = false;
-  let mouseOn = true;
   let toolsExpanded = false;
   const activeToolBlocks = [];
   const renderScheduler = createRenderScheduler({ requestRender: () => tui.requestRender() });
@@ -98,7 +97,7 @@ export function createTuiUI({
   function ensureStarted() {
     if (!started) {
       tui.addInputListener((data) => {
-        const mouseResult = mouseSelectionController.handleMouseInput(data, mouseOn);
+        const mouseResult = mouseSelectionController.handleMouseInput(data);
         if (mouseResult) return mouseResult;
         const copyKeyResult = mouseSelectionController.handleCopyKey(data);
         if (copyKeyResult) return copyKeyResult;
@@ -118,7 +117,7 @@ export function createTuiUI({
   }
 
   function openExternalEditor() {
-    runTuiExternalEditor({ terminal, tui, editor, output, requestRender, mouseOn: () => mouseOn });
+    runTuiExternalEditor({ terminal, tui, editor, output, requestRender, mouseOn: () => true });
   }
 
   function toggleToolOutput() {
@@ -240,18 +239,6 @@ export function createTuiUI({
       requestRender();
     },
 
-    toggleMouse: () => {
-      if (mouseOn) {
-        terminal.write("\x1b[?1002l\x1b[?1006l");
-        mouseOn = false;
-        return false;
-      } else {
-        terminal.write("\x1b[?1002h\x1b[?1006h");
-        mouseOn = true;
-        return true;
-      }
-    },
-
     requestPermission: async ({ toolName, params, category }) => {
       ensureStarted();
       spinnerStatus.stop();
@@ -281,7 +268,7 @@ export function createTuiUI({
       retryStatus.stop();
       if (started) {
         await terminal.drainInput?.();
-        if (mouseOn) terminal.write("\x1b[?1002l\x1b[?1006l");
+        terminal.write("\x1b[?1002l\x1b[?1006l");
         tui.stop();
         terminal.write("\x1b[?1049l");
       }