add a prompt to AI e.g. fix grammar

Author: sspaeti

docs/content/docs/configuration/_index.md

@@ -365,17 +365,34 @@ Workflow + caveats (sending an iMIP REPLY ≠ importing into your calendar) are
 
 ## AI handoff (pre-send `i` key)
 
-`[ai]` wires any external CLI to the pre-send `i` key. neomd writes the current draft to a temp markdown file (with the same `# [neomd: ...]` headers used during compose), spawns the command with the file path appended as the last argument, and re-reads the file on exit so any edits replace the draft body. Quit the AI tool (`ctrl+c`, `q`, `/quit`, `ZZ`, …) to return to neomd's pre-send screen.
+`[ai]` wires any external CLI to the pre-send `i` key. neomd:
+
+1. Shows a one-line prompt for your instruction (e.g. `fix grammar`, `make it more formal`, `tighten this`).
+2. Writes the current draft to a temp markdown file (with the same `# [neomd: ...]` headers used during compose).
+3. Spawns the command with the file path appended as the last arg. Any `{prompt}` token in `args` is replaced by what you typed.
+4. Re-reads the file on exit so the AI's edits replace your draft body.
+
+Press Enter on an empty prompt to run interactively (no `{prompt}` substitution); type an instruction + Enter to run non-interactively; press Esc to cancel. Quit the AI tool (`ctrl+c`, `q`, `/quit`, `ZZ`, …) to return to neomd's pre-send screen.
 
 ```toml
 [ai]
-command = "claude"          # default: Claude Code CLI
-# command = "codex"          # OpenAI Codex
-# command = "aichat"         # https://github.com/sigoden/aichat
-# args    = ["--print"]      # optional extra args, inserted before the file path
+command = "claude"                      # default: Claude Code CLI
+args    = ["edit {file}: {prompt}"]     # default: tells claude what file + what to do
+# command = "codex"
+# command = "aichat"
 ```
 
