editprompt 0.5.1 → 0.6.0

package/README.md

@@ -49,13 +49,25 @@ editprompt
 
 ### 🖥️ Tmux Integration
 
-**Split window version:**
+**Split window version (with pane resume):**
 ```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}"'
+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}"'
 ```
 
+**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
+
+This allows you to toggle between your target pane and editor pane using the same keybinding (`M-q`).
+
+**Benefits:**
+- Prevents pane proliferation and keeps your window management simple
+- Switch between your work pane and editor pane while preserving your editing content
+
 **Popup version:**
 ```tmux
 bind -n M-q run-shell 'tmux display-popup -E \
@@ -66,34 +78,61 @@ bind -n M-q run-shell 'tmux display-popup -E \
 
 
 ### 🖼️ 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()
+
+        -- 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.SendString(
-                    string.format(
-                        "editprompt --editor nvim --always-copy --mux wezterm --target-pane %s\n",
-                        target_pane_id
-                    )
-                ),
-                window:active_pane()
+                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
     end),
 },
 ```
 
+**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
+
+This allows you to toggle between your target pane and editor pane using the same keybinding (`OPT-q`).
+
+**Benefits:**
+- Prevents pane proliferation and keeps your window management simple
+- Switch between your work pane and editor pane while preserving your editing content
+
+**Note:** The `-lc` flag ensures your shell loads the full login environment, making `editprompt` available in your PATH.
+
 ### 💡 Basic Usage
 
 ```bash
@@ -120,7 +159,7 @@ 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"
+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.
@@ -140,7 +179,7 @@ if vim.env.EDITPROMPT then
 
         -- Execute editprompt command
         vim.system(
-            { "editprompt", content },
+            { "editprompt", "--", content },
             { text = true },
             function(obj)
                 vim.schedule(function()
@@ -233,6 +272,76 @@ bun test
 bun run dev
 ```
 
+### 💻 Testing During Development
+
+When developing, you can test the built `dist/index.js` directly:
+
+#### Neovim Configuration
+
+```diff
+- { "editprompt", "--", content },
++ { "node", vim.fn.expand("~/path/to/editprompt/dist/index.js"), "--", content },
+```
+
+#### WezTerm Configuration
+
+```lua
+-- In your wezterm.lua
+local editprompt_cmd = "node " .. os.getenv("HOME") .. "/path/to/editprompt/dist/index.js"
+
+{
+    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),
+},
+```
+
+#### tmux Configuration
+
+```tmux
+# In your .tmux.conf
+set-option -g @editprompt-cmd "node ~/path/to/editprompt/dist/index.js"
+
+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}"'
+```
+
+This allows you to make changes, run `bun run build`, and test immediately without reinstalling globally.
+
 ## 🔍 Technical Details
 
 ### 🔄 Fallback Strategy

package/dist/index.js

@@ -5,10 +5,11 @@ 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.5.1";
+var version = "0.6.0";
 
 //#endregion
 //#region src/config/constants.ts
@@ -37,8 +38,7 @@ function parseEnvVars(envStrings) {
 	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;
+		result[key] = valueParts.join("=");
 	}
 	return result;
 }
