editprompt 0.6.0 → 0.8.0

package/README.md

@@ -1,16 +1,21 @@
+<p align="center">
+    <a href="https://www.npmjs.com/package/editprompt"><img src="https://img.shields.io/npm/v/editprompt?color=CB0200" alt="link to npm.js" /></a>
+</p>
+
 # 📝 editprompt
 
 A CLI tool that lets you write prompts for CLI tools using your favorite text editor. Works seamlessly with Claude Code, Codex CLI, Gemini CLI, and any other CLI process.
 
-https://github.com/user-attachments/assets/01bcda7c-7771-4b33-bf5c-629812d45cc4
+![send without closing editor](https://github.com/user-attachments/assets/b0e486af-78d7-4b70-8c82-64d330c22ba1)
 
 
 ## 🏆 Why editprompt?
 
 - **🎯 Your Editor, Your Way**: Write prompts in your favorite editor with full syntax highlighting, plugins, and customizations
 - **🚫 No Accidental Sends**: Never accidentally hit Enter and send an incomplete prompt again
-- 🔄 **Reusable Prompts**: Save and iterate on prompts with `--always-copy`
-- 📝 **Multi-line Commands**: Complex SQL queries, JSON payloads
+- **🔄 Iterate Efficiently**: Keep your editor open and send multiple prompts without reopening
+- **💬 Quote and Reply**: Collect multiple text selections and reply to specific parts of AI responses
+- **📝 Multi-line Commands**: Complex SQL queries, JSON payloads, and structured prompts
 
 
 ## ✨ Features
@@ -18,8 +23,9 @@ https://github.com/user-attachments/assets/01bcda7c-7771-4b33-bf5c-629812d45cc4
 - 🖊️ **Editor Integration**: Use your preferred text editor to write prompts
 - 🖥️ **Multiplexer Support**: Send prompts directly to tmux or WezTerm sessions
 - 🖥️ **Universal Terminal Support**: Works with any terminal via clipboard - no multiplexer required
+- 📤 **Send Without Closing**: Iterate on prompts without closing your editor
+- 📋 **Quote Buffering**: Collect text selections and send them as quoted replies
 - 📋 **Clipboard Fallback**: Automatically copies to clipboard if sending fails
-- 📋 **Always Copy Option**: Copy to clipboard even after successful tmux delivery (`--always-copy`)
 
 
 ## 📦 Installation
@@ -34,106 +40,61 @@ npx editprompt
 
 ## 🚀 Usage
 
-- Run `editprompt` to open a temporary Markdown file in your editor
-- Write your prompt comfortably with full editor features
-- Save and close - it automatically:
-  - Sends to tmux/wezterm panes if detected
-  - Falls back to clipboard otherwise (works with **any terminal**)
+editprompt supports three main workflows to fit different use cases:
 
-```sh
-editprompt
-```
+### Workflow 1: Basic - Write and Send
 
-**Advanced usage:** You can also send content **without closing the editor** for faster iteration. See `Send Without Closing Editor` for details.
+![wrihte and send prompt by editprompt](https://github.com/user-attachments/assets/6587b0c4-8132-4d5c-be68-3aa32a8d4df2) 
 
+The simplest way to use editprompt:
 
-### 🖥️ Tmux Integration
+1. Run `editprompt` to open your editor
+2. Write your prompt
+3. Save and close the editor
+4. Content is automatically sent to the target pane or clipboard
 
-**Split window version (with pane resume):**
-```tmux
-bind -n M-q run-shell '\
-  editprompt --resume --target-pane #{pane_id} || \
-  tmux split-window -v -l 10 -c "#{pane_current_path}" \
-    "editprompt --editor nvim --always-copy --target-pane #{pane_id}"'
-```
+Perfect for one-off prompts when you need more space than a terminal input line.
 
-**How it works:**
-- **First time**: Creates a new editor pane if one doesn't exist
-- **Subsequent times**: Focuses the existing editor pane instead of creating a new one
-- **Bidirectional**: Pressing the same keybinding from within the editor pane returns you to the original target pane
+### Workflow 2: Interactive - Iterate with Editor Open
 
-This allows you to toggle between your target pane and editor pane using the same keybinding (`M-q`).
+![send without closing editor](https://github.com/user-attachments/assets/b0e486af-78d7-4b70-8c82-64d330c22ba1)
 
-**Benefits:**
-- Prevents pane proliferation and keeps your window management simple
-- Switch between your work pane and editor pane while preserving your editing content
+For iterating on prompts without constantly reopening the editor:
 
-**Popup version:**
-```tmux
-bind -n M-q run-shell 'tmux display-popup -E \
-  -d "#{pane_current_path}" \
-  -w 80% -h 65% \
-  "editprompt --editor nvim --always-copy --target-pane #{pane_id}"'
-```
+1. Set up a keybinding to open editprompt with `--resume` mode
+2. Editor pane stays open between sends
+3. Write, send, refine, send again - all without closing the editor
+4. Use the same keybinding to toggle between your work pane and editor pane
 
+Ideal for trial-and-error workflows with AI assistants.
 
-### 🖼️ WezTerm Integration
+### Workflow 3: Quote - Collect and Reply
 
-```lua
-{
-    key = "q",
-    mods = "OPT",
-    action = wezterm.action_callback(function(window, pane)
-        local target_pane_id = tostring(pane:pane_id())
-
-        -- Try to resume existing editor pane
-        local success, stdout, stderr = wezterm.run_child_process({
-            "/bin/zsh",
-            "-lc",
-            string.format(
-                "editprompt --resume --mux wezterm --target-pane %s",
-                target_pane_id
-            ),
-        })
-
-        -- If resume failed, create new editor pane
-        if not success then
-            window:perform_action(
-                act.SplitPane({
-                    direction = "Down",
-                    size = { Cells = 10 },
-                    command = {
-                        args = {
-                            "/bin/zsh",
-                            "-lc",
-                            string.format(
-                                "editprompt --editor nvim --always-copy --mux wezterm --target-pane %s",
-                                target_pane_id
-                            ),
-                        },
-                    },
-                }),
-                pane
-            )
-        end
-    end),
-},
+![quote and capture with editprompt](https://github.com/user-attachments/assets/33af0702-5c80-4ccf-80d9-0ae42052e6fa)
+
+```markdown
+> Some AI agents include leading spaces in their output,which can make the copied text look a bit awkward.
+
+<!-- Write your reply here -->
+
+> Using editprompt’s quote mode or capture mode makes it easy to reply while quoting the AI agent’s output.
+
+<!-- Write your reply here -->
 ```
 
-**How it works:**
-- **First time**: Creates a new editor pane if one doesn't exist
-- **Subsequent times**: Focuses the existing editor pane instead of creating a new one
-- **Bidirectional**: Pressing the same keybinding from within the editor pane returns you to the original target pane
+For replying to specific parts of AI responses:
 
-This allows you to toggle between your target pane and editor pane using the same keybinding (`OPT-q`).
+1. Select text in your terminal (tmux copy mode or WezTerm selection) and trigger quote mode
+2. Repeat to collect multiple selections
+3. Run `editprompt --capture` to retrieve all collected quotes
+4. Edit and send your reply with context
 
-**Benefits:**
-- Prevents pane proliferation and keeps your window management simple
-- Switch between your work pane and editor pane while preserving your editing content
+Perfect for addressing multiple points in long AI responses.
 
-**Note:** The `-lc` flag ensures your shell loads the full login environment, making `editprompt` available in your PATH.
 
-### 💡 Basic Usage
+## ⚙️ Setup & Configuration
+
+### Basic Setup
 
 ```bash
 # Use with your default editor (from $EDITOR)
@@ -150,21 +111,91 @@ editprompt --always-copy
 editprompt --help
 ```
 
+### Tmux Integration
 
-## 📤 Send Without Closing Editor
+```tmux
+bind -n M-q run-shell '\
+  editprompt --resume --target-pane #{pane_id} || \
+  tmux split-window -v -l 10 -c "#{pane_current_path}" \
+    "editprompt --editor nvim --always-copy --target-pane #{pane_id}"'
+```
+
+
+### WezTerm Integration
+
+```lua
+{
+  key = "q",
+  mods = "OPT",
+  action = wezterm.action_callback(function(window, pane)
+    local target_pane_id = tostring(pane:pane_id())
+
+    -- Try to resume existing editor pane
+    local success, stdout, stderr = wezterm.run_child_process({
+      "/bin/zsh",
+      "-lc",
+      string.format(
+        "editprompt --resume --mux wezterm --target-pane %s",
+        target_pane_id
+      ),
+    })
+
+    -- If resume failed, create new editor pane
+    if not success then
+      window:perform_action(
+        act.SplitPane({
+          direction = "Down",
+          size = { Cells = 10 },
+          command = {
+            args = {
+              "/bin/zsh",
+              "-lc",
+              string.format(
+                "editprompt --editor nvim --always-copy --mux wezterm --target-pane %s",
+                target_pane_id
+              ),
+            },
+          },
+        }),
+        pane
+      )
+    end
+  end),
+},
+```
+
+**Note:** The `-lc` flag ensures your shell loads the full login environment, making `editprompt` available in your PATH.
+
+
+### Editor Integration (Send Without Closing)
 
 While editprompt is running, you can send content to the target pane or clipboard without closing the editor. This allows you to iterate quickly on your prompts.
 
-### Basic Usage
+#### Command Line Usage
 
 ```bash
 # Run this command from within your editor session
 editprompt -- "your content here"
+# Sends content to target pane and moves focus there
+
+editprompt --auto-send -- "your content here"
+# Sends content, automatically submits it (presses Enter), and returns focus to editor pane
+# Perfect for iterating on prompts without leaving your editor
+
+editprompt --auto-send --send-key "C-m" -- "your content here"
+# Customize the key to send after content (tmux format example)
+# WezTerm example: --send-key "\r" (default for WezTerm is \r, tmux default is Enter)
 ```
 
 This sends the content to the target pane (or clipboard) while keeping your editor open, so you can continue editing and send multiple times.
 
-### Neovim Integration Example
+**Options:**
+- `--auto-send`: Automatically sends the content and returns focus to your editor pane (requires multiplexer)
+- `--send-key <key>`: Customize the key to send after content (requires `--auto-send`)
+  - tmux format: `Enter` (default), `C-a`, etc.
+  - WezTerm format: `\r` (default), `\x01`, etc.
+
+#### Neovim Integration Example
 
 You can set up a convenient keybinding to send your buffer content:
 
@@ -198,155 +229,180 @@ if vim.env.EDITPROMPT then
 end
 ```
 
-With this configuration:
-1. Open editprompt using the tmux/wezterm keybinding mentioned above
+**Usage:**
+1. Open editprompt using the tmux/wezterm keybinding
 2. Write your prompt in the editor
 3. Press `<Space>x` to send the content to the target pane
 4. The buffer is automatically cleared on success
 5. Continue editing to send more content
 
+### Quote Workflow Setup
 
-## ⚙️ Configuration
+#### Collecting Quotes in tmux Copy Mode
 
-### 📝 Editor Selection
+Add this keybinding to your `.tmux.conf` to collect selected text as quotes:
 
-editprompt respects the following editor priority:
-
-1. `--editor/-e` command line option
-2. `$EDITOR` environment variable  
-3. Default: `vim`
-
-### 🌍 Environment Variables
-
-- `EDITOR`: Your preferred text editor
+```tmux
+bind-key -T copy-mode-vi C-e { send-keys -X pipe "editprompt --quote --target-pane #{pane_id}" }
+```
 
-### 🔧 Editor Integration with EDITPROMPT
+**Usage:**
+1. Enter tmux copy mode (`prefix + [`)
+2. Select text using vi-mode keybindings
+3. Press `Ctrl-e` to add the selection as a quote
+4. Repeat to collect multiple quotes
+5. All quotes are stored in a pane variable associated with the target pane
 
-editprompt automatically sets `EDITPROMPT=1` when launching your editor. This allows you to detect when your editor is launched by editprompt and enable specific configurations or plugins.
+#### Collecting Quotes in WezTerm
 
-#### 🔍 Example: Neovim Configuration
+Add this event handler and keybinding to your `wezterm.lua` to collect selected text as quotes:
 
 ```lua
--- In your Neovim config (e.g., init.lua)
-if vim.env.EDITPROMPT then
-  vim.opt.wrap = true
-  -- Load a specific colorscheme
-  vim.cmd('colorscheme blue')
-end
+local wezterm = require("wezterm")
+
+wezterm.on("editprompt-quote", function(window, pane)
+  local text = window:get_selection_text_for_pane(pane)
+  local target_pane_id = tostring(pane:pane_id())
+
+  wezterm.run_child_process({
+    "/bin/zsh",
+    "-lc",
+    string.format(
+      "editprompt --quote --mux wezterm --target-pane %s -- %s",
+      target_pane_id,
+      wezterm.shell_quote_arg(text)
+    ),
+  })
+end)
+
+return {
+  keys = {
+    {
+      key = "e",
+      mods = "CTRL",
+      action = wezterm.action.EmitEvent("editprompt-quote"),
+    },
+  },
+}
 ```
 
-#### 🛠️ Setting Custom Environment Variables
+**Usage:**
+1. Select text in WezTerm (by dragging with mouse or using copy mode)
+2. Press `Ctrl-e` to add the selection as a quote
+3. Repeat to collect multiple quotes
+4. All quotes are stored in a configuration file associated with the target pane
 
-You can also pass custom environment variables to your editor:
+#### Capturing Collected Quotes
 
-```bash
-# Single environment variable
-editprompt --env THEME=dark
-
-# Multiple environment variables
-editprompt --env THEME=dark --env FOO=fooooo
+Run this command from within your editor pane to retrieve all collected quotes:
 
-# Useful for editor-specific configurations
-editprompt --env NVIM_CONFIG=minimal
+```bash
+editprompt --capture
 ```
 
----
+This copies all collected quotes to the clipboard and clears the buffer, ready for your reply.
 
-## 🔧 Development
+**Complete workflow:**
+1. AI responds with multiple points
+2. Select each point in copy mode and press `Ctrl-e`
+3. Open your editor pane and run `editprompt --capture`
+4. Edit the quoted text with your responses
+5. Send to AI
 
-```bash
-# Clone the repository
-git clone https://github.com/eetann/editprompt.git
-cd editprompt
+**How quote buffering works:**
+- **tmux**: Quotes are stored in pane variables, automatically cleaned up when the pane closes
+- **WezTerm**: Quotes are stored in a configuration file associated with the pane
+- Text is intelligently processed: removes common indentation, handles line breaks smartly
+- Each quote is prefixed with `> ` in markdown quote format
+- Multiple quotes are separated with blank lines
 
-# Install dependencies
-bun install
+#### Neovim Integration Example
 
-# Build
-bun run build
+You can set up a convenient keybinding to capture your quote content:
+```lua
+vim.keymap.set("n", "<Space>X", function()
+  vim.cmd("update")
 
-# Run tests
-bun test
+  vim.system({ "editprompt", "--capture" }, { text = true }, function(obj)
+    vim.schedule(function()
+      if obj.code == 0 then
+        vim.cmd("silent write")
+        -- Split stdout by lines
+        local output_lines = vim.split(obj.stdout, "\n")
+
+        local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
+        local is_empty = #lines == 1 and lines[1] == ""
+
+        if is_empty then
+          -- If empty, overwrite from the beginning
+          vim.api.nvim_buf_set_lines(0, 0, -1, false, output_lines)
+          vim.cmd("normal 2j")
+        else
+          -- If not empty, append to the end
+          table.insert(output_lines, 1, "")
+          local line_count = vim.api.nvim_buf_line_count(0)
+          vim.api.nvim_buf_set_lines(
+            0,
+            line_count,
+            line_count,
+            false,
+            output_lines
+          )
+          vim.cmd("normal 4j")
+        end
 
-# Development mode
-bun run dev
+        vim.cmd("silent write")
+      else
+        vim.notify(
+          "editprompt failed: " .. (obj.stderr or "unknown error"),
+          vim.log.levels.ERROR
+        )
+      end
+    end)
+  end)
+end, { silent = true, desc = "Capture from editprompt quote mode" })
 ```
 
-### 💻 Testing During Development
+### Environment Variables
 
-When developing, you can test the built `dist/index.js` directly:
+#### Editor Selection
 
-#### Neovim Configuration
+editprompt respects the following editor priority:
 
-```diff
-- { "editprompt", "--", content },
-+ { "node", vim.fn.expand("~/path/to/editprompt/dist/index.js"), "--", content },
-```
+1. `--editor/-e` command line option
+2. `$EDITOR` environment variable
+3. Default: `vim`
 
-#### WezTerm Configuration
+#### EDITPROMPT Environment Variable
 
-```lua
--- In your wezterm.lua
-local editprompt_cmd = "node " .. os.getenv("HOME") .. "/path/to/editprompt/dist/index.js"
+editprompt automatically sets `EDITPROMPT=1` when launching your editor. This allows you to detect when your editor is launched by editprompt and enable specific configurations or plugins.
 
-{
-    key = "e",
-    mods = "OPT",
-    action = wezterm.action_callback(function(window, pane)
-        local target_pane_id = tostring(pane:pane_id())
-
-        local success, stdout, stderr = wezterm.run_child_process({
-            "/bin/zsh",
-            "-lc",
-            string.format(
-                "%s --resume --mux wezterm --target-pane %s",
-                editprompt_cmd,
-                target_pane_id
-            ),
-        })
-
-        if not success then
-            window:perform_action(
-                act.SplitPane({
-                    -- ...
-                    command = {
-                        args = {
-                            "/bin/zsh",
-                            "-lc",
-                            string.format(
-                                "%s --editor nvim --always-copy --mux wezterm --target-pane %s",
-                                editprompt_cmd,
-                                target_pane_id
-                            ),
-                        },
-                    },
-                }),
-                pane
-            )
-        end
-    end),
-},
-```
+**Example: Neovim Configuration**
 
-#### tmux Configuration
+```lua
+-- In your Neovim config (e.g., init.lua)
+if vim.env.EDITPROMPT then
+  vim.opt.wrap = true
+  -- Load a specific colorscheme
+  vim.cmd('colorscheme blue')
+end
+```
 
-```tmux
-# In your .tmux.conf
-set-option -g @editprompt-cmd "node ~/path/to/editprompt/dist/index.js"
+#### Custom Environment Variables
 
-bind-key -n M-q run-shell '\
-  #{@editprompt-cmd} --resume --target-pane #{pane_id} || \
-  tmux split-window -v -l 10 -c "#{pane_current_path}" \
-    "#{@editprompt-cmd} --editor nvim --always-copy --target-pane #{pane_id}"'
-```
+You can also pass custom environment variables to your editor:
 
-This allows you to make changes, run `bun run build`, and test immediately without reinstalling globally.
+```bash
+# Single environment variable
+editprompt --env THEME=dark
 
-## 🔍 Technical Details
+# Multiple environment variables
+editprompt --env THEME=dark --env FOO=fooooo
 
-### 🔄 Fallback Strategy
+# Useful for editor-specific configurations
+editprompt --env NVIM_CONFIG=minimal
+```
 
-editprompt implements a robust fallback strategy:
+#### Target Pane Environment Variable
 
-1. **Tmux Integration**: Direct input to tmux panes (when available)
-2. **Clipboard**: Copy content to clipboard with user notification
+When using the send-without-closing feature or quote capture, editprompt sets `EDITPROMPT_TARGET_PANE` to the target pane ID. This is automatically used by `editprompt --` and `editprompt --capture` commands.

package/dist/index.js

@@ -1,114 +1,15 @@
 #!/usr/bin/env node
 import { cli } from "gunshi";
 import { exec, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import Conf from "conf";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { promisify } from "node:util";
-import Conf from "conf";
 import clipboardy from "clipboardy";
 
 //#region package.json
-var version = "0.6.0";
-
-//#endregion
-//#region src/config/constants.ts
-const TEMP_FILE_PREFIX = ".editprompt-";
-const TEMP_FILE_EXTENSION = ".md";
-const DEFAULT_EDITOR = "vim";
-
-//#endregion
-//#region src/utils/contentProcessor.ts
-function processContent(content) {
-	let processed = content.replace(/\n$/, "");
-	if (/@[^\n]*$/.test(processed)) processed += " ";
-	return processed;
-}
-
-//#endregion
-//#region src/utils/envParser.ts
-/**
-* Parses environment variable strings into an object.
-* @param envStrings - An array of strings in the format ["KEY=VALUE", "FOO=bar"].
-* @returns An object of environment variable key-value pairs.
-*/
-function parseEnvVars(envStrings) {
-	if (!envStrings || envStrings.length === 0) return {};
-	const result = {};
-	for (const envString of envStrings) {
-		const [key, ...valueParts] = envString.split("=");
-		if (!key || valueParts.length === 0) throw new Error(`Invalid environment variable format: ${envString}`);
-		result[key] = valueParts.join("=");
-	}
-	return result;
-}
-
-//#endregion
-//#region src/utils/tempFile.ts
-function getFormattedDateTime() {
-	const now = /* @__PURE__ */ new Date();
-	return `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}${String(now.getSeconds()).padStart(2, "0")}`;
-}
-async function createTempFile() {
-	const tempDir = join(tmpdir(), "editprompt-prompts");
-	await mkdir(tempDir, { recursive: true });
-	const filePath = join(tempDir, `${TEMP_FILE_PREFIX}${getFormattedDateTime()}${TEMP_FILE_EXTENSION}`);
-	await writeFile(filePath, "", "utf-8");
-	return filePath;
-}
-
-//#endregion
-//#region src/modules/editor.ts
-function getEditor(editorOption) {
-	return editorOption || process.env.EDITOR || DEFAULT_EDITOR;
-}
-async function launchEditor(editor, filePath, envVars, sendConfig) {
-	return new Promise((resolve, reject) => {
-		const configEnv = {};
-		if (sendConfig) {
-			if (sendConfig.targetPane) configEnv.EDITPROMPT_TARGET_PANE = sendConfig.targetPane;
-			configEnv.EDITPROMPT_MUX = sendConfig.mux;
-			configEnv.EDITPROMPT_ALWAYS_COPY = sendConfig.alwaysCopy ? "1" : "0";
-		}
-		const processEnv = {
-			...process.env,
-			EDITPROMPT: "1",
-			...configEnv,
-			...envVars
-		};
-		const editorProcess = spawn(editor, [filePath], {
-			stdio: "inherit",
-			shell: true,
-			env: processEnv
-		});
-		editorProcess.on("error", (error) => {
-			reject(/* @__PURE__ */ new Error(`Failed to launch editor: ${error.message}`));
-		});
-		editorProcess.on("exit", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`Editor exited with code: ${code}`));
-		});
-	});
-}
-async function readFileContent(filePath) {
-	try {
-		return processContent(await readFile(filePath, "utf-8"));
-	} catch (error) {
-		throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
-	const tempFilePath = await createTempFile();
-	const editor = getEditor(editorOption);
-	const parsedEnvVars = parseEnvVars(envVars);
-	try {
-		await launchEditor(editor, tempFilePath, parsedEnvVars, sendConfig);
-		return await readFileContent(tempFilePath);
-	} catch (error) {
-		if (error instanceof Error) throw error;
-		throw new Error("An unknown error occurred");
-	}
-}
+var version = "0.8.0";
 
 //#endregion
 //#region src/modules/tmux.ts
@@ -162,11 +63,38 @@ async function isEditorPane(paneId) {
 		return false;
 	}
 }
+async function getQuoteVariableContent(paneId) {
+	try {
+		const { stdout } = await execAsync$2(`tmux show -pt '${paneId}' -v @editprompt_quote`);
+		return stdout;
+	} catch {
+		return "";
+	}
+}
+async function appendToQuoteVariable(paneId, content) {
+	let newContent = "";
+	const existingContent = await getQuoteVariableContent(paneId);
+	if (existingContent.trim() !== "") newContent = `${existingContent}\n${content}`;
+	else newContent = content;
+	await execAsync$2(`tmux set-option -pt '${paneId}' @editprompt_quote '${newContent.replace(/'/g, "'\\''")}' `);
+}
+async function clearQuoteVariable(targetPaneId) {
+	await execAsync$2(`tmux set-option -pt '${targetPaneId}' @editprompt_quote ""`);
+}
+async function sendKeyToTmuxPane(paneId, key) {
+	await execAsync$2(`tmux send-keys -t '${paneId}' ${key}`);
+}
+async function sendContentToTmuxPaneNoFocus(paneId, content) {
+	await execAsync$2(`tmux if-shell -t '${paneId}' '[ "#{pane_in_mode}" = "1" ]' "copy-mode -q -t '${paneId}'"`);
+	await execAsync$2(`tmux send-keys -t '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
+	console.log(`Content sent to tmux pane: ${paneId}`);
+}
 
 //#endregion
 //#region src/modules/wezterm.ts
 const execAsync$1 = promisify(exec);
-const conf = new Conf({ projectName: "editprompt" });
+const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
+const conf = new Conf({ projectName });
 async function getCurrentPaneId$1() {
 	try {
 		const { stdout } = await execAsync$1("wezterm cli list --format json");
@@ -235,6 +163,186 @@ function isEditorPaneFromConf(paneId) {
 		return false;
 	}
 }
+async function appendToQuoteText(paneId, content) {
+	try {
+		const data = conf.get(`wezterm.targetPane.pane_${paneId}`);
+		let newData;
+		if (typeof data === "object" && data !== null) {
+			const existingQuoteText = "quote_text" in data ? String(data.quote_text) : "";
+			const newQuoteText = existingQuoteText.trim() !== "" ? `${existingQuoteText}\n\n${content}` : content;
+			newData = {
+				...data,
+				quote_text: newQuoteText
+			};
+		} else newData = { quote_text: content };
+		conf.set(`wezterm.targetPane.pane_${paneId}`, newData);
+	} catch (error) {
+		console.log(error);
+	}
+}
+async function getQuoteText(paneId) {
+	try {
+		const data = conf.get(`wezterm.targetPane.pane_${paneId}`);
+		if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
+		return "";
+	} catch (error) {
+		console.log(error);
+		return "";
+	}
+}
+async function clearQuoteText(paneId) {
+	try {
+		const key = `wezterm.targetPane.pane_${paneId}.quote_text`;
+		if (conf.has(key)) conf.delete(key);
+	} catch (error) {
+		console.log(error);
+	}
+}
+async function sendKeyToWeztermPane(paneId, key) {
+	await execAsync$1(`wezterm cli send-text --no-paste --pane-id '${paneId}' $'${key}'`);
+}
+async function sendContentToWeztermPaneNoFocus(paneId, content) {
+	await execAsync$1(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
+	console.log(`Content sent to wezterm pane: ${paneId}`);
+}
+
+//#endregion
+//#region src/utils/sendConfig.ts
+const VALID_MUX_TYPES = ["tmux", "wezterm"];
+function readSendConfig() {
+	const targetPane = process.env.EDITPROMPT_TARGET_PANE;
+	const muxValue = process.env.EDITPROMPT_MUX || "tmux";
+	if (!VALID_MUX_TYPES.includes(muxValue)) throw new Error(`Invalid EDITPROMPT_MUX value: ${muxValue}. Must be one of: ${VALID_MUX_TYPES.join(", ")}`);
+	return {
+		targetPane,
+		mux: muxValue,
+		alwaysCopy: process.env.EDITPROMPT_ALWAYS_COPY === "1"
+	};
+}
+
+//#endregion
+//#region src/modes/capture.ts
+async function runCaptureMode() {
+	try {
+		const config = readSendConfig();
+		if (!config.targetPane) {
+			console.error("Error: EDITPROMPT_TARGET_PANE environment variable is required in capture mode");
+			process.exit(1);
+		}
+		let quoteContent;
+		if (config.mux === "tmux") {
+			quoteContent = await getQuoteVariableContent(config.targetPane);
+			await clearQuoteVariable(config.targetPane);
+		} else {
+			quoteContent = await getQuoteText(config.targetPane);
+			await clearQuoteText(config.targetPane);
+		}
+		process.stdout.write(quoteContent.replace(/\n{3,}$/, "\n\n"));
+		process.exit(0);
+	} catch (error) {
+		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/config/constants.ts
+const TEMP_FILE_PREFIX = ".editprompt-";
+const TEMP_FILE_EXTENSION = ".md";
+const DEFAULT_EDITOR = "vim";
+
+//#endregion
+//#region src/utils/contentProcessor.ts
+function processContent(content) {
+	let processed = content.replace(/\n$/, "");
+	if (/@[^\n]*$/.test(processed)) processed += " ";
+	return processed;
+}
+
+//#endregion
+//#region src/utils/envParser.ts
+/**
+* Parses environment variable strings into an object.
+* @param envStrings - An array of strings in the format ["KEY=VALUE", "FOO=bar"].
+* @returns An object of environment variable key-value pairs.
+*/
+function parseEnvVars(envStrings) {
+	if (!envStrings || envStrings.length === 0) return {};
+	const result = {};
+	for (const envString of envStrings) {
+		const [key, ...valueParts] = envString.split("=");
+		if (!key || valueParts.length === 0) throw new Error(`Invalid environment variable format: ${envString}`);
+		result[key] = valueParts.join("=");
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/tempFile.ts
+function getFormattedDateTime() {
+	const now = /* @__PURE__ */ new Date();
+	return `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}${String(now.getSeconds()).padStart(2, "0")}`;
+}
+async function createTempFile() {
+	const tempDir = join(tmpdir(), "editprompt-prompts");
+	await mkdir(tempDir, { recursive: true });
+	const filePath = join(tempDir, `${TEMP_FILE_PREFIX}${getFormattedDateTime()}${TEMP_FILE_EXTENSION}`);
+	await writeFile(filePath, "", "utf-8");
+	return filePath;
+}
+
+//#endregion
+//#region src/modules/editor.ts
+function getEditor(editorOption) {
+	return editorOption || process.env.EDITOR || DEFAULT_EDITOR;
+}
+async function launchEditor(editor, filePath, envVars, sendConfig) {
+	return new Promise((resolve, reject) => {
+		const configEnv = {};
+		if (sendConfig) {
+			if (sendConfig.targetPane) configEnv.EDITPROMPT_TARGET_PANE = sendConfig.targetPane;
+			configEnv.EDITPROMPT_MUX = sendConfig.mux;
+			configEnv.EDITPROMPT_ALWAYS_COPY = sendConfig.alwaysCopy ? "1" : "0";
+		}
+		const processEnv = {
+			...process.env,
+			EDITPROMPT: "1",
+			...configEnv,
+			...envVars
+		};
+		const editorProcess = spawn(editor, [filePath], {
+			stdio: "inherit",
+			shell: true,
+			env: processEnv
+		});
+		editorProcess.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`Failed to launch editor: ${error.message}`));
+		});
+		editorProcess.on("exit", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Editor exited with code: ${code}`));
+		});
+	});
+}
+async function readFileContent(filePath) {
+	try {
+		return processContent(await readFile(filePath, "utf-8"));
+	} catch (error) {
+		throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
+	const tempFilePath = await createTempFile();
+	const editor = getEditor(editorOption);
+	const parsedEnvVars = parseEnvVars(envVars);
+	try {
+		await launchEditor(editor, tempFilePath, parsedEnvVars, sendConfig);
+		return await readFileContent(tempFilePath);
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error("An unknown error occurred");
+	}
+}
 
 //#endregion
 //#region src/modules/process.ts
@@ -270,6 +378,50 @@ async function sendContentToPane(content, mux, targetPaneId, alwaysCopy) {
 	}
 }
 
