[nongnu] elpa/aidermacs 4ed1f8ddb6 429/466: Merge pull request #51 from milanglacier/refactor/vterm-aider-mode

[ELPA Syncer]

branch: elpa/aidermacs
commit 4ed1f8ddb652de9389683f8038efad5a90d6b4b0
Merge: b4a771c777 389d69fddb
Author: Matthew Zeng <matthewzmd@posteo.net>
Commit: GitHub <noreply@github.com>

    Merge pull request #51 from milanglacier/refactor/vterm-aider-mode
    
    Refactor/vterm aider mode
---
 aidermacs-backend-comint.el | 26 +++++++++-----
 aidermacs-backend-vterm.el  | 85 +++++++++++++++++++++++----------------------
 2 files changed, 60 insertions(+), 51 deletions(-)

diff --git a/aidermacs-backend-comint.el b/aidermacs-backend-comint.el
index 22609d2597..403036f8d6 100644
--- a/aidermacs-backend-comint.el
+++ b/aidermacs-backend-comint.el
@@ -297,11 +297,7 @@ BUFFER-NAME is the name for the aidermacs buffer."
         (add-hook 'kill-buffer-hook #'aidermacs--comint-cleanup-hook nil t)
         (add-hook 'comint-output-filter-functions #'aidermacs-fontify-blocks 
100 t)
         (add-hook 'comint-output-filter-functions 
#'aidermacs--comint-output-filter)
-        (advice-add 'comint-interrupt-subjob :around 
#'aidermacs--cleanup-temp-files-on-interrupt-comint)
-        (let ((local-map (make-sparse-keymap)))
-          (set-keymap-parent local-map comint-mode-map)
-          (define-key local-map (kbd aidermacs-comint-multiline-newline-key) 
#'comint-accumulate)
-          (use-local-map local-map))
+        (aidermacs-comint-mode 1)
         (font-lock-add-keywords nil aidermacs-font-lock-keywords t)))))
 
 (defun aidermacs--send-command-comint (buffer command)
@@ -338,13 +334,25 @@ The output is collected and passed to the current 
callback."
       (aidermacs--store-output (with-current-buffer output-buffer
                                  (buffer-string))))))
 
-(defun aidermacs--cleanup-temp-files-on-interrupt-comint (orig-fun &rest args)
-  "Run `aidermacs--cleanup-temp-buffers' after interrupting a comint subjob.
-ORIG-FUN is the original function being advised.  ARGS are its arguments."
-  (apply orig-fun args)
+(defun aidermacs-comint-interrupt-subjob ()
+  "Run `aidermacs--cleanup-temp-buffers' after interrupting a comint subjob."
+  (interactive)
+  (comint-interrupt-subjob)
   (when (aidermacs--is-aidermacs-buffer-p)
     (aidermacs--cleanup-temp-buffers)))
 
+(defvar aidermacs-comint-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd aidermacs-comint-multiline-newline-key) 
#'comint-accumulate)
+    (define-key map (kbd "C-c C-c") #'aidermacs-comint-interrupt-subjob)
+    map)
+  "Keymap used when `aidermacs-comint-mode' is enabled.")
+
+(define-minor-mode aidermacs-comint-mode
+  "Minor mode for vterm backend buffer used by aidermacs."
+  :init-value nil
+  :keymap aidermacs-comint-mode-map)
+
 (provide 'aidermacs-backend-comint)
 
 ;;; aidermacs-backend-comint.el ends here
diff --git a/aidermacs-backend-vterm.el b/aidermacs-backend-vterm.el
index 79ca291a7e..56c784675f 100644
--- a/aidermacs-backend-vterm.el
+++ b/aidermacs-backend-vterm.el
@@ -45,6 +45,9 @@
 (declare-function aidermacs--is-aidermacs-buffer-p "aidermacs")
 (declare-function aidermacs-get-buffer-name "aidermacs")
 
+;; useful because we want to override "RET" key for evil mode insert state
+(declare-function evil-define-minor-mode-key "evil-core")
+
 (defvar-local aidermacs--vterm-active-timer nil
   "Store the active timer for vterm output processing.")
 
@@ -85,10 +88,8 @@ If the finish sequence is detected, store the output via
              (should-check (> prompt-point last-check))
              ;; Simplified pattern that just looks for a shell prompt
              (expected aidermacs-prompt-regexp))
