editprompt 1.2.0 → 1.3.0

package/README.md

@@ -19,7 +19,6 @@ A CLI tool that lets you write prompts for CLI tools using your favorite text ed
 - **💬 Quote and Reply**: Collect multiple text selections and reply to specific parts of AI responses
 - **📝 Multi-line Commands**: Complex SQL queries, JSON payloads, and structured prompts
 
-
 ## ✨ Features
 
 - 🖊️ **Editor Integration**: Use your preferred text editor to write prompts
@@ -29,7 +28,6 @@ A CLI tool that lets you write prompts for CLI tools using your favorite text ed
 - 📋 **Quote Buffering**: Collect text selections and send them as quoted replies
 - 📋 **Clipboard Fallback**: Automatically copies to clipboard if sending fails
 
-
 ## 📦 Installation
 
 ```bash
@@ -97,7 +95,6 @@ For replying to specific parts of AI responses:
 
 Perfect for addressing multiple points in long AI responses.
 
-
 ## ⚙️ Setup & Configuration
 
 ### Basic Setup
@@ -127,7 +124,6 @@ bind -n M-q run-shell '\
     "editprompt open --editor nvim --always-copy --target-pane #{pane_id}"'
 ```
 
-
 ### WezTerm Integration
 
 ```lua
@@ -173,7 +169,6 @@ bind -n M-q run-shell '\
 
 **Note:** The `-lc` flag ensures your shell loads the full login environment, making `editprompt` available in your PATH.
 
-
 ### Editor Integration (Send Without Closing)
 
 While editprompt is running, you can send content to the target pane or clipboard without closing the editor. This allows you to iterate quickly on your prompts.
@@ -197,6 +192,7 @@ editprompt input --auto-send --send-key "C-m" -- "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.
 
 **Options:**
+
 - `--auto-send`: Automatically sends the content and returns focus to your editor pane (requires multiplexer)
 - `--send-key <key>`: Customize the key to send after content (requires `--auto-send`)
   - tmux format: `Enter` (default), `C-a`, etc.
@@ -217,6 +213,7 @@ bind-key -T copy-mode-vi C-e { send-keys -X pipe "editprompt collect --target-pa
 ```
 
 **Usage:**
+
 1. Enter tmux copy mode (`prefix + [`)
 2. Select text using vi-mode keybindings
 3. Press `Ctrl-e` to add the selection as a quote
@@ -257,6 +254,7 @@ return {
 ```
 
 **Usage:**
+
 1. Select text in WezTerm (by dragging with mouse or using copy mode)
 2. Press `Ctrl-e` to add the selection as a quote
 3. Repeat to collect multiple quotes
@@ -273,6 +271,7 @@ editprompt dump
 This copies all collected quotes to the clipboard and clears the buffer, ready for your reply.
 
 **Complete workflow:**
+
 1. AI responds with multiple points
 2. Select each point in copy mode and press `Ctrl-e`
 3. Open your editor pane and run `editprompt dump`
@@ -280,6 +279,7 @@ This copies all collected quotes to the clipboard and clears the buffer, ready f
 5. Send to AI
 
 **How quote buffering works:**
+
 - **tmux**: Quotes are stored in pane variables, automatically cleaned up when the pane closes
 - **WezTerm**: Quotes are stored in a configuration file associated with the pane
 - Text is intelligently processed: removes common indentation, handles line breaks smartly
@@ -358,3 +358,42 @@ editprompt open --env NVIM_CONFIG=minimal
 #### Target Pane Environment Variable
 
 When using the send-without-closing feature or dump, editprompt sets `EDITPROMPT_TARGET_PANE` to the target pane ID. This is automatically used by `editprompt input` and `editprompt dump` commands.
+
+### Logging Options
+
+editprompt uses structured logging via [LogTape](https://logtape.org/). The following flags are available on all subcommands:
+
+| Flag                | Description                                |
+| ------------------- | ------------------------------------------ |
+| `--quiet` / `-q`    | Suppress all log output                    |
+| `--verbose` / `-v`  | Enable debug-level log output              |
+| `--log-file <path>` | Write logs to the specified file (appends) |
+
+You can also configure logging via environment variables:
+
+| Environment Variable   | Description                                          |
+| ---------------------- | ---------------------------------------------------- |
+| `EDITPROMPT_LOG_FILE`  | Path to log file (same as `--log-file`)              |
+| `EDITPROMPT_LOG_LEVEL` | Log level (e.g. `debug`, `info`, `warning`, `error`) |
+
+**Log level resolution priority:**
+
+1. `--quiet` → suppresses all logs
+2. `--verbose` → sets level to `debug`
+3. `EDITPROMPT_LOG_LEVEL` → uses the specified level
+4. Default: `info`
+
+### Send-Key Delay
+
+When using `--auto-send` with `editprompt input`, a delay is inserted before sending the key to allow the target process to finish processing the content.
+
+| Environment Variable        | Description                                  | Default |
+| --------------------------- | -------------------------------------------- | ------- |
+| `EDITPROMPT_SEND_KEY_DELAY` | Delay in milliseconds before sending the key | `1000`  |
+
+**Auto-detection:** editprompt automatically adjusts the delay based on content:
+
+- **Content with image paths** → uses `EDITPROMPT_SEND_KEY_DELAY` (default: `1000` ms)
+- **Content without image paths** → uses `200` ms
+
+Supported image extensions: `.png`, `.webp`, `.avif`, `.jpg`/`.jpeg`, `.gif` (case-insensitive)

package/dist/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
+import { configureSync, getAnsiColorFormatter, getLogger, getTextFormatter, parseLogLevel, withFilter } from "@logtape/logtape";
 import { cli, define } from "gunshi";
+import { appendFileSync } from "node:fs";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import Conf from "conf";
@@ -8,23 +10,86 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+//#region src/modules/logger.ts
+function resolveLogFilePath(options) {
+	if (options.logFile) return options.logFile;
+	const envPath = process.env.EDITPROMPT_LOG_FILE;
+	if (envPath) return envPath;
+}
+function resolveFileLogLevel(options) {
+	if (options.verbose) return "debug";
+	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
+	if (envLevel) return parseLogLevel(envLevel);
+	return "info";
+}
+function resolveLogLevel(options) {
+	if (options.quiet) return null;
+	if (options.verbose) return "debug";
+	const envLevel = process.env.EDITPROMPT_LOG_LEVEL;
+	if (envLevel) return parseLogLevel(envLevel);
+	return "info";
+}
+function setupLogger(options = {}) {
+	const stderrLevel = resolveLogLevel(options);
+	const stderrFormatter = getAnsiColorFormatter({
+		timestamp: "time-timezone",
+		level: "ABBR"
+	});
+	const rawStderrSink = (record) => {
+		process.stderr.write(stderrFormatter(record));
+	};
+	const sinks = { stderr: stderrLevel === null ? () => {} : withFilter(rawStderrSink, stderrLevel) };
+	const loggerSinks = ["stderr"];
+	const logFilePath = resolveLogFilePath(options);
+	const fileLogLevel = resolveFileLogLevel(options);
+	if (logFilePath) try {
+		appendFileSync(logFilePath, "");
+		const fileFormatter = getTextFormatter({
+			timestamp: "date-time-timezone",
+			level: "ABBR"
+		});
+		const rawFileSink = (record) => {
+			appendFileSync(logFilePath, fileFormatter(record));
+		};
+		sinks.file = withFilter(rawFileSink, fileLogLevel);
+		loggerSinks.push("file");
+	} catch {
+		process.stderr.write(`Warning: Cannot write to log file '${logFilePath}', continuing without file logging.\n`);
+	}
+	configureSync({
+		sinks,
+		loggers: [{
+			category: ["editprompt"],
+			sinks: loggerSinks,
+			lowestLevel: "trace"
+		}, {
+			category: ["logtape", "meta"],
+			lowestLevel: null
+		}]
+	});
+}
+
+//#endregion
 //#region package.json
-var version = "1.2.0";
+var version = "1.3.0";
 
 //#endregion
 //#region src/modules/tmux.ts
 const execAsync$1 = promisify(exec);
-async function getCurrentPaneId() {
+const logger$10 = getLogger(["editprompt", "tmux"]);
+async function getCurrentPaneId$1() {
+	const envPaneId = process.env.TMUX_PANE?.trim();
+	if (envPaneId) return envPaneId;
 	const { stdout } = await execAsync$1("tmux display-message -p \"#{pane_id}\"");
 	return stdout.trim();
 }
 async function saveEditorPaneId$1(targetPaneId, editorPaneId) {
 	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane '${editorPaneId}'`);
 }