+//#endregion
+//#region src/modes/sendOnly.ts
+async function sendContentToPaneWithAutoSend(content, mux, targetPaneId, sendKey) {
+	if (mux === "wezterm") {
+		await sendContentToWeztermPaneNoFocus(targetPaneId, content);
+		await sendKeyToWeztermPane(targetPaneId, sendKey);
+	} else {
+		await sendContentToTmuxPaneNoFocus(targetPaneId, content);
+		await sendKeyToTmuxPane(targetPaneId, sendKey);
+	}
+}
+async function runSendOnlyMode(rawContent, autoSend, sendKey) {
+	const content = processContent(rawContent);
+	if (!content) {
+		console.log("No content to send. Exiting.");
+		return;
+	}
+	const config = readSendConfig();
+	if (!config.targetPane) {
+		console.error("Error: EDITPROMPT_TARGET_PANE environment variable is required in send-only mode");
+		process.exit(1);
+	}
+	if (autoSend) {
+		if (!config.mux) {
+			console.error("Error: --auto-send requires a multiplexer (tmux or wezterm)");
+			process.exit(1);
+		}
+		try {
+			const key = sendKey || (config.mux === "wezterm" ? "\\r" : "Enter");
+			await handleAutoSendDelivery(content, config.mux, config.targetPane, key);
+		} catch (error) {
+			console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+			process.exit(1);
+		}
+		return;
+	}
+	try {
+		await handleContentDelivery(content, config.mux, config.targetPane, config.alwaysCopy);
+	} catch (error) {
+		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+}
+
 //#endregion
 //#region src/modes/common.ts
 function outputContent(content) {
@@ -295,6 +447,17 @@ async function handleContentDelivery(content, mux, targetPane, alwaysCopy) {
 	}
 	outputContent(content);
 }
+async function handleAutoSendDelivery(content, mux, targetPane, sendKey) {
+	if (!content || !targetPane) throw new Error("Content and target pane are required");
+	try {
+		await sendContentToPaneWithAutoSend(content, mux, targetPane, sendKey);
+		console.log("Content sent and submitted successfully!");
+	} catch (error) {
+		console.error(`Failed to send content: ${error instanceof Error ? error.message : "Unknown error"}`);
+		throw error;
+	}
+	outputContent(content);
+}
 
 //#endregion
 //#region src/modes/openEditor.ts
@@ -336,6 +499,127 @@ async function runOpenEditorMode(options) {
 	}
 }
 
