REPL v2: multi-line input, history persistence, ns-aware prompt

Three improvements that bring the REPL up to what a daily user expects:

1. Multi-line input. RET now goes through neat-repl-return, which
   checks the pending input's balance via parse-partial-sexp under
   neat-repl-input-syntax-table (Emacs Lisp by default). Balanced ->
   submit; not balanced or in-string -> newline. The user can finish a
   sexp across as many lines as needed and only the last RET submits.

2. History persistence. neat-repl-history-file defaults to
   ~/.emacs.d/neat-repl-history; comint-input-ring-file-name and
   comint-input-ring-size are wired in on mode setup, and the
   kill-buffer hook now writes the ring out before the buffer dies.

3. Namespace-aware prompt. neat-repl-prompt-format (default '%s> ')
   plus a buffer-local neat-repl--current-ns. Every response carrying
   an 'ns' field bumps the slot, and the next prompt picks it up.
   So 'user> (in-ns 'myapp.core)' yields a 'myapp.core> ' prompt next.
   neat-repl-default-ns is what shows up before the server has had a
   chance to tell us anything.

Replaces the old neat-repl-prompt defcustom -- no released versions
to keep compatible with.

Author: bbatsov

CHANGELOG.md

@@ -20,3 +20,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - `.nrepl-port` discovery: `M-x neat` defaults the port to whatever the nearest port file contains, so in a project with a running server `M-x neat RET RET` is enough. Customize via `neat-port-file-name`; library entry points are `neat-discover-port` and `neat-discover-port-file`.
 - Multi-connection support: `neat-connections` tracks every live `neat-connection`; `neat-set-default-connection` is an interactive picker that switches which one source buffers (running `neat-mode`) talk to. Connections drop out of the registry automatically on disconnect or server death, and the default demotes to the next-most-recent live connection if it goes away.
 - Integration test suite now parameterised over nREPL implementations: `neat-it--server-impls` describes each, and any one whose executable is on PATH gets its own `describe` block. Ships with entries for Clojure and Babashka.
+- REPL: multi-line input. `RET` only submits when the form parses as balanced; otherwise it inserts a newline. Balance check uses `neat-repl-input-syntax-table` (Emacs Lisp by default; override for languages with very different bracketing rules).
+- REPL: input history persistence. New `neat-repl-history-file` defaults to `~/.emacs.d/neat-repl-history`; history is loaded on REPL start and saved on buffer kill. Set to nil to disable.
+- REPL: namespace-aware prompt. The prompt is now derived from `neat-repl-prompt-format` (default `"%s> "`) and updates in response to the server's `ns` field, so `user> ` becomes `myapp.core> ` after `(in-ns 'myapp.core)`. `neat-repl-default-ns` controls what appears before the server has reported one.
+
+### Removed
+
+- `neat-repl-prompt` (defcustom). Replaced by `neat-repl-prompt-format` and `neat-repl-default-ns`. There were no released versions, so this is just churn within the unreleased changelog window.

README.md

@@ -51,7 +51,11 @@ M-x neat RET localhost RET 7888 RET
 ```
 
 A `*neat: localhost:7888*` buffer pops up with a prompt. Type an
-expression, hit `RET`, see the result.
+expression, hit `RET`, see the result. Multi-line forms work too --
+`RET` only submits when the input parses as balanced; otherwise it
+inserts a newline so you can finish the form. Input history is
+persisted between sessions in `neat-repl-history-file` and the prompt
+follows the server's reported namespace (`user> `, `myapp.core> `, ...).
 
 To evaluate from a source buffer:
 

neat-repl.el