-async function clearEditorPaneId(targetPaneId) {
+async function clearEditorPaneId$1(targetPaneId) {
 	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_editor_pane ""`);
 }
-async function getEditorPaneId(targetPaneId) {
+async function getEditorPaneId$1(targetPaneId) {
 	try {
 		const { stdout } = await execAsync$1(`tmux show -pt '${targetPaneId}' -v @editprompt_editor_pane`);
 		return stdout.trim();
@@ -32,7 +97,7 @@ async function getEditorPaneId(targetPaneId) {
 		return "";
 	}
 }
-async function checkPaneExists(paneId) {
+async function checkPaneExists$1(paneId) {
 	try {
 		const { stdout } = await execAsync$1("tmux list-panes -a -F \"#{pane_id}\"");
 		return stdout.split("\n").map((id) => id.trim()).includes(paneId);
@@ -40,16 +105,16 @@ async function checkPaneExists(paneId) {
 		return false;
 	}
 }
-async function focusPane(paneId) {
+async function focusPane$1(paneId) {
 	await execAsync$1(`tmux select-pane -t '${paneId}'`);
 }
-async function markAsEditorPane(editorPaneId, targetPaneIds) {
+async function markAsEditorPane$1(editorPaneId, targetPaneIds) {
 	await execAsync$1(`tmux set-option -pt '${editorPaneId}' @editprompt_is_editor 1`);
 	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
 	await execAsync$1(`tmux set-option -pt '${editorPaneId}' @editprompt_target_panes '${uniqueTargetPaneIds.join(",")}'`);
 	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$1(targetPaneId, editorPaneId);
 }
-async function getTargetPaneIds(editorPaneId) {
+async function getTargetPaneIds$1(editorPaneId) {
 	try {
 		const { stdout } = await execAsync$1(`tmux show -pt '${editorPaneId}' -v @editprompt_target_panes`);
 		const value = stdout.trim();
@@ -85,14 +150,14 @@ async function appendToQuoteVariable(paneId, content) {
 async function clearQuoteVariable(targetPaneId) {
 	await execAsync$1(`tmux set-option -pt '${targetPaneId}' @editprompt_quote ""`);
 }
-async function sendKeyToTmuxPane(paneId, key) {
-	await new Promise((resolve) => setTimeout(resolve, 100));
+async function sendKeyToTmuxPane(paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
 	await execAsync$1(`tmux send-keys -t '${paneId}' '${key}'`);
 }
 async function inputToTmuxPane(paneId, content) {
 	await execAsync$1(`tmux if-shell -t '${paneId}' '[ "#{pane_in_mode}" = "1" ]' "copy-mode -q -t '${paneId}'"`);
 	await execAsync$1(`tmux send-keys -t '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
-	console.log(`Content sent to tmux pane: ${paneId}`);
+	logger$10.debug("Content sent to tmux pane: {paneId}", { paneId });
 }
 
 //#endregion
@@ -102,67 +167,68 @@ const conf = new Conf({ projectName });
 
 //#endregion
 //#region src/modules/wezterm.ts
+const logger$9 = getLogger(["editprompt", "wezterm"]);
 const execAsync = promisify(exec);
-async function getCurrentPaneId$1() {
+async function getCurrentPaneId() {
 	try {
 		const { stdout } = await execAsync("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);
+		logger$9.debug("getCurrentPaneId failed: {error}", { error });
 		return "";
 	}
 }
-async function checkPaneExists$1(paneId) {
+async function checkPaneExists(paneId) {
 	try {
 		const { stdout } = await execAsync("wezterm cli list --format json");
-		console.log(stdout);
+		logger$9.debug("wezterm cli list output: {stdout}", { stdout });
 		return JSON.parse(stdout).some((pane) => String(pane.pane_id) === paneId);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("checkPaneExists failed: {error}", { error });
 		return false;
 	}
 }
 async function saveEditorPaneId(targetPaneId, editorPaneId) {
-	console.log(`wezterm.targetPane.pane_${targetPaneId}`);
+	logger$9.debug("Saving editor pane ID to conf key: wezterm.targetPane.pane_{targetPaneId}", { targetPaneId });
 	try {
 		conf.set(`wezterm.targetPane.pane_${targetPaneId}`, { editorPaneId });
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("saveEditorPaneId failed: {error}", { error });
 	}
 }
-async function getEditorPaneId$1(targetPaneId) {
+async function getEditorPaneId(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);
+		logger$9.debug("getEditorPaneId failed: {error}", { error });
 		return "";
 	}
 }
-async function clearEditorPaneId$1(targetPaneId) {
+async function clearEditorPaneId(targetPaneId) {
 	try {
-		const editorPaneId = await getEditorPaneId$1(targetPaneId);
+		const editorPaneId = await getEditorPaneId(targetPaneId);
 		conf.delete(`wezterm.targetPane.pane_${targetPaneId}`);
 		if (editorPaneId) conf.delete(`wezterm.editorPane.pane_${editorPaneId}`);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("clearEditorPaneId failed: {error}", { error });
 	}
 }
-async function focusPane$1(paneId) {
+async function focusPane(paneId) {
 	await execAsync(`wezterm cli activate-pane --pane-id '${paneId}'`);
 }
-async function markAsEditorPane$1(editorPaneId, targetPaneIds) {
+async function markAsEditorPane(editorPaneId, targetPaneIds) {
 	try {
 		const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
 		conf.set(`wezterm.editorPane.pane_${editorPaneId}`, { targetPaneIds: uniqueTargetPaneIds });
 		for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId(targetPaneId, editorPaneId);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("markAsEditorPane failed: {error}", { error });
 	}
 }
-async function getTargetPaneIds$1(editorPaneId) {
+async function getTargetPaneIds(editorPaneId) {
 	try {
 		const data = conf.get(`wezterm.editorPane.pane_${editorPaneId}`);
 		if (typeof data === "object" && data !== null && "targetPaneIds" in data) {
@@ -171,7 +237,7 @@ async function getTargetPaneIds$1(editorPaneId) {
 		}
 		return [];
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("getTargetPaneIds failed: {error}", { error });
 		return [];
 	}
 }
@@ -179,7 +245,7 @@ function isEditorPaneFromConf(paneId) {
 	try {
 		return conf.has(`wezterm.editorPane.pane_${paneId}`);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("isEditorPaneFromConf failed: {error}", { error });
 		return false;
 	}
 }
@@ -197,7 +263,7 @@ async function appendToQuoteText(paneId, content) {
 		} else newData = { quote_text: content };
 		conf.set(`wezterm.targetPane.pane_${paneId}`, newData);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("appendToQuoteText failed: {error}", { error });
 	}
 }
 async function getQuoteText(paneId) {
@@ -206,7 +272,7 @@ async function getQuoteText(paneId) {
 		if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
 		return "";
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("getQuoteText failed: {error}", { error });
 		return "";
 	}
 }
@@ -215,15 +281,16 @@ async function clearQuoteText(paneId) {
 		const key = `wezterm.targetPane.pane_${paneId}.quote_text`;
 		if (conf.has(key)) conf.delete(key);
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("clearQuoteText failed: {error}", { error });
 	}
 }
-async function sendKeyToWeztermPane(paneId, key) {
+async function sendKeyToWeztermPane(paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
 	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' $'${key}'`);
 }
 async function inputToWeztermPane(paneId, content) {
 	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
-	console.log(`Content sent to wezterm pane: ${paneId}`);
+	logger$9.debug("Content sent to wezterm pane: {paneId}", { paneId });
 }
 
 //#endregion
@@ -237,8 +304,12 @@ async function inputToWeztermPane(paneId, content) {
 * @returns Raw content string or undefined if no content provided
 */
 function extractRawContent(rest, positionals) {
-	if (rest.length > 0) return rest.join(" ");
-	return positionals[0];
+	if (rest.length > 0) {
+		const joined = rest.join(" ");
+		if (joined.trim() !== "") return joined;
+	}
+	const first = positionals[0];
+	if (first !== void 0 && first.trim() !== "") return first;
 }
 
 //#endregion
@@ -361,6 +432,7 @@ function processQuoteText(text, options) {
 
 //#endregion
 //#region src/modes/common.ts
+const logger$8 = getLogger(["editprompt", "delivery"]);
 function isMuxType(value) {
 	return value === "tmux" || value === "wezterm";
 }
@@ -374,8 +446,8 @@ async function inputContentToPane(content, mux, targetPaneId) {
 }
 async function focusFirstSuccessPane(mux, targetPanes, failedPanes) {
 	const firstSuccessPane = targetPanes.find((p) => !failedPanes.includes(p));
-	if (firstSuccessPane) if (mux === "tmux") await focusPane(firstSuccessPane);
-	else await focusPane$1(firstSuccessPane);
+	if (firstSuccessPane) if (mux === "tmux") await focusPane$1(firstSuccessPane);
+	else await focusPane(firstSuccessPane);
 }
 async function handleContentDelivery(content, mux, targetPanes) {
 	if (!content) return {
@@ -388,9 +460,9 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	if (targetPanes.length === 0) {
 		try {
 			await copyToClipboard(content);
-			console.log("Content copied to clipboard.");
+			logger$8.info("Content copied to clipboard.");
 		} catch (error) {
-			console.log(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$8.warn(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
 		return {
 			successCount: 0,
@@ -408,7 +480,7 @@ async function handleContentDelivery(content, mux, targetPanes) {
 			success: true
 		});
 	} catch (error) {
-		console.log(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$8.warn(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
 		results.push({
 			pane: targetPane,
 			success: false
@@ -418,13 +490,13 @@ async function handleContentDelivery(content, mux, targetPanes) {
 	const failedPanes = results.filter((r) => !r.success).map((r) => r.pane);
 	const allSuccess = successCount === targetPanes.length;
 	const allFailed = successCount === 0;
-	if (allSuccess) console.log("Content sent successfully to all panes!");
+	if (allSuccess) logger$8.info("Content sent successfully to all panes!");
 	else if (allFailed) {
-		console.error("Error: All target panes failed to receive content.");
-		console.log("Falling back to clipboard...");
+		logger$8.error("All target panes failed to receive content.");
+		logger$8.info("Falling back to clipboard...");
 		await copyToClipboard(content);
-		console.log("Content copied to clipboard.");
-	} else console.warn(`Warning: Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
+		logger$8.info("Content copied to clipboard.");
+	} else logger$8.warn(`Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
 	return {
 		successCount,
 		totalCount: targetPanes.length,
@@ -436,6 +508,7 @@ async function handleContentDelivery(content, mux, targetPanes) {
 
 //#endregion
 //#region src/modes/args.ts
+const logger$7 = getLogger(["editprompt"]);
 const ARG_MUX = {
 	short: "m",
 	description: "Multiplexer type (tmux or wezterm, default: tmux)",
@@ -470,17 +543,31 @@ const ARG_OUTPUT = {
 	type: "string",
 	multiple: true
 };
+const ARG_LOG_FILE = {
+	description: "Write logs to the specified file (appends)",
+	type: "string"
+};
+const ARG_QUIET = {
+	short: "q",
+	description: "Suppress all log output",
+	type: "boolean"
+};
+const ARG_VERBOSE = {
+	short: "v",
+	description: "Enable debug-level log output",
+	type: "boolean"
+};
 function validateMux(value) {
 	const muxValue = value || "tmux";
 	if (!isMuxType(muxValue)) {
-		console.error(`Error: Invalid multiplexer type '${muxValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
+		logger$7.error(`Invalid multiplexer type '${muxValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
 		process.exit(1);
 	}
 	return muxValue;
 }
 function validateTargetPane(value, commandName) {
 	if (!value || typeof value !== "string") {
-		console.error(`Error: --target-pane is required for ${commandName} command`);
+		logger$7.error(`--target-pane is required for ${commandName} command`);
 		process.exit(1);
 	}
 	return value;
@@ -493,6 +580,7 @@ function normalizeTargetPanes(value) {
 
 //#endregion
 //#region src/modes/collect.ts
+const logger$6 = getLogger(["editprompt", "collect"]);
 const SUPPORTED_OUTPUTS = ["buffer", "stdout"];
 async function readStdin() {
 	return new Promise((resolve, reject) => {
@@ -516,7 +604,7 @@ function normalizeCollectOutputs(value) {
 	const uniqueOutputs = [...new Set(outputs)];
 	const invalid = uniqueOutputs.filter((v) => !SUPPORTED_OUTPUTS.includes(v));
 	if (invalid.length > 0) {
-		console.error(`Error: Invalid output(s) '${invalid.join(", ")}'. Supported values: ${SUPPORTED_OUTPUTS.join(", ")}`);
+		logger$6.error(`Invalid output(s) '${invalid.join(", ")}'. Supported values: ${SUPPORTED_OUTPUTS.join(", ")}`);
 		process.exit(1);
 	}
 	return uniqueOutputs;
@@ -532,7 +620,7 @@ async function runCollectMode(mux, targetPaneId, rawContent, outputs = ["buffer"
 			else if (mux === "wezterm") await appendToQuoteText(targetPaneId, processedText);
 		} else if (output === "stdout") process.stdout.write(processedText);
 	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$6.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -543,9 +631,17 @@ const collectCommand = define({
 		mux: ARG_MUX,
 		"target-pane": ARG_TARGET_PANE_SINGLE,
 		output: ARG_OUTPUT,
-		"no-quote": ARG_NO_QUOTE
+		"no-quote": ARG_NO_QUOTE,
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
 	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		const targetPane = validateTargetPane(ctx.values["target-pane"], "collect");
 		const mux = validateMux(ctx.values.mux);
 		const outputs = normalizeCollectOutputs(ctx.values.output);
@@ -554,7 +650,7 @@ const collectCommand = define({
 		if (mux === "wezterm") {
 			rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent === void 0) {
-				console.error("Error: Text content is required for collect mode with wezterm. Use: editprompt collect --mux wezterm --target-pane <id> -- \"<text>\"");
+				logger$6.error("Text content is required for collect mode with wezterm. Use: editprompt collect --mux wezterm --target-pane <id> -- \"<text>\"");
 				process.exit(1);
 			}
 		}
@@ -568,35 +664,41 @@ const VALID_MUX_TYPES = ["tmux", "wezterm"];
 function readSendConfig() {
 	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";
+	const delayValue = process.env.EDITPROMPT_SEND_KEY_DELAY;
+	const parsedDelay = delayValue ? Number.parseInt(delayValue, 10) : NaN;
 	return {
-		mux: muxValue,
-		alwaysCopy: process.env.EDITPROMPT_ALWAYS_COPY === "1"
+		mux,
+		alwaysCopy,
+		sendKeyDelay: Number.isNaN(parsedDelay) ? 1e3 : parsedDelay
 	};
 }
 
 //#endregion
 //#region src/modes/dump.ts
+const logger$5 = getLogger(["editprompt", "dump"]);
 async function runDumpMode() {
 	try {
 		const config = readSendConfig();
 		let currentPaneId;
 		let isEditor;
 		if (config.mux === "tmux") {
-			currentPaneId = await getCurrentPaneId();
+			currentPaneId = await getCurrentPaneId$1();
 			isEditor = await isEditorPane(currentPaneId);
 		} else {
-			currentPaneId = await getCurrentPaneId$1();
+			currentPaneId = await getCurrentPaneId();
 			isEditor = isEditorPaneFromConf(currentPaneId);
 		}
 		if (!isEditor) {
-			console.error("Error: Current pane is not an editor pane");
+			logger$5.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 (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
+		else targetPanes = await getTargetPaneIds(currentPaneId);
 		if (targetPanes.length === 0) {
-			console.error("Error: No target panes registered for this editor pane");
+			logger$5.error("No target panes registered for this editor pane");
 			process.exit(1);
 		}
 		const quoteContents = [];
@@ -615,15 +717,24 @@ async function runDumpMode() {
 		process.stdout.write(combinedContent.replace(/\n{3,}$/, "\n\n"));
 		process.exit(0);
 	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$5.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
 const dumpCommand = define({
 	name: "dump",
 	description: "Output and clear collected quoted text from environment variables",
-	args: {},
-	async run() {
+	args: {
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
+	},
+	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		await runDumpMode();
 	}
 });
@@ -638,55 +749,57 @@ function processContent(content) {
 
 //#endregion
 //#region src/modes/input.ts
-async function runInputMode(rawContent, autoSend, sendKey) {
+const logger$4 = getLogger(["editprompt", "input"]);
+async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 	const content = processContent(rawContent);
 	if (!content) {
-		console.log("No content to send. Exiting.");
+		logger$4.info("No content to send. Exiting.");
 		return;
 	}
 	const config = readSendConfig();
 	let currentPaneId;
 	let isEditor;
 	if (config.mux === "tmux") {
-		currentPaneId = await getCurrentPaneId();
+		currentPaneId = await getCurrentPaneId$1();
 		isEditor = await isEditorPane(currentPaneId);
 	} else {
-		currentPaneId = await getCurrentPaneId$1();
+		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
 	}
 	if (!isEditor) {
-		console.error("Error: Current pane is not an editor pane");
+		logger$4.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 (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
+	else targetPanes = await getTargetPaneIds(currentPaneId);
 	if (targetPanes.length === 0) {
-		console.error("Error: No target panes registered for this editor pane");
+		logger$4.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	if (autoSend) {
 		const key = sendKey || (config.mux === "wezterm" ? "\\r" : "C-m");
+		const delay = /\.(png|webp|avif|jpe?g|gif)\b/i.test(content) ? sendKeyDelay ?? 1e3 : 200;
 		let successCount = 0;
 		for (const targetPane of targetPanes) try {
 			if (config.mux === "wezterm") {
 				await inputToWeztermPane(targetPane, content);
-				await sendKeyToWeztermPane(targetPane, key);
+				await sendKeyToWeztermPane(targetPane, key, delay);
 			} else {
 				await inputToTmuxPane(targetPane, content);
-				await sendKeyToTmuxPane(targetPane, key);
+				await sendKeyToTmuxPane(targetPane, key, delay);
 			}
 			successCount++;
 		} catch (error) {
-			console.error(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$4.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.");
+			logger$4.info("Also copied to clipboard.");
 		}
-		if (successCount > 0) console.log("Content sent and submitted successfully!");
+		if (successCount > 0) logger$4.info("Content sent and submitted successfully!");
 		else {
-			console.error("Error: All target panes failed to receive content");
+			logger$4.error("All target panes failed to receive content");
 			process.exit(1);
 		}
 		return;
@@ -695,12 +808,12 @@ async function runInputMode(rawContent, autoSend, sendKey) {
 		const result = await handleContentDelivery(content, config.mux, targetPanes);
 		if (config.alwaysCopy && !result.allFailed) {
 			await copyToClipboard(content);
-			console.log("Also copied to clipboard.");
+			logger$4.info("Also copied to clipboard.");
 		}
 		if (result.successCount > 0) await focusFirstSuccessPane(config.mux, targetPanes, result.failedPanes);
 		if (result.allFailed) process.exit(1);
 	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$4.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -715,21 +828,30 @@ const inputCommand = define({
 		"send-key": {
 			description: "Key to send after content (requires --auto-send)",
 			type: "string"
-		}
+		},
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
 	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		const rawContent = extractRawContent(ctx.rest, ctx.positionals);
 		if (rawContent === void 0) {
-			console.error("Error: Content is required for input command");
-			console.error("Usage: editprompt input \"your content\"");
-			console.error("   or: editprompt input -- \"your content\"");
+			logger$4.error("Content is required for input command");
+			logger$4.error("Usage: editprompt input \"your content\"");
+			logger$4.error("   or: editprompt input -- \"your content\"");
 			process.exit(1);
 		}
 		if (ctx.values["send-key"] && !ctx.values["auto-send"]) {
-			console.error("Error: --send-key requires --auto-send to be enabled");
+			logger$4.error("--send-key requires --auto-send to be enabled");
 			process.exit(1);
 		}
-		await runInputMode(rawContent, Boolean(ctx.values["auto-send"]), ctx.values["send-key"]);
+		const config = readSendConfig();
+		await runInputMode(rawContent, Boolean(ctx.values["auto-send"]), ctx.values["send-key"], config.sendKeyDelay);
 	}
 });
 
@@ -825,23 +947,25 @@ async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
 
 //#endregion
 //#region src/modes/openEditor.ts
+const logger$3 = getLogger(["editprompt", "open"]);
 async function runOpenEditorMode(options) {
 	if (options.targetPanes.length > 0 && options.mux === "tmux") try {
-		await markAsEditorPane(await getCurrentPaneId(), options.targetPanes);
+		await markAsEditorPane$1(await getCurrentPaneId$1(), options.targetPanes);
 	} catch {}
 	else if (options.targetPanes.length > 0 && options.mux === "wezterm") try {
-		const currentPaneId = await getCurrentPaneId$1();
-		await markAsEditorPane$1(currentPaneId, options.targetPanes);
+		const currentPaneId = await getCurrentPaneId();
+		await markAsEditorPane(currentPaneId, options.targetPanes);
 	} catch {}
 	try {
 		const sendConfig = {
 			mux: options.mux,
-			alwaysCopy: options.alwaysCopy
+			alwaysCopy: options.alwaysCopy,
+			sendKeyDelay: Number.parseInt(process.env.EDITPROMPT_SEND_KEY_DELAY || "", 10) || 1e3
 		};
-		console.log("Opening editor...");
+		logger$3.info("Opening editor...");
 		const content = await openEditorAndGetContent(options.editor, options.env, sendConfig);
 		if (!content) {
-			console.log("No content entered. Exiting.");
+			logger$3.info("No content entered. Exiting.");
 			return;
 		}
 		try {
@@ -850,20 +974,20 @@ async function runOpenEditorMode(options) {
 			console.log(content);
 			if (options.alwaysCopy && !result.allFailed) {
 				await copyToClipboard(content);
-				console.log("Also copied to clipboard.");
+				logger$3.info("Also copied to clipboard.");
 			}
 			if (options.targetPanes.length > 0 && result.successCount > 0) await focusFirstSuccessPane(options.mux, options.targetPanes, result.failedPanes);
 			if (!result.allSuccess) process.exit(1);
 		} catch (error) {
-			console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$3.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 			process.exit(1);
 		}
 	} finally {
 		if (options.targetPanes.length > 0 && options.mux === "tmux") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId(targetPane);
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$1(targetPane);
 		} catch {}
 		else if (options.targetPanes.length > 0 && options.mux === "wezterm") try {
-			for (const targetPane of options.targetPanes) await clearEditorPaneId$1(targetPane);
+			for (const targetPane of options.targetPanes) await clearEditorPaneId(targetPane);
 		} catch {}
 	}
 }
@@ -875,6 +999,9 @@ const openCommand = define({
 		"target-pane": ARG_TARGET_PANE_MULTI,
 		editor: ARG_EDITOR,
 		"always-copy": ARG_ALWAYS_COPY,
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE,
 		env: {
 			short: "E",
 			description: "Environment variables to set (e.g., KEY=VALUE)",
@@ -883,6 +1010,11 @@ const openCommand = define({
 		}
 	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		await runOpenEditorMode({
 			mux: validateMux(ctx.values.mux),
 			targetPanes: normalizeTargetPanes(ctx.values["target-pane"]),
@@ -895,39 +1027,40 @@ const openCommand = define({
 
 //#endregion
 //#region src/modes/register.ts
+const logger$2 = getLogger(["editprompt", "register"]);
 async function runRegisterMode(options) {
 	if (options.targetPanes.length === 0) {
-		console.error("Error: --target-pane is required for register command");
+		logger$2.error("--target-pane is required for register command");
 		process.exit(1);
 	}
 	let editorPaneId;
 	if (options.editorPane) editorPaneId = options.editorPane;
 	else if (options.mux === "tmux") {
-		editorPaneId = await getCurrentPaneId();
+		editorPaneId = await getCurrentPaneId$1();
 		if (!await isEditorPane(editorPaneId)) {
-			console.error("Error: Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			logger$2.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
 			process.exit(1);
 		}
 	} else if (options.mux === "wezterm") {
-		editorPaneId = await getCurrentPaneId$1();
+		editorPaneId = await getCurrentPaneId();
 		if (!isEditorPaneFromConf(editorPaneId)) {
-			console.error("Error: Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			logger$2.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
 			process.exit(1);
 		}
 	} else {
-		console.error("Error: Unsupported multiplexer");
+		logger$2.error("Unsupported multiplexer");
 		process.exit(1);
 	}
 	try {
 		let existingPanes = [];
-		if (options.mux === "tmux") existingPanes = await getTargetPaneIds(editorPaneId);
-		else if (options.mux === "wezterm") existingPanes = await getTargetPaneIds$1(editorPaneId);
+		if (options.mux === "tmux") existingPanes = await getTargetPaneIds$1(editorPaneId);
+		else if (options.mux === "wezterm") existingPanes = await getTargetPaneIds(editorPaneId);
 		const mergedTargetPanes = [...new Set([...existingPanes, ...options.targetPanes])];
-		if (options.mux === "tmux") await markAsEditorPane(editorPaneId, mergedTargetPanes);
-		else if (options.mux === "wezterm") await markAsEditorPane$1(editorPaneId, mergedTargetPanes);
-		console.log(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
+		if (options.mux === "tmux") await markAsEditorPane$1(editorPaneId, mergedTargetPanes);
+		else if (options.mux === "wezterm") await markAsEditorPane(editorPaneId, mergedTargetPanes);
+		logger$2.info(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
 	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$2.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -941,9 +1074,17 @@ const registerCommand = define({
 			short: "e",
 			description: "Editor pane ID (defaults to current pane)",
 			type: "string"
-		}
+		},
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
 	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		await runRegisterMode({
 			mux: validateMux(ctx.values.mux),
 			targetPanes: normalizeTargetPanes(ctx.values["target-pane"]),
@@ -954,68 +1095,72 @@ const registerCommand = define({
 
 //#endregion
 //#region src/modes/resume.ts
+const logger$1 = getLogger(["editprompt", "resume"]);
 async function runResumeMode(targetPane, mux) {
 	if (mux === "wezterm") {
-		const currentPaneId$1 = await getCurrentPaneId$1();
-		if (isEditorPaneFromConf(currentPaneId$1)) {
-			console.log("isEditor");
-			const originalTargetPaneIds = await getTargetPaneIds$1(currentPaneId$1);
+		const currentPaneId = await getCurrentPaneId();
+		if (isEditorPaneFromConf(currentPaneId)) {
+			logger$1.debug("Current pane is an editor pane");
+			const originalTargetPaneIds = await getTargetPaneIds(currentPaneId);
 			if (originalTargetPaneIds.length === 0) {
-				console.log("Not found originalTargetPaneIds");
+				logger$1.debug("No target pane IDs found for editor pane");
 				process.exit(1);
 			}
 			let focused = false;
-			for (const paneId of originalTargetPaneIds) if (await checkPaneExists$1(paneId)) {
-				await focusPane$1(paneId);
+			for (const paneId of originalTargetPaneIds) if (await checkPaneExists(paneId)) {
+				await focusPane(paneId);
 				focused = true;
 				break;
 			}
 			if (!focused) {
-				console.log("All target panes do not exist");
+				logger$1.debug("All target panes do not exist");
 				process.exit(1);
 			}
 			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");
+		logger$1.debug("Current pane is not an editor pane");
+		const editorPaneId = await getEditorPaneId(targetPane);
+		logger$1.debug("wezterm editorPaneId: {editorPaneId}", { editorPaneId });
+		if (editorPaneId === "") {
+			logger$1.debug("Editor pane ID not found");
 			process.exit(1);
 		}
-		if (!await checkPaneExists$1(editorPaneId$1)) {
-			console.log("Not exist editorPaneId");
-			await clearEditorPaneId$1(targetPane);
+		if (!await checkPaneExists(editorPaneId)) {
+			logger$1.debug("Editor pane does not exist");
+			await clearEditorPaneId(targetPane);
 			process.exit(1);
 		}
 		try {
-			await focusPane$1(editorPaneId$1);
+			await focusPane(editorPaneId);
 			process.exit(0);
 		} catch (error) {
-			console.log(`Can't focus editorPaneId: ${editorPaneId$1}\nerror: ${error}`);
+			logger$1.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
+				editorPaneId,
+				error
+			});
 			process.exit(1);
 		}
 	}
-	const currentPaneId = await getCurrentPaneId();
+	const currentPaneId = await getCurrentPaneId$1();
 	if (await isEditorPane(currentPaneId)) {
-		const originalTargetPaneIds = await getTargetPaneIds(currentPaneId);
+		const originalTargetPaneIds = await getTargetPaneIds$1(currentPaneId);
 		if (originalTargetPaneIds.length === 0) process.exit(1);
 		let focused = false;
-		for (const paneId of originalTargetPaneIds) if (await checkPaneExists(paneId)) {
-			await focusPane(paneId);
+		for (const paneId of originalTargetPaneIds) if (await checkPaneExists$1(paneId)) {
+			await focusPane$1(paneId);
 			focused = true;
 			break;
 		}
 		if (!focused) process.exit(1);
 		process.exit(0);
 	}
-	const editorPaneId = await getEditorPaneId(targetPane);
+	const editorPaneId = await getEditorPaneId$1(targetPane);
 	if (editorPaneId === "") process.exit(1);
-	if (!await checkPaneExists(editorPaneId)) {
-		await clearEditorPaneId(targetPane);
+	if (!await checkPaneExists$1(editorPaneId)) {
+		await clearEditorPaneId$1(targetPane);
 		process.exit(1);
 	}
-	await focusPane(editorPaneId);
+	await focusPane$1(editorPaneId);
 	process.exit(0);
 }
 const resumeCommand = define({
@@ -1023,15 +1168,24 @@ const resumeCommand = define({
 	description: "Resume existing editor pane or focus back to target pane",
 	args: {
 		mux: ARG_MUX,
-		"target-pane": ARG_TARGET_PANE_SINGLE
+		"target-pane": ARG_TARGET_PANE_SINGLE,
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
 	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		await runResumeMode(validateTargetPane(ctx.values["target-pane"], "resume"), validateMux(ctx.values.mux));
 	}
 });
 
 //#endregion
 //#region src/modes/stash.ts
+const logger = getLogger(["editprompt", "stash"]);
 function getStashKey(mux, targetPaneId) {
 	return `${mux}.targetPane.pane_${targetPaneId}.stash`;
 }
@@ -1078,21 +1232,21 @@ async function getTargetPaneForStash() {
 	let currentPaneId;
 	let isEditor;
 	if (config.mux === "tmux") {
-		currentPaneId = await getCurrentPaneId();
+		currentPaneId = await getCurrentPaneId$1();
 		isEditor = await isEditorPane(currentPaneId);
 	} else {
-		currentPaneId = await getCurrentPaneId$1();
+		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
 	}
 	if (!isEditor) {
-		console.error("Error: Current pane is not an editor pane");
+		logger.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 (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
+	else targetPanes = await getTargetPaneIds(currentPaneId);
 	if (targetPanes.length === 0) {
-		console.error("Error: No target panes registered for this editor pane");
+		logger.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	return {
@@ -1103,13 +1257,13 @@ async function getTargetPaneForStash() {
 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\"");
+		logger.error("Content is required for stash push");
+		logger.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}`);
+	logger.info("Stashed with key: {key}", { key });
 }
 async function runList() {
 	const { mux, targetPaneId } = await getTargetPaneForStash();
@@ -1120,8 +1274,8 @@ 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");
+		if (key) logger.error("No stash entry found with key: {key}", { key });
+		else logger.error("No stash entries found");
 		process.exit(1);
 	}
 	process.stdout.write(content);
@@ -1129,18 +1283,18 @@ async function runApply(key) {
 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");
+		if (key) logger.error("No stash entry found with key: {key}", { key });
+		else logger.error("No stash entries found");
 		process.exit(1);
 	}
-	console.log("Stash entry dropped");
+	logger.info("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");
+		if (key) logger.error("No stash entry found with key: {key}", { key });
+		else logger.error("No stash entries found");
 		process.exit(1);
 	}
 	process.stdout.write(content);
@@ -1169,8 +1323,17 @@ function parseKeyOption(args) {
 const stashCommand = define({
 	name: "stash",
 	description: "Stash prompts for later use",
-	args: {},
+	args: {
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
+	},
 	async run(ctx) {
+		setupLogger({
+			quiet: Boolean(ctx.values.quiet),
+			verbose: Boolean(ctx.values.verbose),
+			logFile: ctx.values["log-file"]
+		});
 		const args = ctx.positionals.slice(1);
 		if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
 			showHelp();
@@ -1195,8 +1358,8 @@ const stashCommand = define({
 				await runPop(parseKeyOption(subArgs));
 				break;
 			default:
-				console.error(`Error: Unknown subcommand '${subcommand}'`);
-				console.error("");
+				logger.error("Unknown subcommand '{subcommand}'", { subcommand });
+				logger.error("");
 				showHelp();
 				process.exit(1);
 		}
@@ -1210,16 +1373,18 @@ await cli(process.argv.slice(2), {
 	description: "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
 	args: {},
 	async run() {
-		console.error("Error: Subcommand is required");
-		console.error("");
-		console.error("Migration guide from old to new syntax:");
-		console.error("  editprompt           → editprompt open");
-		console.error("  editprompt --resume  → editprompt resume");
-		console.error("  editprompt -- \"text\" → editprompt input \"text\"");
-		console.error("  editprompt --quote   → editprompt collect");
-		console.error("  editprompt --capture → editprompt dump");
-		console.error("");
-		console.error("For details: https://github.com/eetann/editprompt/?tab=readme-ov-file");
+		setupLogger();
+		const logger = getLogger(["editprompt"]);
+		logger.error("Subcommand is required");
+		logger.error("");
+		logger.error("Migration guide from old to new syntax:");
+		logger.error("  editprompt           → editprompt open");
+		logger.error("  editprompt --resume  → editprompt resume");
+		logger.error("  editprompt -- \"text\" → editprompt input \"text\"");
+		logger.error("  editprompt --quote   → editprompt collect");
+		logger.error("  editprompt --capture → editprompt dump");
+		logger.error("");
+		logger.error("For details: https://github.com/eetann/editprompt/?tab=readme-ov-file");
 		process.exit(1);
 	}
 }, {

package/package.json

@@ -1,31 +1,33 @@
 {
   "name": "editprompt",
-  "version": "1.2.0",
-  "author": "eetann",
+  "version": "1.3.0",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
+  "keywords": [
+    "cli",
+    "clipboard",
+    "command-line",
+    "editor",
+    "prompt",
+    "text-editor",
+    "tmux"
+  ],
+  "homepage": "https://github.com/eetann/editprompt",
+  "bugs": {
+    "url": "https://github.com/eetann/editprompt/issues"
+  },
   "license": "MIT",
+  "author": "eetann",
   "repository": {
     "type": "git",
     "url": "https://github.com/eetann/editprompt.git"
   },
-  "homepage": "https://github.com/eetann/editprompt",
-  "bugs": {
-    "url": "https://github.com/eetann/editprompt/issues"
+  "bin": {
+    "editprompt": "./dist/index.js"
   },
-  "keywords": [
-    "cli",
-    "editor",
-    "prompt",
-    "tmux",
-    "clipboard",
-    "command-line",
-    "text-editor"
+  "files": [
+    "dist"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "type": "module",
-  "files": ["dist"],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,31 +35,35 @@
     ".": "./dist/index.js",
     "./package.json": "./package.json"
   },
-  "bin": {
-    "editprompt": "./dist/index.js"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "lint": "biome check",
-    "format": "biome format --write",
+    "lint": "oxlint --type-aware && oxfmt --check",
+    "lint:fix": "oxlint --type-aware --fix && oxfmt",
+    "format": "oxfmt --write .",
     "typecheck": "tsgo --noEmit",
     "release": "bun run lint && bun run typecheck && bun run test && bun run build && bumpp",
     "test": "bun test",
     "test:watch": "bun test --watch"
   },
+  "dependencies": {
+    "@logtape/logtape": "^2.0.2",
+    "clipboardy": "^4.0.0",
+    "conf": "^15.0.2",
+    "gunshi": "^0.29.2"
+  },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
     "@types/bun": "^1.3.2",
     "@types/node": "^24.10.1",
     "@typescript/native-preview": "^7.0.0-dev.20251119.1",
     "bumpp": "^10.3.1",
-    "tsdown": "latest"
-  },
-  "dependencies": {
-    "clipboardy": "^4.0.0",
-    "conf": "^15.0.2",
-    "gunshi": "v0.27.0-beta.3"
+    "oxfmt": "^0.35.0",
+    "oxlint": "^1.50.0",
+    "oxlint-tsgolint": "^0.15.0",
+    "tsdown": "^0.20.3"
   },
   "peerDependencies": {
     "typescript": "^5.8.3"