-`nvim` is intentionally **not** the default: the compose buffer is already open in nvim before pre-send, so spawning nvim on `i` would just re-edit. Pick a tool that does real work. The handoff reuses the same parser as the regular editor flow, so headers (To, Cc, Bcc, Subject) the AI tool may rewrite are picked up automatically. If `command` is empty the `i` key is a no-op.
+Two placeholders are substituted at spawn time: `{prompt}` becomes your typed instruction, `{file}` becomes the draft's basename. neomd also sets the spawned process's working directory to the temp dir holding the draft, so claude's built-in Edit tool reaches the file natively (no `--add-dir` needed).
+
+If you type `fix grammar` at the prompt, the spawn is `claude "edit neomd-ai-XYZ.md: fix grammar"` running in `/tmp/neomd/`. Claude opens interactively, sees the file in cwd, edits in place, you `/quit` when satisfied, neomd picks up the changes.
+
+> [!IMPORTANT]
+> Default args use the **interactive** form, not `claude -p`. The `-p` (print) flag in Claude Code is non-interactive and bills against your **API credits** rather than your Claude Pro/Max subscription — it leaks money even when you're paying for a plan. Interactive mode runs under your subscription auth. Only switch to `args = ["-p", "edit {file}: {prompt}"]` if you have an API key with credits and explicitly want the scripted, no-review flow.
+
+If you press Enter on an empty prompt, only the `{prompt}` placeholder is replaced (with `""`) — the resulting `"edit neomd-ai-XYZ.md: "` still tells claude which file to look at, so claude opens interactively in the temp dir with that file pre-mentioned and waits for your follow-up instruction.
+
+`nvim` is intentionally **not** the default: the compose buffer is already open in nvim before pre-send, so spawning nvim on `i` would just re-edit. You can already use [avante.nvim](https://github.com/yetone/avante.nvim) or others within neovim composer to do any AI you'd like. 
+But instead, pick a tool that does work. The handoff reuses the same parser as the regular editor flow, so headers (To, Cc, Bcc, Subject) the AI tool may rewrite are picked up automatically. If `command` is empty the `i` key is a no-op.
 
 ## OAuth2 Authentication
 

internal/config/config.go

@@ -113,19 +113,24 @@ type CalendarConfig struct {
 	OpenCommand string `toml:"open_command"` // default "xdg-open"
 }
 
-// AIConfig configures the pre-send "AI handoff" key (`i`). On press, neomd
+// AIConfig configures the pre-send "AI handoff" key (`i`). When pressed,
+// neomd shows a one-line prompt for an instruction (e.g. "fix grammar"),
 // writes the current draft to a temp markdown file with the standard
-// `# [neomd: ...]` headers, spawns `<command> [args...] <path>`, and re-reads
-// the file on exit so any changes round-trip back into the draft. Quit the
-// AI tool to return to neomd's pre-send screen.
+// `# [neomd: ...]` headers, spawns `<command> [args...]` with cwd set to
+// the file's directory, and re-reads the file on exit so any changes
+// round-trip back into the draft. Quit the AI tool to return.
 //
-// Default: `claude` (Claude Code CLI). The compose buffer is already in nvim
-// before pre-send, so spawning nvim again is pointless — pick a CLI that does
-// real work (claude, codex, aichat, sgpt, …). If `command` is empty the
-// binding is a no-op.
+// Two placeholders are substituted in args at spawn time:
+//   - `{prompt}` → the typed instruction (or empty for interactive mode)
+//   - `{file}`   → the draft's basename (cwd is set to its directory)
+//
+// Default args = ["edit {file}: {prompt}"]. With prompt "fix grammar" the
+// spawn is `claude "edit neomd-ai-XYZ.md: fix grammar"` (cwd /tmp/neomd) —
+// claude finds the file via cwd and edits in place. Set `command = ""` to
+// disable the binding.
 type AIConfig struct {
 	Command string   `toml:"command"`
-	Args    []string `toml:"args"` // optional extra args inserted before the file path
+	Args    []string `toml:"args"` // {prompt} and {file} placeholders are substituted
 }
 
 // NotificationsConfig controls desktop notifications for emails landing in
@@ -664,11 +669,20 @@ func defaults() *Config {
 			Signature:           "*sent from [neomd](https://neomd.ssp.sh)*",
 		},
 		AI: AIConfig{
-			// Default: hand off to Claude Code. The compose buffer is already
-			// open in nvim before pre-send, so spawning nvim again on `i` is
-			// pointless — drive Claude/Codex/etc. instead. Quit the AI tool
-			// (ctrl+c, q, /quit, ZZ, …) to return to neomd's pre-send screen.
+			// Default: hand off to Claude Code in **interactive** mode (not
+			// `-p` print mode, which would bill against Anthropic API credits
+			// instead of a Pro/Max subscription).
+			//
+			// `{prompt}` is the user's typed instruction. `{file}` is the
+			// basename of the temp draft. neomd sets the spawned command's
+			// cwd to the file's directory, so claude can reach the file
+			// natively via its Edit tool without --add-dir tricks.
+			//
+			// With this default, typing "fix grammar" at the AI prompt
+			// produces `claude "edit neomd-ai-XYZ.md: fix grammar"` (cwd
+			// set), and claude edits the file in place.
 			Command: "claude",
+			Args:    []string{"edit {file}: {prompt}"},
 		},
 	}
 }

internal/config/config_test.go

@@ -564,3 +564,50 @@ account = "Personal"
 		t.Error("UseKeyring() should be false after successful resolution")
 	}
 }
+
+func TestLoad_AIConfigDefaultUsesInteractiveClaude(t *testing.T) {
+	// Regression for two prior bugs:
+	//   1. Defaults must NOT include `-p` (claude's print mode bills against
+	//      API credits even with a Pro/Max subscription — triggered "Credit
+	//      balance is too low" in real use).
+	//   2. The arg string must mention {file} so claude knows which file to
+	//      edit. Without it the spawn was `claude "fix grammar" /path/file`
+	//      — claude treated the path positional as ignored text and started
+	//      running `git status` in its cwd instead of editing the draft.
+	//
+	// Default `args = ["edit {file}: {prompt}"]` paired with cmd.Dir set to
+	// the temp dir lets claude reach the file via its built-in Edit tool.
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "config.toml")
+	cfgBody := `
+[[accounts]]
+name     = "Personal"
+imap     = "imap.example.com:993"
+smtp     = "smtp.example.com:587"
+user     = "me@example.com"
+password = "x"
+from     = "Me <me@example.com>"
+`
+	if err := os.WriteFile(cfgPath, []byte(cfgBody), 0600); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+	cfg, err := Load(cfgPath)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if len(cfg.AI.Args) != 1 {
+		t.Fatalf("AI.Args = %v, want exactly one arg", cfg.AI.Args)
+	}
+	got := cfg.AI.Args[0]
+	if !strings.Contains(got, "{file}") {
+		t.Errorf("AI.Args = %q — must contain {file} placeholder so claude can locate the draft", got)
+	}
+	if !strings.Contains(got, "{prompt}") {
+		t.Errorf("AI.Args = %q — must contain {prompt} placeholder so the typed instruction is forwarded", got)
+	}
+	for _, a := range cfg.AI.Args {
+		if a == "-p" || a == "--print" {
+			t.Errorf("default args contain %q — that forces API billing instead of subscription auth", a)
+		}
+	}
+}

