implemented composing with nvim

Author: jameswexler1

PLAN.md

@@ -2,7 +2,7 @@
 
 ## Current Stage
 
-Implementation is past the local-shell phase and currently sits at a DB-first, live WhatsApp client with remote history/media support, outbound text, single-attachment media send, recent-sticker send, protocol-backed read receipts, reactions with a quick picker, own-message text editing, own-message delete-for-everybody, replies, quote-jump, a right-edge reply gesture in the message pane, typing presence, hybrid fuzzy group-member mention autocomplete, accent-aware search, visible-first chat-avatar sync/rendering with full profile images, first-class sticker receive/render/download behavior, app-state-backed muted/pinned chat settings, stable pending/paused/resumed pixel overlays for media/avatar/sticker rendering, direct-chat PN/LID canonicalization plus split-thread repair, desktop notifications with cached chat-avatar icons where supported plus a local global mute key/right-side configurable status-bar indicator, immediate DB catch-up sync overlay blocking with non-blocking startup app-state sync, async store/protocol-backed TUI actions for sends, lazy loads, filters, read receipts, reactions, retries, stickers, drafts, and mentions, denormalized chat-list previews, media retry UX, first-use-state logout reset, temp-backed non-exported chat media caches, clipboard attachment paste with Windows file-drop support, a persistent in-chat new-message divider, hardened Windows inline preview defaults, composer tail-follow scrolling, detached Shift+Enter external media launch, and the planned media/export CLI helpers. The next major gaps are live validation/polish of the notification and media-send paths on real chats, especially desktop delivery on fresh Linux and Windows installs, notification backend default resolution on a fresh config, audio/document fallback behavior, the new avatar/sticker behavior under daily use, plus attachment draft persistence and follow-on resend polish for failed rows.
+Implementation is past the local-shell phase and currently sits at a DB-first, live WhatsApp client with remote history/media support, outbound text, single-attachment media send, recent-sticker send, external-editor draft composition, protocol-backed read receipts, reactions with a quick picker, own-message text editing, own-message delete-for-everybody, replies, quote-jump, a right-edge reply gesture in the message pane, typing presence, hybrid fuzzy group-member mention autocomplete, accent-aware search, visible-first chat-avatar sync/rendering with full profile images, first-class sticker receive/render/download behavior, app-state-backed muted/pinned chat settings, stable pending/paused/resumed pixel overlays for media/avatar/sticker rendering, direct-chat PN/LID canonicalization plus split-thread repair, desktop notifications with cached chat-avatar icons where supported plus a local global mute key/right-side configurable status-bar indicator, immediate DB catch-up sync overlay blocking with non-blocking startup app-state sync, async store/protocol-backed TUI actions for sends, lazy loads, filters, read receipts, reactions, retries, stickers, drafts, and mentions, denormalized chat-list previews, media retry UX, first-use-state logout reset, temp-backed non-exported chat media caches, clipboard attachment paste with Windows file-drop support, a persistent in-chat new-message divider, hardened Windows inline preview defaults, composer tail-follow scrolling, detached Shift+Enter external media launch, and the planned media/export CLI helpers. The next major gaps are live validation/polish of the notification and media-send paths on real chats, especially desktop delivery on fresh Linux and Windows installs, notification backend default resolution on a fresh config, audio/document fallback behavior, the new avatar/sticker behavior under daily use, plus attachment draft persistence and follow-on resend polish for failed rows.
 
 ### Implemented now
 
@@ -11,7 +11,7 @@ Implementation is past the local-shell phase and currently sits at a DB-first, l
 - GitHub Actions CI validates Linux tests/vet, checks the Windows build graph, uploads Windows amd64/arm64 binaries for machines where local Windows builds are not available, and publishes a stable branch-build `windows-latest` release for direct tester updates.
 - SQLite-backed local state with migrations, chat/message/media/draft storage, denormalized chat previews, startup cache/mmap pragmas, stats, and FTS-backed search.
 - Bubble Tea TUI with modal interaction (`normal`, `insert`, `visual`, `command`, `search`), chat list, message viewport, optional info pane, composer, filters, and help.
