Open a note in $EDITOR

[saforem2]

What

e on a selected note (or ctrl+e from inside the card) hands it to the
user's real editor as a markdown file, and reads it back when they quit.

export EDITOR=nvim        # or: hx, micro, "code -w", "emacsclient -nw"

The card editor is great for a few lines. Past that people want their own
editor with their own bindings, and for a note that's really a document
there's no reason redthread should be in the way.

The file

Title, blank line, body — the same first-line-is-title convention the
built-in editor and clipboard paste already use:

write rfc

- auth spec
- sync protocol

parseNoteFile delegates to the existing splitClipboardText rather than
reimplementing the split, and a test asserts the two agree across the
awkward inputs (no title, no body, leading blank lines). Writing a third
copy of that logic seemed like the obvious way to end up with three
subtly different notions of what a note's text means.

The .md extension is deliberate — it's what makes the editor turn on
markdown highlighting and wrapping.

Resolution

VISUAL beats EDITOR, per the usual convention (EDITOR may be a line
editor; VISUAL is the full-screen one). The value is treated as a command
line, not a program name, so flags survive — code -w and subl -w need
their wait flags or the editor returns instantly and the note appears
unchanged.

With neither set, e shows $EDITOR is not set rather than falling back
to vi. Dropping someone into an editor they may not know how to exit,
from a TUI they were happily using, seemed worse than saying nothing
happened.

Failure paths

The note is left exactly as it was when:

• the editor exits non-zero (:cq)
• the temp file can't be read, or has gone missing
• the file comes back empty — a stray :q! on the wrong buffer
  shouldn't blank a note
• nothing changed, so quitting without saving doesn't bump Updated

Each of those has a test; removing the empty-file guard or the exit-code
check fails one.

Testing

go test ./..., -race, vet, gofmt clean.

The interesting tests use a real subprocess rather than a mock — a
shell script that rewrites the file, and one that exits 1 — so the
exec.Cmd we hand to tea.ExecProcess is the thing under test.

I also drove the built binary end to end through tmux with a scripted
$EDITOR: pressed e, confirmed the title and body updated on the board,
that the TUI redrew correctly after the editor released the terminal, and
that the result reached notes.json. Then again with EDITOR/VISUAL
unset to see the message.

Notes

Independent of #3 and #4 — different files, any merge order works.

editorCommand splits on whitespace, so an editor path containing spaces
needs a wrapper script. That's the same limitation git has, and handling
it properly means a shell-quoting parser I don't think this earns. Easy to
add if you disagree.

[Copilot]

🟡 Changes recommended

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Pull request overview

Adds an “external editor” workflow so users can open a note in their configured $VISUAL/$EDITOR as a temporary .md file, then read the result back into the app when the editor exits.

Changes:

• Adds external-editor handoff (e on board, ctrl+e in card) via a temp .md file and tea.ExecProcess, with guarded read-back behavior.
• Wires the new message flow into the Bubble Tea update loop and updates in-app help/footer hints.
• Adds focused unit/integration tests for the round-trip, including real subprocess scripts.

File summaries

File	Description
README.md	Documents the external editor feature and keybindings.
internal/app/model.go	Adds keybindings and handles externalEditDoneMsg to apply results and restore UI state.
internal/app/extedit.go	Implements editor resolution, temp file write/read, and note-apply logic.
internal/app/extedit_test.go	Adds tests for parsing, temp file behavior, and real subprocess editor execution.
internal/app/edit.go	Updates the card footer hint to include ctrl+e.

Review details

• Files reviewed: 5/5 changed files
• Comments generated: 3
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[saforem2]

One thing worth knowing before this merges — a gap between this PR and #4 that neither can show on its own.

Both were written against main, so neither knows about the other. This PR applies the external edit with m.saver.Touch(), which is correct on a tree with no undo stack. Once #4 is in there is one, and the external edit is the only mutation that does not go through its m.mutate seam — so pressing u after editing a note in your editor leaves the note as the editor wrote it.

The fix is three lines: snapshot before the TUI suspends, at both entry points (e on the board and ctrl+e in the card). It has to happen before rather than in the completion handler, because by the time the editor's result comes back the note has already changed, so that is the last point where the pre-edit text still exists.

I cannot push it here yet — m.mutate does not exist on main, so it would not compile against this base. Happy to add it as soon as #4 lands, or you can take it as a follow-up; either is fine.

I found this by combining all four branches locally to check they compose. Everything else did, and the only other cross-feature issue was cosmetic (the edit-mode footer hint, which #6 replaces with a variable — worth a glance when you merge that one).

No rush on any of it.