editprompt 1.1.1 → 1.3.0

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.1.1";
+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,81 +150,85 @@ 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
-//#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 });
-async function getCurrentPaneId$1() {
+
+//#endregion
+//#region src/modules/wezterm.ts
+const logger$9 = getLogger(["editprompt", "wezterm"]);
+const execAsync = promisify(exec);
+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) {
@@ -168,7 +237,7 @@ async function getTargetPaneIds$1(editorPaneId) {
 		}
 		return [];
 	} catch (error) {
-		console.log(error);
+		logger$9.debug("getTargetPaneIds failed: {error}", { error });
 		return [];
 	}
 }
@@ -176,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;
 	}
 }
@@ -194,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) {
@@ -203,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 "";
 	}
 }
@@ -212,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
@@ -234,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
@@ -358,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";
 }
@@ -371,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 {
@@ -385,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,
@@ -405,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
@@ -415,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,
@@ -433,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)",
@@ -467,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;
@@ -490,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) => {
@@ -513,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;
@@ -529,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);
 	}
 }
@@ -540,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);
@@ -551,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);
 			}
 		}
@@ -565,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 = [];
@@ -612,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();
 	}
 });
@@ -635,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;
@@ -692,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);
 	}
 }
@@ -712,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);
 	}
 });
 
@@ -822,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 {
@@ -847,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 {}
 	}
 }
@@ -872,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)",
@@ -880,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"]),
@@ -892,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);
 	}
 }
@@ -938,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"]),
@@ -951,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({
@@ -1020,13 +1168,204 @@ 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`;
+}
+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$1();
+		isEditor = await isEditorPane(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId();
+		isEditor = isEditorPaneFromConf(currentPaneId);
+	}
+	if (!isEditor) {
+		logger.error("Current pane is not an editor pane");
+		process.exit(1);
+	}
+	let targetPanes;
+	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
+	else targetPanes = await getTargetPaneIds(currentPaneId);
+	if (targetPanes.length === 0) {
+		logger.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() === "") {
+		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);
+	logger.info("Stashed with key: {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) logger.error("No stash entry found with key: {key}", { key });
+		else logger.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) logger.error("No stash entry found with key: {key}", { key });
+		else logger.error("No stash entries found");
+		process.exit(1);
+	}
+	logger.info("Stash entry dropped");
+}
+async function runPop(key) {
+	const { mux, targetPaneId } = await getTargetPaneForStash();
+	const content = getStashContent(mux, targetPaneId, key);
+	if (content === "") {
+		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);
+	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: {
+		"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();
+			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:
+				logger.error("Unknown subcommand '{subcommand}'", { subcommand });
+				logger.error("");
+				showHelp();
+				process.exit(1);
+		}
+	}
+});
+
 //#endregion
 //#region src/index.ts
 await cli(process.argv.slice(2), {
@@ -1034,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);
 	}
 }, {
@@ -1055,7 +1396,8 @@ await cli(process.argv.slice(2), {
 		resume: resumeCommand,
 		input: inputCommand,
 		collect: collectCommand,
-		dump: dumpCommand
+		dump: dumpCommand,
+		stash: stashCommand
 	},
 	renderHeader: null
 });