Add ghostel-compile and ghostel-recompile

Adds compile.el-style integration on top of ghostel: `M-x
ghostel-compile' runs a shell command in a ghostel terminal buffer
and presents the result like `M-x compile' — header, footer,
error highlighting, and `next-error' navigation — but backed by a
real TTY so programs that probe `isatty(3)' (coloured output,
progress bars, curses tools) behave as they do in a normal shell.

Architecture:

  - `ghostel-command-start-functions' / `ghostel-command-finish-
    functions' hooks expose OSC 133 C / D semantic prompt markers
    from the parser.  `ghostel-compile' uses both to track a
    pending → armed → fired state machine so that prompt redraws
    (which can emit a stale D) don't get treated as the user
    command's exit.

  - `ghostel-compile-mode' (minor) wires the OSC 133 hooks into a
    live ghostel buffer.  When the user's command finishes the
    shell process and ghostel renderer are torn down, header and
    footer text are inserted (matching compile.el byte-for-byte),
    the buffer's major mode is switched to a new
    `ghostel-compile-view-mode' (derived from `compilation-mode'),
    and `compilation--ensure-parse' populates the error list.  The
    buffer becomes a regular read-only Emacs buffer that never
    transitions back to an interactive terminal — recompile
    discards it and starts fresh.

  - `mode-line-process' shows :run / :exit [N] using the same
    `compilation-mode-line-{run,exit,fail}' faces `M-x compile'
    uses.

Compile parity:

  - `compile-command' / `compile-history' shared with \[compile]
  - `compilation-read-command' (prefix arg forces the prompt)
  - `compilation-ask-about-save'
  - `compilation-auto-jump-to-first-error'
  - `compilation-finish-functions'

Ghostel-specific options: `ghostel-compile-buffer-name',
`ghostel-compile-finished-major-mode',
`ghostel-compile-hide-prompts', `ghostel-compile-clear-buffer',
`ghostel-compile-finish-functions', `ghostel-compile-debug'.

Keys in the finished view-mode buffer:
  g            - ghostel-recompile
  n / p        - compilation-next-error / -previous-error
  RET / mouse-2 - compile-goto-error
  M-g n / M-g p - standard next-error / previous-error

Recompile preserves the original `default-directory' (captured at
`ghostel-compile' invocation) so pressing `g' from any buffer
re-runs the command in the right directory.

Bash integration fix: the PROMPT_COMMAND wrapper in
`etc/ghostel.bash' captures `$?' on its first line via
`local $?'.  The previous code began with the bare assignment
`__ghostel_in_prompt_command=1' which resets `$?' to 0 in bash,
so OSC 133 D always carried 0 and any consumer reported `:exit
[0]' for every command.

107 new ERT tests across the elisp test suite cover the hook
plumbing, the view-mode switch, error parsing without double
counting, header/footer insertion, prompt hiding, the C-gating
state machine, the bash integration round-trip, default-directory
preservation, and shared `compile-command' / `compile-history'
behaviour.

Author: dakra

Makefile

@@ -4,7 +4,7 @@ XDG_CACHE_HOME ?= $(HOME)/.cache
 MELPAZOID_DIR  ?= $(XDG_CACHE_HOME)/melpazoid
 EVIL_DIR       ?= $(XDG_CACHE_HOME)/evil
 
-ELC := ghostel.elc ghostel-debug.elc
+ELC := ghostel.elc ghostel-debug.elc ghostel-compile.elc
 
 .PHONY: all build test test-native test-all test-evil lint melpazoid byte-compile bench bench-quick clean
 
@@ -53,7 +53,7 @@ checkdoc:
 		              (checkdoc-proper-noun-list nil) \
 		              (checkdoc-verb-check-experimental-flag nil) \
 		              (ok t)) \
