@makefinks/daemon 0.1.0

package/src/hooks/use-daemon-keyboard.ts

@@ -0,0 +1,397 @@
+/**
+ * Hook for handling keyboard input across all application states.
+ */
+
+import { useCallback } from "react";
+import type { KeyEvent } from "@opentui/core";
+import { useKeyboard } from "@opentui/react";
+import { toast } from "@opentui-ui/toast/react";
+import { COLORS } from "../ui/constants";
+import { getDaemonManager } from "../state/daemon-state";
+import { DaemonState, type AppPreferences } from "../types";
+import type { ScrollBoxRenderable } from "@opentui/core";
+export interface KeyboardHandlerState {
+	isOverlayOpen: boolean;
+	escPendingCancel: boolean;
+	hasInteracted: boolean;
+	hasGrounding: boolean;
+	showFullReasoning: boolean;
+	showToolOutput: boolean;
+}
+
+export interface KeyboardHandlerActions {
+	setShowDeviceMenu: (show: boolean) => void;
+	setShowSettingsMenu: (show: boolean) => void;
+	setShowModelMenu: (show: boolean) => void;
+	setShowProviderMenu: (show: boolean) => void;
+	setShowSessionMenu: (show: boolean) => void;
+	setShowHotkeysPane: (show: boolean) => void;
+	setShowGroundingMenu: (show: boolean) => void;
+	setTypingInput: (input: string | ((prev: string) => string)) => void;
+	setCurrentTranscription: (text: string) => void;
+	setCurrentResponse: (text: string) => void;
+	setApiKeyMissingError: (msg: string) => void;
+	setEscPendingCancel: (pending: boolean) => void;
+	setShowFullReasoning: (show: boolean | ((prev: boolean) => boolean)) => void;
+	setShowToolOutput: (show: boolean | ((prev: boolean) => boolean)) => void;
+	persistPreferences: (updates: Partial<AppPreferences>) => void;
+	clearReasoningState: () => void;
+	currentUserInputRef: React.RefObject<string>;
+	conversationScrollRef: React.RefObject<ScrollBoxRenderable | null>;
+	startNewSession: () => void;
+	undoLastTurn: () => void;
+}
+
+export function useDaemonKeyboard(state: KeyboardHandlerState, actions: KeyboardHandlerActions) {
+	const manager = getDaemonManager();
+	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding } = state;
+
+	const handleKeyPress = useCallback(
+		(key: KeyEvent) => {
+			const currentState = manager.state;
+
+			if (isOverlayOpen) return;
+
+			if (
+				key.eventType === "press" &&
+				!key.ctrl &&
+				!key.meta &&
+				!key.shift &&
+				currentState !== DaemonState.TYPING &&
+				(key.name === "up" || key.name === "down" || key.sequence === "k" || key.sequence === "j")
+			) {
+				const scrollbox = actions.conversationScrollRef.current;
+				const viewportHeight = scrollbox?.viewport?.height ?? 0;
+				if (!scrollbox || viewportHeight <= 0) return;
+
+				const maxScrollTop = Math.max(0, scrollbox.scrollHeight - viewportHeight);
+				const step = Math.max(1, Math.floor(viewportHeight * 0.1));
+				const delta = key.name === "up" || key.sequence === "k" ? -step : step;
+				const nextScrollTop = Math.max(0, Math.min(scrollbox.scrollTop + delta, maxScrollTop));
+				if (nextScrollTop !== scrollbox.scrollTop) {
+					scrollbox.scrollTop = nextScrollTop;
+				}
+				key.preventDefault();
+				return;
+			}
+
+			if (key.eventType === "press" && key.ctrl && (key.name === "u" || key.name === "d")) {
+				const scrollbox = actions.conversationScrollRef.current;
+				const viewportHeight = scrollbox?.viewport?.height ?? 0;
+				if (!scrollbox || viewportHeight <= 0) return;
+
+				const maxScrollTop = Math.max(0, scrollbox.scrollHeight - viewportHeight);
+				const delta = key.name === "u" ? -viewportHeight : viewportHeight;
+				const nextScrollTop = Math.max(0, Math.min(scrollbox.scrollTop + delta, maxScrollTop));
+				if (nextScrollTop !== scrollbox.scrollTop) {
+					scrollbox.scrollTop = nextScrollTop;
+				}
+				key.preventDefault();
+				return;
+			}
+
+			// 'D' key to open device menu (only in IDLE state before conversation starts)
+			if (
+				(key.sequence === "d" || key.sequence === "D") &&
+				key.eventType === "press" &&
+				currentState === DaemonState.IDLE &&
+				!hasInteracted
+			) {
+				actions.setShowModelMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowDeviceMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'L' key to open session menu (in IDLE or SPEAKING state)
+			if (
+				(key.sequence === "l" || key.sequence === "L") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
+			) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowModelMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowSessionMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'S' key to open settings menu (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "s" || key.sequence === "S") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowModelMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowSettingsMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'M' key to open model menu (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "m" || key.sequence === "M") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowModelMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'P' key to open provider menu (in IDLE or SPEAKING state)
+			if (
+				(key.sequence === "p" || key.sequence === "P") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
+			) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowModelMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowProviderMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'G' key to open grounding menu (in IDLE or SPEAKING state when grounding exists)
+			if (
+				(key.sequence === "g" || key.sequence === "G") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) &&
+				hasGrounding
+			) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowModelMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowHotkeysPane(false);
+				actions.setShowGroundingMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'N' key to start a new session (in IDLE or SPEAKING state)
+			if (
+				(key.sequence === "n" || key.sequence === "N") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
+			) {
+				actions.startNewSession();
+				key.preventDefault();
+				return;
+			}
+
+			// Ctrl+X to undo last turn (in IDLE or SPEAKING state)
+			if (
+				key.ctrl &&
+				(key.name === "x" || key.sequence === "\u0018") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
+			) {
+				actions.undoLastTurn();
+				key.preventDefault();
+				return;
+			}
+
+			// 'T' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "t" || key.sequence === "T") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				const next = !state.showFullReasoning;
+				actions.setShowFullReasoning(next);
+				actions.persistPreferences({ showFullReasoning: next });
+				toast.info(`FULL PREVIEWS: ${next ? "ON" : "OFF"}`, {
+					description: next
+						? "Reasoning blocks will display in full."
+						: "Reasoning blocks will show as a compact ticker.",
+					style: {
+						foregroundColor: next ? COLORS.DAEMON_TEXT : COLORS.ERROR,
+					},
+				});
+				key.preventDefault();
+				return;
+			}
+
+			// 'O' key to toggle tool output preview (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "o" || key.sequence === "O") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				const next = !state.showToolOutput;
+				actions.setShowToolOutput(next);
+				actions.persistPreferences({ showToolOutput: next });
+				toast.info(`TOOL OUTPUT: ${next ? "ON" : "OFF"}`, {
+					description: next ? "Tool outputs will be displayed." : "Tool outputs will be hidden.",
+					style: {
+						foregroundColor: next ? COLORS.DAEMON_TEXT : COLORS.ERROR,
+					},
+				});
+				key.preventDefault();
+				return;
+			}
+
+			// '?' key to show hotkeys pane
+			if (key.sequence === "?" && key.eventType === "press" && currentState !== DaemonState.TYPING) {
+				actions.setShowDeviceMenu(false);
+				actions.setShowSettingsMenu(false);
+				actions.setShowModelMenu(false);
+				actions.setShowProviderMenu(false);
+				actions.setShowSessionMenu(false);
+				actions.setShowGroundingMenu(false);
+				actions.setShowHotkeysPane(true);
+				key.preventDefault();
+				return;
+			}
+
+			// Space key for voice activation (toggle)
+			if (
+				key.name === "space" &&
+				key.eventType === "press" &&
+				!key.shift &&
+				!key.ctrl &&
+				!key.meta &&
+				currentState !== DaemonState.TYPING
+			) {
+				if (currentState === DaemonState.IDLE) {
+					// Check for OpenRouter API key first (needed for any AI response)
+					if (!process.env.OPENROUTER_API_KEY) {
+						actions.setApiKeyMissingError(
+							"OPENROUTER_API_KEY not found · Set via environment variable or enter in onboarding"
+						);
+						key.preventDefault();
+						return;
+					}
+					// Check for OpenAI API key (needed for voice transcription)
+					if (!process.env.OPENAI_API_KEY) {
+						actions.setApiKeyMissingError("Voice input is disabled because OpenAI API key is not set.");
+						key.preventDefault();
+						return;
+					}
+
+					// Clear any previous error
+					actions.setApiKeyMissingError("");
+					actions.setCurrentTranscription("");
+					actions.setCurrentResponse("");
+					manager.startListening();
+				} else if (currentState === DaemonState.LISTENING) {
+					manager.stopListening();
+				}
+				key.preventDefault();
+				return;
+			}
+
+			// Shift+Tab for typing mode
+			if (key.name === "tab" && key.shift && key.eventType === "press") {
+				if (currentState === DaemonState.IDLE) {
+					// Check for OpenRouter API key (needed for any AI response)
+					if (!process.env.OPENROUTER_API_KEY) {
+						actions.setApiKeyMissingError(
+							"OPENROUTER_API_KEY not found · Set via environment variable or enter in onboarding"
+						);
+						key.preventDefault();
+						return;
+					}
+
+					// Clear any previous error
+					actions.setApiKeyMissingError("");
+					actions.setCurrentTranscription("");
+					actions.setCurrentResponse("");
+					actions.setTypingInput("");
+					manager.enterTypingMode();
+				}
+				key.preventDefault();
+				return;
+			}
+
+			// Escape to cancel current action or exit typing mode
+			if (key.name === "escape" && key.eventType === "press") {
+				if (currentState === DaemonState.TYPING) {
+					manager.exitTypingMode();
+					actions.setTypingInput("");
+				} else if (currentState === DaemonState.LISTENING) {
+					manager.cancelCurrentAction();
+					actions.setCurrentTranscription("");
+					actions.setCurrentResponse("");
+					actions.clearReasoningState();
+					actions.currentUserInputRef.current = "";
+				} else if (currentState === DaemonState.SPEAKING) {
+					// Cancel TTS playback immediately with single ESC
+					manager.cancelCurrentAction();
+				} else if (currentState === DaemonState.TRANSCRIBING || currentState === DaemonState.RESPONDING) {
+					if (escPendingCancel) {
+						manager.cancelCurrentAction();
+						actions.setCurrentTranscription("");
+						actions.setCurrentResponse("");
+						actions.clearReasoningState();
+						actions.currentUserInputRef.current = "";
+						actions.setEscPendingCancel(false);
+					} else {
+						actions.setEscPendingCancel(true);
+					}
+				}
+				key.preventDefault();
+				return;
+			}
+
+			// Enter to submit in typing mode
+			if (key.name === "return" && key.eventType === "press" && currentState === DaemonState.TYPING) {
+				// Let the focused <input> handle submit (global handlers run first in OpenTUI).
+				return;
+			}
+
+			// Regular character input in typing mode (handled by <input> component)
+			if (currentState === DaemonState.TYPING && key.eventType === "press" && !key.ctrl && !key.meta) {
+				// Don't prevent default for regular keys so <input> can receive them
+				// except for those that might trigger global actions
+				return;
+			}
+		},
+		[
+			manager,
+			isOverlayOpen,
+			escPendingCancel,
+			hasInteracted,
+			hasGrounding,
+			state.showFullReasoning,
+			state.showToolOutput,
+			actions,
+		]
+	);
+
+	useKeyboard(handleKeyPress);
+}

