nolo-cli 0.33.0-alpha.19 → 0.33.0-alpha.20

package/index.js

@@ -796,7 +796,7 @@ async function runScript(script, forwardedArgs, env) {
   return proc.exited;
 }
 async function launchTuiWorkspace(args2) {
-  const { startTuiWorkspace } = await import("./readlineWorkspace-P6PZ64PS.js");
+  const { startTuiWorkspace } = await import("./readlineWorkspace-EH77JVMA.js");
   const { createTuiSummaryLlmCaller } = await import("./tuiSummaryLlmCaller-WUVAOIYU.js");
   return startTuiWorkspace({
     ...args2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.33.0-alpha.19",
+  "version": "0.33.0-alpha.20",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {

package/{readlineWorkspace-P6PZ64PS.js → readlineWorkspace-EH77JVMA.js}

@@ -675,13 +675,11 @@ function renderDialogCommand(text, colorEnabled = resolveCliColorEnabled()) {
   return themeText(`  ${text}`, "danger", colorEnabled);
 }
 
-// packages/cli/tui/tuiScrollbar.ts
-var SGR_MOUSE_REGEX = /^\x1b\[<(\d+);\d+;\d+[Mm]$/;
+// packages/cli/tui/tuiMouse.ts
+var SGR_MOUSE_REGEX = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
 function consumeSgrMouseSequence(buffer) {
   if (!buffer.startsWith("\x1B[")) return null;
-  if (!buffer.startsWith("\x1B[<")) {
-    return null;
-  }
+  if (!buffer.startsWith("\x1B[<")) return null;
   const body = buffer.slice(3);
   for (let index = 0; index < body.length; index += 1) {
     const character = body[index];
@@ -695,13 +693,75 @@ function consumeSgrMouseSequence(buffer) {
   }
   return void 0;
 }
+function parseSgrMouseEvent(sequence) {
+  const match = SGR_MOUSE_REGEX.exec(sequence);
+  if (!match) return null;
+  const code = Number(match[1]);
+  const x = Number(match[2]);
+  const y = Number(match[3]);
+  const isRelease = match[4] === "m";
+  const shift = (code & 4) !== 0;
+  const alt = (code & 8) !== 0;
+  const ctrl = (code & 16) !== 0;
+  if ((code & 64) !== 0) {
+    if ((code & 2) !== 0) {
+      return null;
+    }
+    const wheelDirection = (code & 1) !== 0 ? "down" : "up";
+    return {
+      kind: "wheel",
+      button: "none",
+      x,
+      y,
+      shift,
+      alt,
+      ctrl,
+      wheelDirection
+    };
+  }
+  const rawButton = code & 3;
+  let button = "none";
+  if (rawButton === 0) button = "left";
+  else if (rawButton === 1) button = "middle";
+  else if (rawButton === 2) button = "right";
+  if (isRelease) {
+    return {
+      kind: "release",
+      button,
+      x,
+      y,
+      shift,
+      alt,
+      ctrl
+    };
+  }
+  if ((code & 32) !== 0) {
+    return {
+      kind: "drag",
+      button,
+      x,
+      y,
+      shift,
+      alt,
+      ctrl
+    };
+  }
+  return {
+    kind: "press",
+    button,
+    x,
+    y,
+    shift,
+    alt,
+    ctrl
+  };
+}
+
+// packages/cli/tui/tuiScrollbar.ts
 function parseScrollAction(sequence) {
-  const mouse = SGR_MOUSE_REGEX.exec(sequence);
-  if (mouse) {
-    const button = Number(mouse[1]);
-    if ((button & 64) === 0) return null;
-    if ((button & 2) !== 0) return null;
-    return (button & 1) !== 0 ? "wheel-down" : "wheel-up";
+  const mouseEvent = parseSgrMouseEvent(sequence);
+  if (mouseEvent && mouseEvent.kind === "wheel") {
+    return mouseEvent.wheelDirection === "down" ? "wheel-down" : "wheel-up";
   }
   switch (sequence) {
     case "\x1B[5~":
@@ -1685,6 +1745,210 @@ async function runAskChoiceDialog(args) {
   };
 }
 
+// packages/cli/tui/tuiSelection.ts
+function createSelectionState() {
+  return {
+    dragging: false,
+    anchor: null,
+    head: null
+  };
+}
+function compareSelectionPoints(a, b) {
+  if (a.turnIndex !== b.turnIndex) {
+    return a.turnIndex - b.turnIndex;
+  }
+  return a.sourceOffset - b.sourceOffset;
+}
+function areSelectionPointsEqual(a, b) {
+  if (a === null && b === null) return true;
+  if (a === null || b === null) return false;
+  return a.turnIndex === b.turnIndex && a.sourceOffset === b.sourceOffset;
+}
+function hitTestHistory(history, screenRow, screenCol, contentWidth, scrollTop) {
+  if (history.turns.length === 0) return null;
+  const { entries } = buildTurnOffsets2(history, contentWidth);
+  if (entries.length === 0) return null;
+  const globalRow = scrollTop + screenRow;
+  const firstEntry = entries[0];
+  if (globalRow < firstEntry.startRow) {
+    return { turnIndex: 0, sourceOffset: 0 };
+  }
+  const lastIdx = entries.length - 1;
+  const lastEntry = entries[lastIdx];
+  const lastTurn = history.turns[lastIdx];
+  if (globalRow >= lastEntry.startRow + lastEntry.lineCount) {
+    return { turnIndex: lastIdx, sourceOffset: lastTurn.content.length };
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const turn = history.turns[i];
+    const turnStart = entry.startRow;
+    const turnEnd = turnStart + entry.lineCount;
+    if (entry.separatorAbove > 0 && globalRow === turnStart - 1) {
+      return { turnIndex: i, sourceOffset: 0 };
+    }
+    if (globalRow >= turnStart && globalRow < turnEnd) {
+      const rowInTurn = globalRow - turnStart;
+      const sourceOffset = mapRowColToSourceOffset(
+        turn.content,
+        turn.role,
+        contentWidth,
+        rowInTurn,
+        screenCol,
+        turn.command
+      );
+      return { turnIndex: i, sourceOffset };
+    }
+  }
+  return null;
+}
+function mapRowColToSourceOffset(content, role, contentWidth, targetRow, targetCol, command) {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const logicalLines = normalized.split("\n");
+  let currentRow = 0;
+  let charAccumulator = 0;
+  if (role === "local" && command) {
+    const cmdWrapped = wrapTranscriptLine(`\u203A ${command}`, contentWidth);
+    if (targetRow < cmdWrapped.length) {
+      return 0;
+    }
+    currentRow += cmdWrapped.length;
+  }
+  for (let l = 0; l < logicalLines.length; l++) {
+    const lineText = logicalLines[l];
+    const lineLen = lineText.length;
+    let wrappedRows;
+    let prefixFirst = 0;
+    let prefixCont = 0;
+    if (role === "user") {
+      wrappedRows = wrapTranscriptLine(`\u2503  ${lineText}`, contentWidth, "\u2503  ");
+      prefixFirst = 3;
+      prefixCont = 3;
+    } else if (role === "local") {
+      wrappedRows = wrapTranscriptLine(`  ${lineText}`, contentWidth, "  ");
+      prefixFirst = 2;
+      prefixCont = 2;
+    } else {
+      if (l === 0 && !lineText.startsWith("[nolo]")) {
+        wrappedRows = wrapTranscriptLine(`\u25C8 ${lineText}`, contentWidth);
+        prefixFirst = 2;
+        prefixCont = 0;
+      } else {
+        wrappedRows = wrapTranscriptLine(lineText, contentWidth);
+        prefixFirst = 0;
+        prefixCont = 0;
+      }
+    }
+    const rowCount = Math.max(1, wrappedRows.length);
+    if (targetRow >= currentRow && targetRow < currentRow + rowCount) {
+      const subRow = targetRow - currentRow;
+      let offsetInLine = 0;
+      for (let s = 0; s < subRow; s++) {
+        const rowStr = stripAnsi(wrappedRows[s] ?? "");
+        const pLen2 = s === 0 ? prefixFirst : prefixCont;
+        const pureText = rowStr.slice(pLen2);
+        offsetInLine += pureText.length;
+      }
+      const targetRowStr = stripAnsi(wrappedRows[subRow] ?? "");
+      const pLen = subRow === 0 ? prefixFirst : prefixCont;
+      const pureTargetText = targetRowStr.slice(pLen);
+      const effectiveCol = Math.max(0, targetCol - pLen);
+      let colAccum = 0;
+      for (let c = 0; c < pureTargetText.length; c++) {
+        const char = pureTargetText[c];
+        const w = displayWidth(char);
+        if (colAccum + w > effectiveCol) {
+          break;
+        }
+        colAccum += w;
+        offsetInLine += char.length;
+      }
+      let finalOffset = Math.min(normalized.length, charAccumulator + Math.min(lineLen, offsetInLine));
+      if (finalOffset > 0 && finalOffset < normalized.length && normalized.charCodeAt(finalOffset - 1) >= 55296 && normalized.charCodeAt(finalOffset - 1) <= 56319) {
+        finalOffset += 1;
+      }
+      return finalOffset;
+    }
+    currentRow += rowCount;
+    charAccumulator += lineLen + 1;
+  }
+  return normalized.length;
+}
+function extractSelectedText(history, anchor, head) {
+  if (!anchor || !head) return "";
+  const cmp = compareSelectionPoints(anchor, head);
+  if (cmp === 0) return "";
+  const start = cmp < 0 ? anchor : head;
+  const end = cmp < 0 ? head : anchor;
+  if (start.turnIndex === end.turnIndex) {
+    const turn = history.turns[start.turnIndex];
+    if (!turn) return "";
+    const raw = turn.content.slice(start.sourceOffset, end.sourceOffset);
+    return stripAnsi(raw);
+  }
+  const pieces = [];
+  const startTurn2 = history.turns[start.turnIndex];
+  if (startTurn2) {
+    pieces.push(startTurn2.content.slice(start.sourceOffset));
+  }
+  for (let i = start.turnIndex + 1; i < end.turnIndex; i++) {
+    const midTurn = history.turns[i];
+    if (midTurn) {
+      pieces.push(midTurn.content);
+    }
+  }
+  const endTurn = history.turns[end.turnIndex];
+  if (endTurn) {
+    pieces.push(endTurn.content.slice(0, end.sourceOffset));
+  }
+  return stripAnsi(pieces.join("\n\n"));
+}
+function applySelectionOverlay(visibleLines, history, contentWidth, scrollTop, selection) {
+  if (!selection.dragging || !selection.anchor || !selection.head) {
+    return visibleLines;
+  }
+  const cmp = compareSelectionPoints(selection.anchor, selection.head);
+  if (cmp === 0) return visibleLines;
+  const start = cmp < 0 ? selection.anchor : selection.head;
+  const end = cmp < 0 ? selection.head : selection.anchor;
+  const { entries } = buildTurnOffsets2(history, contentWidth);
+  const result = [...visibleLines];
+  for (let screenRow = 0; screenRow < visibleLines.length; screenRow++) {
+    const globalRow = scrollTop + screenRow;
+    let isSelectedRow = false;
+    for (let i = start.turnIndex; i <= end.turnIndex; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const turnStart = entry.startRow;
+      const turnEnd = turnStart + entry.lineCount;
+      if (i === start.turnIndex && i === end.turnIndex) {
+        if (globalRow >= turnStart && globalRow < turnEnd) {
+          isSelectedRow = true;
+        }
+      } else if (i === start.turnIndex) {
+        if (globalRow >= turnStart) {
+          isSelectedRow = true;
+        }
+      } else if (i === end.turnIndex) {
+        if (globalRow < turnEnd) {
+          isSelectedRow = true;
+        }
+      } else {
+        if (globalRow >= turnStart && globalRow < turnEnd) {
+          isSelectedRow = true;
+        }
+      }
+    }
+    if (isSelectedRow) {
+      const line = result[screenRow] ?? "";
+      if (line.length > 0) {
+        result[screenRow] = `\x1B[7m${line}\x1B[27m`;
+      }
+    }
+  }
+  return result;
+}
+
 // packages/cli/tui/tuiHistory.ts
 var MAX_TUI_HISTORY_TURNS = 500;
 var turnLineCache = /* @__PURE__ */ new WeakMap();
@@ -1965,7 +2229,7 @@ function countTurnLines(role, content, contentWidth, command) {
   }
   return count;
 }
-function buildTurnOffsets(history, contentWidth) {
+function buildTurnOffsets2(history, contentWidth) {
   const density = getActiveDensity();
   const entries = [];
   let offset = 0;
@@ -2009,7 +2273,7 @@ function buildCopyViewLines(history) {
   }
   return lines;
 }
-function renderHistory(output, history, inputLines) {
+function renderHistory(output, history, inputLines, selection) {
   const tty = output;
   if (!tty.isTTY) return;
   const rows = tty.rows ?? 24;
@@ -2019,7 +2283,7 @@ function renderHistory(output, history, inputLines) {
   const colorEnabled = resolveCliColorEnabled();
   const density = getActiveDensity();
   const surface = colorEnabled ? userSurfaceBackgroundSequence() : "";
-  const { entries, totalLines: finalizedLines } = buildTurnOffsets(
+  const { entries, totalLines: finalizedLines } = buildTurnOffsets2(
     history,
     contentWidth
   );
@@ -2050,7 +2314,7 @@ function renderHistory(output, history, inputLines) {
   history.hasMoreBelow = history.scrollTop + visibleHeight < totalLines;
   const winStart = history.scrollTop;
   const winEnd = Math.min(totalLines, winStart + visibleHeight);
-  const visibleLines = new Array(visibleHeight).fill("");
+  let visibleLines = new Array(visibleHeight).fill("");
   for (let i = 0; i < entries.length; i++) {
     const entry = entries[i];
     if (entry.separatorAbove > 0) {
@@ -2101,6 +2365,15 @@ function renderHistory(output, history, inputLines) {
       }
     }
   }
+  if (selection && selection.dragging) {
+    visibleLines = applySelectionOverlay(
+      visibleLines,
+      history,
+      contentWidth,
+      winStart,
+      selection
+    );
+  }
   const prevBuffer = typeof output === "object" && output !== null ? frameBufferByOutput.get(output) : void 0;
   const isGeometryCompatible = prevBuffer !== void 0 && prevBuffer.rows === rows && prevBuffer.columns === columns && prevBuffer.inputLines === inputLines && prevBuffer.lines.length === visibleHeight;
   const prevLines = isGeometryCompatible ? prevBuffer.lines : void 0;
@@ -2153,7 +2426,7 @@ function applyScrollAction(history, action, output, inputLines) {
   const columns = tty.columns ?? 80;
   const visibleHeight = Math.max(1, rows - inputLines);
   const contentWidth = Math.max(1, columns - 1);
-  const { totalLines: finalizedLines } = buildTurnOffsets(history, contentWidth);
+  const { totalLines: finalizedLines } = buildTurnOffsets2(history, contentWidth);
   let totalLines = finalizedLines;
   if (history.currentRole !== null && history.currentContent) {
     totalLines += currentTurnSeparator(history, getActiveDensity()) + countTurnLines(history.currentRole, history.currentContent, contentWidth);
@@ -5157,9 +5430,9 @@ function createFixedInput(output, config) {
   };
   let mouseEnabled = true;
   const enableMouse = () => {
-    if (mouseEnabled) write("\x1B[?1006h\x1B[?1000h");
+    if (mouseEnabled) write("\x1B[?1006h\x1B[?1002h");
   };
-  const disableMouse = () => write("\x1B[?1000l\x1B[?1006l");
+  const disableMouse = () => write("\x1B[?1002l\x1B[?1006l");
   let lastRenderedText = null;
   let lastStartRow = -1;
   let lastCursorRow = -1;
@@ -5334,9 +5607,9 @@ function createFixedInput(output, config) {
     setMouseEnabled(enabled) {
       mouseEnabled = enabled;
       if (enabled) {
-        write("\x1B[?1006h\x1B[?1000h");
+        write("\x1B[?1006h\x1B[?1002h");
       } else {
-        write("\x1B[?1000l\x1B[?1006l");
+        write("\x1B[?1002l\x1B[?1006l");
       }
     },
     setAltScreenEnabled(enabled) {
@@ -6217,12 +6490,32 @@ async function startTuiWorkspace(options) {
     }
   });
   let syncingLayout = false;
+  const selectionState = createSelectionState();
+  let autoScrollTimer = null;
+  let lastDragMouseX = 1;
+  const stopAutoScroll = () => {
+    if (autoScrollTimer) {
+      clearInterval(autoScrollTimer);
+      autoScrollTimer = null;
+    }
+  };
+  const clearSelection = () => {
+    stopAutoScroll();
+    selectionState.dragging = false;
+    selectionState.anchor = null;
+    selectionState.head = null;
+  };
   const renderHistoryToOutput = () => {
     if (fixedInput.isPaused()) return;
     if (syncingLayout) return;
     syncingLayout = true;
     try {
-      renderHistory(output, history, fixedInput.getInputLines());
+      renderHistory(
+        output,
+        history,
+        fixedInput.getInputLines(),
+        selectionState
+      );
     } finally {
       syncingLayout = false;
     }
@@ -6964,6 +7257,10 @@ ${err.message}` : ""}`
       repaint(draft, cursorPos2) {
         syncWindowTitle();
         return baseFixedInput.repaint(draft, cursorPos2);
+      },
+      pause() {
+        clearSelection();
+        return baseFixedInput.pause();
       }
     };
     fixedInput.init();
@@ -6973,6 +7270,7 @@ ${err.message}` : ""}`
     };
     const onResize = () => {
       if (done) return;
+      clearSelection();
       if (copyViewExitResolver) {
         copyViewRender?.();
         return;
@@ -6991,6 +7289,7 @@ ${err.message}` : ""}`
       if (done) return;
       done = true;
       sessionEnded = true;
+      clearSelection();
       if (autoThemeTimer !== null) {
         clearInterval(autoThemeTimer);
         autoThemeTimer = null;
@@ -7084,6 +7383,51 @@ ${err.message}` : ""}`
         );
       });
     };
+    let autoScrollDirection = "up";
+    const startAutoScroll = (direction, mouseX) => {
+      autoScrollDirection = direction;
+      lastDragMouseX = mouseX;
+      if (autoScrollTimer) return;
+      autoScrollTimer = setInterval(() => {
+        if (!selectionState.dragging || !selectionState.anchor || fixedInput.isPaused()) {
+          stopAutoScroll();
+          return;
+        }
+        const tty = output;
+        const rows = tty.rows ?? 24;
+        const columns = tty.columns ?? 80;
+        const visibleHeight = Math.max(1, rows - fixedInput.getInputLines());
+        const contentWidth = Math.max(1, columns - 1);
+        if (autoScrollDirection === "up") {
+          if (history.scrollTop > 0) {
+            history.scrollTop = Math.max(0, history.scrollTop - 1);
+            history.followBottom = false;
+          } else {
+            stopAutoScroll();
+          }
+        } else {
+          const { totalLines } = buildTurnOffsets(history, contentWidth);
+          const maxScroll = Math.max(0, totalLines - visibleHeight);
+          if (history.scrollTop < maxScroll) {
+            history.scrollTop = Math.min(maxScroll, history.scrollTop + 1);
+          } else {
+            stopAutoScroll();
+          }
+        }
+        const screenRow = autoScrollDirection === "up" ? 0 : visibleHeight - 1;
+        const hit = hitTestHistory(
+          history,
+          screenRow,
+          lastDragMouseX - 1,
+          contentWidth,
+          history.scrollTop
+        );
+        if (hit) {
+          selectionState.head = hit;
+        }
+        paintFrame(buffer);
+      }, 60);
+    };
     const handleInputToken = async (sequence) => {
       if (done) return;
       if (copyViewExitResolver) {
@@ -7158,6 +7502,84 @@ ${merged}` : merged;
         return handleInputToken("\r");
       }
       const busyLock = busy;
+      const mouseEvent = parseSgrMouseEvent(sequence);
+      if (mouseEvent) {
+        if (fixedInput.isPaused()) return;
+        if (mouseEvent.kind === "wheel") {
+          const scrollAction2 = mouseEvent.wheelDirection === "down" ? "wheel-down" : "wheel-up";
+          applyScrollAction(history, scrollAction2, output, fixedInput.getInputLines());
+          paintFrame(buffer);
+          return;
+        }
+        const tty = output;
+        const rows = tty.rows ?? 24;
+        const columns = tty.columns ?? 80;
+        const visibleHeight = Math.max(1, rows - fixedInput.getInputLines());
+        const contentWidth = Math.max(1, columns - 1);
+        const screenRow = mouseEvent.y - 1;
+        const screenCol = mouseEvent.x - 1;
+        if (mouseEvent.kind === "press" && mouseEvent.button === "left") {
+          stopAutoScroll();
+          if (screenRow < visibleHeight && screenCol < contentWidth) {
+            const hit = hitTestHistory(
+              history,
+              screenRow,
+              screenCol,
+              contentWidth,
+              history.scrollTop
+            );
+            selectionState.anchor = hit;
+            selectionState.head = hit;
+            selectionState.dragging = false;
+          } else {
+            clearSelection();
+          }
+          return;
+        }
+        if (mouseEvent.kind === "drag" && mouseEvent.button === "left") {
+          if (!selectionState.anchor) return;
+          selectionState.dragging = true;
+          lastDragMouseX = mouseEvent.x;
+          const clampedRow = Math.max(0, Math.min(visibleHeight - 1, screenRow));
+          const hit = hitTestHistory(
+            history,
+            clampedRow,
+            screenCol,
+            contentWidth,
+            history.scrollTop
+          );
+          if (hit) {
+            selectionState.head = hit;
+          }
+          if (screenRow <= 1 && history.scrollTop > 0) {
+            startAutoScroll("up", mouseEvent.x);
+          } else if (screenRow >= visibleHeight - 2) {
+            startAutoScroll("down", mouseEvent.x);
+          } else {
+            stopAutoScroll();
+          }
+          paintFrame(buffer);
+          return;
+        }
+        if (mouseEvent.kind === "release") {
+          stopAutoScroll();
+          if (selectionState.dragging && selectionState.anchor && selectionState.head && !areSelectionPointsEqual(selectionState.anchor, selectionState.head)) {
+            const textToCopy = extractSelectedText(
+              history,
+              selectionState.anchor,
+              selectionState.head
+            );
+            if (textToCopy.length > 0) {
+              import("./clipboardy-MMBYVRLF.js").then(({ default: clipboard }) => clipboard.write(textToCopy)).catch(() => {
+              });
+            }
+          }
+          clearSelection();
+          paintFrame(buffer);
+          return;
+        }
+        return;
+      }
       const scrollAction = parseScrollAction(sequence);
       if (scrollAction) {
         if (fixedInput.isPaused()) return;