@@ -47,19 +47,12 @@ function parseEnvVars(envStrings) {
 //#region src/utils/tempFile.ts
 function getFormattedDateTime() {
 	const now = /* @__PURE__ */ new Date();
-	const year = now.getFullYear();
-	const month = String(now.getMonth() + 1).padStart(2, "0");
-	const day = String(now.getDate()).padStart(2, "0");
-	const hours = String(now.getHours()).padStart(2, "0");
-	const minutes = String(now.getMinutes()).padStart(2, "0");
-	const seconds = String(now.getSeconds()).padStart(2, "0");
-	return `${year}${month}${day}${hours}${minutes}${seconds}`;
+	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 fileName = `${TEMP_FILE_PREFIX}${getFormattedDateTime()}${TEMP_FILE_EXTENSION}`;
-	const filePath = join(tempDir, fileName);
+	const filePath = join(tempDir, `${TEMP_FILE_PREFIX}${getFormattedDateTime()}${TEMP_FILE_EXTENSION}`);
 	await writeFile(filePath, "", "utf-8");
 	return filePath;
 }
@@ -89,18 +82,17 @@ async function launchEditor(editor, filePath, envVars, sendConfig) {
 			env: processEnv
 		});
 		editorProcess.on("error", (error) => {
-			reject(new Error(`Failed to launch editor: ${error.message}`));
+			reject(/* @__PURE__ */ new Error(`Failed to launch editor: ${error.message}`));
 		});
 		editorProcess.on("exit", (code) => {
 			if (code === 0) resolve();
-			else reject(new Error(`Editor exited with code: ${code}`));
+			else reject(/* @__PURE__ */ new Error(`Editor exited with code: ${code}`));
 		});
 	});
 }
 async function readFileContent(filePath) {
 	try {
-		const content = await readFile(filePath, "utf-8");
-		return processContent(content);
+		return processContent(await readFile(filePath, "utf-8"));
 	} catch (error) {
 		throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
@@ -111,14 +103,139 @@ async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
 	const parsedEnvVars = parseEnvVars(envVars);
 	try {
 		await launchEditor(editor, tempFilePath, parsedEnvVars, sendConfig);
-		const content = await readFileContent(tempFilePath);
-		return content;
+		return await readFileContent(tempFilePath);
 	} catch (error) {
 		if (error instanceof Error) throw error;
 		throw new Error("An unknown error occurred");
 	}
 }
 
+//#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;
+	}
+}
+
+//#endregion
+//#region src/modules/wezterm.ts
+const execAsync$1 = promisify(exec);
+const conf = new Conf({ projectName: "editprompt" });
+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;
+	}
+}
+
 //#endregion
 //#region src/modules/process.ts
 const execAsync = promisify(exec);
@@ -182,23 +299,98 @@ 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 {
-		await handleContentDelivery(content, options.mux, options.targetPane, options.alwaysCopy);
-	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		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/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
@@ -208,12 +400,10 @@ 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(", ")}`);
-	const mux = muxValue;
-	const alwaysCopy = process.env.EDITPROMPT_ALWAYS_COPY === "1";
 	return {
 		targetPane,
-		mux,
-		alwaysCopy
+		mux: muxValue,
+		alwaysCopy: process.env.EDITPROMPT_ALWAYS_COPY === "1"
 	};
 }
 
@@ -238,13 +428,31 @@ async function runSendOnlyMode(rawContent) {
 	}
 }
 
+//#endregion
+//#region src/utils/argumentParser.ts
+/**
+* Extract raw content from CLI arguments
+* Prioritizes ctx.rest (for -- separator) over ctx.positionals
+*
+* @param rest - Arguments passed after -- separator
+* @param positionals - Positional arguments
+* @returns Raw content string or undefined if no content provided
+*/
+function extractRawContent(rest, positionals) {
+	if (rest.length > 0) return rest.join(" ");
+	return positionals[0];
+}
+
 //#endregion
 //#region src/index.ts
-const argv = process.argv.slice(2);
-await cli(argv, {
+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)",
@@ -278,7 +486,20 @@ await cli(argv, {
 	},
 	async run(ctx) {
 		try {
-			const rawContent = ctx.positionals[0];
+			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;
+			}
+			const rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent !== void 0) {
 				await runSendOnlyMode(rawContent);
 				return;
@@ -311,4 +532,5 @@ await cli(argv, {
 	}
 }, { version });
 
-//#endregion
+//#endregion
+export {  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editprompt",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "author": "eetann",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "license": "MIT",
@@ -48,17 +48,18 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/bun": "^1.2.16",
-    "@types/node": "^24.0.1",
-    "@typescript/native-preview": "^7.0.0-dev.20250712.1",
-    "bumpp": "^10.2.0",
+    "@types/bun": "^1.3.0",
+    "@types/node": "^24.9.1",
+    "@typescript/native-preview": "^7.0.0-dev.20251021.1",
+    "bumpp": "^10.3.1",
     "tsdown": "latest"
   },
   "dependencies": {
     "clipboardy": "^4.0.0",
+    "conf": "^15.0.2",
     "gunshi": "^0.26.3"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": "^5.8.3"
   }
 }