@codexstar/pi-listen 1.0.14 → 1.0.16

package/extensions/voice.ts

@@ -567,6 +567,7 @@ export default function (pi: ExtensionAPI) {
 	function voiceCleanup() {
 		if (statusTimer) { clearInterval(statusTimer); statusTimer = null; }
 		clearHoldTimer();
+		clearReleaseTimer();
 		stopRecordingWidgetAnimation();
 		if (activeSession) {
 			finalizeSession(activeSession);
@@ -636,23 +637,31 @@ export default function (pi: ExtensionAPI) {
 	/** Animated recording indicator with live waveform */
 	function showRecordingWidget(target: "editor" | "btw") {
 		if (!ctx?.hasUI) return;
-		let frame = 0;
-		const waveChars = ["▁", "▂", "▃", "▅", "▆", "▇", "▆", "▅", "▃", "▂"];
 
-		// Animate the widget every 200ms
+		// Store initial state — once live transcription arrives,
+		// updateLiveTranscriptWidget takes over and we stop the animation.
+		(showRecordingWidget as any)._target = target;
+		(showRecordingWidget as any)._frame = 0;
+		(showRecordingWidget as any)._hasTranscript = false;
+
+		// Animate the widget every 300ms (only while no transcript is showing)
 		const animTimer = setInterval(() => {
-			frame++;
-			if (ctx?.hasUI) ctx.ui.setWidget("voice-recording", undefined); // force re-render
-			showRecordingWidgetFrame(target, frame, waveChars);
-		}, 200);
+			// Stop animating once live transcript takes over
+			if ((showRecordingWidget as any)?._hasTranscript) return;
+
+			(showRecordingWidget as any)._frame = ((showRecordingWidget as any)._frame || 0) + 1;
+			showRecordingWidgetFrame(target, (showRecordingWidget as any)._frame);
+		}, 300);
 
 		// Store the timer so we can clean it up
 		(showRecordingWidget as any)._animTimer = animTimer;
 
-		showRecordingWidgetFrame(target, frame, waveChars);
+		showRecordingWidgetFrame(target, 0);
 	}
 
-	function showRecordingWidgetFrame(target: "editor" | "btw", frame: number, waveChars: string[]) {
+	const waveChars = ["▁", "▂", "▃", "▅", "▆", "▇", "▆", "▅", "▃", "▂"];
+
+	function showRecordingWidgetFrame(target: "editor" | "btw", frame: number) {
 		if (!ctx?.hasUI) return;
 		ctx.ui.setWidget("voice-recording", (tui, theme) => {
 			return {
@@ -691,7 +700,7 @@ export default function (pi: ExtensionAPI) {
 						? theme.fg("dim", "  Press Ctrl+Shift+B to stop")
 						: kittyReleaseDetected
 							? theme.fg("dim", "  Release SPACE to finalize")
-							: theme.fg("dim", "  Press SPACE again to stop");
+							: theme.fg("dim", "  Release SPACE to stop");
 
 					const lines = [
 						topBorder,
@@ -717,6 +726,10 @@ export default function (pi: ExtensionAPI) {
 	function updateLiveTranscriptWidget(interim: string, finals: string[]) {
 		if (!ctx?.hasUI) return;
 
+		// Stop the recording animation — live transcript takes over
+		(showRecordingWidget as any)._hasTranscript = true;
+		stopRecordingWidgetAnimation();
+
 		const finalized = finals.join(" ");
 		const displayText = finalized + (interim ? (finalized ? " " : "") + interim : "");
 
@@ -743,10 +756,7 @@ export default function (pi: ExtensionAPI) {
 					const label = theme.bold(theme.fg("accent", " VOICE "));
 					const timeStyled = theme.fg("muted", timeStr);
 					const titleLine = `  ${dot} ${label}  ${timeStyled}`;
-					const hint = kittyReleaseDetected
-						? theme.fg("dim", "  Release SPACE to finalize")
-						: theme.fg("dim", "  Press SPACE again to stop");
-
+					const hint = theme.fg("dim", "  Release SPACE to stop");
 					const lines = [topBorder, side(titleLine)];
 
 					if (!displayText.trim()) {
@@ -999,19 +1009,27 @@ export default function (pi: ExtensionAPI) {
 	// If SPACE is released before the threshold, a regular space character
 	// is typed into the editor (normal typing behavior).
 	//
-	// This prevents accidental voice activation when typing and matches
-	// Claude Code's hold-to-talk UX pattern.
+	// KEY DESIGN for non-Kitty terminals (no key-release events):
+	//   Holding a key generates rapid press events (~30ms apart). We detect
+	//   "release" by watching for the stream of space presses to STOP.
+	//   Once the gap exceeds RELEASE_DETECT_MS (200ms), we know the user
+	//   lifted their finger and we stop recording.
 	//
-	// For Kitty protocol terminals: hold → wait threshold → activate →
-	//   release → stop recording. True hold-to-talk.
-	// For non-Kitty terminals: hold → wait threshold → activate →
-	//   press SPACE again → stop recording. Toggle after activation.
+	// Flow:
+	//   Hold SPACE → rapid presses arrive → first press starts 500ms timer →
+	//   timer fires → recording starts → presses keep coming (consumed) →
+	//   user releases → presses stop → 200ms silence → auto-stop recording
+	//
+	// Kitty protocol terminals get true key-release events and work natively.
 
 	const HOLD_THRESHOLD_MS = 500; // minimum hold time before voice activates
+	const RELEASE_DETECT_MS = 200; // gap in key-repeat that means "released"
 	let kittyReleaseDetected = false;
-	let spaceDownTime: number | null = null; // timestamp when SPACE was first pressed
+	let spaceDownTime: number | null = null;
 	let holdActivationTimer: ReturnType<typeof setTimeout> | null = null;
-	let spaceConsumed = false; // whether we've committed to voice (past threshold)
+	let spaceConsumed = false;
+	let lastSpacePressTime = 0;
+	let releaseDetectTimer: ReturnType<typeof setTimeout> | null = null;
 
 	function clearHoldTimer() {
 		if (holdActivationTimer) {
@@ -1020,6 +1038,49 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	function clearReleaseTimer() {
+		if (releaseDetectTimer) {
+			clearTimeout(releaseDetectTimer);
+			releaseDetectTimer = null;
+		}
+	}
+
+	/** Called when we detect the user has released SPACE (non-Kitty) */
+	function onSpaceReleaseDetected() {
+		releaseDetectTimer = null;
+
+		// If we're still in the threshold wait (< 500ms), user just tapped space
+		if (spaceDownTime && !spaceConsumed) {
+			clearHoldTimer();
+			spaceDownTime = null;
+			spaceConsumed = false;
+			// Insert a space character
+			if (ctx?.hasUI) {
+				ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
+				hideHoldHintWidget();
+			}
+			return;
+		}
+
+		// If we're recording, stop
+		if (spaceConsumed && voiceState === "recording") {
+			isHolding = false;
+			spaceConsumed = false;
+			spaceDownTime = null;
+			stopVoiceRecording("editor");
+		}
+	}
+
+	/** Reset the release detection timer — called on every space press */
+	function resetReleaseDetect() {
+		clearReleaseTimer();
+		// If we're in a hold state (threshold pending or recording),
+		// start a timer to detect release
+		if (spaceDownTime || spaceConsumed || voiceState === "recording") {
+			releaseDetectTimer = setTimeout(onSpaceReleaseDetected, RELEASE_DETECT_MS);
+		}
+	}
+
 	function setupHoldToTalk() {
 		if (!ctx?.hasUI) return;
 
@@ -1034,6 +1095,7 @@ export default function (pi: ExtensionAPI) {
 				const editorText = ctx?.hasUI ? ctx.ui.getEditorText() : "";
 				if (editorText && editorText.trim().length > 0) {
 					clearHoldTimer();
+					clearReleaseTimer();
 					spaceDownTime = null;
 					spaceConsumed = false;
 					return undefined; // let the default space character through
@@ -1042,19 +1104,19 @@ export default function (pi: ExtensionAPI) {
 				// ── Kitty key-release ──
 				if (isKeyRelease(data)) {
 					kittyReleaseDetected = true;
+					clearReleaseTimer();
 
 					// Released before threshold → type a space character
 					if (spaceDownTime && !spaceConsumed) {
 						clearHoldTimer();
 						spaceDownTime = null;
 						spaceConsumed = false;
-						// Insert a space into editor
 						if (ctx?.hasUI) ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
 						return { consume: true };
 					}
 
 					// Released after threshold → stop recording (true hold-to-talk)
-					if (spaceConsumed && isHolding && voiceState === "recording") {
+					if (spaceConsumed && voiceState === "recording") {
 						isHolding = false;
 						spaceConsumed = false;
 						spaceDownTime = null;
@@ -1067,33 +1129,42 @@ export default function (pi: ExtensionAPI) {
 					return undefined;
 				}
 
-				// ── Kitty key-repeat: suppress while holding past threshold ──
+				// ── Kitty key-repeat: ALWAYS suppress while holding/recording ──
 				if (isKeyRepeat(data)) {
-					if (spaceConsumed || isHolding) return { consume: true };
+					if (spaceDownTime || spaceConsumed || isHolding || voiceState === "recording") {
+						resetReleaseDetect(); // keep resetting — still holding
+						return { consume: true };
+					}
 					return undefined;
 				}
 
 				// === Key PRESS ===
+				// In non-Kitty terminals, holding a key sends rapid press events.
+				// We use these to detect "still holding" and the gap to detect "released".
 
-				// If already recording (toggle mode for non-Kitty) → stop
-				if (voiceState === "recording" && spaceConsumed) {
-					isHolding = false;
-					spaceConsumed = false;
-					spaceDownTime = null;
-					clearHoldTimer();
-					stopVoiceRecording("editor");
-					return { consume: true };
-				}
+				// Reset release detection — user is still holding
+				resetReleaseDetect();
 
 				// If transcribing → ignore
 				if (voiceState === "transcribing") {
 					return { consume: true };
 				}
 
-				// Idle → start the hold timer
-				if (voiceState === "idle" && !spaceDownTime) {
+				// If already recording → just consume (release detect handles stop)
+				if (voiceState === "recording") {
+					return { consume: true };
+				}
+
+				// If we already started the hold timer, this is a repeat → consume
+				if (spaceDownTime) {
+					return { consume: true };
+				}
+
+				// Idle, first press → start the hold timer
+				if (voiceState === "idle") {
 					spaceDownTime = Date.now();
 					spaceConsumed = false;
+					lastSpacePressTime = Date.now();
 
 					// Show a subtle "preparing" indicator
 					if (ctx?.hasUI) {
@@ -1103,7 +1174,6 @@ export default function (pi: ExtensionAPI) {
 					// After threshold: activate voice recording
 					holdActivationTimer = setTimeout(() => {
 						holdActivationTimer = null;
-						// Double-check: still idle, still holding, editor still empty
 						const currentText = ctx?.hasUI ? ctx.ui.getEditorText() : "";
 						if (voiceState === "idle" && spaceDownTime && !(currentText && currentText.trim().length > 0)) {
 							spaceConsumed = true;
@@ -1121,7 +1191,7 @@ export default function (pi: ExtensionAPI) {
 						}
 					}, HOLD_THRESHOLD_MS);
 
-					return { consume: true }; // consume now — we'll insert space on early release
+					return { consume: true };
 				}
 
 				if (isHolding || spaceConsumed) return { consume: true };
@@ -1131,14 +1201,13 @@ export default function (pi: ExtensionAPI) {
 			// ── Any other key while holding space (pre-threshold) → cancel hold, insert space ──
 			if (spaceDownTime && !spaceConsumed && !matchesKey(data, "space")) {
 				clearHoldTimer();
-				// Insert the space that was consumed during hold detection
+				clearReleaseTimer();
 				if (ctx?.hasUI) {
 					ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
 					hideHoldHintWidget();
 				}
 				spaceDownTime = null;
 				spaceConsumed = false;
-				// Don't consume this key — let it through
 				return undefined;
 			}
 
@@ -1159,7 +1228,6 @@ export default function (pi: ExtensionAPI) {
 					return undefined;
 				}
 
-				// Toggle: stop if recording
 				if (voiceState === "recording") {
 					isHolding = false;
 					stopVoiceRecording("btw");
@@ -1326,9 +1394,19 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 			if (voiceState === "idle") {
-				await startVoiceRecording("editor");
+				// Direct start — bypass hold threshold
+				spaceConsumed = true;
+				isHolding = true;
+				const ok = await startVoiceRecording("editor");
+				if (!ok) {
+					isHolding = false;
+					spaceConsumed = false;
+				}
 			} else if (voiceState === "recording") {
 				isHolding = false;
+				spaceConsumed = false;
+				spaceDownTime = null;
+				clearHoldTimer();
 				await stopVoiceRecording("editor");
 			}
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexstar/pi-listen",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Voice input, first-run onboarding, and side-channel BTW conversations for Pi",
   "type": "module",
   "keywords": [