@@ -24,8 +24,16 @@
 (require 'neat-bencode)
 (require 'neat-client)
 
-(defcustom neat-repl-prompt "neat> "
-  "Prompt string displayed in the REPL buffer."
+(defcustom neat-repl-prompt-format "%s> "
+  "Format string used to build the REPL prompt.
+The single %s is replaced with the current namespace (see
+`neat-repl--current-ns'), or `neat-repl-default-ns' before the
+server has reported one."
+  :type 'string
+  :group 'neat)
+
+(defcustom neat-repl-default-ns "neat"
+  "Namespace shown in the REPL prompt before the server reports one."
   :type 'string
   :group 'neat)
 
@@ -39,6 +47,24 @@
   :type 'integer
   :group 'neat)
 
+(defcustom neat-repl-history-file
+  (expand-file-name "neat-repl-history" user-emacs-directory)
+  "File where REPL input history is persisted between sessions.
+Set to nil to disable persistence."
+  :type '(choice file (const :tag "Disabled" nil))
+  :group 'neat)
+
+(defcustom neat-repl-history-size 1000
+  "Maximum number of input entries to keep in the REPL history ring."
+  :type 'integer
+  :group 'neat)
+
+(defvar neat-repl-input-syntax-table emacs-lisp-mode-syntax-table
+  "Syntax table used when checking REPL input balance before submit.
+Defaults to Emacs Lisp syntax, which is close enough for the Clojure
+family.  Set to a different syntax table if you're talking to a server
+in a language with very different bracketing rules.")
+
 (defface neat-repl-output
   '((t :inherit shadow))
   "Face for `out' (stdout) chunks streamed back from the server."
@@ -57,21 +83,31 @@
 (defvar-local neat-repl-connection nil
   "The `neat-connection' associated with this REPL buffer.")
 
+(defvar-local neat-repl--current-ns nil
+  "Most-recent namespace reported by the server for this buffer.")
+
 (defvar neat-repl-mode-map
   (let ((map (make-sparse-keymap)))
     (set-keymap-parent map comint-mode-map)
+    (define-key map (kbd "RET") #'neat-repl-return)
     (define-key map (kbd "C-c C-c") #'neat-repl-interrupt)
     (define-key map (kbd "C-c C-q") #'neat-repl-quit)
     map)
   "Keymap for `neat-repl-mode'.")
 
 (define-derived-mode neat-repl-mode comint-mode "neat-repl"
   "Major mode for an nREPL REPL buffer."
-  (setq-local comint-prompt-regexp (concat "^" (regexp-quote neat-repl-prompt)))
+  ;; A permissive prompt regex so the prompt format can vary with the
+  ;; current namespace.  Matches `<anything-but-newline>> ' at line start.
+  (setq-local comint-prompt-regexp "^[^\n]*?> ")
   (setq-local comint-prompt-read-only t)
   (setq-local comint-input-sender #'neat-repl--input-sender)
   (setq-local comint-use-prompt-regexp nil)
   (setq-local comint-scroll-show-maximum-output t)
+  (when neat-repl-history-file
+    (setq-local comint-input-ring-file-name neat-repl-history-file)
+    (setq-local comint-input-ring-size neat-repl-history-size)
+    (ignore-errors (comint-read-input-ring t)))
   (add-hook 'kill-buffer-hook #'neat-repl--kill-buffer-cleanup nil t))
 
 (defun neat-repl-buffer-name (conn)
@@ -105,11 +141,41 @@ purpose is to satisfy `comint-output-filter' and friends."
                  :coding 'utf-8)))
       (set-marker (process-mark proc) (point-max)))))
 
+(defun neat-repl--prompt ()
+  "Compute the prompt string for the current buffer."
+  (format neat-repl-prompt-format
+          (or neat-repl--current-ns neat-repl-default-ns)))
+
 (defun neat-repl--insert-prompt ()
   "Insert a fresh prompt at the end of the buffer."
   (let ((proc (get-buffer-process (current-buffer))))
     (when proc
-      (comint-output-filter proc neat-repl-prompt))))
+      (comint-output-filter proc (neat-repl--prompt)))))
+
+(defun neat-repl--input-complete-p (input)
+  "Return non-nil if INPUT is a balanced, complete form.
+
+Empty input counts as complete.  Otherwise the string is parsed under
+`neat-repl-input-syntax-table' and we require zero open parens, no
+in-string state, and no in-comment state at end of input."
+  (or (string-empty-p (string-trim input))
+      (with-temp-buffer
+        (set-syntax-table neat-repl-input-syntax-table)
+        (insert input)
+        (let ((state (parse-partial-sexp (point-min) (point-max))))
+          (and (zerop (car state))   ; depth in parens
+               (null (nth 3 state))   ; inside a string
+               (null (nth 4 state)))))))
+
+(defun neat-repl-return ()
+  "Submit the pending REPL input when it is balanced.
+Otherwise insert a newline so the user can keep typing the form."
+  (interactive)
+  (let* ((start (comint-line-beginning-position))
+         (input (buffer-substring-no-properties start (point-max))))
+    (if (neat-repl--input-complete-p input)
+        (comint-send-input)
+      (newline))))
 
 (defun neat-repl--input-sender (_proc input)
   "Eval INPUT on the current REPL buffer's connection."
@@ -136,7 +202,12 @@ purpose is to satisfy `comint-output-filter' and friends."
         (out (neat-bencode-get resp "out"))
         (err (neat-bencode-get resp "err"))
         (ex (neat-bencode-get resp "ex"))
+        (ns (neat-bencode-get resp "ns"))
         (status (neat-bencode-get resp "status")))
+    ;; Track the namespace as soon as we see one so the next prompt
+    ;; reflects any `(in-ns ...)' or namespace-switching form.
+    (when ns
+      (setq neat-repl--current-ns ns))
     (when proc
       (when out
         (comint-output-filter
@@ -151,7 +222,7 @@ purpose is to satisfy `comint-output-filter' and friends."
         (comint-output-filter
          proc (propertize (format "%s\n" ex) 'face 'neat-repl-error)))
       (when (member "done" status)
-        (comint-output-filter proc neat-repl-prompt)))))
+        (comint-output-filter proc (neat-repl--prompt))))))
 
 (defun neat-repl-interrupt ()
   "Send an `interrupt' op to the REPL's connection."
@@ -172,7 +243,9 @@ purpose is to satisfy `comint-output-filter' and friends."
   (bury-buffer))
 
 (defun neat-repl--kill-buffer-cleanup ()
-  "Tear down the connection and pipe process when the REPL buffer dies."
+  "Tear down the connection, persist history, and stop the pipe process."
+  (when comint-input-ring-file-name
+    (ignore-errors (comint-write-input-ring)))
   (when (and neat-repl-connection
              (neat-connection-live-p neat-repl-connection))
     (ignore-errors (neat-disconnect neat-repl-connection)))

test/neat-repl-test.el

@@ -0,0 +1,84 @@
+;;; neat-repl-test.el --- Tests for the REPL buffer helpers  -*- lexical-binding: t; -*-
+
+;;; Commentary:
+
+;; Unit tests for the pure helpers in `neat-repl' -- balance-aware
+;; input checks, prompt formatting, and namespace tracking via the
+;; rendered response.  The full comint UI is not driven here; that's
+;; out of scope for the fast suite.
+
+;;; Code:
+
+(require 'buttercup)
+(require 'neat-bencode)
+(require 'neat-repl)
+
+(describe "neat-repl--input-complete-p"
+  (it "accepts an empty string as complete"
+    (expect (neat-repl--input-complete-p "") :to-be-truthy))
+
+  (it "accepts whitespace-only input as complete"
+    (expect (neat-repl--input-complete-p "   \n  ") :to-be-truthy))
+
+  (it "accepts a balanced form as complete"
+    (expect (neat-repl--input-complete-p "(+ 1 2)") :to-be-truthy))
+
+  (it "accepts a balanced multi-line form as complete"
+    (expect (neat-repl--input-complete-p "(let [x 1\n      y 2]\n  (+ x y))")
+            :to-be-truthy))
+
+  (it "rejects an unclosed open paren"
+    (expect (neat-repl--input-complete-p "(+ 1 2") :to-be nil))
+
+  (it "rejects mismatched bracket types as unbalanced"
+    ;; Emacs Lisp syntax doesn't recognise [ ] as paren-like, so this
+    ;; spec keeps to plain (), which is the common Clojure/Lisp case.
+    (expect (neat-repl--input-complete-p "(foo (bar 1)") :to-be nil))
+
+  (it "rejects input that ends inside a string"
+    (expect (neat-repl--input-complete-p "(println \"hello") :to-be nil))
+
+  (it "accepts input with a closed string"
+    (expect (neat-repl--input-complete-p "(println \"hi\")") :to-be-truthy)))
+
+(describe "neat-repl--prompt"
+  (it "uses `neat-repl-default-ns' when no namespace is known"
+    (let ((neat-repl-prompt-format "%s> ")
+          (neat-repl-default-ns "neat")
+          (neat-repl--current-ns nil))
+      (expect (neat-repl--prompt) :to-equal "neat> ")))
+
+  (it "uses the tracked namespace when one is set"
+    (let ((neat-repl-prompt-format "%s> ")
+          (neat-repl-default-ns "neat")
+          (neat-repl--current-ns "myapp.core"))
+      (expect (neat-repl--prompt) :to-equal "myapp.core> ")))
+
+  (it "honours a custom prompt format"
+    (let ((neat-repl-prompt-format "[%s] => ")
+          (neat-repl-default-ns "neat")
+          (neat-repl--current-ns nil))
+      (expect (neat-repl--prompt) :to-equal "[neat] => "))))
+
+(describe "neat-repl--render-response (namespace tracking)"
+  (it "updates `neat-repl--current-ns' when the server reports `ns'"
+    (with-temp-buffer
+      (setq-local neat-repl--current-ns nil)
+      ;; Render a response with an `ns' field.  We don't have a comint
+      ;; process attached, so the user-visible writes are no-ops, but
+      ;; the buffer-local ns slot should still get updated.
+      (neat-repl--render-response
+       '(("id" . "1")
+         ("ns" . "myapp.core")
+         ("value" . "nil")
+         ("status" "done")))
+      (expect neat-repl--current-ns :to-equal "myapp.core")))
+
+  (it "leaves `neat-repl--current-ns' alone when the response has no `ns'"
+    (with-temp-buffer
+      (setq-local neat-repl--current-ns "stays")
+      (neat-repl--render-response
+       '(("id" . "1") ("value" . "nil") ("status" "done")))
+      (expect neat-repl--current-ns :to-equal "stays"))))
+
+;;; neat-repl-test.el ends here