editprompt 1.1.0 → 1.2.0

package/README.md

@@ -40,6 +40,10 @@ npm install -g editprompt
 npx editprompt
 ```
 
+### Neovim Plugin
+
+For Neovim users, [editprompt.nvim](https://github.com/eetann/editprompt.nvim) provides easy integration. For manual configuration, see [docs/neovim.md](docs/neovim.md).
+
 ## 🚀 Usage
 
 editprompt supports three main workflows to fit different use cases:
@@ -198,46 +202,9 @@ This sends the content to the target pane (or clipboard) while keeping your edit
   - 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:
-
-```lua
--- Send buffer content while keeping the editor open
-if vim.env.EDITPROMPT then
-    vim.keymap.set("n", "<Space>x", function()
-        vim.cmd("update")
-        -- Get buffer content
-        local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
-        local content = table.concat(lines, "\n")
-
-        -- Execute editprompt command
-        vim.system(
-            { "editprompt", "input", "--", content },
-            { text = true },
-            function(obj)
-                vim.schedule(function()
-                    if obj.code == 0 then
-                        -- Clear buffer on success
-                        vim.api.nvim_buf_set_lines(0, 0, -1, false, {})
-                        vim.cmd("silent write")
-                    else
-                        -- Show error notification
-                        vim.notify("editprompt failed: " .. (obj.stderr or "unknown error"), vim.log.levels.ERROR)
-                    end
-                end)
-            end
-        )
-    end, { silent = true, desc = "Send buffer content to editprompt" })
-end
-```
+#### Neovim Integration
 
-**Usage:**
-1. Open editprompt using the tmux/wezterm keybinding
-2. Write your prompt in the editor
-3. Press `<Space>x` to send the content to the target pane
-4. The buffer is automatically cleared on success
-5. Continue editing to send more content
+For Neovim users, we recommend using [editprompt.nvim](https://github.com/eetann/editprompt.nvim) for easy setup. For manual configuration, see [docs/neovim.md](docs/neovim.md).
 
 ### Quote Workflow Setup
 
@@ -333,53 +300,32 @@ editprompt register --target-pane %1 --target-pane %2
 
 The content will be sent sequentially to all specified panes. This is useful when you want to send the same prompt to multiple CLI sessions.
 
-#### Neovim Integration Example
+### Prompt Stash
 
-You can set up a convenient keybinding to capture your quote content:
-```lua
-vim.keymap.set("n", "<Space>X", function()
-  vim.cmd("update")
-
-  vim.system({ "editprompt", "dump" }, { text = true }, function(obj)
-    vim.schedule(function()
-      if obj.code == 0 then
-        vim.cmd("silent write")
-        -- Split stdout by lines
-        local output_lines = vim.split(obj.stdout, "\n")
-
-        local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
-        local is_empty = #lines == 1 and lines[1] == ""
-
-        if is_empty then
-          -- If empty, overwrite from the beginning
-          vim.api.nvim_buf_set_lines(0, 0, -1, false, output_lines)
-          vim.cmd("normal 2j")
-        else
-          -- If not empty, append to the end
-          table.insert(output_lines, 1, "")
-          local line_count = vim.api.nvim_buf_line_count(0)
-          vim.api.nvim_buf_set_lines(
-            0,
-            line_count,
-            line_count,
-            false,
-            output_lines
-          )
-          vim.cmd("normal 4j")
-        end
-
-        vim.cmd("silent write")
-      else
-        vim.notify(
-          "editprompt failed: " .. (obj.stderr or "unknown error"),
-          vim.log.levels.ERROR
-        )
-      end
-    end)
-  end)
-end, { silent = true, desc = "Capture from editprompt quote mode" })
+Store prompts temporarily for later use, similar to `git stash`. This is useful when you want to save a prompt idea and use it later.
+
+```bash
+# Save a prompt to stash (must be run from editor pane)
+editprompt stash push -- "your prompt here"
+
+# List all stashed prompts (JSON output)
+editprompt stash list
+
+# Get the latest stashed prompt (outputs to stdout)
+editprompt stash apply
+
+# Get a specific stashed prompt by key
+editprompt stash apply --key "2025-01-07T12:34:56.789Z"
+
+# Remove the latest stashed prompt
+editprompt stash drop
+
+# Get and remove the latest stashed prompt (apply + drop)
+editprompt stash pop
 ```
 