package/src/hooks/use-grounding.ts

@@ -0,0 +1,46 @@
+import { useState, useEffect, useCallback } from "react";
+import type { GroundingMap } from "../types";
+import { loadLatestGroundingMap } from "../state/session-store";
+import { daemonEvents } from "../state/daemon-events";
+
+export interface UseGroundingReturn {
+	latestGroundingMap: GroundingMap | null;
+	hasGrounding: boolean;
+	refreshGrounding: () => Promise<void>;
+}
+
+export function useGrounding(sessionId: string | null): UseGroundingReturn {
+	const [latestGroundingMap, setLatestGroundingMap] = useState<GroundingMap | null>(null);
+
+	const refreshGrounding = useCallback(async () => {
+		if (!sessionId) {
+			setLatestGroundingMap(null);
+			return;
+		}
+		const map = await loadLatestGroundingMap(sessionId);
+		setLatestGroundingMap(map);
+	}, [sessionId]);
+
+	useEffect(() => {
+		void refreshGrounding();
+	}, [refreshGrounding]);
+
+	useEffect(() => {
+		const handleGroundingSaved = (savedSessionId: string) => {
+			if (savedSessionId === sessionId) {
+				void refreshGrounding();
+			}
+		};
+
+		daemonEvents.on("groundingSaved", handleGroundingSaved);
+		return () => {
+			daemonEvents.off("groundingSaved", handleGroundingSaved);
+		};
+	}, [sessionId, refreshGrounding]);
+
+	return {
+		latestGroundingMap,
+		hasGrounding: latestGroundingMap !== null && latestGroundingMap.items.length > 0,
+		refreshGrounding,
+	};
+}

