march-cli 0.1.42 → 0.1.46

package/src/agent/runtime/ui-event-bridge.mjs

@@ -50,7 +50,7 @@ export function createRuntimeUiClient(eventBus) {
     retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
     status: (text) => eventBus.emit({ type: "status", text }),
     debugLines: (lines) => eventBus.emit({ type: "debug_lines", lines }),
-    recall: ({ source, hints }) => eventBus.emit({ type: "recall", source, hints }),
+    recall: ({ hints, report, variant }) => eventBus.emit({ type: "recall", hints, report, variant }),
     providerQuotaSnapshot: (snapshot) => eventBus.emit({ type: "provider_quota_snapshot", snapshot }),
     editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
   };
@@ -71,7 +71,7 @@ export function dispatchRuntimeUiEvent(ui, event) {
     case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
     case "status": return ui.status?.(event.text);
     case "debug_lines": return writeDebugLines(ui, event.lines);
-    case "recall": return ui.recall?.({ source: event.source, hints: event.hints });
+    case "recall": return ui.recall?.({ hints: event.hints, report: event.report, variant: event.variant });
     case "provider_quota_snapshot": return ui.providerQuotaSnapshot?.(event.snapshot);
     case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
     default: return undefined;

package/src/agent/turn/turn-runner.mjs

@@ -20,14 +20,15 @@ export async function runRunnerTurn({
   autoNameSession,
   contextMode = "rebuild",
   recordHistory = null,
+  trackMidTurnRecallInjection = null,
 }) {
   const {
     userRecallHints = [],
-    currentProject = "",
   } = options;
   const activeSession = sessionBinding.get();
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
+  const midTurnRecallTasks = [];
   const idleWatchdog = createModelStreamIdleWatchdog({ session: activeSession, logger, setPhase });
   ui.turnStart();
   setPhase?.("subscribed");
@@ -57,12 +58,9 @@ export async function runRunnerTurn({
     }
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
-      const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
-      if (hints.length > 0) {
-        midTurnRecallHints.push(...hints);
-        queueMidTurnRecallHints(activeSession, hints, logger);
-        ui.recall?.({ source: "assistant", hints });
-      }
+      const task = flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints, trackMidTurnRecallInjection });
+      trackMidTurnRecallInjection?.({ task });
+      midTurnRecallTasks.push(task);
     }
   });
 
