editprompt 0.0.6 → 0.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 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.
 
+https://github.com/user-attachments/assets/01bcda7c-7771-4b33-bf5c-629812d45cc4
+
 ## Features
 
 - 🖊️ **Editor Integration**: Use your preferred text editor to write prompts  
@@ -36,6 +38,14 @@ editprompt -e nvim
 editprompt --process gemini
 editprompt -p gemini
 
+# Send content to a specific tmux pane
+editprompt --target-pane %45
+editprompt -t %45
+
+# Set environment variables for the editor
+editprompt --env THEME=dark
+editprompt -E THEME=dark -E LANG=ja_JP.UTF-8
+
 # Show help
 editprompt --help
 
@@ -43,15 +53,39 @@ editprompt --help
 editprompt --version
 ```
 
-It is useful to configure tmux as follows.
+### Tmux Integration
+
+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.
 
+**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}"'
+```
+
+**Popup version:**
+```tmux
+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}"'
+```
+
+#### 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'
 ```
 
-If you prefer popup, you can configure it as follows.
+**Popup version:**
 ```tmux
 bind -n M-q display-popup -E \
   -d '#{pane_current_path}' \
@@ -62,25 +96,13 @@ bind -n M-q display-popup -E \
 
 1. **Opens your editor** with a temporary markdown file
 2. **Write your prompt** and save/exit the editor  
-3. **Detects target processes** running on your system (default: claude)
-4. **Sends the prompt** using the best available method:
-   - 🎯 **Tmux sessions**: Direct input via `tmux send-keys`
-   - 📋 **Clipboard**: Copies content as final fallback
-
-### Process Selection
-
-When multiple processes are detected, you'll see an interactive selection menu:
+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)
 
-```
-? Select a process:
-  1. PID: 12345 | Tmux: main:0.1 | Directory: /home/user/project1
-  2. PID: 67890 | Directory: /home/user/project2
-```
-
-The display shows:
-- **PID**: Process ID
-- **Tmux**: Session, window, and pane (if running in tmux)
-- **Directory**: Working directory of the process
 
 ## Configuration
 
@@ -96,11 +118,37 @@ editprompt respects the following editor priority:
 
 - `EDITOR`: Your preferred text editor
 
-## Requirements
+### 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
+
+```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
+```
+
+#### Setting Custom Environment Variables
 
-- Node.js 18+ or Bun
-- Target CLI process (default: `claude` command)
-- Optional: tmux (for direct session integration)
+You can also pass custom environment variables to your editor:
+
+```bash
+# Single environment variable
+editprompt --env THEME=dark
+
+# Multiple environment variables
+editprompt --env THEME=dark --env FOO=fooooo
+
+# Useful for editor-specific configurations
+editprompt --env NVIM_CONFIG=minimal
+```
+
+---
 
 ## Development
 
@@ -141,12 +189,14 @@ src/
 
 ### Tmux Integration
 
-When the target process is running in a tmux session, editprompt uses `tmux send-keys` to send input directly to the appropriate pane. This provides seamless integration without disrupting your existing session.
+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
 
 ### Fallback Strategy
 
-editprompt implements fallback strategy:
+editprompt implements a robust fallback strategy:
 
 1. **Tmux Integration**: Direct input to tmux panes (when available)
-<!-- 2. **New Process**: Launch new Claude instance with piped input -->
-2. **Clipboard**: Copy content to clipboard with error notification
+2. **Clipboard**: Copy content to clipboard with user notification

package/dist/index.js

@@ -10,7 +10,7 @@ import find from "find-process";
 import inquirer from "inquirer";
 
 //#region package.json
-var version = "0.0.6";
+var version = "0.2.0";
 
 //#endregion
 //#region src/config/constants.ts
@@ -19,6 +19,25 @@ const TEMP_FILE_EXTENSION = ".md";
 const DEFAULT_EDITOR = "vim";
 const DEFAULT_PROCESS_NAME = "claude";
 