-
         ;; Update the last check point
         (setq aidermacs--vterm-last-check-point prompt-point)
-
         (when should-check
           (let* ((seq-start (or (save-excursion
                                   (goto-char prompt-point)
@@ -100,13 +101,10 @@ If the finish sequence is detected, store the output via
                  (prompt-line-end (min (+ seq-start 200) (point-max)))
                  (prompt-line (buffer-substring-no-properties seq-start 
prompt-line-end))
                  (output (buffer-substring-no-properties start-point 
seq-start)))
-
             ;; Parse output for files
             (aidermacs--parse-output-for-files output)
-
             ;; If we found a shell prompt indicating output finished
             (when (string-match-p expected prompt-line)
-              (setq-local aidermacs--vterm-processing-command nil)
               (aidermacs--store-output (string-trim output))
               (let ((edited-files (aidermacs--detect-edited-files)))
                 ;; Check if any files were edited and show ediff if needed
@@ -118,43 +116,30 @@ If the finish sequence is detected, store the output via
                 (set-process-filter proc orig-filter)
                 (aidermacs--maybe-cancel-active-timer (process-buffer 
proc))))))))))
 
-(defvar-local aidermacs--vterm-processing-command nil
-  "Flag to indicate if we're currently processing a command.")
-
-(defun aidermacs--vterm-output-advice (orig-fun &rest args)
+(defun aidermacs--vterm-capture-output ()
   "Capture vterm output until the finish sequence appears.
 ORIG-FUN is the original function being advised.  ARGS are its arguments.
 This sets a temporary process filter that checks for the finish sequence
 after each output chunk, reducing the need for timers."
-  (if (and (aidermacs--is-aidermacs-buffer-p)
-           (not (string-empty-p aidermacs--last-command)))
+  (when (and (aidermacs--is-aidermacs-buffer-p)
+             (not (string-empty-p aidermacs--last-command)))
       (let* ((start-point (condition-case nil
                               (vterm--get-prompt-point)
                             (error (point-min))))
              (proc (get-buffer-process (current-buffer)))
              (orig-filter (process-filter proc)))
-
         ;; Store the command for tracking in the correct buffer
         (with-current-buffer (process-buffer proc)
-          (when (and args (car args) (stringp (car args)))
-            (setq aidermacs--last-command (car args)))
-          ;; Set flag that we're processing a command
-          (setq aidermacs--vterm-processing-command t)
           ;; Initialize tracking variables
           (setq aidermacs--vterm-last-check-point nil)
           ;; Cancel any existing timer first
           (aidermacs--maybe-cancel-active-timer)
-
           ;; Create a new timer immediately to start checking for command 
completion
           (setq aidermacs--vterm-active-timer
                 (run-with-timer
                  aidermacs-vterm-check-interval
                  aidermacs-vterm-check-interval
-                 (lambda ()
-                   ; Check if we're still in a valid state
-                   (aidermacs--vterm-check-finish-sequence-repeated proc 
orig-filter start-point))))
-          (apply orig-fun args)))
-    (apply orig-fun args)))
+                 (lambda () (aidermacs--vterm-check-finish-sequence-repeated 
proc orig-filter start-point))))))))
 
 (defun aidermacs--maybe-cancel-active-timer (&optional buffer)
   "Cancel the active timer if it exists.
@@ -181,14 +166,7 @@ BUFFER-NAME is the name for the vterm buffer."
         (setq-local vterm-max-scrollback 1000
                     aidermacs--vterm-active-timer nil
                     aidermacs--vterm-last-check-point nil)
-        (advice-add 'vterm-send-return :around 
#'aidermacs--vterm-output-advice)
-        (advice-add 'vterm-send-return :before 
#'aidermacs--vterm-capture-keyboard-input)
-        (advice-add 'vterm--self-insert :after 
#'aidermacs--cleanup-temp-files-on-interrupt-vterm)
-        ;; Set up multi-line keybinding
-        (let ((map (make-sparse-keymap)))
-          (set-keymap-parent map (current-local-map))
-          (define-key map (kbd aidermacs-vterm-multiline-newline-key) 
#'aidermacs-vterm-insert-newline)
-          (use-local-map map))
+        (aidermacs-vterm-mode 1)
         ;; Add cleanup hook
         (add-hook 'kill-buffer-hook #'aidermacs--vterm-cleanup nil t))))
   buffer-name)
@@ -201,13 +179,24 @@ BUFFER is the target buffer to send to.  COMMAND is the 
text to send."
     (aidermacs--maybe-cancel-active-timer)
     ;; Only process if we have a non-empty command
     (when (and command (not (string-empty-p (string-trim command))))
-      ;; Set processing flag to true before sending command
-      (setq-local aidermacs--vterm-processing-command t)
-      ;; Store the command for tracking
+      ;; Store the command and reset output
       (setq-local aidermacs--last-command command)
       ;; Send the command
       (vterm-send-string command)
-      (vterm-send-return))))
+      (aidermacs-vterm-send-return))))
+
+(defun aidermacs-vterm-send-return ()
+  "Send return to the aidermacs vterm buffer, and process the output."
+  (interactive)
+  (aidermacs--vterm-capture-keyboard-input)
+  (aidermacs--vterm-capture-output)
+  (vterm-send-return))
+
+(defun aidermacs-vterm-send-C-c ()
+  "Send C-c to the aidermacs vterm buffer, and clenaup."
+  (interactive)
+  (vterm-send-C-c)
+  (aidermacs--cleanup-temp-files-on-interrupt-vterm))
 
 (defun aidermacs-vterm-insert-newline ()
   "Insert a newline in vterm without sending the command."
@@ -234,20 +223,32 @@ BUFFER is the target buffer to send to.  COMMAND is the 
text to send."
 (defun aidermacs--vterm-cleanup ()
   "Clean up vterm resources when buffer is killed."
   (aidermacs--maybe-cancel-active-timer)
-  (setq-local aidermacs--vterm-last-check-point nil)
-  (setq-local aidermacs--vterm-processing-command nil)
-  (advice-remove 'vterm-send-return #'aidermacs--vterm-capture-keyboard-input))
+  (setq-local aidermacs--vterm-last-check-point nil))
 