@@ -90,11 +88,11 @@ export async function runRunnerTurn({
     }
 
     setPhase?.("finalizing");
-    finalizeTurn({
+    await Promise.allSettled(midTurnRecallTasks);
+    await finalizeTurn({
       prompt,
       userMessage,
       userRecallHints,
-      currentProject,
       memoryStore,
       engine,
       ui,
@@ -172,17 +170,17 @@ function throwIfAssistantEndedWithError(turnState) {
 }
 
 function queueMidTurnRecallHints(session, hints, logger) {
-  const content = formatRecallHints("assistant", hints);
-  if (!content) return;
-  const injected = session.sendCustomMessage?.({
+  const content = formatRecallHints(hints);
+  if (!content) return null;
+  const task = Promise.resolve(session.sendCustomMessage?.({
     customType: "march.recall",
     content,
     display: false,
-    details: { source: "assistant" },
-  }, { deliverAs: "steer" });
-  void injected?.catch?.((err) => {
+    details: { type: "recall" },
+  }, { deliverAs: "steer" })).catch((err) => {
     logger?.debug("memory.mid_turn_recall.inject_failed", { errorMessage: err?.message ?? String(err) });
   });
+  return { content, task };
 }
 
 function logSessionEvent(logger, event) {
@@ -209,11 +207,11 @@ function logSessionEvent(logger, event) {
   });
 }
 
-function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentMarchSessionState, autoNameSession, recordHistory }) {
+async function finalizeTurn({ prompt, userMessage, userRecallHints, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentMarchSessionState, autoNameSession, recordHistory }) {
   closeAssistantReply({ ui, state: turnState });
-  const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
-  engine.setPendingAssistantRecallHints?.(assistantRecallHints);
-  const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
+  const assistantRecall = await flushAssistantRecall({ memoryStore, engine, turnState });
+  engine.setPendingAssistantRecallHints?.(assistantRecall.hints, assistantRecall.report);
+  const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecall.hints]);
 
   const turn = engine.recordTurn({
     userMessage: userMessage ?? prompt.slice(0, 300),
@@ -228,17 +226,30 @@ function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, me
   syncCurrentMarchSessionState();
 }
 
-function flushAssistantRecall({ memoryStore, engine, turnState, currentProject }) {
-  if (!memoryStore) return [];
+async function flushAssistantRecall({ memoryStore, engine, turnState }) {
+  if (!memoryStore) return { hints: [], report: null };
   const text = assistantRecallDeltaText(turnState);
   advanceAssistantRecallCursor(turnState);
-  if (!text.trim()) return [];
-  return memoryStore.recallForAssistant(text, {
-    currentProject,
+  if (!text.trim()) return { hints: [], report: null };
+  return await memoryStore.recallForAssistant(text, {
     excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
   });
 }
 
+async function flushMidTurnAssistantRecall({ memoryStore, engine, turnState, activeSession, ui, logger, midTurnRecallHints, trackMidTurnRecallInjection }) {
+  try {
+    const { hints, report } = await flushAssistantRecall({ memoryStore, engine, turnState });
+    if (hints.length > 0) {
+      midTurnRecallHints.push(...hints);
+      const injection = queueMidTurnRecallHints(activeSession, hints, logger);
+      if (injection) trackMidTurnRecallInjection?.(injection);
+    }
+    if (report) ui.recall?.({ hints, report, variant: "assistant" });
+  } catch (err) {
+    logger?.debug("memory.mid_turn_recall.failed", { errorMessage: err?.message ?? String(err) });
+  }
+}
+
 function assistantRecallDeltaText(turnState) {
   const cursor = turnState.recallCursor ?? { draftLength: 0, thinkingLength: 0 };
   const thinking = assistantThinkingText(turnState);

package/src/cli/fallback-ui.mjs

@@ -109,9 +109,9 @@ export function createPlainUI() {
     },
     textDelta: writeText,
     status: (text) => { ensureNewline(); stdout.write(`${brightBlack(`● ${text}`)}\n`); },
-    recall: ({ hints }) => {
+    recall: ({ hints, report, variant }) => {
       ensureNewline();
-      for (const line of formatRecallLines(hints)) stdout.write(`${brightBlack(line)}\n`);
+      for (const line of formatRecallLines(hints, report, { variant })) stdout.write(`${brightBlack(line)}\n`);
     },
     clearOutput: () => {},
     restoreTranscript: () => {},

package/src/cli/repl-loop.mjs

@@ -16,10 +16,10 @@ export async function runSingleShotPrompt({
 }) {
   memoryStore.beginTurn();
   try {
-    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    const turnInput = await prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
     ui.writeln(turnInput.displayMessage);
-    ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
-    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
+    ui.recall?.({ hints: turnInput.userRecallHints, report: turnInput.userRecallReport });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ hints: turnInput.carryoverRecallHints, report: turnInput.carryoverRecallReport, variant: "assistant" });
     refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
@@ -185,10 +185,10 @@ function startReplTurn({ runtime, prompt, ui, refreshStatusBar, setTurnRunning,
 async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
   memoryStore.beginTurn();
   try {
-    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    const turnInput = await prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
     ui.writeln(turnInput.displayMessage);
-    ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
-    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
+    ui.recall?.({ hints: turnInput.userRecallHints, report: turnInput.userRecallReport });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ hints: turnInput.carryoverRecallHints, report: turnInput.carryoverRecallReport, variant: "assistant" });
     setTurnRunning(true);
     refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
@@ -215,7 +215,8 @@ async function handleTurnLifecycleAction(action, { runner, ui }) {
 function renderPendingAssistantRecallPreview({ runner, ui }) {
   if (runner.engine.hasRenderedPendingAssistantRecallHints?.()) return;
   const hints = runner.engine.peekPendingAssistantRecallHints?.() ?? [];
-  if (hints.length === 0) return;
-  ui.recall?.({ source: "assistant", hints });
+  const report = runner.engine.peekPendingAssistantRecallReport?.() ?? null;
+  if (hints.length === 0 && !report) return;
+  ui.recall?.({ hints, report, variant: "assistant" });
   runner.engine.markPendingAssistantRecallHintsRendered?.();
 }

package/src/cli/startup/app-runtime.mjs

@@ -11,6 +11,7 @@ import { createMarchAuthStorage } from "../../auth/storage.mjs";
 import { createRuntimeRunner } from "./create-runtime-runner.mjs";
 import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
+import { startSemanticMemoryRecallPreload } from "../../memory/markdown/semantic-preload.mjs";
 import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
 import { loadOrCreateProjectId, resumeStartupSession } from "./startup-session.mjs";
@@ -68,7 +69,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
   const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
   const profilePaths = defaultProfilePaths();
   ensureProfileFiles(profilePaths);
-  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
+  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot, stateRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
   const currentProject = basename(cwd);
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
@@ -140,6 +141,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
     return { ok: false, code: 1, logger };
   }
   syncRuntimeSessionStateFromRunner(sessionState, runner, sessionsRoot);
+  startSemanticMemoryRecallPreload({ memoryStore, logger, delayMs: 1000 });
 
   const initialRuntime = {
     project: currentProjectInfo,
@@ -166,7 +168,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
         stateRoot,
         memoryRoot,
         profilePaths,
-        createMemoryStore: () => new MarkdownMemoryStore({ root: memoryRoot }),
+        createMemoryStore: () => new MarkdownMemoryStore({ root: memoryRoot, stateRoot }),
         provider,
         serviceTier,
         model,

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

@@ -12,6 +12,7 @@ export function createMouseSelectionController({
   writeClipboard,
   requestRender,
 }) {
+  let leftDown = null;
   function copySelectionText(text) {
     if (!text) return false;
     let result;
@@ -43,6 +44,12 @@ export function createMouseSelectionController({
     requestRender();
   }
 
+  function toggleOutputToolCard(mouse) {
+    const hit = selection.hitTest?.(mouse);
+    if (hit?.regionId !== "output") return false;
+    return output.toggleToolCardAtVisibleRow?.(hit.row, terminal.columns || 80) === true;
+  }
+
   return {
     handleMouseInput(data) {
       const mouse = parseMouseEvent(data);
@@ -56,6 +63,7 @@ export function createMouseSelectionController({
         return { consume: true };
       }
       if (mouse?.type === "down" && mouse.button === 0) {
+        leftDown = mouse;
         selection.start(mouse);
         requestRender();
         return { consume: true };
@@ -66,7 +74,14 @@ export function createMouseSelectionController({
         return { consume: true };
       }
       if (mouse?.type === "up") {
+        const wasClick = isSamePoint(leftDown, mouse);
+        leftDown = null;
         selection.finish(mouse, { clear: false });
+        if (wasClick && toggleOutputToolCard(mouse)) {
+          selection.clear();
+          requestRender();
+          return { consume: true };
+        }
         requestRender();
         return { consume: true };
       }
@@ -84,6 +99,10 @@ export function createMouseSelectionController({
   };
 }
 
+function isSamePoint(a, b) {
+  return Boolean(a && b && a.row === b.row && a.col === b.col && a.button === b.button);
+}
+
 function compactStatusMessage(message) {
   const text = String(message || "unknown error").replace(/\s+/g, " ").trim();
   return text.length > 80 ? `${text.slice(0, 79)}…` : text;

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

@@ -4,7 +4,7 @@ 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 });
+    for (const line of lines) entries.push({ line, source: null, codeSource: null, block, baseRow: entries.length });
     return;
   }
   const source = { kind: "markdown", text: block.text, startRow: entries.length, endRow: entries.length + lines.length - 1 };
@@ -18,10 +18,10 @@ export function appendSelectableEntries(entries, block, lines, width) {
 }
 
 export function sliceEntriesWithTail(baseEntries, tailLine, range) {
-  if (!range) return tailLine == null ? baseEntries : [...baseEntries, { line: tailLine, source: null, codeSource: null, baseRow: baseEntries.length }];
+  if (!range) return tailLine == null ? baseEntries : [...baseEntries, { line: tailLine, source: null, codeSource: null, block: 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 });
+  if (tailLine != null && end > baseEntries.length) visible.push({ line: tailLine, source: null, codeSource: null, block: null, baseRow: baseEntries.length });
   return visible;
 }
 

package/src/cli/tui/output/timeline-block-restore.mjs

@@ -30,7 +30,7 @@ function appendTimelineBlock(output, block) {
       output.addBlock({ type: "status", lines: [String(block.content ?? "")] });
       break;
     case "recall":
-      output.addBlock({ type: "plain", lines: formatRecallLines(block.hints ?? []) });
+      output.addBlock({ type: "plain", lines: formatRecallLines(block.hints ?? [], block.report ?? null) });
       break;
     case "editDiff":
       output.addBlock({ type: "diff", path: block.path, diffLines: block.diffLines ?? [] });

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

@@ -206,6 +206,15 @@ export class OutputBuffer {
     return changed;
   }
 
+  toggleToolCardAtVisibleRow(row, width) {
+    const entry = this._visibleEntryAt(row, width);
+    const block = entry?.block;
+    if (block?.type !== "tool-card") return false;
+    block.expanded = !block.expanded;
+    this._invalidateBaseLines();
+    return true;
+  }
+
   invalidate() { this._invalidateBaseLines(); }
 
   _invalidateBaseLines() {
@@ -232,6 +241,15 @@ export class OutputBuffer {
     return brightBlack(`${SPINNER_FRAMES[this.spinnerIdx]} ${this.spinnerText}`);
   }
 
+  _visibleEntryAt(row, width) {
+    const visibleRow = Math.trunc(row);
+    if (visibleRow < 0) return null;
+    const baseEntries = this._renderBaseEntries(width);
+    const tailLine = this.spinning ? this._spinnerLine() : null;
+    const entries = sliceEntriesWithTail(baseEntries, tailLine, this.scrollState.sliceRange());
+    return entries[visibleRow] ?? null;
+  }
+
   _renderBaseLines(width) {
     const cached = this._baseLinesCache.get(width);
     if (cached) return cached;

package/src/cli/tui/recall-rendering.mjs

@@ -1,27 +1,56 @@
+import { formatScore } from "../../memory/markdown/markdown-recall.mjs";
 import { brightBlack } from "./ui-theme.mjs";
 
 const RECALL_ICON = "✦";
 
-export function formatRecallLines(hints = []) {
-  if (!hints.length) return [];
-  const noun = hints.length === 1 ? "note" : "notes";
+export function formatRecallLines(hints = [], report = null, { variant = "user" } = {}) {
+  if (variant === "assistant") return formatAssistantRecallLines(hints, report);
+  const candidates = report?.candidates ?? [];
+  const displayed = candidates.length ? candidates : hints.map((hint) => ({ ...hint, recalled: true }));
+  if (!hints.length && !displayed.length) return [];
+  const threshold = Number.isFinite(report?.threshold) ? ` · threshold ${formatScore(report.threshold)}` : "";
+  const fallback = report?.vectorizerStatus === "fallback" ? " · fallback" : "";
   return [
-    `${RECALL_ICON} Memory Recall · ${hints.length} ${noun}`,
-    ...hints.flatMap(formatHintLines),
+    `${RECALL_ICON} Memory Recall · ${recallSummary(hints, displayed)}${threshold}${fallback}`,
+    ...(report?.warning ? [`    ! ${report.warning}`] : []),
+    ...displayed.flatMap(formatHintLines),
   ];
 }
 
-export function writeRecall({ output, hints = [] }) {
-  const lines = formatRecallLines(hints);
+export function writeRecall({ output, hints = [], report = null, variant = "user" }) {
+  const lines = formatRecallLines(hints, report, { variant });
   lines.forEach((line) => {
-    if (line.startsWith("    ")) output.writeln(brightBlack(line));
+    if (variant === "assistant" || line.startsWith("    ")) output.writeln(brightBlack(line));
     else output.writeln(line);
   });
 }
 
+function formatAssistantRecallLines(hints, report) {
+  const candidates = (report?.candidates?.length ? report.candidates : hints.map((hint) => ({ ...hint, recalled: true }))).slice(0, 3);
+  const threshold = Number.isFinite(report?.threshold) ? ` · threshold ${formatScore(report.threshold)}` : "";
+  const fallback = report?.vectorizerStatus === "fallback" ? " · fallback" : "";
+  return [
+    `${RECALL_ICON} Memory Recall · ${recallSummary(hints, report?.candidates ?? candidates)}${threshold}${fallback}`,
+    ...(report?.warning ? [`  ! ${report.warning}`] : []),
+    ...(candidates.length ? candidates.map(formatCompactHintLine) : ["  no candidates"]),
+  ];
+}
+
+function recallSummary(hints, candidates) {
+  return `${hints.length} recalled · ${candidates.length} ${candidates.length === 1 ? "candidate" : "candidates"}`;
+}
+
+function formatCompactHintLine(hint) {
+  const title = hint.name || hint.id || "Untitled memory";
+  const mark = hint.recalled === false ? "×" : "✓";
+  return `  ${mark} ${formatScore(hint.score)} ${title}`;
+}
+
 function formatHintLines(hint) {
   const title = hint.name || hint.id || "Untitled memory";
-  const lines = [`  • ${title}`];
+  const mark = hint.recalled === false ? "×" : "✓";
+  const score = `${formatScore(hint.score)} `;
+  const lines = [`  ${mark} ${score}${title}`];
   if (hint.description) lines.push(`    ${hint.description}`);
   return lines;
 }

package/src/cli/tui/selection/ansi-range.mjs

@@ -0,0 +1,88 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+const INVERSE = "\x1b[7m";
+const RESET = "\x1b[0m";
+
+export function highlightAnsiLine(line, startCol, endCol) {
+  const { before, selected, after, activeAtStart, activeAtEnd } = splitAnsiColumns(line, startCol, endCol);
+  return `${before}${INVERSE}${activeAtStart}${keepInverseAfterReset(selected)}${RESET}${activeAtEnd}${after}`;
+}
+
+export function sliceColumns(text, startCol, endCol) {
+  let col = 0;
+  let result = "";
+  for (const ch of String(text ?? "")) {
+    const next = col + visibleWidth(ch);
+    if (next > startCol && col < endCol) result += ch;
+    col = next;
+    if (col >= endCol) break;
+  }
+  return result;
+}
+
+function keepInverseAfterReset(text) {
+  return String(text ?? "").replace(/\x1b\[([0-9;]*)m/g, (seq, body) => {
+    const params = body === "" ? ["0"] : body.split(";");
+    return params.includes("0") ? `${seq}${INVERSE}` : seq;
+  });
+}
+
+function splitAnsiColumns(text, startCol, endCol) {
+  let col = 0;
+  let i = 0;
+  let before = "";
+  let selected = "";
+  let after = "";
+  let active = "";
+  let activeAtStart = "";
+  let activeAtEnd = "";
+  let capturedStart = false;
+  let capturedEnd = false;
+  const source = String(text ?? "");
+
+  while (i < source.length) {
+    const ansi = readAnsi(source, i);
+    if (ansi) {
+      active = updateActiveSgr(active, ansi);
+      if (col < startCol) before += ansi;
+      else if (col < endCol) selected += ansi;
+      else after += ansi;
+      i += ansi.length;
+      continue;
+    }
+
+    const ch = source[i];
+    if (!capturedStart && col >= startCol) {
+      activeAtStart = active;
+      capturedStart = true;
+    }
+    if (!capturedEnd && col >= endCol) {
+      activeAtEnd = active;
+      capturedEnd = true;
+    }
+
+    const next = col + visibleWidth(ch);
+    if (next <= startCol) before += ch;
+    else if (col >= endCol) after += ch;
+    else selected += ch;
+    col = next;
+    i += 1;
+  }
+
+  if (!capturedStart) activeAtStart = active;
+  if (!capturedEnd) activeAtEnd = active;
+  return { before, selected, after, activeAtStart, activeAtEnd };
+}
+
+function readAnsi(text, offset) {
+  if (text[offset] !== "\x1b") return null;
+  const match = text.slice(offset).match(/^\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/);
+  return match?.[0] ?? null;
+}
+
+function updateActiveSgr(active, seq) {
+  if (!seq.startsWith("\x1b[") || !seq.endsWith("m")) return active;
+  const body = seq.slice(2, -1);
+  if (body === "" || body.split(";").includes("0")) return "";
+  return seq;
+}

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

@@ -1,8 +1,7 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
+import { highlightAnsiLine, sliceColumns } from "./selection/ansi-range.mjs";
 
 const CONTROL_RE = /\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
-const INVERSE = "\x1b[7m";
-const RESET = "\x1b[0m";
 
 export class ScreenSelection {
   constructor() {
@@ -118,6 +117,12 @@ export class ScreenSelection {
     });
   }
 
+  hitTest(point) {
+    const hit = hitRegion(point, this.regions);
+    if (!hit) return null;
+    return { regionId: hit.region.id, row: hit.localRow, col: hit.localCol };
+  }
+
   _plainLine(row) {
     if (!this._plainLines.has(row)) this._plainLines.set(row, stripAnsi(this.lines[row] ?? ""));
     return this._plainLines.get(row);
@@ -167,24 +172,19 @@ function localRange(range, region) {
 }
 
 function normalizePoint({ row, col }, regions, clamp) {
+  const hit = hitRegion({ row, col }, regions);
+  if (hit) {
+    const maxCol = Number.isFinite(hit.region.width) ? hit.region.width : Infinity;
+    return {
+      row: hit.region.docStart + hit.localRow,
+      col: clampNumber(hit.localCol, 0, maxCol),
+    };
+  }
+  if (!clamp) return null;
+
   const screenRow = Math.trunc(row) - 1;
-  const screenCol = Math.trunc(col) - 1;
   if (regions.length === 0) return null;
 
-  for (const region of regions) {
-    const localRow = screenRow - region.topRow;
-    const localCol = screenCol - region.leftCol;
-    const maxCol = Number.isFinite(region.width) ? region.width : Infinity;
-    if (localRow >= 0 && localRow < region.lines.length) {
-      if (!clamp && (localCol < 0 || localCol > maxCol)) return null;
-      return {
-        row: region.docStart + localRow,
-        col: clampNumber(localCol, 0, maxCol),
-      };
-    }
-  }
-
-  if (!clamp) return null;
   const first = regions[0];
   const last = regions.at(-1);
   if (screenRow < first.topRow) return { row: first.docStart, col: 0 };
@@ -205,94 +205,26 @@ function normalizePoint({ row, col }, regions, clamp) {
   return nearest ? { row: nearest.row, col: nearest.col } : null;
 }
 
-function comparePoints(a, b) {
-  if (a.row !== b.row) return a.row - b.row;
-  return a.col - b.col;
-}
-
-function highlightAnsiLine(line, startCol, endCol) {
-  const { before, selected, after, activeAtStart, activeAtEnd } = splitAnsiColumns(line, startCol, endCol);
-  return `${before}${INVERSE}${activeAtStart}${keepInverseAfterReset(selected)}${RESET}${activeAtEnd}${after}`;
-}
-
-function keepInverseAfterReset(text) {
-  return String(text ?? "").replace(/\x1b\[([0-9;]*)m/g, (seq, body) => {
-    const params = body === "" ? ["0"] : body.split(";");
-    return params.includes("0") ? `${seq}${INVERSE}` : seq;
-  });
-}
-
-function sliceColumns(text, startCol, endCol) {
-  let col = 0;
-  let result = "";
-  for (const ch of String(text ?? "")) {
-    const next = col + visibleWidth(ch);
-    if (next > startCol && col < endCol) result += ch;
-    col = next;
-    if (col >= endCol) break;
+function hitRegion({ row, col }, regions) {
+  const screenRow = Math.trunc(row) - 1;
+  const screenCol = Math.trunc(col) - 1;
+  for (const region of regions) {
+    const localRow = screenRow - region.topRow;
+    const localCol = screenCol - region.leftCol;
+    const maxCol = Number.isFinite(region.width) ? region.width : Infinity;
+    if (localRow < 0 || localRow >= region.lines.length) continue;
+    if (localCol < 0 || localCol > maxCol) continue;
+    return { region, localRow, localCol };
   }
-  return result;
+  return null;
 }
 
-function splitAnsiColumns(text, startCol, endCol) {
-  let col = 0;
-  let i = 0;
-  let before = "";
-  let selected = "";
-  let after = "";
-  let active = "";
-  let activeAtStart = "";
-  let activeAtEnd = "";
-  let capturedStart = false;
-  let capturedEnd = false;
-  const source = String(text ?? "");
-
-  while (i < source.length) {
-    const ansi = readAnsi(source, i);
-    if (ansi) {
-      active = updateActiveSgr(active, ansi);
-      if (col < startCol) before += ansi;
-      else if (col < endCol) selected += ansi;
-      else after += ansi;
-      i += ansi.length;
-      continue;
-    }
-
-    const ch = source[i];
-    if (!capturedStart && col >= startCol) {
-      activeAtStart = active;
-      capturedStart = true;
-    }
-    if (!capturedEnd && col >= endCol) {
-      activeAtEnd = active;
-      capturedEnd = true;
-    }
-
-    const next = col + visibleWidth(ch);
-    if (next <= startCol) before += ch;
-    else if (col >= endCol) after += ch;
-    else selected += ch;
-    col = next;
-    i += 1;
-  }
-
-  if (!capturedStart) activeAtStart = active;
-  if (!capturedEnd) activeAtEnd = active;
-  return { before, selected, after, activeAtStart, activeAtEnd };
+function comparePoints(a, b) {
+  if (a.row !== b.row) return a.row - b.row;
+  return a.col - b.col;
 }
 
-function readAnsi(text, offset) {
-  if (text[offset] !== "\x1b") return null;
-  const match = text.slice(offset).match(/^\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/);
-  return match?.[0] ?? null;
-}
 
-function updateActiveSgr(active, seq) {
-  if (!seq.startsWith("\x1b[") || !seq.endsWith("m")) return active;
-  const body = seq.slice(2, -1);
-  if (body === "" || body.split(";").includes("0")) return "";
-  return seq;
-}
 
 function clampNumber(value, min, max) {
   return Math.min(max, Math.max(min, value));