-- Local draft persistence, local outgoing message persistence, normal/visual message yanking, text clipboard integration, clipboard image copy plus clipboard attachment paste/file-drop staging, attachment staging, message delete flow, and search routing by pane.
+- Local draft persistence, external-editor draft composition through configurable `$EDITOR`/`editor`, local outgoing message persistence, normal/visual message yanking, text clipboard integration, clipboard image copy plus clipboard attachment paste/file-drop staging, attachment staging, message delete flow, and search routing by pane.
 - Media backend detection and in-chat preview behavior with Unix `ueberzug++`, Windows-only `sixel`, `chafa`, compact audio playback rows, foreground and detached external media launch, plus native external open/save fallback paths. Linux auto preview uses `ueberzug++` pixel overlays before falling back to `chafa`/external openers and never selects Sixel; Windows auto preview still prefers Sixel in WezTerm when a Sixel renderer is installed, falls back to inline `chafa` before external openers when `preview_backend = "auto"`, draws Sixel out-of-band instead of embedding image escape payloads in Bubble Tea text frames, and explicit backend config wins when the requested backend is available on that platform.
 - Real `whatsmeow` session store, QR login, logout, rejected-session cleanup, first-use-state local reset on logout, and `doctor` session status reporting.
 - Live WhatsApp connection bootstrap from a paired session, protocol event subscription, inbound chat/message/receipt/media metadata ingestion into SQLite, DB-first UI refreshes, and visible connection state.

README.md

@@ -174,6 +174,7 @@ key_normal_open = "enter"
 key_normal_open_media = "o"
 key_normal_yank_message = "y"
 key_normal_edit_message = "leader e"
+key_normal_compose_editor = "leader c e"
 key_normal_pick_sticker = "leader t"
 key_normal_copy_image = "leader y"
 key_normal_save_media = "leader s"
@@ -218,6 +219,7 @@ Useful command-mode actions:
 :paste-image
 :attach
 :attach <path>
+:compose-editor
 :edit-message
 :sticker
 :delete-message
@@ -235,6 +237,8 @@ Useful command-mode actions:
 
 Image clipboard paste/copy is image-only. `key_insert_paste_image` stages the current clipboard image as the composer attachment, preserving composer text as the caption. `key_normal_copy_image` copies the focused image message to the clipboard and auto-downloads remote image media first when possible. The default image clipboard commands auto-detect Wayland/X11 tools; set `clipboard_image_paste_command` or `clipboard_image_copy_command` to override them. Paste commands may write to `{path}` or stdout, and copy commands may use `{path}` and `{mime}` or receive image bytes on stdin.
 
+External editor composition uses `key_normal_compose_editor` or `:compose-editor`. It opens the active chat draft in `editor`, writes the saved result back into the inline composer, persists it as the draft, and does not send until the normal composer send key is pressed. Editor commands are argv templates; if `{path}` is absent, vimwhat appends the temp draft file path.
+
 Sticker sending uses `key_normal_pick_sticker` or `:sticker`. Linux defaults to `sticker_picker_command = "nsxiv -t -o -p {files}"`; commands may use `{files}` for the temporary sticker file list, `{dir}` for the picker directory, and `{chooser}` for a chooser-output file. WebP stickers are selectable in v1; Lottie/TGS stickers are cached as metadata but skipped by the current picker/send path.
 
 All TUI action keys are configurable in `config.toml` using flat `key_<mode>_<action>` variables. Bindings accept printable single keys plus named tokens such as `space`, `enter`, `shift+enter`, `esc`, `tab`, `shift+tab`, `backspace`, `ctrl+x`, `alt+x`, `alt+enter`, and leader sequences. Duplicate bindings in the same mode and prefix conflicts such as binding both `space` and `leader s` are rejected at startup with a config error. Composer `shift+enter` only works when the terminal reports it distinctly; `ctrl+j` is the reliable newline fallback.

config.example.toml

@@ -47,6 +47,7 @@ key_normal_cancel = "esc"
 key_normal_quit = "q"
 key_normal_help = "?"
 key_normal_insert = "i"
+key_normal_compose_editor = "leader c e"
 key_normal_reply = "r"
 key_normal_react = "leader r"
 key_normal_forward = "f"