package/src/hooks/use-input-history.ts

@@ -0,0 +1,92 @@
+import { useCallback, useRef, useState, useEffect } from "react";
+import { loadPreferences, updatePreferences } from "../utils/preferences";
+
+const MAX_HISTORY_SIZE = 20;
+
+export interface UseInputHistoryReturn {
+	addToHistory: (input: string) => void;
+	navigateUp: (currentInput: string) => string | null;
+	navigateDown: () => string | null;
+	resetNavigation: () => void;
+	isNavigating: boolean;
+}
+
+export function useInputHistory(): UseInputHistoryReturn {
+	const [history, setHistory] = useState<string[]>([]);
+	const navigationIndexRef = useRef<number>(-1);
+	const savedCurrentInputRef = useRef<string>("");
+	const isNavigatingRef = useRef<boolean>(false);
+
+	useEffect(() => {
+		loadPreferences().then((prefs) => {
+			if (prefs?.inputHistory) {
+				setHistory(prefs.inputHistory);
+			}
+		});
+	}, []);
+
+	const addToHistory = useCallback((input: string) => {
+		const trimmed = input.trim();
+		if (!trimmed) return;
+
+		setHistory((prev) => {
+			const filtered = prev.filter((item) => item !== trimmed);
+			const next = [trimmed, ...filtered].slice(0, MAX_HISTORY_SIZE);
+			void updatePreferences({ inputHistory: next });
+			return next;
+		});
+
+		navigationIndexRef.current = -1;
+		savedCurrentInputRef.current = "";
+		isNavigatingRef.current = false;
+	}, []);
+
+	const navigateUp = useCallback(
+		(currentInput: string): string | null => {
+			if (history.length === 0) return null;
+
+			if (!isNavigatingRef.current) {
+				savedCurrentInputRef.current = currentInput;
+				isNavigatingRef.current = true;
+				navigationIndexRef.current = 0;
+				return history[0] ?? null;
+			}
+
+			const nextIndex = navigationIndexRef.current + 1;
+			if (nextIndex >= history.length) return null;
+
+			navigationIndexRef.current = nextIndex;
+			return history[nextIndex] ?? null;
+		},
+		[history]
+	);
+
+	const navigateDown = useCallback((): string | null => {
+		if (!isNavigatingRef.current) return null;
+
+		const nextIndex = navigationIndexRef.current - 1;
+
+		if (nextIndex < 0) {
+			isNavigatingRef.current = false;
+			navigationIndexRef.current = -1;
+			return savedCurrentInputRef.current;
+		}
+
+		navigationIndexRef.current = nextIndex;
+		return history[nextIndex] ?? null;
+	}, [history]);
+
+	const resetNavigation = useCallback(() => {
+		navigationIndexRef.current = -1;
+		savedCurrentInputRef.current = "";
+		isNavigatingRef.current = false;
+	}, []);
+
+	return {
+		addToHistory,
+		navigateUp,
+		navigateDown,
+		resetNavigation,
+		isNavigating: isNavigatingRef.current,
+	};
+}

