dsh-neotui 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-neotui",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Neo-TUI: mouse-driven terminal UI client for DeepSeek Harness (B-tier per dsh-tui-design.md)",
   "type": "module",
   "bin": { "dsh-neotui": "bin/dsh-tui.js" },

package/src/views.js

@@ -696,7 +696,7 @@ export class ChatView extends Widget {
     if (idx < 0 || idx >= this.nodes.length) return false;
     for (let li = 0; li < this.lineMap.length; li++) {
       if (this.lineMap[li]?.nodeIdx === idx) {
-        this.view.scrollY = Math.max(0, li - 2);
+        this.view.anchorLock = null; this.view.scrollY = Math.max(0, li - 2);
         this.app.redraw();
         return true;
       }
@@ -770,7 +770,7 @@ export class ChatView extends Widget {
     this.#rebuild();
     // Jump to the LIVE tail (the newest content) on open — the view would
     // otherwise sit at the top showing the oldest turns.
-    this.view.scrollY = this.view.maxScroll();
+    this.view.anchorLock = null; this.view.scrollY = this.view.maxScroll();
   }
 
   async loadOlder() {
@@ -817,6 +817,7 @@ export class ChatView extends Widget {
   send(text) {
     if (!this.sessionId) return;
     const trimmed = text.trim();
+    if (trimmed === "/reload") { this.app.reloadApp(); return; }
     if (!trimmed) return;
     const { parts, images, errors } = buildPromptParts(trimmed, {
       readFile: (p) => {
@@ -836,12 +837,29 @@ export class ChatView extends Widget {
   }
 
   #clickLine(y, ev) {
-    // Capture the viewport geometry BEFORE any flush: the flush can grow the
-    // streaming tail (and atBottom snaps the view 1–2 rows), so anchoring on
-    // the post-flush state would reproduce exactly the shift the user saw.
-    // The pre-flush lineMap is what the user clicked on.
+    // NO flush here: the click maps against the exact frame the user saw.
+    // Flushing would re-derive the streaming tail (the chunk-stream and the
+    // poll snapshot produce DIFFERENT block structures) and make y point at a
+    // different block — the source of the 5–6 line offsets.
+    return this.#toggleAt(this.lineMap?.[y]);
+  }
+
+  /** Toggle the block/node under a line-mark, then re-anchor the viewport.
+   *  `info` must be the mark of the frame the user clicked on. */
+  #toggleAt(info) {
+    if (!info) return false;
+    if (info.imgIdx !== undefined) {
+      const node = this.nodes[info.nodeIdx];
+      const ref = node?.images?.[info.imgIdx];
+      if (ref) { this.app.openImage(ref, { all: node.images, index: info.imgIdx }); return true; }
+    }
+    const node = this.nodes[info.nodeIdx];
+    if (!node) return false;
+    // anchor context captured from the frame the user saw:
+    // - the clicked block's header line + its viewport row (primary anchor)
+    // - the viewport-top line's identity + offset (fallback for deep clicks)
     const lineKey = (m) => (m ? `${m.nodeIdx}:${m.blockIdx ?? "n"}` : null);
-    const topKey = lineKey(this.lineMap?.[this.view.scrollY]) ?? null;
+    const topKey = lineKey(this.lineMap[this.view.scrollY]) ?? null;
     let topFirst = -1;
     if (topKey !== null) {
       for (let i = 0; i < this.lineMap.length; i++) {
@@ -849,91 +867,78 @@ export class ChatView extends Widget {
       }
     }
     const topOffset = topFirst >= 0 ? this.view.scrollY - topFirst : 0;
-    // the clicked block's header (first non-empty line with its mark) and its
-    // pre-click viewport row — the PRIMARY anchor: keep the clicked thing put
-    const preInfo = this.lineMap?.[y];
-    const clickedMatch = preInfo?.blockIdx !== null
-      ? (m) => m?.nodeIdx === preInfo?.nodeIdx && m?.blockIdx === preInfo?.blockIdx
-      : (m) => m?.nodeIdx === preInfo?.nodeIdx;
-    const firstNonEmpty = (match) => {
+    const match = info.blockIdx !== null
+      ? (m) => m?.nodeIdx === info.nodeIdx && m?.blockIdx === info.blockIdx
+      : (m) => m?.nodeIdx === info.nodeIdx;
+    const firstNonEmpty = (m) => {
       for (let i = 0; i < this.lineMap.length; i++) {
-        if (match(this.lineMap[i]) && (this.lines[i] ?? []).some((g) => g.t.trim() !== "")) return i;
+        if (m(this.lineMap[i]) && (this.lines[i] ?? []).some((g) => g.t.trim() !== "")) return i;
       }
       return -1;
     };
-    const preHeaderIdx = preInfo ? firstNonEmpty(clickedMatch) : -1;
+    const preHeaderIdx = firstNonEmpty(match);
     const preHeaderRow = preHeaderIdx >= 0 ? preHeaderIdx - this.view.scrollY : null;
-    // A queued (deferred) rebuild would leave lineMap one frame behind the
-    // nodes array; flush now so the click maps to the CURRENT node/block.
-    this.flushRebuild();
-    // map rendered line back to node via cached line→node map
-    const info = this.lineMap?.[y];
-    if (info) {
-      if (info.imgIdx !== undefined) {
-        const node = this.nodes[info.nodeIdx];
-        const ref = node?.images?.[info.imgIdx];
-        if (ref) { this.app.openImage(ref, { all: node.images, index: info.imgIdx }); return true; }
-      }
-      const node = this.nodes[info.nodeIdx];
-      // Expand/collapse changes the line count around the click. Primary
-      // anchor: the clicked block's header stays at its pre-click viewport
-      // row (zero shift). Fallback (header was above the viewport — a deep
-      // content click): restore the pre-click viewport-top position.
-      const reanchor = () => {
-        // primary anchor applies only when the header was ON-SCREEN (a deep
-        // content click has the header above the viewport — use the fallback)
-        if (preHeaderRow !== null && preHeaderRow >= 0 && preHeaderIdx >= 0) {
-          const h2 = firstNonEmpty((m) => m?.nodeIdx === info.nodeIdx && m?.blockIdx === info.blockIdx);
-          if (h2 >= 0) {
-            this.view.scrollY = Math.max(0, Math.min(h2 - preHeaderRow, this.view.maxScroll()));
-            return;
-          }
-        }
-        if (topKey === null || topFirst < 0) return;
-        let first = -1, last = -1;
-        for (let i = 0; i < this.lineMap.length; i++) {
-          if (lineKey(this.lineMap[i]) !== topKey) continue;
-          if (first < 0) first = i;
-          last = i;
-        }
-        if (first < 0) return;
-        const target = Math.min(first + topOffset, last);
-        this.view.scrollY = Math.max(0, Math.min(target, this.view.maxScroll()));
-      };
-      // never park the viewport on a blank separator row — it reads as a
-      // spurious offset right after the click
-      const nudge = () => {
-        while (
-          this.view.scrollY < this.lineMap.length - 1 &&
-          !(this.lines[this.view.scrollY] ?? []).some((g) => g.t.trim() !== "")
-        ) this.view.scrollY++;
-      };
-      if (node?.kind === "assistant" && info.blockIdx !== null) {
-        const b = node.blocks[info.blockIdx];
-        if (b && (b.kind === "tool" || b.kind === "reasoning" || b.kind === "other" || b.kind === "text")) {
-          const key = `${info.nodeIdx}:${info.blockIdx}`;
-          if (b.kind === "reasoning") {
-            // clean two-state override: expand ⇄ collapse (never a no-op click)
-            const open = this.expanded.has(key) || (!this.collapsedBlocks.has(key) && this.thinkMode === "expanded");
-            if (open) { this.expanded.delete(key); this.collapsedBlocks.add(key); }
-            else { this.collapsedBlocks.delete(key); this.expanded.add(key); }
-          } else {
-            if (this.collapsedBlocks.has(key)) this.collapsedBlocks.delete(key);
-            else this.collapsedBlocks.add(key);
-          }
-          this.#rebuild();
-          reanchor(); nudge();
-          return true;
+    const reanchor = () => {
+      // primary anchor: the clicked block's header stays at its pre-click
+      // viewport row (zero shift) — only when the header was ON-SCREEN.
+      // When the fold removed the tail content below, the anchored position
+      // may exceed maxScroll: hold it via the view's anchorLock instead of
+      // clamping (the clamp is exactly the 5–6 line slide the user sees).
+      if (preHeaderRow !== null && preHeaderRow >= 0 && preHeaderIdx >= 0) {
+        const h2 = firstNonEmpty(match);
+        if (h2 >= 0) {
+          const sy = h2 - preHeaderRow;
+          this.view.scrollY = Math.max(0, sy);
+          if (sy > this.view.maxScroll()) this.view.anchorLock = sy;
+          return;
         }
       }
-      if (node && (node.kind === "assistant" || node.kind === "user")) {
-        if (this.expanded.has(info.nodeIdx)) this.expanded.delete(info.nodeIdx);
-        else this.expanded.add(info.nodeIdx);
+      // fallback (deep content click): restore the viewport-top position
+      if (topKey === null || topFirst < 0) return;
+      let first = -1, last = -1;
+      for (let i = 0; i < this.lineMap.length; i++) {
+        if (lineKey(this.lineMap[i]) !== topKey) continue;
+        if (first < 0) first = i;
+        last = i;
+      }
+      if (first < 0) return;
+      const target = Math.min(first + topOffset, last);
+      this.view.scrollY = Math.max(0, target);
+      if (target > this.view.maxScroll()) this.view.anchorLock = target;
+    };
+    // never park the viewport on a blank separator row — it reads as a
+    // spurious offset right after the click
+    const nudge = () => {
+      while (
+        this.view.scrollY < this.lineMap.length - 1 &&
+        !(this.lines[this.view.scrollY] ?? []).some((g) => g.t.trim() !== "")
+      ) this.view.scrollY++;
+    };
+    if (node.kind === "assistant" && info.blockIdx !== null) {
+      const b = node.blocks[info.blockIdx];
+      if (b && (b.kind === "tool" || b.kind === "reasoning" || b.kind === "other" || b.kind === "text")) {
+        const key = `${info.nodeIdx}:${info.blockIdx}`;
+        if (b.kind === "reasoning") {
+          // clean two-state override: expand ⇄ collapse (never a no-op click)
+          const open = this.expanded.has(key) || (!this.collapsedBlocks.has(key) && this.thinkMode === "expanded");
+          if (open) { this.expanded.delete(key); this.collapsedBlocks.add(key); }
+          else { this.collapsedBlocks.delete(key); this.expanded.add(key); }
+        } else {
+          if (this.collapsedBlocks.has(key)) this.collapsedBlocks.delete(key);
+          else this.collapsedBlocks.add(key);
+        }
         this.#rebuild();
         reanchor(); nudge();
         return true;
       }
     }
+    if (node.kind === "assistant" || node.kind === "user") {
+      if (this.expanded.has(info.nodeIdx)) this.expanded.delete(info.nodeIdx);
+      else this.expanded.add(info.nodeIdx);
+      this.#rebuild();
+      reanchor(); nudge();
+      return true;
+    }
     return false;
   }
 
@@ -1336,14 +1341,14 @@ export class ChatView extends Widget {
         return true;
       }
       if (ev.kind === "press" && ev.button === 2) {
-        this.flushRebuild(); // keep lineMap current with the nodes array
+        // map against the frame the user saw — no flush (see #clickLine)
         const y = ev.y - this.view.y + this.view.scrollY;
         const info = this.lineMap?.[y];
         if (info) {
           const node = this.nodes[info.nodeIdx];
           const items = [
             { label: "复制消息", action: () => this.app.copyNode(info.nodeIdx) },
-            { label: "展开 / 折叠", action: () => this.#clickLine(y, ev) },
+            { label: "展开 / 折叠", action: () => this.#toggleAt(info) },
           ];
           if (node?.id) {
             items.push({ label: "转跳轨迹", action: () => this.app.jumpToTrajectoryNode(info.nodeIdx) });
@@ -1381,12 +1386,12 @@ export class ChatView extends Widget {
       case "pgdn": return this.view.scroll(this.view.h);
     }
     if (ev.name === "char" && ev.key === "g" && !ev.ctrl && !ev.shift) {
-      if (this.gKey) { this.gKey = false; this.view.scrollY = 0; return true; }
+      if (this.gKey) { this.gKey = false; this.view.anchorLock = null; this.view.scrollY = 0; return true; }
       this.gKey = true;
       this.app.toast("再按 g 回顶");
       return true;
     }
-    if (ev.name === "char" && ev.key === "g" && ev.shift) { this.view.scrollY = this.view.maxScroll(); return true; }
+    if (ev.name === "char" && ev.key === "g" && ev.shift) { this.view.anchorLock = null; this.view.scrollY = this.view.maxScroll(); return true; }
     if (ev.name === "escape" && this.app.searchQuery) { this.app.searchQuery = null; this.queueRebuild(); return true; }
     if (ev.name === "escape" && this.selStart !== null) { this.selStart = this.selEnd = null; this.app.redraw(); return true; }
     if (ev.name === "char" && ev.key === "i" && !ev.ctrl) { this.app.focus(this.input); return true; }
@@ -2189,6 +2194,25 @@ export class App {
   showModePicker() { this.overlay = buildModePicker(this); this.redraw(); }
   showPermissionPicker() { this.overlay = buildPermissionPicker(this); this.redraw(); }
 
+  /** /reload: restart the TUI process in the same terminal so a freshly
+   *  published build (the profile symlinks the repo) takes effect without
+   *  quitting and re-running `dsh` by hand. */
+  async reloadApp() {
+    this.toast("正在重启 TUI…");
+    this.redraw();
+    await new Promise((r) => setTimeout(r, 250));
+    try { this.term?.stop?.(); } catch {}
+    try {
+      const { spawn } = await import("node:child_process");
+      const child = spawn(process.argv[0], process.argv.slice(1), { detached: true, stdio: "inherit" });
+      child.unref();
+    } catch (e) {
+      this.toast(`重启失败: ${e.message}（请手动重启）`);
+      return;
+    }
+    process.exit(0);
+  }
+
   /** Ctrl+E: fzf-style quick jump to a step — type to fuzzy-filter the step
    *  list, Enter opens the trajectory window around the picked step. */
   async quickJumpStep() {

package/src/widgets.js

@@ -27,6 +27,7 @@ export class ScrollView extends Widget {
     super(opts);
     this.lines = [];       // array of arrays of segs: {t, fg, bg, bold, italic, underline, strike, code, link}
     this.scrollY = 0;
+    this.anchorLock = null; // click anchor held beyond maxScroll (fold at the tail)
     this.autoScroll = opts.autoScroll ?? false;
     this.onClick = opts.onClick ?? null;    // (y, ev) => bool
     this.onWheel = null;                    // optional custom wheel handler
@@ -36,7 +37,12 @@ export class ScrollView extends Widget {
   setLines(lines, { keep = false } = {}) {
     const atBottom = this.autoScroll && this.scrollY + this.h >= this.lines.length - 1 || (keep && this.scrollY + this.h >= this.lines.length);
     this.lines = lines;
-    if (atBottom || this.scrollY > Math.max(0, this.lines.length - this.h)) {
+    if (this.anchorLock != null) {
+      // A click fold removed the tail content: hold the exact anchored
+      // position even though the buffer now ends above it (no delayed snap).
+      this.scrollY = this.anchorLock;
+      if (this.scrollY <= Math.max(0, this.lines.length - this.h)) this.anchorLock = null;
+    } else if (atBottom || this.scrollY > Math.max(0, this.lines.length - this.h)) {
       this.scrollY = Math.max(0, this.lines.length - this.h);
     }
   }
@@ -44,6 +50,7 @@ export class ScrollView extends Widget {
   maxScroll() { return Math.max(0, this.lines.length - this.h); }
   scroll(dy) {
     const before = this.scrollY;
+    this.anchorLock = null; // explicit scroll releases the click anchor
     this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY + dy));
     return this.scrollY !== before;
   }
@@ -78,7 +85,8 @@ export class ScrollView extends Widget {
       const trackH = Math.max(1, this.h - 2);
       const total = Math.max(1, this.lines.length);
       const thumbH = Math.max(1, Math.floor(this.h * this.h / total));
-      const thumbY = Math.floor((this.h - 2) * this.scrollY / Math.max(1, this.maxScroll()));
+      const frac = Math.min(1, this.scrollY / Math.max(1, this.maxScroll()));
+      const thumbY = Math.floor((this.h - 2) * frac);
       for (let i = 0; i < this.h; i++) {
         const inThumb = i >= 1 + thumbY && i < 1 + thumbY + thumbH;
         const inTrack = i >= 1 && i < this.h - 1;
@@ -114,6 +122,7 @@ export class ScrollView extends Widget {
     return false;
   }
   #scrubTo(ey) {
+    this.anchorLock = null; // scrubbing releases the click anchor
     const trackH = Math.max(1, this.h - 2);
     const total = Math.max(1, this.lines.length);
     const thumbH = Math.max(1, Math.floor(this.h * this.h / total));