feat: Dispatch built-in slash commands client-side (#143) (#148)

Built-in slash commands (/new, /model, /compact, /session, /name,
/fork, /resume, /reload, /export, /copy, /quit) were not autocompleted
or dispatched locally — they were sent verbatim as prompts, causing the
LLM to respond about them instead of executing them.

Dispatch table and autocomplete
  Data-driven table in ui.el maps command names to existing handler
  functions with an :args spec (nil, optional, required).  Autocomplete
  in input.el merges builtin names with RPC-provided commands.
  Dispatch in render.el replaces the old /compact-only special case.

Fix session state reads in menu functions
  Menu functions (model description, thinking description, select-model)
  read pi-coding-agent--state directly, but state is buffer-local in the
  chat buffer.  When called from the input buffer, state was nil giving
  'unknown'.  New --menu-state accessor reads via buffer-local-value.

Model selector improvements
  Shortened display names (Opus 4.6 not Claude Opus 4.6), matching the
  header-line.  Case-insensitive flex completion so 'opus' matches
  'Opus 4.6' and 'code' matches 'GPT-5.1 Codex Max'.  Unique flex
  match auto-selects without opening the picker (/model op46 sets
  Opus 4.6 directly).  No match prints a message; multiple matches
  open the picker pre-filled.

Argument passing for /model and /export
  /model accepts optional search text as initial-input.
  /export accepts optional output path, sent as :outputPath in the RPC.
  Interactive C-c C-p e now prompts for export path (RET for default).

Author: dnouri

pi-coding-agent-input.el

@@ -352,13 +352,15 @@ cancels, the session remains intact."
 (defun pi-coding-agent--command-capf ()
   "Completion-at-point function for /commands in input buffer.
 Returns completion data when point is after / at start of buffer.
-Uses commands from pi's `get_commands' RPC."
+Includes both built-in commands and commands from pi's `get_commands' RPC."
   (when (and (eq (char-after (point-min)) ?/)
              (> (point) (point-min)))
     (let* ((start (1+ (point-min)))
            (end (point))
-           (commands (mapcar (lambda (cmd) (plist-get cmd :name))
-                             pi-coding-agent--commands)))
+           (builtin-names (mapcar #'car pi-coding-agent--builtin-commands))
+           (rpc-names (mapcar (lambda (cmd) (plist-get cmd :name))
+                              pi-coding-agent--commands))
+           (commands (delete-dups (append builtin-names rpc-names))))
       (list start end commands :exclusive 'no))))
 
 ;;;; Editor Features: File Reference (@)

pi-coding-agent-menu.el

@@ -71,14 +71,24 @@ PROC is the pi process.  CALLBACK receives the command list on success."
 
 ;;;; Session Management
 
+(defun pi-coding-agent--menu-state ()
+  "Return session state from the chat buffer.
+State is buffer-local in the chat buffer; this accessor works
+from either chat or input buffer."
+  (let ((chat-buf (pi-coding-agent--get-chat-buffer)))
+    (and chat-buf (buffer-local-value 'pi-coding-agent--state chat-buf))))
+
 (defun pi-coding-agent--menu-model-description ()
   "Return model description for transient menu."
-  (let ((model (plist-get (plist-get pi-coding-agent--state :model) :name)))
-    (format "Model: %s" (or model "unknown"))))
+  (let* ((state (pi-coding-agent--menu-state))
+         (model (plist-get (plist-get state :model) :name))
+         (short (and model (pi-coding-agent--shorten-model-name model))))
+    (format "Model: %s" (or short "unknown"))))
 
 (defun pi-coding-agent--menu-thinking-description ()
   "Return thinking level description for transient menu."
-  (let ((level (plist-get pi-coding-agent--state :thinking-level)))
+  (let* ((state (pi-coding-agent--menu-state))
+         (level (plist-get state :thinking-level)))
     (format "Thinking: %s" (or level "off"))))
 
 ;;;###autoload
@@ -414,26 +424,51 @@ The name is displayed in the resume picker and header-line."
                 (message "Pi: Failed to set session name: %s"
                          (or (plist-get response :error) "unknown error")))))))))
 
-(defun pi-coding-agent-select-model ()
-  "Select a model interactively."
+(defun pi-coding-agent-select-model (&optional initial-input)
+  "Select a model interactively.
+Optional INITIAL-INPUT pre-fills the completion prompt for filtering."
   (interactive)
   (let ((proc (pi-coding-agent--get-process))
         (chat-buf (pi-coding-agent--get-chat-buffer)))
     (unless proc
       (user-error "No pi process running"))
-    (let* ((response (pi-coding-agent--rpc-sync proc '(:type "get_available_models") 5))
+    (let* ((state (pi-coding-agent--menu-state))
+           (response (pi-coding-agent--rpc-sync proc '(:type "get_available_models") 5))
            (data (plist-get response :data))
            (models (plist-get data :models))
-           (current-name (plist-get (plist-get pi-coding-agent--state :model) :name))
-           ;; Build alist of (display-name . model-plist) for selection
+           (current-name (plist-get (plist-get state :model) :name))
+           (current-short (and current-name
+                               (pi-coding-agent--shorten-model-name current-name)))
+           ;; Build alist of (short-name . model-plist) for selection
            (model-alist (mapcar (lambda (m)
-                                  (cons (plist-get m :name) m))
+                                  (cons (pi-coding-agent--shorten-model-name
+                                         (plist-get m :name))
+                                        m))
                                 models))
            (names (mapcar #'car model-alist))
-           (choice (completing-read
-                    (format "Model (current: %s): " (or current-name "unknown"))
-                    names nil t)))
-      (when (and choice (not (equal choice current-name)))
+           (choice (let ((completion-ignore-case t)
+                         (completion-styles '(basic flex)))
+                     (if initial-input
+                         ;; Try auto-selecting on unique match
+                         (let ((matches (completion-all-completions
+                                         initial-input names nil
+                                         (length initial-input))))
+                           (when (consp matches)
+                             (setcdr (last matches) nil))
+                           (cond
+                            ((= (length matches) 1) (car matches))
+                            ((null matches)
+                             (message "Pi: No model matching \"%s\"" initial-input)
+                             nil)
+                            (t (completing-read
+                                (format "Model (current: %s): "
+                                        (or current-short "unknown"))
+                                names nil t initial-input))))
+                       (completing-read
+                        (format "Model (current: %s): "
+                                (or current-short "unknown"))
+                        names nil t)))))
+      (when (and choice (not (equal choice current-short)))
         (let* ((selected-model (cdr (assoc choice model-alist)))
                (model-id (plist-get selected-model :id))
                (provider (plist-get selected-model :provider)))
@@ -561,11 +596,18 @@ Optional CUSTOM-INSTRUCTIONS provide guidance for the compaction summary."
          (lambda (response)
            (pi-coding-agent--handle-manual-compaction-response chat-buf response))))))))
 
-(defun pi-coding-agent-export-html ()
-  "Export session to HTML file."
-  (interactive)
+(defun pi-coding-agent-export-html (&optional output-path)
+  "Export session to HTML file.
+Optional OUTPUT-PATH specifies where to save; nil uses pi's default."
+  (interactive
+   (list (let ((path (read-string "Export path (RET for default): ")))
+           (and (not (string-empty-p path)) path))))
   (when-let ((proc (pi-coding-agent--get-process)))
-    (pi-coding-agent--rpc-async proc '(:type "export_html")
+    (pi-coding-agent--rpc-async proc
+                   (if output-path
+                       (list :type "export_html" :outputPath
+                             (expand-file-name output-path))
+                     '(:type "export_html"))
                    (lambda (response)
                      (if (plist-get response :success)
                          (let* ((data (plist-get response :data))

pi-coding-agent-render.el

@@ -373,20 +373,38 @@ Note: status is set to `idle' by the event handler."
     (unless was-aborted
       (pi-coding-agent--process-followup-queue))))
 
+(defun pi-coding-agent--dispatch-builtin-command (text)
+  "Try to dispatch TEXT as a built-in slash command.
+Returns non-nil if TEXT matched a built-in command and was handled."
+  (when (string-prefix-p "/" text)
+    (let* ((without-slash (substring text 1))
+           (words (split-string without-slash))
+           (cmd-name (car words))
+           (entry (assoc cmd-name pi-coding-agent--builtin-commands)))
+      (when entry
+        (let ((handler (plist-get (cdr entry) :handler))
+              (args-spec (plist-get (cdr entry) :args))
+              (arg-str (let ((rest (string-trim
+                                    (substring without-slash (length cmd-name)))))
+                         (and (not (string-empty-p rest)) rest))))
+          (pcase args-spec
+            ('optional (funcall handler arg-str))
+            ('required (if arg-str
+                          (funcall handler arg-str)
+                        (call-interactively handler)))
+            (_ (funcall handler)))
+          t)))))
+
 (defun pi-coding-agent--prepare-and-send (text)
   "Prepare chat buffer state and send TEXT to pi.
-For slash commands: don't display locally, let pi send expanded content.
-For regular text: display locally for responsiveness.
-The /compact command is handled specially by calling `pi-coding-agent-compact'.
+Built-in slash commands are dispatched locally via the dispatch table.
+Other slash commands (extensions, skills, prompts) are sent to pi.
+Regular text is displayed locally for responsiveness, then sent.
 Must be called with chat buffer current.
 Status transitions are handled by pi events (agent_start, agent_end)."
   (cond
-   ;; /compact is handled locally, invoking `pi-coding-agent-compact' directly
-   ((or (string= text "/compact")
-        (string-prefix-p "/compact " text))
-    (let ((args (when (string-prefix-p "/compact " text)
-                  (string-trim (substring text (length "/compact "))))))
-      (pi-coding-agent-compact (and args (not (string-empty-p args)) args))))
+   ;; Built-in slash commands: dispatch locally
+   ((pi-coding-agent--dispatch-builtin-command text))
    ;; Other slash commands: don't display locally, send to pi
    ((string-prefix-p "/" text)
     (pi-coding-agent--send-prompt text))

pi-coding-agent-ui.el

@@ -872,6 +872,28 @@ Extracted from session_info entries when session is loaded or switched.")
 Each entry is a plist with :name, :description, :source.
 Source is \"prompt\", \"extension\", or \"skill\".")
 
+(defvar pi-coding-agent--builtin-commands
+  '(("compact" :handler pi-coding-agent-compact       :args optional)
+    ("new"     :handler pi-coding-agent-new-session)
+    ("model"   :handler pi-coding-agent-select-model  :args optional)
+    ("session" :handler pi-coding-agent-session-stats)
+    ("name"    :handler pi-coding-agent-set-session-name :args required)
+    ("fork"    :handler pi-coding-agent-fork)
+    ("resume"  :handler pi-coding-agent-resume-session)
+    ("reload"  :handler pi-coding-agent-reload)
+    ("export"  :handler pi-coding-agent-export-html  :args optional)
+    ("copy"    :handler pi-coding-agent-copy-last-message)
+    ("quit"    :handler pi-coding-agent-quit))
+  "Built-in slash commands dispatched client-side.
+Each entry is (NAME . PLIST) where PLIST has:
+  :handler  Function to call (symbol)
+  :args     nil (no args), `optional', or `required'
+
+Commands with :args `optional' pass the trailing text (or nil) to the
+handler.  Commands with :args `required' prompt interactively when no
+argument is given (the handler's `interactive' spec handles this).
+Descriptions come from the handler's docstring.")
+
 (defun pi-coding-agent--set-commands (commands)
   "Set COMMANDS in current buffer and propagate to sibling session buffers.
 COMMANDS is a list of plists with :name, :description, :source.

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

@@ -2022,7 +2022,32 @@ only offer our own capfs (slash commands, file references, paths)."
     (insert "Some context:\n/te")
     (should-not (pi-coding-agent--command-capf))))
 
+(ert-deftest pi-coding-agent-test-command-capf-includes-builtins ()
+  "Completion includes built-in commands even when RPC returns nothing."
+  (with-temp-buffer
+    (pi-coding-agent-input-mode)
+    (setq pi-coding-agent--commands nil)
+    (insert "/co")
+    (let ((result (pi-coding-agent--command-capf)))
+      (should result)
+      (should (member "compact" (nth 2 result)))
+      (should (member "new" (nth 2 result)))
+      (should (member "model" (nth 2 result))))))
 
+(ert-deftest pi-coding-agent-test-command-capf-merges-builtins-and-rpc ()
+  "Completion merges built-in and RPC commands without duplicates."
+  (with-temp-buffer
+    (pi-coding-agent-input-mode)
+    (setq pi-coding-agent--commands '((:name "my-ext" :description "Extension")))
+    (insert "/")
+    (let* ((result (pi-coding-agent--command-capf))
+           (names (nth 2 result)))
+      ;; Has built-in
+      (should (member "compact" names))
+      ;; Has RPC command
+      (should (member "my-ext" names))
+      ;; No duplicates
+      (should (= (length (seq-filter (lambda (n) (equal n "compact")) names)) 1)))))
 
 (ert-deftest pi-coding-agent-test-send-prompt-sends-literal ()
   "pi-coding-agent--send-prompt sends text literally (no expansion).