package/src/hooks/use-menu-keyboard.ts

@@ -0,0 +1,93 @@
+import type { KeyEvent } from "@opentui/core";
+import { useKeyboard } from "@opentui/react";
+import type { Dispatch, SetStateAction } from "react";
+import { useCallback, useEffect, useState } from "react";
+import { handleMenuKey, isNavigateDownKey, isNavigateUpKey } from "./menu-navigation";
+
+interface UseMenuKeyboardParams {
+	itemCount: number;
+	initialIndex?: number;
+	onClose: () => void;
+	onSelect: (selectedIndex: number) => void;
+	enableViKeys?: boolean;
+	closeOnSelect?: boolean;
+	ignoreEscape?: boolean;
+}
+
+interface UseMenuKeyboardReturn {
+	selectedIndex: number;
+	setSelectedIndex: Dispatch<SetStateAction<number>>;
+}
+
+export function useMenuKeyboard({
+	itemCount,
+	initialIndex = 0,
+	onClose,
+	onSelect,
+	enableViKeys = true,
+	closeOnSelect = true,
+	ignoreEscape = false,
+}: UseMenuKeyboardParams): UseMenuKeyboardReturn {
+	const [selectedIndex, setSelectedIndex] = useState(initialIndex);
+
+	useEffect(() => {
+		setSelectedIndex(initialIndex);
+	}, [initialIndex]);
+
+	useEffect(() => {
+		if (itemCount <= 0) {
+			setSelectedIndex(0);
+			return;
+		}
+		setSelectedIndex((prev) => {
+			if (prev < 0) return 0;
+			if (prev >= itemCount) return itemCount - 1;
+			return prev;
+		});
+	}, [itemCount]);
+
+	const handleKeyPress = useCallback(
+		(key: KeyEvent) => {
+			if (key.eventType !== "press") return;
+			if (ignoreEscape && key.name === "escape") {
+				return;
+			}
+
+			if (itemCount === 0) {
+				if (key.name === "escape") {
+					onClose();
+					key.preventDefault();
+					return;
+				}
+				if (
+					key.name === "return" ||
+					isNavigateUpKey(key, enableViKeys) ||
+					isNavigateDownKey(key, enableViKeys)
+				) {
+					key.preventDefault();
+				}
+				return;
+			}
+
+			const result = handleMenuKey(key, selectedIndex, itemCount, enableViKeys, closeOnSelect);
+			if (!result.handled) return;
+
+			setSelectedIndex(result.selectedIndex);
+
+			if (result.itemSelected) {
+				onSelect(result.selectedIndex);
+			}
+
+			if (result.shouldClose) {
+				onClose();
+			}
+
+			key.preventDefault();
+		},
+		[itemCount, selectedIndex, onClose, onSelect, enableViKeys, closeOnSelect]
+	);
+
+	useKeyboard(handleKeyPress);
+
+	return { selectedIndex, setSelectedIndex };
+}

package/src/hooks/use-playwright-notification.ts

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+import { toast } from "@opentui-ui/toast/react";
+import { detectLocalPlaywrightChromium } from "../utils/js-rendering";
+
+export function usePlaywrightNotification(): void {
+	useEffect(() => {
+		let cancelled = false;
+
+		void (async () => {
+			const capability = await detectLocalPlaywrightChromium();
+			if (cancelled) return;
+
+			if (capability.available) return;
+
+			const description = capability.hint ? `${capability.reason}\n\n${capability.hint}` : capability.reason;
+			toast.warning("JS-rendered pages unavailable", { description });
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+}