editprompt 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 eetann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# 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.
+
+## 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
+- 📋 **Clipboard Fallback**: Automatically copies to clipboard if sending fails
+- ⚡ **Smart Fallbacks**: Multiple fallback strategies ensure your prompt gets delivered
+
+## Installation
+
+```bash
+# Install globally via npm
+npm install -g editprompt
+
+# Or use with npx
+npx editprompt
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Use with your default editor (from $EDITOR)
+editprompt
+
+# Specify a different editor
+editprompt --editor nvim
+editprompt -e nvim
+
+# Target a different process (default: claude)
+editprompt --process foobar
+editprompt -p foobar
+
+# Show help
+editprompt --help
+
+# Show version
+editprompt --version
+```
+
+It is useful to configure tmux as follows.
+
+```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.
+```tmux
+bind -n M-q display-popup -E \
+  -d '#{pane_current_path}' \
+  'editprompt --editor nvim'
+```
+
+### How it Works
+
+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:
+
+```
+? 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
+
+### Editor Selection
+
+editprompt respects the following editor priority:
+
+1. `--editor/-e` command line option
+2. `$EDITOR` environment variable  
+3. Default: `vi`
+
+### Environment Variables
+
+- `EDITOR`: Your preferred text editor
+
+## Requirements
+
+- Node.js 18+ or Bun
+- Target CLI process (default: `claude` command)
+- Optional: tmux (for direct session integration)
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/eetann/editprompt.git
+cd editprompt
+
+# Install dependencies
+bun install
+
+# Build
+bun run build
+
+# Run tests
+bun test
+
+# Development mode
+bun run dev
+```
+
+### Project Structure
+
+```
+src/
+├── config/
+│   └── constants.ts          # Configuration constants
+├── modules/
+│   ├── editor.ts             # Editor launching and file handling
+│   ├── process.ts            # Process detection and communication
+│   └── selector.ts           # Interactive process selection
+├── utils/
+│   └── tempFile.ts           # Temporary file management
+└── index.ts                  # CLI entry point
+```
+
+## Technical Details
+
+### 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.
+
+### Fallback Strategy
+
+editprompt implements 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

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.js

@@ -0,0 +1,253 @@
+#!/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 { 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 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/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}`;
+}
+async function createTempFile() {
+	const tempDir = await mkdtemp(join(tmpdir(), "editprompt-"));
+	const fileName = `${TEMP_FILE_PREFIX}${getFormattedDateTime()}${TEMP_FILE_EXTENSION}`;
+	const filePath = join(tempDir, fileName);
+	await writeFile(filePath, "", "utf-8");
+	return filePath;
+}
+
+//#endregion
+//#region src/modules/editor.ts
+function getEditor(editorOption) {
+	return editorOption || process.env.EDITOR || DEFAULT_EDITOR;
+}
+async function launchEditor(editor, filePath) {
+	return new Promise((resolve, reject) => {
+		const editorProcess = spawn(editor, [filePath], {
+			stdio: "inherit",
+			shell: true
+		});
+		editorProcess.on("error", (error) => {
+			reject(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}`));
+		});
+	});
+}
+async function readFileContent(filePath) {
+	try {
+		const content = await readFile(filePath, "utf-8");
+		return content.trim();
+	} catch (error) {
+		throw new Error(`Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function openEditorAndGetContent(editorOption) {
+	const tempFilePath = await createTempFile();
+	const editor = getEditor(editorOption);
+	try {
+		await launchEditor(editor, tempFilePath);
+		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;
+		throw new Error("An unknown error occurred");
+	}
+}
+
+//#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;
+	}
+}
+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 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(":");
+			const [window, pane] = windowPane.split(".");
+			return {
+				session,
+				window,
+				pane,
+				pid: Number.parseInt(pid, 10),
+				command
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+async function findTargetInTmux(processName = DEFAULT_PROCESS_NAME) {
+	const processes = await find("name", processName);
+	const targetProcesses = processes.filter((p) => p.name === 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) 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 copyToClipboard(content) {
+	await clipboardy.write(content);
+}
+async function sendContentToProcess(process$1, content) {
+	try {
+		if (process$1.tmuxSession && process$1.tmuxWindow && process$1.tmuxPane) {
+			await sendToTmuxPane(process$1.tmuxSession, process$1.tmuxWindow, process$1.tmuxPane, content);
+			return;
+		}
+	} catch (error) {
+		console.log(`Failed to send to process. Content copied to clipboard. Error: ${error instanceof Error ? error.message : "Unknown 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
+	}]);
+	return selectedProcess;
+}
+
+//#endregion
+//#region src/index.ts
+const argv = process.argv.slice(2);
+await cli(argv, {
+	name: "editprompt",
+	description: "A CLI tool that lets you write prompts for Claude Code using your favorite text editor",
+	args: {
+		editor: {
+			short: "e",
+			description: "Editor to use (overrides $EDITOR)",
+			type: "string"
+		},
+		process: {
+			short: "p",
+			description: "Process name to target (default: claude)",
+			type: "string"
+		}
+	},
+	async run(ctx) {
+		try {
+			console.log("Opening editor...");
+			const content = await openEditorAndGetContent(ctx.values.editor);
+			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);
+				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"}`);
+			process.exit(1);
+		}
+	}
+}, { version: "0.0.1" });
+
+//#endregion

package/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "editprompt",
+	"version": "0.0.1",
+	"author": "eetann",
+	"description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/eetann/editprompt.git"
+	},
+	"homepage": "https://github.com/eetann/editprompt",
+	"bugs": {
+		"url": "https://github.com/eetann/editprompt/issues"
+	},
+	"keywords": [
+		"cli",
+		"editor",
+		"prompt",
+		"tmux",
+		"clipboard",
+		"command-line",
+		"text-editor"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"files": ["dist"],
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": "./dist/index.js",
+		"./package.json": "./package.json"
+	},
+	"bin": {
+		"editprompt": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "tsdown",
+		"dev": "tsdown --watch",
+		"test": "bun test",
+		"test:watch": "bun test --watch"
+	},
+	"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",
+		"tsdown": "latest"
+	},
+	"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"
+	}
+}