+//#endregion
+//#region src/utils/quoteProcessor.ts
+/**
+* Calculate the minimum leading whitespace count across all non-empty lines
+*/
+function getMinLeadingWhitespace(lines) {
+	let min = 99;
+	for (const line of lines) {
+		if (line.length === 0) continue;
+		const match = line.match(/^[ \t]*/);
+		const count = match ? match[0].length : 0;
+		if (count < min) min = count;
+	}
+	return min === 99 ? 0 : min;
+}
+/**
+* Check if we need a space separator between two lines
+*/
+function needsSpaceSeparator(prevLine, currentLine) {
+	if (prevLine.length === 0 || currentLine.length === 0) return false;
+	const lastChar = prevLine[prevLine.length - 1] ?? "";
+	const firstChar = currentLine[0] ?? "";
+	const isLastCharAlpha = /[a-zA-Z]/.test(lastChar);
+	const isFirstCharAlpha = /[a-zA-Z]/.test(firstChar);
+	return isLastCharAlpha && isFirstCharAlpha;
+}
+/**
+* Determine if two lines should be merged
+*/
+function shouldMergeLines(prevLine, currentLine) {
+	if (/^[-*+]\s/.test(currentLine)) return false;
+	const hasColon = (line) => line.includes(":") || line.includes("：");
+	if (hasColon(prevLine) && hasColon(currentLine)) return false;
+	return true;
+}
+/**
+* Remove common leading whitespace and merge lines
+*/
+function removeWhitespaceAndMergeLines(lines) {
+	const minWhitespace = getMinLeadingWhitespace(lines);
+	const trimmedLines = lines.map((line) => {
+		if (line.length === 0) return line;
+		return line.slice(minWhitespace);
+	});
+	const result = [];
+	let currentLine = "";
+	for (let i = 0; i < trimmedLines.length; i++) {
+		const line = trimmedLines[i] ?? "";
+		if (i === 0) {
+			currentLine = line;
+			continue;
+		}
+		if (line.length === 0) {
+			result.push(currentLine);
+			result.push("");
+			currentLine = "";
+			continue;
+		}
+		if (currentLine.length === 0) {
+			currentLine = line;
+			continue;
+		}
+		const prevLine = trimmedLines[i - 1] ?? "";
+		if (shouldMergeLines(prevLine, line)) {
+			const separator = needsSpaceSeparator(prevLine, line) ? " " : "";
+			currentLine += separator + line;
+		} else {
+			result.push(currentLine);
+			currentLine = line;
+		}
+	}
+	if (currentLine !== "") result.push(currentLine);
+	return result;
+}
+/**
+* Processes text for quote buffering by:
+* 1. Detecting if 2nd+ lines have no leading whitespace (Pattern A) or all lines have common leading whitespace (Pattern B)
+* 2. Pattern A: Remove only leading whitespace, preserve all line breaks
+* 3. Pattern B: Remove common leading whitespace and merge lines (with exceptions)
+* 4. Adding quote prefix ("> ") to each line
+* 5. Adding two newlines at the end
+*/
+function processQuoteText(text) {
+	const lines = text.replace(/^\n+|\n+$/g, "").split("\n");
+	const hasNoLeadingWhitespaceInLaterLines = lines.slice(1).some((line) => line.length > 0 && !line.startsWith(" ") && !line.startsWith("	"));
+	let processedLines;
+	if (hasNoLeadingWhitespaceInLaterLines) processedLines = lines.map((line) => line.trimStart());
+	else processedLines = removeWhitespaceAndMergeLines(lines);
+	return `${processedLines.map((line) => `> ${line}`).join("\n")}\n\n`;
+}
+
+//#endregion
+//#region src/modes/quote.ts
+async function readStdin() {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		process.stdin.on("end", () => {
+			resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+		process.stdin.on("error", (error) => {
+			reject(error);
+		});
+	});
+}
+async function runQuoteMode(mux, targetPaneId, rawContent) {
+	try {
+		let selection;
+		if (rawContent !== void 0) selection = rawContent;
+		else selection = await readStdin();
+		const processedText = processQuoteText(selection);
+		if (mux === "tmux") await appendToQuoteVariable(targetPaneId, processedText);
+		else if (mux === "wezterm") await appendToQuoteText(targetPaneId, processedText);
+	} catch (error) {
+		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+}
+
 //#endregion
 //#region src/modes/resume.ts
 async function runResumeMode(targetPane, mux) {
@@ -393,41 +677,6 @@ async function runResumeMode(targetPane, mux) {
 	process.exit(0);
 }
 
-//#endregion
-//#region src/utils/sendConfig.ts
-const VALID_MUX_TYPES = ["tmux", "wezterm"];
-function readSendConfig() {
-	const targetPane = process.env.EDITPROMPT_TARGET_PANE;
-	const muxValue = process.env.EDITPROMPT_MUX || "tmux";
-	if (!VALID_MUX_TYPES.includes(muxValue)) throw new Error(`Invalid EDITPROMPT_MUX value: ${muxValue}. Must be one of: ${VALID_MUX_TYPES.join(", ")}`);
-	return {
-		targetPane,
-		mux: muxValue,
-		alwaysCopy: process.env.EDITPROMPT_ALWAYS_COPY === "1"
-	};
-}
-
-//#endregion
-//#region src/modes/sendOnly.ts
-async function runSendOnlyMode(rawContent) {
-	const content = processContent(rawContent);
-	if (!content) {
-		console.log("No content to send. Exiting.");
-		return;
-	}
-	const config = readSendConfig();
-	if (!config.targetPane) {
-		console.error("Error: EDITPROMPT_TARGET_PANE environment variable is required in send-only mode");
-		process.exit(1);
-	}
-	try {
-		await handleContentDelivery(content, config.mux, config.targetPane, config.alwaysCopy);
-	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-		process.exit(1);
-	}
-}
-
 //#endregion
 //#region src/utils/argumentParser.ts
 /**
@@ -482,10 +731,30 @@ await cli(process.argv.slice(2), {
 		"always-copy": {
 			description: "Always copy content to clipboard, even if tmux pane is available",
 			type: "boolean"
+		},
+		quote: {
+			description: "Quote buffering mode - add quoted text to pane variable",
+			type: "boolean"
+		},
+		capture: {
+			description: "Capture mode - copy pane variable to clipboard and clear",
+			type: "boolean"
+		},
+		"auto-send": {
+			description: "Automatically send content and return focus to editor pane",
+			type: "boolean"
+		},
+		"send-key": {
+			description: "Key to send after content (default: Enter, requires --auto-send)",
+			type: "string"
 		}
 	},
 	async run(ctx) {
 		try {
+			if (ctx.values["send-key"] && !ctx.values["auto-send"]) {
+				console.error("Error: --send-key requires --auto-send option");
+				process.exit(1);
+			}
 			if (ctx.values.resume) {
 				if (!ctx.values["target-pane"]) {
 					console.error("Error: --target-pane is required when using --resume");
@@ -499,9 +768,33 @@ await cli(process.argv.slice(2), {
 				await runResumeMode(ctx.values["target-pane"], mux$1);
 				return;
 			}
+			if (ctx.values.quote) {
+				if (!ctx.values["target-pane"]) {
+					console.error("Error: --target-pane is required when using --quote");
+					process.exit(1);
+				}
+				const muxValue$1 = ctx.values.mux || "tmux";
+				if (!isMuxType(muxValue$1)) {
+					console.error(`Error: Invalid mux type '${muxValue$1}'. Supported values: tmux, wezterm`);
+					process.exit(1);
+				}
+				if (muxValue$1 === "wezterm") {
+					const rawContent$1 = extractRawContent(ctx.rest, ctx.positionals);
+					if (rawContent$1 === void 0) {
+						console.error("Error: Text content is required for quote mode with wezterm. Use: editprompt --quote --mux wezterm --target-pane <id> -- \"<text>\"");
+						process.exit(1);
+					}
+					await runQuoteMode(muxValue$1, ctx.values["target-pane"], rawContent$1);
+				} else await runQuoteMode(muxValue$1, ctx.values["target-pane"]);
+				return;
+			}
+			if (ctx.values.capture) {
+				await runCaptureMode();
+				return;
+			}
 			const rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent !== void 0) {
-				await runSendOnlyMode(rawContent);
+				await runSendOnlyMode(rawContent, ctx.values["auto-send"], ctx.values["send-key"]);
 				return;
 			}
 			const muxValue = ctx.values.mux || "tmux";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editprompt",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "author": "eetann",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "license": "MIT",