editprompt 0.5.2 → 0.7.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,67 +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:**
-```tmux
-bind -n M-q run-shell 'tmux split-window -v -l 20 \
--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.
 
-**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}"'
-```
+### Workflow 2: Interactive - Iterate with Editor Open
 
+![send without closing editor](https://github.com/user-attachments/assets/b0e486af-78d7-4b70-8c82-64d330c22ba1)
 
-### 🖼️ WezTerm Integration
-```lua
-{
-    key = "q",
-    mods = "OPT",
-    action = wezterm.action_callback(function(window, pane)
-        local target_pane_id = tostring(pane:pane_id())
-        window:perform_action(
-            act.SplitPane({
-                direction = "Down",
-                size = { Cells = 10 },
-            }),
-            pane
-        )
-        wezterm.time.call_after(1, function()
-            window:perform_action(
-                act.SendString(
-                    string.format(
-                        "editprompt --editor nvim --always-copy --mux wezterm --target-pane %s\n",
-                        target_pane_id
-                    )
-                ),
-                window:active_pane()
-            )
-        end)
-    end),
-},
+For iterating on prompts without constantly reopening the editor:
+
+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.
+
+### Workflow 3: Quote - Collect and Reply
+
+![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 -->
 ```
 
-### 💡 Basic Usage
+For replying to specific parts of AI responses:
+
+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
+
+Perfect for addressing multiple points in long AI responses.
+
+
+## ⚙️ Setup & Configuration
+
+### Basic Setup
 
 ```bash
 # Use with your default editor (from $EDITOR)
@@ -111,12 +111,67 @@ editprompt --always-copy
 editprompt --help
 ```
 
+### Tmux Integration
+
+```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}"'
+```
+
 
-## 📤 Send Without Closing Editor
+### 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
@@ -125,7 +180,7 @@ editprompt -- "your content here"
 
 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
+#### Neovim Integration Example
 
 You can set up a convenient keybinding to send your buffer content:
 
@@ -159,33 +214,155 @@ 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
+
+#### Collecting Quotes in tmux Copy Mode
 
-## ⚙️ Configuration
+Add this keybinding to your `.tmux.conf` to collect selected text as quotes:
 
-### 📝 Editor Selection
+```tmux
+bind-key -T copy-mode-vi C-e { send-keys -X pipe "editprompt --quote --target-pane #{pane_id}" }
+```
+
+**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
+
+#### Collecting Quotes in WezTerm
+
+Add this event handler and keybinding to your `wezterm.lua` to collect selected text as quotes:
+
+```lua
+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"),
+    },
+  },
+}
+```
+
+**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
+
+#### Capturing Collected Quotes
+
+Run this command from within your editor pane to retrieve all collected quotes:
+
+```bash
+editprompt --capture
+```
+
+This copies all collected quotes to the clipboard and clears the buffer, ready for your reply.
+
+**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
+
+**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
+
+#### Neovim Integration Example
+
+You can set up a convenient keybinding to capture your quote content:
+```lua
+vim.keymap.set("n", "<Space>X", function()
+  vim.cmd("update")
+
+  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
+
+        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" })
+```
+
+### Environment Variables
+
+#### Editor Selection
 
 editprompt respects the following editor priority:
 
 1. `--editor/-e` command line option
-2. `$EDITOR` environment variable  
+2. `$EDITOR` environment variable
 3. Default: `vim`
 
-### 🌍 Environment Variables
-
-- `EDITOR`: Your preferred text editor
-
-### 🔧 Editor Integration with EDITPROMPT
+#### EDITPROMPT Environment Variable
 
 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.
 
-#### 🔍 Example: Neovim Configuration
+**Example: Neovim Configuration**
 
 ```lua
 -- In your Neovim config (e.g., init.lua)
@@ -196,7 +373,7 @@ if vim.env.EDITPROMPT then
 end
 ```
 
-#### 🛠️ Setting Custom Environment Variables
+#### Custom Environment Variables
 
 You can also pass custom environment variables to your editor:
 
@@ -211,33 +388,6 @@ editprompt --env THEME=dark --env FOO=fooooo
 editprompt --env NVIM_CONFIG=minimal
 ```
 
----
-
-## 🔧 Development
-
-```bash
-# Clone the repository
-git clone https://github.com/eetann/editprompt.git
-cd editprompt
-
-# Install dependencies
-bun install
-
-# Build
-bun run build
-
-# Run tests
-bun test
-
-# Development mode
-bun run dev
-```
-
-## 🔍 Technical Details
-
-### 🔄 Fallback Strategy
-
-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,14 +1,234 @@
 #!/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 clipboardy from "clipboardy";
 
 //#region package.json
-var version = "0.5.2";
+var version = "0.7.0";
+
+//#endregion
+//#region src/modules/tmux.ts
+const execAsync$2 = promisify(exec);
+async function getCurrentPaneId() {
+	const { stdout } = await execAsync$2("tmux display-message -p \"#{pane_id}\"");
+	return stdout.trim();
+}
+async function saveEditorPaneId(targetPaneId, editorPaneId) {
+	await execAsync$2(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane '${editorPaneId}'`);
+}
+async function clearEditorPaneId(targetPaneId) {
+	await execAsync$2(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane ""`);
+}
+async function getEditorPaneId(targetPaneId) {
+	try {
+		const { stdout } = await execAsync$2(`tmux show -pt '${targetPaneId}' -v @editprompt_editor_pane`);
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+async function checkPaneExists(paneId) {
+	try {
+		const { stdout } = await execAsync$2("tmux list-panes -a -F \"#{pane_id}\"");
+		return stdout.split("\n").map((id) => id.trim()).includes(paneId);
+	} catch {
+		return false;
+	}
+}
+async function focusPane(paneId) {
+	await execAsync$2(`tmux select-pane -t '${paneId}'`);
+}
+async function markAsEditorPane(editorPaneId, targetPaneId) {
+	await execAsync$2(`tmux set-option -pt '${editorPaneId}' @editprompt_is_editor 1`);
+	await execAsync$2(`tmux set-option -pt '${editorPaneId}' @editprompt_target_pane '${targetPaneId}'`);
+}
+async function getTargetPaneId(editorPaneId) {
+	try {
+		const { stdout } = await execAsync$2(`tmux show -pt '${editorPaneId}' -v @editprompt_target_pane`);
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+async function isEditorPane(paneId) {
+	try {
+		const { stdout } = await execAsync$2(`tmux show -pt '${paneId}' -v @editprompt_is_editor`);
+		return stdout.trim() === "1";
+	} catch {
+		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 ""`);
+}
+
+//#endregion
+//#region src/modules/wezterm.ts
+const execAsync$1 = promisify(exec);
+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");
+		const activePane = JSON.parse(stdout).find((pane) => pane.is_active === true);
+		return String(activePane?.pane_id);
+	} catch (error) {
+		console.log(error);
+		return "";
+	}
+}
+async function checkPaneExists$1(paneId) {
+	try {
+		const { stdout } = await execAsync$1("wezterm cli list --format json");
+		console.log(stdout);
+		return JSON.parse(stdout).some((pane) => String(pane.pane_id) === paneId);
+	} catch (error) {
+		console.log(error);
+		return false;
+	}
+}
+async function getEditorPaneId$1(targetPaneId) {
+	try {
+		const data = conf.get(`wezterm.targetPane.pane_${targetPaneId}`);
+		if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
+		return "";
+	} catch (error) {
+		console.log(error);
+		return "";
+	}
+}
+async function clearEditorPaneId$1(targetPaneId) {
+	try {
+		const editorPaneId = await getEditorPaneId$1(targetPaneId);
+		conf.delete(`wezterm.targetPane.pane_${targetPaneId}`);
+		if (editorPaneId) conf.delete(`wezterm.editorPane.pane_${editorPaneId}`);
+	} catch (error) {
+		console.log(error);
+	}
+}
+async function focusPane$1(paneId) {
+	await execAsync$1(`wezterm cli activate-pane --pane-id '${paneId}'`);
+}
+async function markAsEditorPane$1(editorPaneId, targetPaneId) {
+	try {
+		conf.set(`wezterm.targetPane.pane_${targetPaneId}`, { editorPaneId });
+		conf.set(`wezterm.editorPane.pane_${editorPaneId}`, { targetPaneId });
+	} catch (error) {
+		console.log(error);
+	}
+}
+async function getTargetPaneId$1(editorPaneId) {
+	try {
+		const data = conf.get(`wezterm.editorPane.pane_${editorPaneId}`);
+		if (typeof data === "object" && data !== null && "targetPaneId" in data) return String(data.targetPaneId);
+		return "";
+	} catch (error) {
+		console.log(error);
+		return "";
+	}
+}
+function isEditorPaneFromConf(paneId) {
+	try {
+		return conf.has(`wezterm.editorPane.pane_${paneId}`);
+	} catch (error) {
+		console.log(error);
+		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);
+	}
+}
+
+//#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
@@ -172,19 +392,158 @@ async function handleContentDelivery(content, mux, targetPane, alwaysCopy) {
 //#endregion
 //#region src/modes/openEditor.ts
 async function runOpenEditorMode(options) {
-	const sendConfig = {
-		targetPane: options.targetPane,
-		mux: options.mux,
-		alwaysCopy: options.alwaysCopy
-	};
-	console.log("Opening editor...");
-	const content = await openEditorAndGetContent(options.editor, options.env, sendConfig);
-	if (!content) {
-		console.log("No content entered. Exiting.");
-		return;
+	if (options.targetPane && options.mux === "tmux") try {
+		const currentPaneId = await getCurrentPaneId();
+		await saveEditorPaneId(options.targetPane, currentPaneId);
+		await markAsEditorPane(currentPaneId, options.targetPane);
+	} catch {}
+	else if (options.targetPane && options.mux === "wezterm") try {
+		const currentPaneId = await getCurrentPaneId$1();
+		await markAsEditorPane$1(currentPaneId, options.targetPane);
+	} catch {}
+	try {
+		const sendConfig = {
+			targetPane: options.targetPane,
+			mux: options.mux,
+			alwaysCopy: options.alwaysCopy
+		};
+		console.log("Opening editor...");
+		const content = await openEditorAndGetContent(options.editor, options.env, sendConfig);
+		if (!content) {
+			console.log("No content entered. Exiting.");
+			return;
+		}
+		try {
+			await handleContentDelivery(content, options.mux, options.targetPane, options.alwaysCopy);
+		} catch (error) {
+			console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+			process.exit(1);
+		}
+	} finally {
+		if (options.targetPane && options.mux === "tmux") try {
+			await clearEditorPaneId(options.targetPane);
+		} catch {}
+		else if (options.targetPane && options.mux === "wezterm") try {
+			await clearEditorPaneId$1(options.targetPane);
+		} catch {}
 	}
+}
+
+//#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 {
-		await handleContentDelivery(content, options.mux, options.targetPane, options.alwaysCopy);
+		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);
@@ -192,17 +551,60 @@ async function runOpenEditorMode(options) {
 }
 
 //#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"
-	};
+//#region src/modes/resume.ts
+async function runResumeMode(targetPane, mux) {
+	if (mux === "wezterm") {
+		const currentPaneId$1 = await getCurrentPaneId$1();
+		if (isEditorPaneFromConf(currentPaneId$1)) {
+			console.log("isEditor");
+			const originalTargetPaneId = await getTargetPaneId$1(currentPaneId$1);
+			if (!originalTargetPaneId) {
+				console.log("Not found originalTargetPaneId");
+				process.exit(1);
+			}
+			if (!await checkPaneExists$1(originalTargetPaneId)) {
+				console.log("Not exist originalTargetPaneId");
+				process.exit(1);
+			}
+			await focusPane$1(originalTargetPaneId);
+			process.exit(0);
+		}
+		console.log("not isEditor");
+		const editorPaneId$1 = await getEditorPaneId$1(targetPane);
+		console.log(`wezterm editorPaneId: ${editorPaneId$1}`);
+		if (editorPaneId$1 === "") {
+			console.log("Not found editorPaneId");
+			process.exit(1);
+		}
+		if (!await checkPaneExists$1(editorPaneId$1)) {
+			console.log("Not exist editorPaneId");
+			await clearEditorPaneId$1(targetPane);
+			process.exit(1);
+		}
+		try {
+			await focusPane$1(editorPaneId$1);
+			process.exit(0);
+		} catch (error) {
+			console.log(`Can't focus editorPaneId: ${editorPaneId$1}\nerror: ${error}`);
+			process.exit(1);
+		}
+	}
+	const currentPaneId = await getCurrentPaneId();
+	if (await isEditorPane(currentPaneId)) {
+		const originalTargetPaneId = await getTargetPaneId(currentPaneId);
+		if (!originalTargetPaneId) process.exit(1);
+		if (!await checkPaneExists(originalTargetPaneId)) process.exit(1);
+		await focusPane(originalTargetPaneId);
+		process.exit(0);
+	}
+	const editorPaneId = await getEditorPaneId(targetPane);
+	if (editorPaneId === "") process.exit(1);
+	if (!await checkPaneExists(editorPaneId)) {
+		await clearEditorPaneId(targetPane);
+		process.exit(1);
+	}
+	await focusPane(editorPaneId);
+	process.exit(0);
 }
 
 //#endregion
@@ -247,6 +649,10 @@ await cli(process.argv.slice(2), {
 	name: "editprompt",
 	description: "A CLI tool that lets you write prompts for Claude Code using your favorite text editor",
 	args: {
+		resume: {
+			description: "Resume existing editor pane instead of creating new one",
+			type: "boolean"
+		},
 		editor: {
 			short: "e",
 			description: "Editor to use (overrides $EDITOR)",
@@ -276,10 +682,55 @@ 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"
 		}
 	},
 	async run(ctx) {
 		try {
+			if (ctx.values.resume) {
+				if (!ctx.values["target-pane"]) {
+					console.error("Error: --target-pane is required when using --resume");
+					process.exit(1);
+				}
+				const mux$1 = ctx.values.mux || "tmux";
+				if (!isMuxType(mux$1)) {
+					console.error(`Error: Invalid mux type '${mux$1}'. Supported values: tmux, wezterm`);
+					process.exit(1);
+				}
+				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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editprompt",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "author": "eetann",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "license": "MIT",
@@ -56,6 +56,7 @@
   },
   "dependencies": {
     "clipboardy": "^4.0.0",
+    "conf": "^15.0.2",
     "gunshi": "^0.26.3"
   },
   "peerDependencies": {