internal/app/app.go

@@ -424,6 +424,9 @@ func runTUI(env Environment, stderr io.Writer) int {
 		ForwardMessages: func(request ui.ForwardMessagesRequest) tea.Cmd {
 			return forwardMessagesCmd(liveEnabled, forwardRequests, request)
 		},
+		ComposeInEditor: func(chatID, initial string) tea.Cmd {
+			return composeInEditor(env.Paths, env.Config, chatID, initial)
+		},
 		SaveMedia: func(media store.MediaMetadata) error {
 			storeCtx, cancelStore := uiStoreWriteContext()
 			defer cancelStore()

internal/app/integrations.go

@@ -502,6 +502,102 @@ func pickAttachment(commandTemplate string) tea.Cmd {
 	})
 }
 
+func composeInEditor(paths config.Paths, cfg config.Config, chatID, initial string) tea.Cmd {
+	draftPath, err := prepareComposeEditorDraft(paths, initial)
+	if err != nil {
+		return composerEditorError(chatID, err)
+	}
+	cmd, err := composeEditorCommand(paths, cfg.Editor, draftPath)
+	if err != nil {
+		_ = os.Remove(draftPath)
+		return composerEditorError(chatID, err)
+	}
+	return tea.ExecProcess(cmd, func(err error) tea.Msg {
+		return composerEditedMessage(chatID, draftPath, err)
+	})
+}
+
+func composerEditorError(chatID string, err error) tea.Cmd {
+	return func() tea.Msg {
+		return ui.ComposerEditedMsg{ChatID: chatID, Err: err}
+	}
+}
+
+func prepareComposeEditorDraft(paths config.Paths, initial string) (string, error) {
+	root := strings.TrimSpace(paths.TransientDir)
+	if root == "" {
+		root = os.TempDir()
+	} else if err := os.MkdirAll(root, 0o700); err != nil {
+		return "", fmt.Errorf("create editor temp dir: %w", err)
+	}
+	dir := filepath.Join(root, "compose")
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return "", fmt.Errorf("create editor compose dir: %w", err)
+	}
+	file, err := os.CreateTemp(dir, "vimwhat-compose-*.txt")
+	if err != nil {
+		return "", fmt.Errorf("create editor draft: %w", err)
+	}
+	path := file.Name()
+	if _, err := file.WriteString(initial); err != nil {
+		_ = file.Close()
+		_ = os.Remove(path)
+		return "", fmt.Errorf("write editor draft: %w", err)
+	}
+	if err := file.Close(); err != nil {
+		_ = os.Remove(path)
+		return "", fmt.Errorf("close editor draft: %w", err)
+	}
+	return path, nil
+}
+
+func composeEditorCommand(paths config.Paths, editor, draftPath string) (*exec.Cmd, error) {
+	editor = strings.TrimSpace(editor)
+	if editor == "" {
+		editor = config.Default(paths).Editor
+	}
+	hasPathPlaceholder := strings.Contains(editor, "{path}")
+	argv, err := splitCommandLine(editor)
+	if err != nil {
+		return nil, err
+	}
+	if len(argv) == 0 {
+		return nil, fmt.Errorf("editor command is empty")
+	}
+	replaceArgPlaceholder(argv, "{path}", draftPath)
+	if !hasPathPlaceholder {
+		argv = append(argv, draftPath)
+	}
+	if _, err := exec.LookPath(argv[0]); err != nil {
+		return nil, fmt.Errorf("editor %q not found", argv[0])
+	}
+	cmd := exec.Command(argv[0], argv[1:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd, nil
+}
+
+func composerEditedMessage(chatID, draftPath string, err error) ui.ComposerEditedMsg {
+	defer os.Remove(draftPath)
+	if err != nil {
+		return ui.ComposerEditedMsg{ChatID: chatID, Err: err}
+	}
+	body, err := readEditedComposerDraft(draftPath)
+	return ui.ComposerEditedMsg{ChatID: chatID, Body: body, Err: err}
+}
+
+func readEditedComposerDraft(path string) (string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("read editor draft: %w", err)
+	}
+	body := strings.ReplaceAll(string(data), "\r\n", "\n")
+	body = strings.ReplaceAll(body, "\r", "\n")
+	body = strings.TrimSuffix(body, "\n")
+	return body, nil
+}
+
 func pickSticker(paths config.Paths, cfg config.Config, db *store.Store) tea.Cmd {
 	return func() tea.Msg {
 		cmd, err := stickerPickerCommand(paths, cfg, db)

internal/app/integrations_test.go

@@ -358,6 +358,75 @@ func TestPickStickerUsesExistingCacheWithoutSync(t *testing.T) {
 	}
 }
 
+func TestPrepareComposeEditorDraftUsesTransientDir(t *testing.T) {
+	root := t.TempDir()
+	path, err := prepareComposeEditorDraft(config.Paths{TransientDir: root}, "hello")
+	if err != nil {
+		t.Fatalf("prepareComposeEditorDraft() error = %v", err)
+	}
+	defer os.Remove(path)
+	if !strings.HasPrefix(path, filepath.Join(root, "compose")) {
+		t.Fatalf("draft path = %q, want under transient compose dir", path)
+	}
+	if got := string(mustReadFile(t, path)); got != "hello" {
+		t.Fatalf("draft content = %q, want hello", got)
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("Stat(draft) error = %v", err)
+	}
+	if info.Mode().Perm() != 0o600 {
+		t.Fatalf("draft mode = %03o, want 600", info.Mode().Perm())
+	}
+}
+
+func TestComposeEditorCommandAppendsDraftPathWhenPlaceholderMissing(t *testing.T) {
+	draftPath := filepath.Join(t.TempDir(), "draft.txt")
+	cmd, err := composeEditorCommand(config.Paths{}, "sh -c true", draftPath)
+	if err != nil {
+		t.Fatalf("composeEditorCommand() error = %v", err)
+	}
+	want := "sh\x00-c\x00true\x00" + draftPath
+	if got := strings.Join(cmd.Args, "\x00"); got != want {
+		t.Fatalf("args = %q, want %q", got, want)
+	}
+	if cmd.Stdin != os.Stdin || cmd.Stdout != os.Stdout || cmd.Stderr != os.Stderr {
+		t.Fatalf("editor stdio = stdin %T stdout %T stderr %T, want real process stdio", cmd.Stdin, cmd.Stdout, cmd.Stderr)
+	}
+}
+
+func TestComposeEditorCommandReplacesPathPlaceholder(t *testing.T) {
+	draftPath := filepath.Join(t.TempDir(), "draft with spaces.txt")
+	cmd, err := composeEditorCommand(config.Paths{}, `sh -c "printf edited > {path}"`, draftPath)
+	if err != nil {
+		t.Fatalf("composeEditorCommand() error = %v", err)
+	}
+	if len(cmd.Args) != 3 || !strings.Contains(cmd.Args[2], draftPath) {
+		t.Fatalf("args = %#v, want placeholder replaced without appending", cmd.Args)
+	}
+}
+
+func TestComposeEditorCommandReportsMissingEditor(t *testing.T) {
+	_, err := composeEditorCommand(config.Paths{}, "vimwhat-editor-definitely-missing", filepath.Join(t.TempDir(), "draft.txt"))
+	if err == nil || !strings.Contains(err.Error(), "editor") || !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("composeEditorCommand() error = %v, want missing editor", err)
+	}
+}
+
+func TestComposerEditedMessageReadsNormalizesAndCleansUp(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "draft.txt")
+	if err := os.WriteFile(path, []byte("hello\r\nworld\r\n"), 0o600); err != nil {
+		t.Fatalf("WriteFile(draft) error = %v", err)
+	}
+	msg := composerEditedMessage("chat-1", path, nil)
+	if msg.Err != nil || msg.ChatID != "chat-1" || msg.Body != "hello\nworld" {
+		t.Fatalf("composerEditedMessage() = %+v, want normalized body", msg)
+	}
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Fatalf("draft cleanup Stat() error = %v, want not exist", err)
+	}
+}
+
 func TestExpandStickerPickerArgsSplicesFiles(t *testing.T) {
 	got := expandStickerPickerArgs(
 		[]string{"nsxiv", "-t", "-o", "-p", "{files}"},