Fix streaming performance bottlenecks in thinking blocks and redisplay (dnouri#153)

* Fix streaming performance bottlenecks in thinking blocks and redisplay

Thinking-block rendering was O(n) in accumulated content: every delta
deleted and reinserted the entire blockquote region.  Track previously
rendered text and append only the new suffix when possible, falling
back to full rewrite only when normalization alters earlier content.

Bind inhibit-redisplay in the process filter so that multiple JSON
lines delivered in one read() produce a single redisplay cycle.

Filter function-based entries from treesit-range-settings when
harvesting embedded-mode configs in md-ts-mode.  Such entries create
host-level parsers that re-parse the whole buffer on every redisplay.

* pi-coding-agent-render.el (pi-coding-agent--render-thinking-content):
  Use incremental suffix insertion; track state in new variable
  pi-coding-agent--thinking-prev-rendered.
  (pi-coding-agent--reset-thinking-state): Clear it.
* pi-coding-agent-ui.el (pi-coding-agent--thinking-prev-rendered): New.
* pi-coding-agent-core.el (pi-coding-agent--process-filter):
  Bind inhibit-redisplay around the dispatch loop.
* md-ts-mode.el (md-ts--add-config-for-mode):
  Keep only query-based range settings; drop function-based ones.
* test/pi-coding-agent-core-test.el: Test that inhibit-redisplay is
  bound during dispatch.
* test/pi-coding-agent-render-test.el: Test incremental suffix path,
  tool-header short-circuit, and range-settings filtering.

* Sync md-ts-mode.el with upstream (dnouri/md-ts-mode bd2ac57)

Picks up two fixes from upstream that affect streaming sessions:

Workaround for tree-sitter < 0.25.0 integer underflow in local
parsers.  After an edit outside a local parser's included range,
unsigned subtraction in length_sub/point_sub corrupts point fields
and makes incremental reparse silently return zero query matches.
Inline markup (backticks, bold, links) fails to fontify when
content is inserted line by line, as happens during LLM streaming.
The workaround recreates each local parser when the buffer has been
modified since the parser was last updated, forcing a full reparse.

Filter function-based range settings when harvesting embedded mode
configs.  Function-based entries create host-level parsers that
re-parse the whole buffer as the embedded language on every
redisplay cycle.

The range-settings filter test moves to the upstream test suite;
remove the local copy from pi-coding-agent-render-test.el.

Author: dnouri

md-ts-mode.el

@@ -342,6 +342,38 @@ BEG, END, OFFSET, and RANGE-FN are passed through."
                 (md-ts--treesit-query-range
                  parser query beg end offset range-fn)))))
 
