editprompt 0.5.2 → 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
@@ -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.2";
+var version = "0.6.0";
 
 //#endregion
 //#region src/config/constants.ts
@@ -109,6 +110,132 @@ async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
 	}
 }
 
+//#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);
@@ -172,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
@@ -247,6 +449,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)",
@@ -280,6 +486,19 @@ await cli(process.argv.slice(2), {
 	},
 	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;
+			}
 			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.6.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": {