editprompt 0.2.2 → 0.3.0

package/README.md

@@ -1,19 +1,28 @@
-# editprompt
+# 📝 editprompt
 
-A CLI tool that lets you write prompts for CLI tools using your favorite text editor. Originally designed for [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview), but works with any CLI process.
+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
 
-## Features
 
-- 🖊️ **Editor Integration**: Use your preferred text editor to write prompts  
-- 🔍 **Process Detection**: Automatically detects running CLI processes (configurable)
-- 🖥️ **Tmux Support**: Send prompts directly to tmux sessions
+## 🏆 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
+
+
+## ✨ Features
+
+- 🖊️ **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
 - 📋 **Clipboard Fallback**: Automatically copies to clipboard if sending fails
 - 📋 **Always Copy Option**: Copy to clipboard even after successful tmux delivery (`--always-copy`)
-- ⚡ **Smart Fallbacks**: Multiple fallback strategies ensure your prompt gets delivered
 
-## Installation
+
+## 📦 Installation
 
 ```bash
 # Install globally via npm
@@ -23,52 +32,33 @@ npm install -g editprompt
 npx editprompt
 ```
 
-## Usage
-
-### Basic Usage
-
-```bash
-# Use with your default editor (from $EDITOR)
-editprompt
-
-# Specify a different editor
-editprompt --editor nvim
-editprompt -e nvim
+## 🚀 Usage
 
-# Target a different process (default: claude)
-editprompt --process gemini
-editprompt -p gemini
+1. Run `editprompt` to open a temporary Markdown file in your editor
+2. Write your prompt and save the file
+3. Your prompt is automatically sent to the target pane or copied to clipboard if no pane is found
 
-# Send content to a specific tmux pane
-editprompt --target-pane %45
-editprompt -t %45
+editprompt works with **any terminal** - no special setup required!
 
-# Set environment variables for the editor
-editprompt --env THEME=dark
-editprompt -E THEME=dark -E LANG=ja_JP.UTF-8
-
-# Always copy to clipboard after sending to tmux pane
-editprompt --always-copy
-
-# Show help
-editprompt --help
-
-# Show version
-editprompt --version
+```sh
+# Just run it - content will be copied to clipboard
+editprompt
+# Then paste (Ctrl+V / Cmd+V) into any CLI tool:
+# - Claude Code
+# - Codex
+# - Any REPL or interactive prompt
 ```
 
-### Tmux Integration
+Optional integrations (Tmux/Wezterm) provide seamless auto-send.
 
-editprompt offers two modes for tmux integration:
 
-#### Recommended: Direct Pane Targeting
-Use `--target-pane #{pane_id}` to automatically send content back to the pane where you triggered the command. This is useful when using Claude Code, etc. in multiple panes.
+### 🖥️ Tmux Integration
 
 **Split window version:**
 ```tmux
 bind -n M-q run-shell 'tmux split-window -v -l 20 \
-  -c "#{pane_current_path}" \
-  "editprompt --editor nvim --target-pane #{pane_id}"'
+-c "#{pane_current_path}" \
+"editprompt --editor nvim --always-copy --target-pane #{pane_id}"'
 ```
 
 **Popup version:**
@@ -76,41 +66,61 @@ bind -n M-q run-shell 'tmux split-window -v -l 20 \
 bind -n M-q run-shell 'tmux display-popup -E \
   -d "#{pane_current_path}" \
   -w 80% -h 65% \
-  "editprompt --editor nvim --target-pane #{pane_id}"'
+  "editprompt --editor nvim --always-copy --target-pane #{pane_id}"'
 ```
 
-#### Alternative: Process Auto-detection
-Let editprompt automatically detect and select target processes:
 
-**Split window version:**
-```tmux
-bind -n M-q split-window -v -l 10 \
-  -c '#{pane_current_path}' \
-  'editprompt --editor nvim'
+### 🖼️ 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),
+},
 ```
 
-**Popup version:**
-```tmux
-bind -n M-q display-popup -E \
-  -d '#{pane_current_path}' \
-  'editprompt --editor nvim'
-```
+### 💡 Basic Usage
+
+```bash
+# Use with your default editor (from $EDITOR)
+editprompt
+
+# Specify a different editor
+editprompt --editor nvim
+editprompt -e nvim
 