+;; WORKAROUND: tree-sitter < 0.25.0 integer underflow in
+;; `length_sub'/`point_sub'.  After an edit outside a local parser's
+;; included range, unsigned subtraction underflows, corrupting point
+;; fields and making incremental reparse silently produce zero query
+;; matches.  Fixed upstream by commit f3d50f27 (ts 0.25.0, 2025-01-31).
+;;
+;; Workaround: replace the parser with a fresh one so
+;; `ts_parser_parse' does a full (non-incremental) reparse.
+;;
+;; REMOVAL: once tree-sitter >= 0.25.0 can be assumed, delete this
+;; function and its two call-sites (in
+;; `md-ts--treesit--update-ranges-local' and
+;; `md-ts--refresh-local-parsers').
+(defun md-ts--recreate-local-parser (ov old-parser)
+  "Delete OLD-PARSER on OV and create a fresh replacement.
+Return the new parser, or nil if creation fails."
+  (let ((lang (treesit-parser-language old-parser))
+        (embed-level
+         (when (fboundp 'treesit-parser-embed-level)
+           (funcall (intern "treesit-parser-embed-level") old-parser))))
+    (treesit-parser-delete old-parser)
+    (let ((new-parser
+           (condition-case nil
+               (md-ts--parser-create lang nil t 'embedded)
+             (treesit-load-language-error nil))))
+      (when new-parser
+        (when embed-level
+          (funcall (intern "treesit-parser-set-embed-level")
+                   new-parser embed-level))
+        (overlay-put ov 'treesit-parser new-parser))
+      new-parser)))
+
 (defun md-ts--treesit--update-ranges-local
     (query embedded-lang modified-tick &optional beg end offset range-fn)
   "Update ranges for local parsers between BEG and END.
@@ -365,11 +397,19 @@ OFFSET, and RANGE-FN control overlay timestamps and range computation."
                                  (parser-lang (treesit-parser-language
                                                embedded-parser)))
                        (when (eq parser-lang lang)
-                         (treesit-parser-set-included-ranges
-                          embedded-parser `((,beg . ,end)))
-                         (move-overlay ov beg end)
-                         (overlay-put ov 'treesit-parser-ov-timestamp
-                                      modified-tick)
+                         (let ((ov-tick (overlay-get
+                                         ov
+                                         'treesit-parser-ov-timestamp)))
+                           (when (not (eql ov-tick modified-tick))
+                             (setq embedded-parser
+                                   (md-ts--recreate-local-parser
+                                    ov embedded-parser))))
+                         (when embedded-parser
+                           (treesit-parser-set-included-ranges
+                            embedded-parser `((,beg . ,end)))
+                           (move-overlay ov beg end)
+                           (overlay-put ov 'treesit-parser-ov-timestamp
+                                        modified-tick))
                          (throw 'done t)))))))
             (when (not has-parser)
               (let ((embedded-parser
@@ -447,6 +487,32 @@ If BEG and END are non-nil, only update ranges in that region."
     (fset (car pair) (symbol-function (cdr pair))))
   (setq md-ts--range-shims-installed t))
 
+;; On Emacs 31+ the native `treesit--update-ranges-local' is used
+;; (our shims are not installed), so the workaround from
+;; `md-ts--recreate-local-parser' must be applied via :before advice
+;; on `treesit-update-ranges'.  It must be :before because the native
+;; function stamps overlays with the current tick.
+(unless md-ts--range-shims-installed
+  (defun md-ts--refresh-local-parsers (&optional beg end)
+    "Replace local parsers whose buffer was modified since last update.
+Workaround for tree-sitter < 0.25.0 integer underflow — see
+`md-ts--recreate-local-parser' for details.
+Must run as :before advice on `treesit-update-ranges'."
+    (let ((tick (buffer-chars-modified-tick))
+          (beg (or beg (point-min)))
+          (end (or end (point-max))))
+      (dolist (ov (overlays-in beg end))
+        (when-let* ((old-parser (overlay-get ov 'treesit-parser))
+                    ((treesit-parser-language old-parser))
+                    (ov-tick (overlay-get ov 'treesit-parser-ov-timestamp)))
+          (when (not (eql ov-tick tick))
+            (when-let* ((new-parser
+                         (md-ts--recreate-local-parser ov old-parser)))
+              (treesit-parser-set-included-ranges
+               new-parser `((,(overlay-start ov) . ,(overlay-end ov))))))))))
+  (advice-add 'treesit-update-ranges :before
+              'md-ts--refresh-local-parsers))
+
 ;; Emacs 29 font-lock polyfill — local parser support.
 ;;
 ;; Emacs 29's `treesit-font-lock-fontify-region' calls
@@ -986,9 +1052,13 @@ Return non-nil on success, nil if MODE could not be harvested."
       (setq treesit-simple-indent-rules
             (append treesit-simple-indent-rules
                     (plist-get configs :simple-indent)))
-      (setq treesit-range-settings
-            (append treesit-range-settings
-                    (plist-get configs :range)))
+      ;; Only keep query-based range settings; function-based entries
+      ;; create host-level parsers that re-parse the whole buffer.
+      (let ((safe-ranges (seq-filter
+                          (lambda (s) (not (functionp (nth 0 s))))
+                          (plist-get configs :range))))
+        (setq treesit-range-settings
+              (append treesit-range-settings safe-ranges)))
       (setq-local indent-line-function #'treesit-indent)
       (setq-local indent-region-function #'treesit-indent-region)
       t)))

pi-coding-agent-core.el

@@ -131,9 +131,9 @@ Returns nil on timeout."
 
 (defun pi-coding-agent--process-filter (proc output)
   "Handle OUTPUT from pi PROC.
-Accumulates output and processes complete JSON lines.
-Uses process property for per-process partial output storage."
-  (let* ((partial (or (process-get proc 'pi-coding-agent-partial-output) ""))
+Accumulates output and dispatches complete JSON lines."
+  (let* ((inhibit-redisplay t)
+         (partial (or (process-get proc 'pi-coding-agent-partial-output) ""))
          (result (pi-coding-agent--accumulate-lines partial output))
          (lines (car result)))
     (process-put proc 'pi-coding-agent-partial-output (cdr result))

pi-coding-agent-render.el

@@ -217,14 +217,28 @@ Returns non-nil when meaningful content remains after normalization."
            (end (marker-position pi-coding-agent--thinking-marker))
            (normalized (pi-coding-agent--thinking-normalize-text
                         pi-coding-agent--thinking-raw))
-           (rendered (pi-coding-agent--thinking-blockquote-text normalized)))
+           (rendered (pi-coding-agent--thinking-blockquote-text normalized))
+           (prev pi-coding-agent--thinking-prev-rendered))
       (when (<= start end)
-        (let ((existing (buffer-substring-no-properties start end)))
-          (unless (equal existing rendered)
-            (goto-char start)
-            (delete-region start end)
-            (insert rendered)
-            (set-marker pi-coding-agent--thinking-marker (point)))))
+        (cond
+         ;; Fast path: new rendered text extends previous — just append suffix.
+         ((and prev
+               (not (string-empty-p prev))
+               (string-prefix-p prev rendered))
+          (let ((suffix (substring rendered (length prev))))
+            (unless (string-empty-p suffix)
+              (goto-char end)
+              (insert suffix)
+              (set-marker pi-coding-agent--thinking-marker (point)))))
+         ;; Slow path: full rewrite; skip if buffer already matches.
+         (t
+          (let ((existing (buffer-substring-no-properties start end)))
+            (unless (equal existing rendered)
+              (goto-char start)
+              (delete-region start end)
+              (insert rendered)
+              (set-marker pi-coding-agent--thinking-marker (point))))))
+        (setq pi-coding-agent--thinking-prev-rendered rendered))
       (and (<= start end)
            (not (string-empty-p normalized))))))
 
@@ -262,7 +276,8 @@ separated from preceding content."
     (set-marker pi-coding-agent--thinking-start-marker nil))
   (setq pi-coding-agent--thinking-marker nil
         pi-coding-agent--thinking-start-marker nil
-        pi-coding-agent--thinking-raw nil))
+        pi-coding-agent--thinking-raw nil
+        pi-coding-agent--thinking-prev-rendered nil))
 
 (defun pi-coding-agent--display-thinking-start ()
   "Insert opening marker for thinking block (blockquote)."

pi-coding-agent-ui.el

@@ -662,6 +662,12 @@ Used to rewrite thinking content in place after whitespace normalization.")
   "Accumulated raw thinking deltas for the current thinking block.
 Normalized and re-rendered incrementally to avoid excess whitespace.")
 
+(defvar-local pi-coding-agent--thinking-prev-rendered nil
+  "Previously rendered blockquote text for the current thinking block.
+Used for incremental rendering: when the new rendered text extends the
+previous text, only the suffix is inserted instead of replacing the
+entire region.  Reset by `pi-coding-agent--reset-thinking-state'.")
+
 (defvar-local pi-coding-agent--line-parse-state 'line-start
   "Parsing state for current line during streaming.
 Values:

test/pi-coding-agent-core-test.el

@@ -622,5 +622,22 @@ Mocks `make-process' to capture :command, binding
                   '("npx" "pi") '("-e" "/path/to/ext.ts"))
                  '("npx" "pi" "--mode" "rpc" "-e" "/path/to/ext.ts"))))
 
+;;;; Process Filter Tests
+
+(ert-deftest pi-coding-agent-test-process-filter-inhibits-redisplay ()
+  "Process filter binds `inhibit-redisplay' to t during dispatch.
+This batches N JSON lines delivered in one read() into a single
+redisplay cycle instead of triggering N separate redraws."
+  (let ((captured-inhibit nil)
+        (fake-proc (start-process "cat" nil "cat")))
+    (unwind-protect
+        (progn
+          (process-put fake-proc 'pi-coding-agent-display-handler
+                       (lambda (_e) (setq captured-inhibit inhibit-redisplay)))
+          (pi-coding-agent--process-filter
+           fake-proc "{\"type\":\"agent_start\"}\n")
+          (should (eq captured-inhibit t)))
+      (delete-process fake-proc))))
+
 (provide 'pi-coding-agent-core-test)
 ;;; pi-coding-agent-core-test.el ends here

test/pi-coding-agent-render-test.el

@@ -192,6 +192,29 @@ Models may send \\n\\n before thinking content too."
       (should (equal before (buffer-string)))
       (should (= before-tick (buffer-chars-modified-tick))))))
 
+(ert-deftest pi-coding-agent-test-thinking-incremental-appends-suffix-only ()
+  "Consecutive thinking deltas use the fast path: insert suffix, not full rewrite.
+After the first delta stabilizes, subsequent deltas that extend the
+rendered text should only insert the new suffix.  We verify by placing
+a text property in the existing content — the fast path preserves it
+because it inserts at the end, while a full rewrite would lose it."
+  (with-temp-buffer
+    (pi-coding-agent-chat-mode)
+    (pi-coding-agent--display-agent-start)
+    (pi-coding-agent--display-thinking-start)
+    (pi-coding-agent--display-thinking-delta "First thought.")
+    (should pi-coding-agent--thinking-prev-rendered)
+    ;; Place a marker property inside the rendered thinking region
+    (let ((think-start (marker-position pi-coding-agent--thinking-start-marker))
+          (inhibit-read-only t))
+      (put-text-property think-start (1+ think-start) 'test-marker t)
+      ;; Second delta extends the text — fast path should preserve the property
+      (pi-coding-agent--display-thinking-delta " Second thought.")
+      ;; Property should survive (fast path doesn't delete existing region)
+      (should (get-text-property think-start 'test-marker))
+      ;; And the new content appears
+      (should (string-match-p "Second thought" (buffer-string))))))
+
 (ert-deftest pi-coding-agent-test-thinking-paragraph-spacing-no-runaway-blank-lines ()
   "Thinking paragraphs keep a single readable separator, not multiple blanks."
   (with-temp-buffer
@@ -3944,6 +3967,18 @@ This validates that our hook-based tests are meaningful."
 
 
 
+;;;; Tool Header Short-Circuit
+
+(ert-deftest pi-coding-agent-test-tool-update-header-skips-when-unchanged ()
+  "display-tool-update-header does not modify buffer when header is unchanged.
+Avoids unnecessary delete+insert cycles on repeated toolcall_delta
+events where the header text hasn't changed."
+  (pi-coding-agent-test--with-toolcall "read" '(:path "/tmp/foo.py")
+    (let ((tick-before (buffer-modified-tick)))
+      ;; Send delta with same args — header should be identical
+      (pi-coding-agent--display-tool-update-header "read" '(:path "/tmp/foo.py"))
+      (should (= (buffer-modified-tick) tick-before)))))
+
 ;;;; Built-in Slash Command Dispatch
 
 (ert-deftest pi-coding-agent-test-dispatch-builtin-compact ()