editprompt 0.7.0 → 0.8.1

package/README.md

@@ -176,10 +176,25 @@ While editprompt is running, you can send content to the target pane or clipboar
 ```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.
 
+**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:

package/dist/index.js

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import clipboardy from "clipboardy";
 
 //#region package.json
-var version = "0.7.0";
+var version = "0.8.1";
 
 //#endregion
 //#region src/modules/tmux.ts
@@ -81,6 +81,15 @@ async function appendToQuoteVariable(paneId, content) {
 async function clearQuoteVariable(targetPaneId) {
 	await execAsync$2(`tmux set-option -pt '${targetPaneId}' @editprompt_quote ""`);
 }
+async function sendKeyToTmuxPane(paneId, key) {
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	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
@@ -190,6 +199,13 @@ async function clearQuoteText(paneId) {
 		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
@@ -363,6 +379,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" : "C-m");
+			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) {
@@ -388,6 +448,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
@@ -607,27 +678,6 @@ async function runResumeMode(targetPane, mux) {
 	process.exit(0);
 }
 
-//#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
 /**
@@ -690,10 +740,22 @@ await cli(process.argv.slice(2), {
 		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");
@@ -733,7 +795,7 @@ await cli(process.argv.slice(2), {
 			}
 			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.7.0",
+  "version": "0.8.1",
   "author": "eetann",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "license": "MIT",