(require 'cl-lib)

(require 'seq)

(require 'subr-x)

(require 'ai-code-editor-viewport)

(require 'ai-code-session)

(require 'ai-code-session-link)

(require 'ai-code-backends-infra-vterm)

(require 'ai-code-backends-infra-eat)

(require 'ai-code-backends-infra-ghostel)

(declare-function ai-code--session-handle-at-input "ai-code-input" ())

(declare-function ai-code--session-project-root "ai-code-utils" ())

(declare-function ai-code-mcp-agent-refresh-source-context

"ai-code-mcp-agent" (agent-buffer source-buffer))

(defgroup ai-code-backends-infra nil

"Infrastructure for AI Code terminals."

:group 'tools)

(defcustom ai-code-backends-infra-terminal-backend 'vterm

"Terminal backend to use for sessions.

:type '(choice (const :tag "vterm" vterm)

(const :tag "eat" eat)

(const :tag "ghostel" ghostel))

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-window-side 'right

"Side of the frame where the window should appear."

:type '(choice (const :tag "Left" left)

(const :tag "Right" right)

(const :tag "Top" top)

(const :tag "Bottom" bottom))

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-window-width 90

"Body width of the side window when opened on left or right."

:type 'integer

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-window-height 20

"Height of the side window when opened on top or bottom."

:type 'integer

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-use-side-window t

"Whether to display the terminal in a side window."

:type 'boolean

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-focus-on-open t

"Whether to focus the terminal window when it opens."

:type 'boolean

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-terminal-initialization-delay 0.1

"Initialization delay for terminal stability."

:type 'number

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-prevent-reflow-glitch t

"Workaround for terminal scrolling bug #1422."

:type 'boolean

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-strip-alternate-screen t

"Strip alternate screen buffer sequences from terminal output.

:type 'boolean

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-scrollback-inject-interval 1.0

"Minimum seconds between scrollback-preservation injections.

:type 'number

:group 'ai-code-backends-infra)

(defcustom ai-code-backends-infra-use-paste-backends '("antigravity")

"List of backend session prefixes for which multiline inputs should be pasted.

:type '(repeat string)

:group 'ai-code-backends-infra)

(defvar ai-code-backends-infra--processes (make-hash-table :test 'equal)

"Hash table mapping session keys to their processes.")

(defvar ai-code-backends-infra--last-accessed-buffer nil

"The most recently accessed AI Code buffer.")

(defvar ai-code-backends-infra--directory-buffer-map (make-hash-table :test 'equal)

"Hash table mapping (prefix . directory) to last selected session buffer.")

(defvar ai-code-backends-infra--file-session-map (make-hash-table :test 'equal)

"Hash table mapping (prefix workspace file) to attached session buffers.")

(defvar ai-code-backends-infra--preferred-session-buffer nil

"Preferred session buffer to place first when prompting for session selection.")

(defvar ai-code-backends-infra--launch-program nil

"AI CLI program associated with the terminal session currently being created.

backend registry.")

(defvar ai-code-backends-infra--reflow-advised-handlers nil

"Resize handlers currently advised with reflow filter.")

(defvar-local ai-code-backends-infra--idle-timer nil

"Timer for detecting idle state (response completion).")

(defvar-local ai-code-backends-infra--response-seen nil

"Non-nil when the current response has been observed.

being sent for the response completion.")

(defvar-local ai-code-backends-infra--last-meaningful-output-time nil

"Float timestamp of the most recent meaningful output.")

(defvar-local ai-code-backends-infra--session-directory nil

"Normalized working directory associated with the current session buffer.")

(defvar-local ai-code-backends-infra--session-terminal-backend nil

"Terminal backend used by the current session buffer.")

(defvar-local ai-code-backends-infra--session-prefix nil

"Backend prefix associated with the current session buffer.")

(defvar-local ai-code-backends-infra--session-task-file nil

"Task file associated with the current session buffer, when available.")

(defvar-local ai-code-backends-infra--multiline-input-sequence nil

"Terminal sequence sent for multiline input in the current session buffer.")

(defvar-local ai-code-backends-infra--terminal-active-cursor-type nil

"Cursor type to restore when returning to terminal interaction mode.")

(defvar-local ai-code-backends-infra--navigation-cursor-active nil

"Non-nil when Emacs temporarily owns the cursor for output navigation.")

(defvar ai-code-cli-args-history nil

"History list for CLI args prompts.")

(defconst ai-code-backends-infra--uuid-regexp

"[[:xdigit:]]\\{8\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{12\\}"

"Regexp matching the general UUID 8-4-4-4-12 text structure.

This validates the textual shape, but not UUID version or variant bits.")

(defun ai-code-backends-infra--selected-session-id ()

"Return active region text if it has a UUID session id."

(when (use-region-p)

(let ((candidate

(string-trim

(buffer-substring-no-properties (region-beginning) (region-end)))))

(when (string-match-p

(concat "\\`" ai-code-backends-infra--uuid-regexp "\\'")

candidate)

candidate))))

(defcustom ai-code-backends-infra-idle-delay 5.0

"Delay in seconds of inactivity before considering response complete.

:type 'number

:group 'ai-code-backends-infra)

(defconst ai-code-backends-infra--alternate-screen-regexp

"\033\\[\\?1049[hl]"

"Regexp matching alternate screen buffer enter/exit sequences.

Matches \\e[?1049h (enter) and \\e[?1049l (exit).")

(defconst ai-code-backends-infra--screen-clear-regexp

"\033\\[2J"

"Regexp matching the Erase Display (ED 2) screen clear sequence.")

(defconst ai-code-backends-infra--scrollback-clear-regexp

"\033\\[3J"

"Regexp matching the Erase Display (ED 3) scrollback clear sequence.")

(defconst ai-code-backends-infra--sync-redraw-regexp

"\033\\[\\?2026h\033\\[1;1H"

"Regexp matching synchronized-update frame start with cursor home.

entire screen in place.")

(defvar ai-code-backends-infra-strip-alternate-screen-debug nil

"When non-nil, log alternate-screen filter matches to *Messages*.

Set to t to debug scrollback-preservation transformations.")

(defvar-local ai-code-backends-infra--last-scrollback-inject-time 0

"Timestamp of the last scrollback-preservation injection.

`ai-code-backends-infra-scrollback-inject-interval'.")

(defvar-local ai-code-backends-infra--sync-redraw-scrollback nil

"Non-nil means inject scrollback-preserving newlines before redraws.

to t via their post-start-fn.")

(defun ai-code-backends-infra--scroll-to-scrollback-sequence ()

"Return a sequence that pushes visible content into scrollback.

(let ((height (or (when-let* ((win (get-buffer-window (current-buffer) t)))

(window-body-height win))

50)))

(concat "\033[" (number-to-string height) ";1H"

(make-string height ?\n)

"\033[H")))

(defun ai-code-backends-infra--log-alternate-screen-debug (str)

"Log alternate-screen debug details for STR when debugging is enabled."

(when (and ai-code-backends-infra-strip-alternate-screen-debug

(string-match-p "\033\\[" str))

(let ((visible (replace-regexp-in-string

"\033" "<ESC>" (substring str 0 (min 200 (length str))))))

(message "alt-screen-filter: len=%d alt=%s 2J=%s 3J=%s H+J=%s sync=%s seq=[%s]"

(length str)

(if (string-match-p ai-code-backends-infra--alternate-screen-regexp str) "Y" "N")

(if (string-match-p ai-code-backends-infra--screen-clear-regexp str) "Y" "N")

(if (string-match-p ai-code-backends-infra--scrollback-clear-regexp str) "Y" "N")

(if (string-match-p "\033\\[H.*\033\\[J\\|\033\\[H.*\033\\[0J" str) "Y" "N")

(if (string-match-p ai-code-backends-infra--sync-redraw-regexp str) "Y" "N")

visible))))

(defun ai-code-backends-infra--strip-alternate-screen-transitions (str)

"Strip alternate screen transitions from STR."

(replace-regexp-in-string ai-code-backends-infra--alternate-screen-regexp "" str))

(defun ai-code-backends-infra--maybe-inject-screen-clear-scrollback (str scroll-seq now inject-ok)

"Inject SCROLL-SEQ for screen-clear sequences in STR when allowed.

(if (and inject-ok

(string-match-p ai-code-backends-infra--screen-clear-regexp str))

(progn

(setq ai-code-backends-infra--last-scrollback-inject-time now)

(replace-regexp-in-string

ai-code-backends-infra--screen-clear-regexp

scroll-seq str t t))

str))

(defun ai-code-backends-infra--strip-scrollback-clear (str)

"Strip scrollback-clear sequences from STR."

(replace-regexp-in-string ai-code-backends-infra--scrollback-clear-regexp "" str))

(defun ai-code-backends-infra--maybe-inject-home-erase-scrollback (str scroll-seq now inject-ok)

"Inject SCROLL-SEQ for home+erase redraws in STR when allowed.

(let ((home-erase-re "\033\\[H\033\\[J\\|\033\\[H\033\\[0J"))

(if (and inject-ok

(string-match-p home-erase-re str))

(progn

(setq ai-code-backends-infra--last-scrollback-inject-time now)

(replace-regexp-in-string

home-erase-re

(concat scroll-seq "\033[H") str t t))

str)))

(defun ai-code-backends-infra--maybe-inject-sync-redraw-scrollback (str scroll-seq)

"Inject SCROLL-SEQ before synchronized redraw frames in STR when allowed."

(if (and ai-code-backends-infra--sync-redraw-scrollback

(> (length str) 500)

(string-match ai-code-backends-infra--sync-redraw-regexp str)

(>= (- (float-time)

ai-code-backends-infra--last-scrollback-inject-time)

ai-code-backends-infra-scrollback-inject-interval))

(progn

(setq ai-code-backends-infra--last-scrollback-inject-time (float-time))

(let ((match-start (match-beginning 0)))

(concat (substring str 0 match-start)

scroll-seq

(substring str match-start))))

str))

(defun ai-code-backends-infra--strip-alternate-screen-sequences (str)

"Normalize terminal sequences in STR to preserve scrollback.

(if (and ai-code-backends-infra-strip-alternate-screen

(ai-code-backends-infra--session-buffer-p (current-buffer)))

(let* ((result str)

(scroll-seq (ai-code-backends-infra--scroll-to-scrollback-sequence))

(now (float-time))

(inject-ok (>= (- now

ai-code-backends-infra--last-scrollback-inject-time)

ai-code-backends-infra-scrollback-inject-interval)))

(ai-code-backends-infra--log-alternate-screen-debug str)

;; 1. Strip alternate screen transitions.

(setq result (ai-code-backends-infra--strip-alternate-screen-transitions result))

;; 2. Convert ED 2 (clear screen) to newline-scroll, throttled

;; to avoid flooding the scrollback ring with repeated TUI

;; frames. When throttled the plain \e[2J clears the screen

;; without preserving content, which is acceptable since a

;; recent snapshot was already pushed.

(setq result

(ai-code-backends-infra--maybe-inject-screen-clear-scrollback

result scroll-seq now inject-ok))

;; 3. Strip ED 3 (clear scrollback).

(setq result (ai-code-backends-infra--strip-scrollback-clear result))

;; 4. Convert cursor-home + erase-to-end (\e[H\e[J) into a

;; scrollback-preserving sequence, throttled to avoid flooding

;; the scrollback ring with repeated TUI frames (e.g. the

;; Claude Code badge appearing on every redraw).

(setq result

(ai-code-backends-infra--maybe-inject-home-erase-scrollback

result scroll-seq now inject-ok))

;; 5. Detect synchronized-update frames (\e[?2026h followed by

;; cursor to row 1) and inject scrollback preservation before

;; the frame redraw, throttled to avoid flooding the scrollback

;; ring. Only trigger on chunks > 500 bytes (meaningful

;; redraws, not small cursor movements). Guarded by the

;; buffer-local `--sync-redraw-scrollback' flag so that only

;; backends that explicitly opt in (e.g. Copilot CLI) get

;; the injection.

(setq result

(ai-code-backends-infra--maybe-inject-sync-redraw-scrollback

result scroll-seq))

result)

str))

(declare-function ai-code-notifications-response-ready "ai-code-notifications" (&optional backend-name))

(defun ai-code-backends-infra--output-meaningful-p (output)

"Return non-nil if OUTPUT has meaningful printable content."

(let* ((str (or output ""))

;; Strip OSC sequences (ESC ] ... BEL or ESC ] ... ESC \).

(str (replace-regexp-in-string "\x1b\\][^\x07\x1b]*\\(?:\x07\\|\x1b\\\\\\)" "" str))

;; Strip ANSI escape sequences.

(str (replace-regexp-in-string "\x1b\\[[0-9;?]*[ -/]*[@-~]" "" str))

;; Strip other control characters.

(str (replace-regexp-in-string "[\x00-\x1f\x7f]" "" str)))

(string-match-p "[^ \t\n\r]" str)))

(defun ai-code-backends-infra--buffer-user-visible-p (buffer)

"Return non-nil when BUFFER is visible in any live window."

(and (get-buffer-window-list buffer nil t) t))

(defun ai-code-backends-infra--check-response-complete (buffer)

"Check if AI response is complete in BUFFER and notify if enabled."

(when (buffer-live-p buffer)

(with-current-buffer buffer

(if (ai-code-backends-infra--idle-delay-elapsed-p)

(let ((visible (ai-code-backends-infra--buffer-user-visible-p buffer)))

(if visible

(setq ai-code-backends-infra--response-seen t)

(when (not ai-code-backends-infra--response-seen)

(setq ai-code-backends-infra--response-seen t)

(when (require 'ai-code-notifications nil t)

(when (fboundp 'ai-code-notifications-response-ready)

(let ((buffer-name (buffer-name buffer)))

;; Extract backend name from buffer name format: *<backend>[<dir>]*

;; Example: "*codex[my-project]*" extracts "codex"

;; Regex breakdown:

;; \\* - matches literal asterisk

;; \\( - start capture group 1

;; [^[]+ - one or more chars that are not '['

;; \\) - end capture group 1 (this is the backend name)

;; \\[ - matches literal '['

(when (string-match "\\*\\([^[]+\\)\\[" buffer-name)

(let ((backend-name (match-string 1 buffer-name)))

(ai-code-notifications-response-ready backend-name)))))))))

(ai-code-backends-infra--schedule-idle-check)))))

(defun ai-code-backends-infra--schedule-idle-check ()

"Schedule a check for response completion after idle period.

(when ai-code-backends-infra--idle-timer

(cancel-timer ai-code-backends-infra--idle-timer))

(let ((buffer (current-buffer)))

(setq ai-code-backends-infra--idle-timer

(run-at-time ai-code-backends-infra-idle-delay nil

#'ai-code-backends-infra--check-response-complete

buffer))))

(defun ai-code-backends-infra--idle-delay-elapsed-p ()

"Return non-nil when idle delay has elapsed since last output."

(let ((last ai-code-backends-infra--last-meaningful-output-time))

(or (null last)

(>= (- (float-time) last) ai-code-backends-infra-idle-delay))))

(defun ai-code-backends-infra--note-meaningful-output ()

"Record meaningful output and schedule idle tracking."

(setq ai-code-backends-infra--response-seen nil

ai-code-backends-infra--last-meaningful-output-time (float-time))

(ai-code-backends-infra--schedule-idle-check))

(defun ai-code-backends-infra--configure-session-input-shortcuts ()

"Install session-local shortcuts for prompt-oriented terminal input."

(when (fboundp 'ai-code--session-handle-at-input)

(local-set-key (kbd "@") #'ai-code--session-handle-at-input))

(when (fboundp 'ai-code--session-handle-hash-input)

(local-set-key (kbd "#") #'ai-code--session-handle-hash-input)))

(defun ai-code-backends-infra--terminal-ensure-backend ()

"Ensure the selected terminal backend is available."

(pcase ai-code-backends-infra-terminal-backend

('vterm (ai-code-backends-infra-vterm-ensure-backend))

('eat (ai-code-backends-infra-eat-ensure-backend))

('ghostel (ai-code-backends-infra-ghostel-ensure-backend))

(_ (user-error "Invalid terminal backend: %s" ai-code-backends-infra-terminal-backend)))

;; Keep reflow advice synchronized with current backend/settings.

(ai-code-backends-infra--sync-reflow-filter-advice))

(defun ai-code-backends-infra--terminal-dispatch (operation &rest args)

"Dispatch OPERATION to the current terminal backend, passing ARGS.

(let* ((backend (ai-code-backends-infra--current-terminal-backend))

(fn (intern (format "ai-code-backends-infra-%s-%s" backend operation))))

(if (fboundp fn)

(apply fn args)

(error "Terminal backend %s does not support %s (looked up: %s)"

backend operation fn))))

(defun ai-code-backends-infra--current-terminal-backend ()

"Return terminal backend for current buffer operations."

(or ai-code-backends-infra--session-terminal-backend

ai-code-backends-infra-terminal-backend))

(defun ai-code-backends-infra--terminal-navigation-mode-p ()

"Return non-nil when the current terminal buffer is in navigation mode."

(pcase (ai-code-backends-infra--current-terminal-backend)

('vterm (ai-code-backends-infra-vterm-navigation-mode-p))

('eat (ai-code-backends-infra-eat-navigation-mode-p))

('ghostel (ai-code-backends-infra-ghostel-navigation-mode-p))

(_ nil)))

(defun ai-code-backends-infra--sync-terminal-cursor ()

"Hand cursor ownership between the terminal and Emacs navigation modes."

(if (ai-code-backends-infra--terminal-navigation-mode-p)

(unless ai-code-backends-infra--navigation-cursor-active

(setq ai-code-backends-infra--terminal-active-cursor-type cursor-type

ai-code-backends-infra--navigation-cursor-active t

cursor-type t))

(when ai-code-backends-infra--navigation-cursor-active

(setq cursor-type ai-code-backends-infra--terminal-active-cursor-type

ai-code-backends-infra--navigation-cursor-active nil))))

(defun ai-code-backends-infra--install-navigation-cursor-sync ()

"Install buffer-local hooks for cursor handoff in terminal navigation modes."

(ai-code-backends-infra--terminal-dispatch "install-navigation-cursor-sync"))

(defun ai-code-backends-infra--terminal-send-string (string &optional paste)

"Send STRING to the terminal in the current buffer.

(if paste

(ai-code-backends-infra--terminal-dispatch "send-string" string paste)

(ai-code-backends-infra--terminal-dispatch "send-string" string)))

(defun ai-code-backends-infra--terminal-send-escape ()

"Send escape key to the terminal in the current buffer."

(ai-code-backends-infra--terminal-dispatch "send-escape"))

(defun ai-code-backends-infra--terminal-send-return ()

"Send return key to the terminal in the current buffer."

(ai-code-backends-infra--terminal-dispatch "send-return"))

(defun ai-code-backends-infra--terminal-send-backspace ()

"Send backspace key to the terminal in the current buffer."

(ai-code-backends-infra--terminal-dispatch "send-backspace"))

(defun ai-code-backends-infra--terminal-send-multiline-input ()

"Send the configured multiline-input sequence for the current session buffer."

(interactive)

(unless ai-code-backends-infra--multiline-input-sequence

(user-error "No multiline input sequence configured for this session"))

(ai-code-backends-infra--terminal-send-string

ai-code-backends-infra--multiline-input-sequence))

(defun ai-code-backends-infra--ensure-buffer-local-keymap ()

"Use a buffer-local copy of the current local keymap."

(use-local-map (copy-keymap (or (current-local-map)

(make-sparse-keymap))))

(current-local-map))

(defun ai-code-backends-infra--configure-multiline-input (sequence)

"Configure multiline input keybindings in the current session buffer.

(if sequence

(progn

(setq-local ai-code-backends-infra--multiline-input-sequence sequence)

(define-key (current-local-map) (kbd "S-<return>")

#'ai-code-backends-infra--terminal-send-multiline-input)

(define-key (current-local-map) (kbd "C-<return>")

#'ai-code-backends-infra--terminal-send-multiline-input))

(setq-local ai-code-backends-infra--multiline-input-sequence nil)

(dolist (key (list (kbd "S-<return>") (kbd "C-<return>")))

(when (eq (lookup-key (current-local-map) key)

#'ai-code-backends-infra--terminal-send-multiline-input)

(define-key (current-local-map) key nil)))))

(defun ai-code-backends-infra--configure-session-buffer (buffer

&optional escape-fn

multiline-input-sequence)

"Configure BUFFER with shared session keybindings.

(with-current-buffer buffer

(ai-code-backends-infra--ensure-buffer-local-keymap)

(setq-local ai-code-editor-viewport--submit-function

#'ai-code-backends-infra--terminal-send-return)

(when escape-fn

(define-key (current-local-map) (kbd "C-<escape>") escape-fn))

(ai-code-backends-infra--configure-multiline-input

multiline-input-sequence)

(ai-code-session-link--linkify-session-region (point-min) (point-max))))

(defun ai-code-backends-infra--terminal-resize-handler (&optional backend)

"Retrieve the resize handling function for BACKEND.

(pcase (or backend ai-code-backends-infra-terminal-backend)

('vterm (ai-code-backends-infra-vterm-resize-handler))

('eat (ai-code-backends-infra-eat-resize-handler))

('ghostel (ai-code-backends-infra-ghostel-resize-handler))

(_ (error "Unsupported terminal backend"))))

(defun ai-code-backends-infra--session-buffer-p (buffer)

"Check if BUFFER belongs to an AI session."

(when-let* ((name (if (stringp buffer) buffer (buffer-name buffer))))

(string-match-p "\\`\\*.*\\[.*\\].*\\*\\'" name)))

(defun ai-code-backends-infra--terminal-reflow-filter (original-fn &rest args)

"Filter terminal reflows to prevent height-only resize triggers.

(let* ((base-result (apply original-fn args))

(dimensions-stable t))

(dolist (win (window-list))

(when-let* ((buf (window-buffer win))

((ai-code-backends-infra--session-buffer-p buf)))

(let* ((new-width (window-width win))

(cached-width (window-parameter win 'ai-code-backends-infra-cached-width)))

(unless (eql new-width cached-width)

(setq dimensions-stable nil)

(set-window-parameter win 'ai-code-backends-infra-cached-width new-width)))))

(cond

;; Not in a session buffer - pass through

((not (ai-code-backends-infra--session-buffer-p (current-buffer)))

base-result)

;; In scroll/copy mode - suppress reflow to avoid disrupting navigation

((ai-code-backends-infra--terminal-navigation-mode-p)

nil)

;; Width changed - allow reflow

((not dimensions-stable)

base-result)

;; Height-only change with reflow glitch prevention - suppress

(ai-code-backends-infra-prevent-reflow-glitch

nil)

;; Default - pass through

(t base-result))))

(defun ai-code-backends-infra--sync-reflow-filter-advice ()

"Add or remove terminal reflow advice according to current settings."

(let* ((resize-handler (ai-code-backends-infra--terminal-resize-handler))

(enabled (and ai-code-backends-infra-prevent-reflow-glitch

(eq ai-code-backends-infra-terminal-backend 'eat))))

(dolist (handler (cl-copy-list ai-code-backends-infra--reflow-advised-handlers))

(unless (and enabled (eq handler resize-handler))

(when (advice-member-p #'ai-code-backends-infra--terminal-reflow-filter

handler)

(advice-remove handler

#'ai-code-backends-infra--terminal-reflow-filter))

(setq ai-code-backends-infra--reflow-advised-handlers

(delq handler ai-code-backends-infra--reflow-advised-handlers))))

(unless enabled

(when (advice-member-p #'ai-code-backends-infra--terminal-reflow-filter

resize-handler)

(advice-remove resize-handler

#'ai-code-backends-infra--terminal-reflow-filter))

(setq ai-code-backends-infra--reflow-advised-handlers

(delq resize-handler ai-code-backends-infra--reflow-advised-handlers)))

(when (and enabled resize-handler)

(unless (advice-member-p #'ai-code-backends-infra--terminal-reflow-filter

resize-handler)

(advice-add resize-handler

:around

#'ai-code-backends-infra--terminal-reflow-filter))

(cl-pushnew resize-handler ai-code-backends-infra--reflow-advised-handlers

:test #'eq))))

(defun ai-code-backends-infra--display-buffer-in-side-window (buffer)

"Display BUFFER in a side window."

(let ((window

(if ai-code-backends-infra-use-side-window

(let* ((side ai-code-backends-infra-window-side)

(display-buffer-alist

`((,(regexp-quote (buffer-name buffer))

(display-buffer-in-side-window)

(side . ,side)

(slot . 0)

,@(when (memq side '(left right))

`((window-width . ,#'ai-code-backends-infra--fit-side-window-body-width)

(preserve-size . (t . nil))))

,@(when (memq side '(top bottom))

`((window-height . ,ai-code-backends-infra-window-height)

(preserve-size . (nil . t))))

(window-parameters . ((no-delete-other-windows . t)

(window-size-fixed . ,(if (memq side '(left right)) 'width 'height))))))))

(display-buffer buffer))

(display-buffer buffer))))

(setq ai-code-backends-infra--last-accessed-buffer buffer)

(when (and window ai-code-backends-infra-focus-on-open)

(select-window window))

;; Sync terminal dimensions with the actual window size.

;; The buffer may have been created with different dimensions before

;; being displayed in this window.

(when (and window (buffer-live-p buffer))

(ai-code-backends-infra--sync-terminal-dimensions buffer window)

(with-current-buffer buffer

(when (eq ai-code-backends-infra--session-terminal-backend 'ghostel)

(ai-code-ghostel-image-preview-schedule-visible-linkify window))))

window))

(defun ai-code-backends-infra--fit-side-window-body-width (window)

"Resize WINDOW so its body width matches `ai-code-backends-infra-window-width'."

(let ((delta (- ai-code-backends-infra-window-width

(window-body-width window))))

(unless (zerop delta)

(window-resize window delta t t))))

(defun ai-code-backends-infra--sync-terminal-dimensions (buffer window)

"Sync terminal dimensions in BUFFER to match WINDOW size.

(when (and buffer window (buffer-live-p buffer) (window-live-p window))

(with-current-buffer buffer

(when-let* ((proc (get-buffer-process buffer)))

(let ((backend (ai-code-backends-infra--current-terminal-backend))

(windows (or (get-buffer-window-list buffer nil t)

(list window))))

(if (eq backend 'ghostel)

(set-process-window-size proc

(window-body-height window)

(window-body-width window))

(pcase backend

('vterm

(let ((result

(funcall (ai-code-backends-infra--terminal-resize-handler

'vterm)

proc windows)))

(when result

(ai-code-backends-infra-vterm-flush-render-queue buffer))

result))

(_

(set-process-window-size proc

(window-body-height window)

(window-body-width window))))))))))

(defun ai-code-backends-infra--session-working-directory (&optional prompt-p)

"Return the working directory, preferring the current project root.

(let ((working-dir (ai-code--session-project-root)))

(if prompt-p

(read-directory-name "Working directory: "

working-dir

working-dir

t)

working-dir)))

(defun ai-code-backends-infra--normalize-session-directory (directory)

"Return DIRECTORY normalized for robust session matching."

(file-name-as-directory (file-truename (expand-file-name directory))))

(defun ai-code-backends-infra--normalize-file-path (file)

"Return normalized absolute path for FILE."

(expand-file-name file))

(declare-function magit-get-current-branch "magit-git" ())

(defun ai-code-backends-infra--sanitize-instance-name (instance-name)

"Return INSTANCE-NAME with buffer name delimiters sanitized."

(replace-regexp-in-string "]" "-" instance-name t t))

(defun ai-code-backends-infra--branch-instance-name (&optional existing-instance-names)

"Return the current branch as an instance name, unless already used.

(let* ((branch (ignore-errors (magit-get-current-branch)))

(instance (and (stringp branch)

(ai-code-backends-infra--sanitize-instance-name

branch))))

(when (and instance

(not (string-empty-p instance))

(not (member instance existing-instance-names)))

instance)))

(defun ai-code-backends-infra--default-instance-name (&optional existing-instance-names)

"Return the default instance name for the current buffer, or nil.

(ai-code-backends-infra--branch-instance-name existing-instance-names))

(defun ai-code-backends-infra--file-session-map-key (prefix source-buffer)

"Return workspace-scoped file-session key for PREFIX and SOURCE-BUFFER."

(when (and prefix (buffer-live-p source-buffer))

(with-current-buffer source-buffer

(when (and (stringp buffer-file-name)

(> (length buffer-file-name) 0))

(list prefix

(ai-code-backends-infra--normalize-session-directory

(ai-code--session-project-root))

(ai-code-backends-infra--normalize-file-path

buffer-file-name))))))

(defun ai-code-backends-infra--remember-file-session-buffer (prefix source-buffer session-buffer)

"Remember SESSION-BUFFER as attached session for SOURCE-BUFFER and PREFIX."

(when-let* ((key (ai-code-backends-infra--file-session-map-key prefix source-buffer)))

(if (and session-buffer (buffer-live-p session-buffer))

(puthash key session-buffer ai-code-backends-infra--file-session-map)

(remhash key ai-code-backends-infra--file-session-map))))

(defun ai-code-backends-infra--live-terminal-session-p (buffer)

"Return non-nil when BUFFER is a managed terminal with a live process."

(and (buffer-live-p buffer)

(buffer-local-value

'ai-code-backends-infra--session-terminal-backend buffer)

(when-let* ((process (get-buffer-process buffer)))

(process-live-p process))))

(defun ai-code-backends-infra--preferred-session (sessions)

"Return an unambiguous session from SESSIONS, or nil."

(cond

((memq ai-code-backends-infra--last-accessed-buffer sessions)

ai-code-backends-infra--last-accessed-buffer)

((length= sessions 1) (car sessions))))

(defun ai-code-backends-infra--attached-sessions (source)

"Return live sessions explicitly attached to SOURCE's file."

(when-let* ((file (buffer-local-value 'buffer-file-name source))

(normalized-file

(ai-code-backends-infra--normalize-file-path file))

(root (with-current-buffer source

(ai-code--session-project-root)))

(normalized-root

(ai-code-backends-infra--normalize-session-directory root)))

(let (sessions)

(maphash

(lambda (key session)

(when (and (equal (nth 1 key) normalized-root)

(equal (nth 2 key) normalized-file)

(ai-code-backends-infra--live-terminal-session-p session))

(push session sessions)))

ai-code-backends-infra--file-session-map)

(delete-dups sessions))))

(defun ai-code-backends-infra--project-sessions (source)

"Return live sessions belonging to SOURCE's current project."

(when-let* ((root

(with-current-buffer source

(ai-code--session-project-root)))

(normalized-root

(ignore-errors

(ai-code-backends-infra--normalize-session-directory root))))

(seq-filter

(lambda (session)

(when-let* ((directory

(ai-code-backends-infra-session-directory session)))

(string= directory normalized-root)))

(ai-code-backends-infra-session-buffers))))

(defun ai-code-backends-infra-current-buffer-session (&optional buffer)

"Return the unambiguous live TUI session associated with BUFFER.

(let ((source (or buffer (current-buffer))))

(when (buffer-live-p source)

(if (ai-code-backends-infra--live-terminal-session-p source)

source

(let ((attached (ai-code-backends-infra--attached-sessions source)))

(or (ai-code-backends-infra--preferred-session attached)

(unless attached

(ai-code-backends-infra--preferred-session

(ai-code-backends-infra--project-sessions source)))))))))

(defun ai-code-backends-infra-session-buffers ()

"Return all live managed terminal session buffers."

(cl-remove-if-not #'ai-code-backends-infra--live-terminal-session-p

(buffer-list)))

(defun ai-code-backends-infra--send-string-with-paste

(string paste send-function paste-function paste-active-p backend-name)

"Send STRING safely through a terminal backend.

(cond

((not paste) (funcall send-function string))

((and paste-function paste-active-p (funcall paste-active-p))

(funcall paste-function string))

(t

(user-error

"This %s session cannot paste multiline input without submitting"

backend-name))))

(defun ai-code-backends-infra-insert-string (string buffer)

"Insert STRING into TUI session BUFFER without submitting it.

(unless (ai-code-backends-infra--live-terminal-session-p buffer)

(user-error "AI session is no longer available"))

(with-current-buffer buffer

(ai-code-backends-infra--terminal-send-string

string (and (string-match-p "\n" string) t)))

(setq ai-code-backends-infra--last-accessed-buffer buffer)

(if-let* ((window (get-buffer-window buffer)))

(select-window window)

(ai-code-backends-infra--display-buffer-in-side-window buffer)))

(defun ai-code-backends-infra--attached-file-session (prefix source-buffer working-dir)

"Return attached session state for PREFIX and SOURCE-BUFFER.

(let ((key (ai-code-backends-infra--file-session-map-key prefix source-buffer)))

(if (null key)

(cons nil nil)

(let* ((attached (gethash key ai-code-backends-infra--file-session-map))

(valid (and (buffer-live-p attached)

(ai-code-backends-infra--session-buffer-matches-directory-p

attached

working-dir))))

(cond

(valid

(cons attached nil))

(attached

(remhash key ai-code-backends-infra--file-session-map)

(cons nil t))

(t

(cons nil nil)))))))

(defun ai-code-backends-infra--resolve-session-buffer (buffer-name missing-message prefix working-dir

force-prompt source-buffer)

"Resolve session buffer using BUFFER-NAME or selection rules.

(let* ((file-session-key (and prefix

source-buffer

(ai-code-backends-infra--file-session-map-key

prefix

source-buffer)))

(attached-state (and prefix working-dir

(ai-code-backends-infra--attached-file-session

prefix

source-buffer

working-dir)))

(attached-buffer (car-safe attached-state))

(attached-missing (cdr-safe attached-state))

(needs-initial-file-selection (and (null buffer-name)

file-session-key

(null attached-buffer)

(not attached-missing)))

(effective-force-prompt

(or force-prompt

attached-missing

needs-initial-file-selection))

(buffer (or (and buffer-name (get-buffer buffer-name))

(and attached-buffer (not force-prompt) attached-buffer)

(and prefix working-dir

(let ((ai-code-backends-infra--preferred-session-buffer

attached-buffer))

(ai-code-backends-infra--select-session-buffer

prefix

working-dir

effective-force-prompt))))))

(when (and attached-missing (null buffer-name))

(message "Attached AI session for this file no longer exists. Please select a target session again."))

(if buffer

(progn

(ai-code-backends-infra--remember-session-buffer prefix working-dir buffer)

(ai-code-backends-infra--remember-file-session-buffer prefix source-buffer buffer)

buffer)

(user-error "%s" missing-message))))

(defun ai-code-backends-infra--set-session-directory (buffer directory)

"Store DIRECTORY on BUFFER for exact session matching."

(when (and (buffer-live-p buffer) (stringp directory))

(with-current-buffer buffer

(setq-local ai-code-backends-infra--session-directory

(ai-code-backends-infra--normalize-session-directory directory)))))

(defun ai-code-backends-infra-session-directory (buffer)

"Return BUFFER session directory, using legacy `default-directory' as fallback."

(when (buffer-live-p buffer)

(with-current-buffer buffer

(cond

((and (stringp ai-code-backends-infra--session-directory)

(> (length ai-code-backends-infra--session-directory) 0))

(ai-code-backends-infra--normalize-session-directory

ai-code-backends-infra--session-directory))

((and (stringp default-directory)

(> (length default-directory) 0))

(ai-code-backends-infra--normalize-session-directory

default-directory))

(t nil)))))

(defun ai-code-backends-infra--source-task-file (source-buffer)

"Return the AI task file associated with SOURCE-BUFFER, or nil."

(when (buffer-live-p source-buffer)

(with-current-buffer source-buffer

(when (and (stringp buffer-file-name)

(string-suffix-p ".org" buffer-file-name)

(or (derived-mode-p 'ai-code-prompt-mode)

(string-match-p "/\\.ai\\.code\\.files/" buffer-file-name)))

(expand-file-name buffer-file-name)))))

(defun ai-code-backends-infra--sync-session-registry (buffer working-dir prefix

&optional task-file)

"Register or update BUFFER in the AI session registry.

(when (buffer-live-p buffer)

(let ((resolved-task-file

(or task-file

(with-current-buffer buffer

ai-code-backends-infra--session-task-file))))

(with-current-buffer buffer

(setq-local ai-code-backends-infra--session-prefix prefix)

(setq-local ai-code-backends-infra--session-task-file resolved-task-file))

(ai-code-session-register

:buffer buffer

:backend prefix

:repo-root working-dir

:task-file resolved-task-file))))

(defun ai-code-backends-infra--session-buffer-name (prefix directory &optional instance-name)

"Return a session buffer name for PREFIX in DIRECTORY.

(let* ((base (file-name-nondirectory (directory-file-name directory)))

(instance (and instance-name

(not (string= instance-name ""))

(not (string= instance-name "default"))

instance-name)))

(format "*%s[%s%s]*"

prefix

base

(if instance (format ":%s" instance) ""))))

(defun ai-code-backends-infra--normalize-instance-name (instance-name)

"Return a normalized INSTANCE-NAME, defaulting to \"default\"."

(if (and instance-name (not (string= instance-name "")))

instance-name

"default"))

(defun ai-code-backends-infra--session-key (directory instance-name)

"Return a session key for DIRECTORY and INSTANCE-NAME."

(cons (ai-code-backends-infra--normalize-session-directory directory)

(ai-code-backends-infra--normalize-instance-name instance-name)))