-		  (dolist (f '(\"ghostel.el\" \"ghostel-debug.el\")) \
+		  (dolist (f '(\"ghostel.el\" \"ghostel-debug.el\" \"ghostel-compile.el\")) \
 		    (ignore-errors (kill-buffer \"*Warnings*\")) \
 		    (let ((inhibit-message t)) \
 		      (checkdoc-file f)) \
@@ -67,7 +67,7 @@ melpazoid:
 	@if [ ! -d "$(MELPAZOID_DIR)" ]; then \
 		git clone https://github.com/riscy/melpazoid.git "$(MELPAZOID_DIR)"; \
 	fi
-	RECIPE='(ghostel :fetcher github :repo "dakra/ghostel" :files ("ghostel.el" "ghostel-debug.el" "ghostel-module.*"))' \
+	RECIPE='(ghostel :fetcher github :repo "dakra/ghostel" :files ("ghostel.el" "ghostel-debug.el" "ghostel-compile.el" "ghostel-module.*"))' \
 		LOCAL_REPO=$(CURDIR) \
 		make -C "$(MELPAZOID_DIR)"
 

README.md

@@ -19,6 +19,7 @@ process, keymap, and buffer.
   - [TRAMP (Remote Terminals)](#tramp-remote-terminals)
 - [Configuration](#configuration)
 - [Commands](#commands)
+  - [Compilation mode](#compilation-mode)
 - [Running Tests](#running-tests)
 - [Performance](#performance)
 - [Ghostel vs vterm](#ghostel-vs-vterm)
@@ -457,6 +458,110 @@ with a project-prefixed buffer name.  To make it available from
 (add-to-list 'project-switch-commands '(ghostel-project "Ghostel") t)
 ```
 
+### Compilation mode
+
+`ghostel-compile` runs a shell command in a ghostel buffer and presents
+the result like `M-x compile` — `compilation-mode`-style header,
+footer, error highlighting, and `next-error` navigation — but backed by
+a real TTY so programs that probe `isatty(3)` (coloured output, progress
+bars, curses tools) behave as they do in a normal shell.
+
+```elisp
+(require 'ghostel-compile)
+
+(global-set-key (kbd "C-c c") #'ghostel-compile)
+```
+
+Commands:
+
+| Command                 | Description                                         |
+|-------------------------|-----------------------------------------------------|
+| `M-x ghostel-compile`   | Prompt for a command and run it (uses `compile-command`) |
+| `M-x ghostel-recompile` | Re-run the last command in its original directory   |
+
+What a run looks like — the buffer text matches `M-x compile`:
+
+```
+-*- mode: ghostel-compile -*-
+Compilation started at Wed Apr 15 08:30:11
+
+make -j4 test
+
+...command output (live, with full TTY)...
+
+Compilation finished at Wed Apr 15 08:30:19, duration 8.20 s
+```
+
+When the command finishes, the live shell and ghostel renderer are torn
+down and the buffer's major mode is switched to `ghostel-compile-view-mode`
+(derived from `compilation-mode`).  The buffer becomes a regular,
+read-only Emacs buffer with compile-mode's coloured error / line-number
+faces; the buffer never returns to an interactive ghostel terminal —
+a recompile discards it and starts fresh in the original directory.
+Point stays at the end of the output (where the renderer left it) so
+you see the latest output and the footer rather than jumping to the
+top.  `mode-line-process` shows `:run` while the command is running
+and `:exit [N]` afterwards, using the same faces `M-x compile` uses.
+
+Keybindings (in `ghostel-compile-view-mode`):
+
+| Key             | Action                                                  |
+|-----------------|---------------------------------------------------------|
+| `g`             | Re-run via `ghostel-recompile`                          |
+| `n` / `p`       | Move point to next / previous error (no auto-open)      |
+| `RET` / `mouse-2` | Jump to the source of the error under point           |
+| `M-g n` / `M-g p` | Standard `next-error` / `previous-error`              |
+| `C-c C-c`       | `compile-goto-error` (same as RET)                      |
+
+These standard `compile` options are honoured:
+
+- **`compile-command` / `compile-history`** — shared with `M-x compile`.
+  The prompt defaults to `compile-command`, the chosen command is
+  written back, and the history list is `compile-history`, so recent
+  commands round-trip between the two commands.
+- **`compilation-read-command`** — when nil, `ghostel-compile` runs
+  `compile-command` silently; pass a prefix arg to force the prompt.
+- **`compilation-ask-about-save`** — modified buffers are offered for
+  saving before launching.
+- **`compilation-auto-jump-to-first-error`** — jumps to the first error
+  after parsing.
+- **`compilation-finish-functions`** — runs with `(buffer msg)` just
+  like with `M-x compile`.
+- Output scrolling is always on (terminal behaviour — equivalent to
+  `compilation-scroll-output` non-nil).
+
+`ghostel-recompile` runs in the directory the original `ghostel-compile`
+was invoked from, regardless of which buffer you're in when you press
+`g`.
+
+Ghostel-specific customisation:
+
+| Option                                | Effect                                                                                                          |
+|---------------------------------------|-----------------------------------------------------------------------------------------------------------------|
+| `ghostel-compile-buffer-name`         | Buffer name (default `*ghostel-compile*`)                                                                        |
+| `ghostel-compile-finished-major-mode` | Major mode to switch to after each run (default `ghostel-compile-view-mode`; set to nil to stay in `ghostel-mode`) |
+| `ghostel-compile-hide-prompts`        | Hide surrounding shell prompts (default `t`)                                                                     |
+| `ghostel-compile-clear-buffer`        | Clear the buffer before each run (default `t`)                                                                   |
+| `ghostel-compile-finish-functions`    | Ghostel-specific finish hook (runs alongside `compilation-finish-functions`)                                     |
+| `ghostel-compile-debug`               | Log every OSC 133 C/D event to `*Messages*` (default `nil`)                                                      |
+
+Completion is detected via the OSC 133 `D;<exit>` semantic prompt
+marker, so shell integration (`ghostel-shell-integration`, enabled by
+default) must be active.
+
+#### Hooks for your own integrations
+
+Outside of a compile buffer, two hooks let you react to *any* shell
+command in *any* ghostel buffer:
+
+- `ghostel-command-start-functions` — called with `(BUFFER)` when the
+  shell emits OSC 133 `C` (a command starts running).
+- `ghostel-command-finish-functions` — called with `(BUFFER EXIT-STATUS)`
+  when the shell emits OSC 133 `D` (a command finishes).
+
+Errors raised by individual hook functions are caught and logged so
+one bad consumer can't break the rest.
+
 ## Running Tests
 
 Tests use ERT.  The Makefile provides convenient targets:

etc/ghostel.bash

@@ -17,11 +17,6 @@ __ghostel_osc7() {
 
 # --- Semantic prompt markers (OSC 133) ---
 
-# Save exit status before PROMPT_COMMAND overwrites $?.
-__ghostel_save_status() {
-    __ghostel_last_status="$?"
-}
-
 # Emit "command finished" (D) for the previous command, then "prompt start" (A).
 # D is skipped on the very first prompt (no previous command).
 __ghostel_prompt_start() {
@@ -46,8 +41,15 @@ __ghostel_preexec() {
 }
 
 __ghostel_wrapped_prompt_command() {
+    # Capture $? FIRST.  A bare assignment such as
+    # `__ghostel_in_prompt_command=1' on its own line counts as a
+    # successful command and resets $? to 0 in bash, so any later
+    # `$?' read here would always see 0 and we'd report `:exit [0]'
+    # for every command.  `local' with `=$?' evaluates `$?' before
+    # invoking the local builtin, preserving the real exit status.
+    local __ghostel_status=$?
     __ghostel_in_prompt_command=1
-    __ghostel_save_status
+    __ghostel_last_status=$__ghostel_status
     __ghostel_prompt_start
     __ghostel_osc7
     eval "${__ghostel_original_prompt_command:-}"