-### How it Works
+# Always copy to clipboard
+editprompt --always-copy
+
+# Show help
+editprompt --help
+```
 
-1. **Opens your editor** with a temporary markdown file
-2. **Write your prompt** and save/exit the editor  
-3. **Sends the prompt** using one of two modes:
-   - 🎯 **Direct pane mode** (`--target-pane`): Sends directly to specified tmux pane
-   - 🔍 **Process detection mode**: Finds target processes and sends via tmux or clipboard
-4. **Fallback strategy** ensures delivery:
-   - Tmux integration (preferred)
-   - Clipboard copy (fallback)
 
 
-## Configuration
+## ⚙️ Configuration
 
-### Editor Selection
+### 📝 Editor Selection
 
 editprompt respects the following editor priority:
 
@@ -118,15 +128,15 @@ editprompt respects the following editor priority:
 2. `$EDITOR` environment variable  
 3. Default: `nvim`
 
-### Environment Variables
+### 🌍 Environment Variables
 
 - `EDITOR`: Your preferred text editor
 
-### Editor Integration with EDITPROMPT
+### 🔧 Editor Integration with EDITPROMPT
 
 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)
@@ -137,7 +147,7 @@ if vim.env.EDITPROMPT then
 end
 ```
 
-#### Setting Custom Environment Variables
+#### 🛠️ Setting Custom Environment Variables
 
 You can also pass custom environment variables to your editor:
 
@@ -154,7 +164,7 @@ editprompt --env NVIM_CONFIG=minimal
 
 ---
 
-## Development
+## 🔧 Development
 
 ```bash
 # Clone the repository
@@ -174,7 +184,7 @@ bun test
 bun run dev
 ```
 
-### Project Structure
+### 📁 Project Structure
 
 ```
 src/
@@ -189,16 +199,9 @@ src/
 └── index.ts                  # CLI entry point
 ```
 
-## Technical Details
-
-### Tmux Integration
-
-editprompt supports two tmux integration modes:
-
-- **Direct pane targeting** (`--target-pane`): Bypasses process detection and sends content directly to specified pane ID
-- **Process-based targeting**: Detects target processes and links them to tmux panes for delivery
+## 🔍 Technical Details
 
-### Fallback Strategy
+### 🔄 Fallback Strategy
 
 editprompt implements a robust fallback strategy:
 

package/dist/index.js

@@ -1,23 +1,20 @@
 #!/usr/bin/env node
 import { cli } from "gunshi";
 import { exec, spawn } from "node:child_process";