+**Note:** The stash commands must be run from within an editprompt editor session (where `EDITPROMPT=1` is set). Stash data is associated with the target pane and persisted using the Conf library.
+
 ### Environment Variables
 
 #### Editor Selection
@@ -392,18 +338,7 @@ editprompt respects the following editor priority:
 
 #### EDITPROMPT Environment Variable
 
-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
-```
+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. For Neovim integration examples, see [docs/neovim.md](docs/neovim.md).
 
 #### Custom Environment Variables
 

package/dist/index.js

@@ -9,7 +9,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 //#region package.json
-var version = "1.1.0";
+var version = "1.2.0";
 
 //#endregion
 //#region src/modules/tmux.ts
@@ -96,10 +96,13 @@ async function inputToTmuxPane(paneId, content) {
 }
 
 //#endregion
-//#region src/modules/wezterm.ts
-const execAsync = promisify(exec);
+//#region src/modules/conf.ts
 const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
 const conf = new Conf({ projectName });
+
+//#endregion
+//#region src/modules/wezterm.ts
+const execAsync = promisify(exec);
 async function getCurrentPaneId$1() {
 	try {
 		const { stdout } = await execAsync("wezterm cli list --format json");
@@ -677,6 +680,10 @@ async function runInputMode(rawContent, autoSend, sendKey) {
 		} catch (error) {
 			console.error(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
+		if (config.alwaysCopy) {
+			await copyToClipboard(content);
+			console.log("Also copied to clipboard.");
+		}
 		if (successCount > 0) console.log("Content sent and submitted successfully!");
 		else {
 			console.error("Error: All target panes failed to receive content");
@@ -1023,6 +1030,179 @@ const resumeCommand = define({
 	}
 });
 
+//#endregion
+//#region src/modes/stash.ts
+function getStashKey(mux, targetPaneId) {
+	return `${mux}.targetPane.pane_${targetPaneId}.stash`;
+}
+async function pushStash(mux, targetPaneId, content) {
+	const key = (/* @__PURE__ */ new Date()).toISOString();
+	const stashKey = getStashKey(mux, targetPaneId);
+	const existing = conf.get(stashKey) || {};
+	existing[key] = content;
+	conf.set(stashKey, existing);
+	return key;
+}
+function getStashList(mux, targetPaneId) {
+	const stashKey = getStashKey(mux, targetPaneId);
+	const data = conf.get(stashKey) || {};
+	return Object.entries(data).map(([key, content]) => ({
+		key,
+		content
+	})).sort((a, b) => b.key.localeCompare(a.key));
+}
+function getStashContent(mux, targetPaneId, key) {
+	const stashKey = getStashKey(mux, targetPaneId);
+	const data = conf.get(stashKey) || {};
+	if (key) return data[key] ?? "";
+	const keys = Object.keys(data);
+	if (keys.length === 0) return "";
+	return data[keys.sort().pop()];
+}
+function dropStash(mux, targetPaneId, key) {
+	const stashKey = getStashKey(mux, targetPaneId);
+	const data = conf.get(stashKey) || {};
+	let targetKey = key;
+	if (!targetKey) {
+		const keys = Object.keys(data);
+		if (keys.length === 0) return false;
+		targetKey = keys.sort().pop();
+	}
+	if (!(targetKey in data)) return false;
+	delete data[targetKey];
+	conf.set(stashKey, data);
+	return true;
+}
+async function getTargetPaneForStash() {
+	const config = readSendConfig();
+	let currentPaneId;
+	let isEditor;
+	if (config.mux === "tmux") {
+		currentPaneId = await getCurrentPaneId();
+		isEditor = await isEditorPane(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$1();
+		isEditor = isEditorPaneFromConf(currentPaneId);
+	}
+	if (!isEditor) {
+		console.error("Error: Current pane is not an editor pane");
+		process.exit(1);
+	}
+	let targetPanes;
+	if (config.mux === "tmux") targetPanes = await getTargetPaneIds(currentPaneId);
+	else targetPanes = await getTargetPaneIds$1(currentPaneId);
+	if (targetPanes.length === 0) {
+		console.error("Error: No target panes registered for this editor pane");
+		process.exit(1);
+	}
+	return {
+		mux: config.mux,
+		targetPaneId: targetPanes[0]
+	};
+}
+async function runPush(rest, positionals) {
+	const rawContent = extractRawContent(rest, positionals);
+	if (rawContent === void 0 || rawContent.trim() === "") {
+		console.error("Error: Content is required for stash push");
+		console.error("Usage: editprompt stash push -- \"your content\"");
+		process.exit(1);
+	}
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	const key = await pushStash(mux, targetPaneId, rawContent);
+	console.log(`Stashed with key: ${key}`);
+}
+async function runList() {
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	const entries = getStashList(mux, targetPaneId);
+	console.log(JSON.stringify(entries, null, 2));
+}
+async function runApply(key) {
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	const content = getStashContent(mux, targetPaneId, key);
+	if (content === "") {
+		if (key) console.error(`Error: No stash entry found with key: ${key}`);
+		else console.error("Error: No stash entries found");
+		process.exit(1);
+	}
+	process.stdout.write(content);
+}
+async function runDrop(key) {
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	if (!dropStash(mux, targetPaneId, key)) {
+		if (key) console.error(`Error: No stash entry found with key: ${key}`);
+		else console.error("Error: No stash entries found");
+		process.exit(1);
+	}
+	console.log("Stash entry dropped");
+}
+async function runPop(key) {
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	const content = getStashContent(mux, targetPaneId, key);
+	if (content === "") {
+		if (key) console.error(`Error: No stash entry found with key: ${key}`);
+		else console.error("Error: No stash entries found");
+		process.exit(1);
+	}
+	process.stdout.write(content);
+	dropStash(mux, targetPaneId, key);
+}
+function showHelp() {
+	console.log("Usage: editprompt stash <subcommand> [options]");
+	console.log("");
+	console.log("Stash prompts for later use");
+	console.log("");
+	console.log("Subcommands:");
+	console.log("  push -- \"<content>\"   Push content to stash");
+	console.log("  list                  List stashed entries (JSON)");
+	console.log("  apply [--key <key>]   Apply (output) stashed content");
+	console.log("  drop [--key <key>]    Drop stashed entry");
+	console.log("  pop [--key <key>]     Apply and drop stashed entry");
+	console.log("");
+	console.log("Options:");
+	console.log("  -k, --key <key>       Stash key (ISO datetime). Default: latest");
+	console.log("  -h, --help            Show this help message");
+}
+function parseKeyOption(args) {
+	const keyIndex = args.findIndex((arg) => arg === "-k" || arg === "--key");
+	if (keyIndex !== -1 && args[keyIndex + 1]) return args[keyIndex + 1];
+}
+const stashCommand = define({
+	name: "stash",
+	description: "Stash prompts for later use",
+	args: {},
+	async run(ctx) {
+		const args = ctx.positionals.slice(1);
+		if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
+			showHelp();
+			process.exit(args.length === 0 ? 1 : 0);
+		}
+		const subcommand = args[0];
+		const subArgs = args.slice(1);
+		switch (subcommand) {
+			case "push":
+				await runPush(ctx.rest, subArgs);
+				break;
+			case "list":
+				await runList();
+				break;
+			case "apply":
+				await runApply(parseKeyOption(subArgs));
+				break;
+			case "drop":
+				await runDrop(parseKeyOption(subArgs));
+				break;
+			case "pop":
+				await runPop(parseKeyOption(subArgs));
+				break;
+			default:
+				console.error(`Error: Unknown subcommand '${subcommand}'`);
+				console.error("");
+				showHelp();
+				process.exit(1);
+		}
+	}
+});
+
 //#endregion
 //#region src/index.ts
 await cli(process.argv.slice(2), {
@@ -1051,7 +1231,8 @@ await cli(process.argv.slice(2), {
 		resume: resumeCommand,
 		input: inputCommand,
 		collect: collectCommand,
-		dump: dumpCommand
+		dump: dumpCommand,
+		stash: stashCommand
 	},
 	renderHeader: null
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editprompt",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "author": "eetann",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "license": "MIT",