-(defun aidermacs--cleanup-temp-files-on-interrupt-vterm (&rest _args)
+(defun aidermacs--cleanup-temp-files-on-interrupt-vterm ()
   "Run `aidermacs--cleanup-temp-buffers' after interrupting a vterm subjob.
 _ARGS are the arguments."
-  (when (and (aidermacs--is-aidermacs-buffer-p)
-             (equal (this-command-keys) "\C-c\C-c"))
-    ;; Reset processing flag when user interrupts
-    (setq-local aidermacs--vterm-processing-command nil)
+  (when (aidermacs--is-aidermacs-buffer-p)
     ;; Cancel any active timer
     (aidermacs--maybe-cancel-active-timer)
     (aidermacs--cleanup-temp-buffers)))
 
+(defvar aidermacs-vterm-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd aidermacs-vterm-multiline-newline-key) 
#'aidermacs-vterm-insert-newline)
+    (define-key map (kbd "RET") #'aidermacs-vterm-send-return)
+    (define-key map (kbd "<return>") #'aidermacs-vterm-send-return)
+    (define-key map (kbd "C-c C-c") #'aidermacs-vterm-send-C-c)
+    (when (featurep 'evil)
+      (evil-define-minor-mode-key map 'insert
+          (kbd "RET") (function aidermacs-vterm-send-return)))
+    map)
+  "Keymap used when `aidermacs-vterm-mode' is enabled.")
+
+(define-minor-mode aidermacs-vterm-mode
+  "Minor mode for vterm backend buffer used by aidermacs."
+  :init-value nil
+  :keymap aidermacs-vterm-mode-map)
+
 (provide 'aidermacs-backend-vterm)
 ;;; aidermacs-backend-vterm.el ends here