+//#endregion
+//#region src/utils/envParser.ts
+/**
+* 環境変数文字列をパースしてオブジェクトに変換
+* @param envStrings - ["KEY=VALUE", "FOO=bar"] 形式の配列
+* @returns 環境変数のキーバリューオブジェクト
+*/
+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}`);
+		const value = valueParts.join("=");
+		result[key] = value;
+	}
+	return result;
+}
+
 //#endregion
 //#region src/utils/tempFile.ts
 function getFormattedDateTime() {
@@ -44,11 +63,17 @@ async function createTempFile() {
 function getEditor(editorOption) {
 	return editorOption || process.env.EDITOR || DEFAULT_EDITOR;
 }
-async function launchEditor(editor, filePath) {
+async function launchEditor(editor, filePath, envVars) {
 	return new Promise((resolve, reject) => {
+		const processEnv = {
+			...process.env,
+			EDITPROMPT: "1",
+			...envVars
+		};
 		const editorProcess = spawn(editor, [filePath], {
 			stdio: "inherit",
-			shell: true
+			shell: true,
+			env: processEnv
 		});
 		editorProcess.on("error", (error) => {
 			reject(new Error(`Failed to launch editor: ${error.message}`));
@@ -67,13 +92,13 @@ async function readFileContent(filePath) {
 		throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
 }
-async function openEditorAndGetContent(editorOption) {
+async function openEditorAndGetContent(editorOption, envVars) {
 	const tempFilePath = await createTempFile();
 	const editor = getEditor(editorOption);
+	const parsedEnvVars = parseEnvVars(envVars);
 	try {
-		await launchEditor(editor, tempFilePath);
+		await launchEditor(editor, tempFilePath, parsedEnvVars);
 		const content = await readFileContent(tempFilePath);
-		if (!content) throw new Error("No content was entered in the editor");
 		return content;
 	} catch (error) {
 		if (error instanceof Error) throw error;
@@ -169,11 +194,20 @@ 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(`tmux load-buffer -b editprompt - <<< '${tempContent}'`);
+	await execAsync(`tmux paste-buffer -d -t '${paneId}' -b editprompt`);
+}
 async function copyToClipboard(content) {
 	await clipboardy.write(content);
 }
-async function sendContentToProcess(process$1, content) {
+async function sendContentToProcess(process$1, content, targetPaneId) {
 	try {
+		if (targetPaneId) {
+			await sendToSpecificPane(targetPaneId, content);
+			return;
+		}
 		if (process$1.tmuxSession && process$1.tmuxWindow && process$1.tmuxPane) {
 			await sendToTmuxPane(process$1.tmuxSession, process$1.tmuxWindow, process$1.tmuxPane, content);
 			return;
@@ -226,30 +260,51 @@ await cli(argv, {
 			short: "p",
 			description: "Process name to target (default: claude)",
 			type: "string"
+		},
+		"target-pane": {
+			short: "t",
+			description: "Target tmux pane ID to send content to",
+			type: "string"
+		},
+		env: {
+			short: "E",
+			description: "Environment variables to set (e.g., KEY=VALUE)",
+			type: "string",
+			multiple: true
 		}
 	},
 	async run(ctx) {
 		try {
 			console.log("Opening editor...");
-			const content = await openEditorAndGetContent(ctx.values.editor);
+			const content = await openEditorAndGetContent(ctx.values.editor, ctx.values.env);
 			if (!content) {
 				console.log("No content entered. Exiting.");
 				return;
 			}
-			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);
+			const targetPane = ctx.values["target-pane"];
+			if (targetPane) {
+				console.log("Sending content to specified pane...");
+				await sendContentToProcess({
+					pid: 0,
+					name: "direct-pane"
+				}, content, targetPane);
 				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);
+					console.log("Content sent successfully!");
+				}
 			}
 		} catch (error) {
 			console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "editprompt",
-	"version": "0.0.6",
+	"version": "0.2.0",
 	"author": "eetann",
 	"description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
 	"license": "MIT",
@@ -40,6 +40,7 @@
 		"build": "tsdown",
 		"dev": "tsdown --watch",
 		"lint": "biome check",
+		"formant": "biome format --write",
 		"typecheck": "tsgo --noEmit",
 		"release": "bun run lint && bun run typecheck && bun run test && bun run build && bumpp",
 		"test": "bun test",