-import { mkdtemp, readFile, readlink, writeFile } from "node:fs/promises";
+import { mkdtemp, 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";
-import find from "find-process";
-import inquirer from "inquirer";
 
 //#region package.json
-var version = "0.2.2";
+var version = "0.3.0";
 
 //#endregion
 //#region src/config/constants.ts
 const TEMP_FILE_PREFIX = ".editprompt-";
 const TEMP_FILE_EXTENSION = ".md";
 const DEFAULT_EDITOR = "vim";
-const DEFAULT_PROCESS_NAME = "claude";
 
 //#endregion
 //#region src/utils/envParser.ts
@@ -109,147 +106,32 @@ async function openEditorAndGetContent(editorOption, envVars) {
 //#endregion
 //#region src/modules/process.ts
 const execAsync = promisify(exec);
-async function getProcessCwd(pid) {
-	try {
-		const cwdPath = join("/proc", pid.toString(), "cwd");
-		const cwd = await readlink(cwdPath);
-		return cwd;
-	} catch (error) {
-		return void 0;
-	}
+function isMuxType(value) {
+	return value === "tmux" || value === "wezterm";
 }
-async function findTargetProcesses(processName = DEFAULT_PROCESS_NAME) {
-	const tmuxAvailable = await checkTmuxAvailable();
-	if (tmuxAvailable) {
-		const tmuxProcesses = await findTargetInTmux(processName);
-		if (tmuxProcesses.length > 0) return Promise.all(tmuxProcesses.map(async (proc) => {
-			const cwd = await getProcessCwd(proc.pid);
-			return {
-				...proc,
-				cwd
-			};
-		}));
-	}
-	const processes = await find("name", processName);
-	const targetProcesses = await Promise.all(processes.map(async (proc) => {
-		const cwd = await getProcessCwd(proc.pid);
-		return {
-			pid: proc.pid,
-			name: proc.name,
-			cmd: proc.cmd,
-			cwd
-		};
-	}));
-	return targetProcesses.filter((p) => p.name === processName);
+async function sendToTmuxPane(paneId, content) {
+	await execAsync(`tmux send-keys -t '${paneId}' '${content.replace(/'/g, "'\\''")}'`);
+	console.log(`Content sent to tmux pane: ${paneId}`);
 }
-async function checkTmuxAvailable() {
-	try {
-		await execAsync("tmux list-sessions");
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function getTmuxPanes() {
-	try {
-		const { stdout } = await execAsync("tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index}:#{pane_pid}:#{pane_current_command}'");
-		return stdout.trim().split("\n").map((line) => {
-			const [session, windowPane, pid, command] = line.split(":");
-			let win = void 0;
-			let pane = void 0;
-			if (windowPane) [win, pane] = windowPane.split(".");
-			return {
-				session,
-				window: win,
-				pane,
-				pid: pid ? Number.parseInt(pid, 10) : void 0,
-				command
-			};
-		});
-	} catch {
-		return [];
-	}
-}
-async function findTargetInTmux(processName = DEFAULT_PROCESS_NAME) {
-	const processes = await find("name", processName);
-	const targetProcesses = processes.filter((p) => p.cmd.match(processName));
-	if (targetProcesses.length === 0) return [];
-	const tmuxPanes = await getTmuxPanes();
-	if (tmuxPanes.length === 0) return [];
-	const matchedProcesses = [];
-	for (const process$1 of targetProcesses) {
-		const matchingPane = tmuxPanes.find((pane) => pane.pid === process$1.ppid);
-		if (matchingPane?.session && matchingPane.window && matchingPane.pane) matchedProcesses.push({
-			pid: process$1.pid,
-			name: process$1.name,
-			cmd: process$1.cmd,
-			tmuxSession: matchingPane.session,
-			tmuxWindow: matchingPane.window,
-			tmuxPane: matchingPane.pane
-		});
-	}
-	return matchedProcesses;
-}
-async function sendToTmuxPane(session, window, pane, content) {
-	const target = `${session}:${window}.${pane}`;
-	await execAsync(`tmux send-keys -t '${target}' '${content.replace(/'/g, "'\\''")}'`);
-}
-async function sendToSpecificPane(paneId, content) {
-	const tempContent = content.replace(/'/g, "'\\''");
-	await execAsync(`printf %s '${tempContent}' | tmux load-buffer -b editprompt -`);
-	await execAsync(`tmux paste-buffer -d -t '${paneId}' -b editprompt`);
+async function sendToWeztermPane(paneId, content) {
+	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' '${content.replace(/'/g, "'\\''")}'`);
+	console.log(`Content sent to wezterm pane: ${paneId}`);
 }
 async function copyToClipboard(content) {
 	await clipboardy.write(content);
 }
-async function sendContentToProcess(process$1, content, targetPaneId, alwaysCopy) {
+async function sendContentToPane(targetPaneId, content, mux = "tmux", alwaysCopy) {
 	try {
-		if (targetPaneId) {
-			await sendToSpecificPane(targetPaneId, content);
-			if (alwaysCopy) {
-				await copyToClipboard(content);
-				console.log("Copy!");
-			}
-			return;
-		}
-		if (process$1.tmuxSession && process$1.tmuxWindow && process$1.tmuxPane) {
-			await sendToTmuxPane(process$1.tmuxSession, process$1.tmuxWindow, process$1.tmuxPane, content);
-			if (alwaysCopy) {
-				await copyToClipboard(content);
-				console.log("Copy!");
-			}
-			return;
+		if (mux === "wezterm") await sendToWeztermPane(targetPaneId, content);
+		else await sendToTmuxPane(targetPaneId, content);
+		if (alwaysCopy) {
+			await copyToClipboard(content);
+			console.log("Also copied to clipboard.");
 		}
 	} catch (error) {
-		console.log(`Failed to send to process. Content copied to clipboard. Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		console.log(`Failed to send to pane. Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		throw error;
 	}
-	await copyToClipboard(content);
-	console.log("Copy!");
-}
-
-//#endregion
-//#region src/modules/selector.ts
-function formatProcessChoice(proc, index) {
-	const parts = [`PID: ${proc.pid}`];
-	if (proc.tmuxSession) parts.push(`Tmux: ${proc.tmuxSession}:${proc.tmuxWindow}.${proc.tmuxPane}`);
-	if (proc.cwd) parts.push(`Directory: ${proc.cwd}`);
-	return {
-		name: `${index + 1}. ${parts.join(" | ")}`,
-		value: proc
-	};
-}
-async function selectProcess(processes) {
-	if (processes.length === 0) throw new Error("No processes to select from");
-	if (processes.length === 1) return processes[0];
-	const choices = processes.map((proc, index) => formatProcessChoice(proc, index));
-	const { selectedProcess } = await inquirer.prompt([{
-		type: "list",
-		name: "selectedProcess",
-		message: "Select a process:",
-		choices
-	}]);
-	if (!selectedProcess) throw new Error("No process was selected");
-	return selectedProcess;
 }
 
 //#endregion
@@ -266,12 +148,17 @@ await cli(argv, {
 		},
 		process: {
 			short: "p",
-			description: "Process name to target (default: claude)",
+			description: "Process name to target (DEPRECATED - will be removed in v0.4.0)",
 			type: "string"
 		},
 		"target-pane": {
 			short: "t",
-			description: "Target tmux pane ID to send content to",
+			description: "Target pane ID to send content to",
+			type: "string"
+		},
+		mux: {
+			short: "m",
+			description: "Multiplexer type (tmux or wezterm, default: tmux)",
 			type: "string"
 		},
 		env: {
@@ -287,6 +174,20 @@ await cli(argv, {
 	},
 	async run(ctx) {
 		try {
+			const muxValue = ctx.values.mux || "tmux";
+			if (!isMuxType(muxValue)) {
+				console.error(`Error: Invalid mux type '${muxValue}'. Supported values: tmux, wezterm`);
+				process.exit(1);
+			}
+			const mux = muxValue;
+			if (mux === "wezterm" && !ctx.values["target-pane"]) {
+				console.error("Error: --target-pane is required when using --mux=wezterm");
+				process.exit(1);
+			}
+			if (ctx.values.process) {
+				console.warn("Warning: --process option is deprecated and will be removed in future versions.");
+				console.warn("Use --target-pane to specify the target pane directly.");
+			}
 			console.log("Opening editor...");
 			const content = await openEditorAndGetContent(ctx.values.editor, ctx.values.env);
 			if (!content) {
@@ -295,30 +196,24 @@ await cli(argv, {
 			}
 			const targetPane = ctx.values["target-pane"];
 			const alwaysCopy = ctx.values["always-copy"];
-			if (targetPane) {
+			if (targetPane) try {
 				console.log("Sending content to specified pane...");
-				await sendContentToProcess({
-					pid: 0,
-					name: "direct-pane"
-				}, content, targetPane, alwaysCopy);
+				await sendContentToPane(targetPane, content, mux, alwaysCopy);
 				console.log("Content sent successfully!");
-			} else {
-				const processName = ctx.values.process || DEFAULT_PROCESS_NAME;
-				console.log(`Searching for ${processName} processes...`);
-				const processes = await findTargetProcesses(processName);
-				if (processes.length === 0) console.log(`No ${processName} process found.`);
-				else {
-					const selectedProcess = await selectProcess(processes);
-					if (!selectedProcess) return;
-					const processInfo = [`PID ${selectedProcess.pid}`];
-					if (selectedProcess.tmuxSession) processInfo.push(`Tmux: ${selectedProcess.tmuxSession}:${selectedProcess.tmuxWindow}.${selectedProcess.tmuxPane}`);
-					if (selectedProcess.cwd) processInfo.push(`Directory: ${selectedProcess.cwd}`);
-					console.log(`Selected process: ${processInfo.join(" | ")}`);
-					console.log(`Sending content to ${processName} process...`);
-					await sendContentToProcess(selectedProcess, content, void 0, alwaysCopy);
-					console.log("Content sent successfully!");
-				}
+			} catch (error) {
+				console.log(`Failed to send to pane: ${error instanceof Error ? error.message : "Unknown error"}`);
+				console.log("Falling back to clipboard...");
+				await copyToClipboard(content);
+				console.log("Content copied to clipboard.");
+			}
+			else try {
+				await copyToClipboard(content);
+				console.log("Content copied to clipboard.");
+			} catch (error) {
+				console.log(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
 			}
+			console.log("---");
+			console.log(content);
 		} catch (error) {
 			console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
 			process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "editprompt",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"author": "eetann",
 	"description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
 	"license": "MIT",
@@ -49,8 +49,6 @@
 	"devDependencies": {
 		"@biomejs/biome": "1.9.4",
 		"@types/bun": "^1.2.16",
-		"@types/find-process": "^1.2.2",
-		"@types/inquirer": "^9.0.8",
 		"@types/node": "^24.0.1",
 		"@typescript/native-preview": "^7.0.0-dev.20250712.1",
 		"bumpp": "^10.2.0",
@@ -59,9 +57,7 @@
 	"packageManager": "pnpm@10.8.1+sha512.c50088ba998c67b8ca8c99df8a5e02fd2ae2e2b29aaf238feaa9e124248d3f48f9fb6db2424949ff901cffbb5e0f0cc1ad6aedb602cd29450751d11c35023677",
 	"dependencies": {
 		"clipboardy": "^4.0.0",
-		"find-process": "^1.4.10",
-		"gunshi": "^0.26.3",
-		"inquirer": "^12.6.3"
+		"gunshi": "^0.26.3"
 	},
 	"peerDependencies": {
 		"typescript": "^5"