internal/ui/model.go

@@ -18,6 +18,7 @@ import (
 
 	"github.com/charmbracelet/bubbles/list"
 	"github.com/charmbracelet/bubbles/spinner"
+	"github.com/charmbracelet/bubbles/textinput"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
@@ -542,6 +543,12 @@ type Model struct {
 	pendingSend  *pendingSendData
 	presendFromI int // index into presendFroms() for the From field cycle
 
+	// AI handoff (pre-send `i`) — when active, shows a one-line input for the
+	// instruction that gets substituted into [ai].args via {prompt}. Empty
+	// input falls through to interactive mode (no substitution).
+	aiPromptActive bool
+	aiPromptInput  textinput.Model
+
 	// Reaction
 	reactionEmail    *imap.Email // email being reacted to
 	reactionSelected int         // selected emoji index (0-7)
@@ -2096,7 +2103,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 		}
 		m.openLinks = extractLinks(msg.body)
-		_ = loadEmailIntoReader(&m.reader, msg.email, msg.body, msg.attachments, m.openSpyPixels, m.openLinks, m.cfg.UI.Theme, m.width)
+		_ = loadEmailIntoReader(&m.reader, msg.email, msg.body, msg.attachments, m.openSpyPixels, m.openLinks, glamourStyleFor(m.cfg.UI.Theme), m.width)
 		m.state = stateReading
 		// Refresh inbox list if immediate mode, or start timer
 		if m.cfg.UI.MarkAsReadAfterSecs <= 0 {
@@ -4169,9 +4176,14 @@ func (m Model) openICSCmd() tea.Cmd {
 		m.status = "No calendar invite to open."
 		return nil
 	}
-	cmdName := strings.TrimSpace(m.cfg.Calendar.OpenCommand)
-	if cmdName == "" {
-		cmdName = "xdg-open"
+	// Split open_command on whitespace so configs like
+	// `open_command = "khal import"` exec the binary `khal` with arg
+	// `import`, not a literal binary named "khal import". Empty falls back
+	// to xdg-open. Quoted multi-word paths are not supported here — users
+	// who need that should symlink or wrap in a shell script.
+	cmdParts := strings.Fields(strings.TrimSpace(m.cfg.Calendar.OpenCommand))
+	if len(cmdParts) == 0 {
+		cmdParts = []string{"xdg-open"}
 	}
 
 	home, err := os.UserHomeDir()
@@ -4186,8 +4198,12 @@ func (m Model) openICSCmd() tea.Cmd {
 		m.isError = true
 		return nil
 	}
-	name := att.Filename
-	if name == "" {
+	// Path traversal hardening: filepath.Base() strips any directory
+	// components the sender may have stuck in Content-Disposition: filename
+	// (e.g. "../../../.bashrc" → ".bashrc"). The result is then joined under
+	// the cache dir so we can never write outside ~/.cache/neomd/ical/.
+	name := filepath.Base(att.Filename)
+	if name == "" || name == "." || name == "/" {
 		name = fmt.Sprintf("invite-%d.ics", time.Now().Unix())
 	}
 	dst := filepath.Join(dir, name)
@@ -4198,7 +4214,8 @@ func (m Model) openICSCmd() tea.Cmd {
 	}
 
 	return func() tea.Msg {
-		if err := exec.Command(cmdName, dst).Start(); err != nil {
+		args := append(cmdParts[1:], dst)
+		if err := exec.Command(cmdParts[0], args...).Start(); err != nil {
 			return icsOpenedMsg{path: dst, err: err}
 		}
 		return icsOpenedMsg{path: dst}
@@ -4443,6 +4460,23 @@ func (m Model) updatePresend(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			return m, nil
 		}
 	}
+	// AI prompt input mode: typed when user pressed `i`. Enter submits
+	// (empty → interactive, non-empty → templated into [ai].args). Esc
+	// cancels back to the normal pre-send screen.
+	if m.aiPromptActive {
+		switch msg.String() {
+		case "esc":
+			m.aiPromptActive = false
+			return m, nil
+		case "enter":
+			prompt := strings.TrimSpace(m.aiPromptInput.Value())
+			m.aiPromptActive = false
+			return m.launchAIHandoffCmd(ps, prompt)
+		}
+		var cmd tea.Cmd
+		m.aiPromptInput, cmd = m.aiPromptInput.Update(msg)
+		return m, cmd
+	}
 	switch msg.String() {
 	case "enter":
 		m.loading = true
@@ -4493,15 +4527,22 @@ func (m Model) updatePresend(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		// Open in nvim with spell checking, cursor on first error.
 		return m.launchSpellCheckCmd(ps)
 	case "i":
-		// AI handoff: write draft to a temp file and spawn [ai].command. The
-		// command is typically `nvim` (so the user can drive Claude/Codex from
-		// inside the editor) or a CLI like `claude` invoked directly. Body
-		// changes round-trip back through editorDoneMsg.
+		// AI handoff: prompt for a one-line instruction, then spawn
+		// [ai].command. Empty input → interactive mode (no {prompt}
+		// substitution); a typed instruction (e.g. "fix grammar") gets
+		// templated into [ai].args via {prompt} so e.g. claude can run
+		// non-interactively as `claude -p "fix grammar" <draft>`.
 		if strings.TrimSpace(m.cfg.AI.Command) == "" {
 			m.status = "AI handoff: set [ai].command in config.toml (e.g. command = \"claude\")"
 			return m, nil
 		}
-		return m.launchAIHandoffCmd(ps)
+		ti := textinput.New()
+		ti.Placeholder = "fix grammar  (Enter to run · empty = interactive · esc to cancel)"
+		ti.CharLimit = 200
+		ti.Focus()
+		m.aiPromptInput = ti
+		m.aiPromptActive = true
+		return m, nil
 	case "d":
 		// Save to Drafts without sending.
 		return m, m.saveDraftCmd(m.presendIMAPClient(), m.presendFrom(), ps.to, ps.cc, ps.bcc, ps.subject, ps.body, m.attachments)
@@ -4593,7 +4634,13 @@ func (m Model) launchSpellCheckCmd(ps *pendingSendData) (tea.Model, tea.Cmd) {
 // spell-check flows: on exit, the file is re-parsed and the draft body is
 // replaced. The configured command receives the file path as its final
 // argument so e.g. `claude` or `codex` work the same as `nvim`.
-func (m Model) launchAIHandoffCmd(ps *pendingSendData) (tea.Model, tea.Cmd) {
+//
+// `prompt` is the optional one-line instruction the user typed after `i`.
+// Any `{prompt}` placeholder in [ai].args is replaced by it so non-interactive
+// CLIs can run directly, e.g. with [ai].args = ["-p", "{prompt}"] and
+// prompt = "fix grammar" the spawn becomes `claude -p "fix grammar" <file>`.
+// Empty prompt → no substitution → interactive mode (current behaviour).
+func (m Model) launchAIHandoffCmd(ps *pendingSendData, prompt string) (tea.Model, tea.Cmd) {
 	prelude := editor.Prelude(ps.to, ps.cc, ps.bcc, m.presendFrom(), ps.subject, "")
 	content := prelude + ps.body
 
@@ -4607,20 +4654,48 @@ func (m Model) launchAIHandoffCmd(ps *pendingSendData) (tea.Model, tea.Cmd) {
 	f.WriteString(content) //nolint
 	f.Close()
 
-	args := append([]string{}, m.cfg.AI.Args...)
-	args = append(args, tmpPath)
+	// Expand {prompt} and {file} placeholders. {file} is the basename only
+	// (claude/codex/aichat take files via prompt mention, not positional);
+	// the directory containing the file becomes the spawned command's cwd
+	// just below so the AI tool's built-in file-edit tool can reach it
+	// without --add-dir or absolute paths.
+	filename := filepath.Base(tmpPath)
+	args := make([]string, 0, len(m.cfg.AI.Args))
+	for _, a := range m.cfg.AI.Args {
+		hadPromptPlaceholder := strings.Contains(a, "{prompt}")
+		s := strings.ReplaceAll(a, "{prompt}", prompt)
+		s = strings.ReplaceAll(s, "{file}", filename)
+		// Empty input + arg that was just `{prompt}` → drop the arg so the
+		// spawn becomes `claude` rather than `claude ""`. (An arg that
+		// contained both `{prompt}` and `{file}`, like the default, is
+		// non-empty after {file} expansion and survives.)
+		if hadPromptPlaceholder && s == "" {
+			continue
+		}
+		args = append(args, s)
+	}
 	cmd := exec.Command(m.cfg.AI.Command, args...)
+	cmd.Dir = filepath.Dir(tmpPath)
 	m.state = stateCompose
 	draftBackups := m.cfg.UI.DraftBackups()
 	return m, tea.ExecProcess(cmd, func(execErr error) tea.Msg {
 		backupDraft(tmpPath, draftBackups)
 		defer os.Remove(tmpPath)
-		if execErr != nil {
-			return editorDoneMsg{err: execErr}
-		}
+		// Read the temp file regardless of exit code. AI CLIs typically exit
+		// non-zero on Ctrl+C (130 = SIGINT), and that's the documented "quit
+		// to return" path — treating it as an error would clear attachments
+		// and bounce the user back to the inbox via editorDoneMsg{err}. The
+		// file we wrote at launch is still there even if the tool exited
+		// cleanly without touching it; parsing then yields the original draft.
 		raw, readErr := os.ReadFile(tmpPath)
 		if readErr != nil {
-			return editorDoneMsg{err: readErr}
+			// Surface the exec error too if both happened — useful for
+			// diagnosing missing-binary cases ([ai].command typo).
+			err := readErr
+			if execErr != nil {
+				err = fmt.Errorf("%w (ai exec: %v)", readErr, execErr)
+			}
+			return editorDoneMsg{err: err}
 		}
 		pto, pcc, pbcc, pfrom, psubject, _ := editor.ParseHeaders(string(raw))
 		if pto == "" {
@@ -5328,17 +5403,21 @@ func (m Model) viewPresend() string {
 		}
 		b.WriteString("\n")
 	}
-	if m.status != "" {
+	if m.aiPromptActive {
+		// One-line instruction prompt active — replaces the help footer
+		// until the user submits (Enter) or cancels (Esc).
+		b.WriteString(styleInputLabel.Render("AI prompt:") + " " + m.aiPromptInput.View())
+	} else if m.status != "" {
 		b.WriteString(statusBar(m.status, m.isError))
 	} else {
 		if isListmonk {
 			b.WriteString(styleHelp.Render("  enter schedule campaign · e edit · p preview · ctrl+f from · d draft · esc cancel · x discard"))
 		} else {
 			aiHint := ""
 			if strings.TrimSpace(m.cfg.AI.Command) != "" {
-				aiHint = fmt.Sprintf(" · i AI (%s, quit to return)", strings.Fields(m.cfg.AI.Command)[0])
+				aiHint = " · i AI (quit to return)"
 			}
-			b.WriteString(styleHelp.Render("  enter send · e edit · s spell · p preview" + aiHint + " · a attach · D remove attach · ctrl+f from · ctrl+b cc/bcc · d draft · esc cancel · x discard"))
+			b.WriteString(styleHelp.Render("  enter send · e edit · s spell · p preview · a attach · D remove attach" + aiHint + " · ctrl+f from · ctrl+b cc/bcc · d draft · esc cancel · x discard"))
 		}
 	}
 	return b.String()

internal/ui/styles.go

@@ -119,6 +119,21 @@ func init() {
 	ApplyTheme("kanagawa", config.Theme{})
 }
 
+// glamourStyleFor maps a neomd theme name to a glamour built-in style for
+// rendering email markdown in the reader. Glamour ships with a fixed set of
+// styles (`dark`, `light`, `auto`, `notty`, …); passing an unknown name
+// silently falls back to `notty` which strips colours and wrapping, so we
+// must translate. Light palettes → `light`; everything else (including the
+// pre-theme legacy values "dark"/"light"/"auto" and unknown names) →
+// `dark`. The legacy "auto" was rarely useful in practice and would now
+// be ambiguous, so we collapse it to `dark` for predictability.
+func glamourStyleFor(themeName string) string {
+	if themeName == "kanagawa-light" || themeName == "light" {
+		return "light"
+	}
+	return "dark"
+}
+
 // ApplyTheme switches the active palette and rebuilds the style vars. Pass an
 // override theme to mutate individual slots; empty fields fall through to the
 // named built-in. Unknown names fall back to kanagawa.