@makefinks/daemon 0.1.0

package/src/hooks/use-app-callbacks.ts

@@ -0,0 +1,202 @@
+import { useCallback } from "react";
+import { setOpenRouterProviderTag, setResponseModel } from "../ai/model-config";
+import { setAudioDevice } from "../voice/audio-recorder";
+import { getDaemonManager } from "../state/daemon-state";
+import type {
+	AppPreferences,
+	AudioDevice,
+	ModelOption,
+	OnboardingStep,
+	ReasoningEffort,
+	SpeechSpeed,
+	VoiceInteractionType,
+} from "../types";
+import { determineNextStep } from "./keyboard-handlers";
+
+export interface UseAppCallbacksParams {
+	currentModelId: string;
+	setCurrentModelId: (modelId: string) => void;
+	setCurrentDevice: (deviceName: string | undefined) => void;
+	setCurrentOutputDevice: (deviceName: string | undefined) => void;
+	setCurrentOpenRouterProviderTag: (tag: string | undefined) => void;
+	setInteractionMode: (mode: "text" | "voice") => void;
+	setVoiceInteractionType: (type: VoiceInteractionType) => void;
+	setSpeechSpeed: (speed: SpeechSpeed) => void;
+	setReasoningEffort: (effort: ReasoningEffort) => void;
+	persistPreferences: (updates: Partial<AppPreferences>) => void;
+	loadedPreferences: AppPreferences | null;
+	onboardingStep: OnboardingStep;
+	setOnboardingStep: (step: OnboardingStep) => void;
+	apiKeyTextareaRef: React.RefObject<{ plainText?: string; setText: (v: string) => void } | null>;
+	setShowDeviceMenu: (show: boolean) => void;
+	setShowModelMenu: (show: boolean) => void;
+	setShowProviderMenu: (show: boolean) => void;
+	setShowSettingsMenu: (show: boolean) => void;
+	setShowSessionMenu: (show: boolean) => void;
+	setOnboardingActive: (active: boolean) => void;
+}
+
+export interface UseAppCallbacksReturn {
+	handleDeviceSelect: (device: AudioDevice) => void;
+	handleOutputDeviceSelect: (device: AudioDevice) => void;
+	handleModelSelect: (model: ModelOption) => void;
+	handleProviderSelect: (providerTag: string | undefined) => void;
+	toggleInteractionMode: () => void;
+	completeOnboarding: () => void;
+	handleApiKeySubmit: () => void;
+}
+
+export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksReturn {
+	const {
+		currentModelId,
+		setCurrentModelId,
+		setCurrentDevice,
+		setCurrentOutputDevice,
+		setCurrentOpenRouterProviderTag,
+		setInteractionMode,
+		setVoiceInteractionType,
+		setSpeechSpeed,
+		setReasoningEffort,
+		persistPreferences,
+		loadedPreferences,
+		onboardingStep,
+		setOnboardingStep,
+		apiKeyTextareaRef,
+		setShowDeviceMenu,
+		setShowModelMenu,
+		setShowProviderMenu,
+		setShowSettingsMenu,
+		setShowSessionMenu,
+		setOnboardingActive,
+	} = params;
+
+	const handleDeviceSelect = useCallback(
+		(device: AudioDevice) => {
+			setAudioDevice(device.name);
+			setCurrentDevice(device.name);
+			persistPreferences({ audioDeviceName: device.name });
+		},
+		[setCurrentDevice, persistPreferences]
+	);
+
+	const handleOutputDeviceSelect = useCallback(
+		(device: AudioDevice) => {
+			const manager = getDaemonManager();
+			manager.outputDeviceName = device.name;
+			setCurrentOutputDevice(device.name);
+			persistPreferences({ audioOutputDeviceName: device.name });
+		},
+		[setCurrentOutputDevice, persistPreferences]
+	);
+
+	const handleModelSelect = useCallback(
+		(model: ModelOption) => {
+			if (model.id !== currentModelId) {
+				setResponseModel(model.id);
+				setOpenRouterProviderTag(undefined);
+				setCurrentModelId(model.id);
+				setCurrentOpenRouterProviderTag(undefined);
+				persistPreferences({
+					modelId: model.id,
+					openRouterProviderTag: undefined,
+				});
+			}
+		},
+		[currentModelId, setCurrentModelId, setCurrentOpenRouterProviderTag, persistPreferences]
+	);
+
+	const handleProviderSelect = useCallback(
+		(providerTag: string | undefined) => {
+			setOpenRouterProviderTag(providerTag);
+			setCurrentOpenRouterProviderTag(providerTag);
+			persistPreferences({ openRouterProviderTag: providerTag });
+		},
+		[setCurrentOpenRouterProviderTag, persistPreferences]
+	);
+
+	const toggleInteractionMode = useCallback(() => {
+		const mgr = getDaemonManager();
+		const newMode = mgr.interactionMode === "text" ? "voice" : "text";
+		if (newMode === "voice" && !process.env.OPENAI_API_KEY) {
+			return;
+		}
+		mgr.interactionMode = newMode;
+		setInteractionMode(newMode);
+	}, [setInteractionMode]);
+
+	const completeOnboarding = useCallback(() => {
+		persistPreferences({ onboardingCompleted: true });
+		setShowDeviceMenu(false);
+		setShowModelMenu(false);
+		setShowProviderMenu(false);
+		setShowSettingsMenu(false);
+		setShowSessionMenu(false);
+		setOnboardingActive(false);
+		setOnboardingStep("complete");
+	}, [
+		persistPreferences,
+		setShowDeviceMenu,
+		setShowModelMenu,
+		setShowProviderMenu,
+		setShowSettingsMenu,
+		setShowSessionMenu,
+		setOnboardingActive,
+		setOnboardingStep,
+	]);
+
+	const handleApiKeySubmit = useCallback(() => {
+		const key = (apiKeyTextareaRef.current?.plainText ?? "").trim();
+		if (!key) return;
+
+		if (onboardingStep === "openrouter_key") {
+			process.env.OPENROUTER_API_KEY = key;
+			persistPreferences({ openRouterApiKey: key });
+			const nextStep = determineNextStep("openrouter_key", loadedPreferences);
+			if (nextStep === "complete") {
+				persistPreferences({ onboardingCompleted: true });
+				completeOnboarding();
+			} else {
+				setOnboardingStep(nextStep);
+			}
+		} else if (onboardingStep === "openai_key") {
+			process.env.OPENAI_API_KEY = key;
+			persistPreferences({ openAiApiKey: key });
+			const nextStep = determineNextStep("openai_key", loadedPreferences);
+			if (nextStep === "complete") {
+				persistPreferences({ onboardingCompleted: true });
+				completeOnboarding();
+			} else {
+				setOnboardingStep(nextStep);
+			}
+		} else if (onboardingStep === "exa_key") {
+			process.env.EXA_API_KEY = key;
+			persistPreferences({ exaApiKey: key });
+			const nextStep = determineNextStep("exa_key", loadedPreferences);
+			if (nextStep === "complete") {
+				persistPreferences({ onboardingCompleted: true });
+				completeOnboarding();
+			} else {
+				setOnboardingStep(nextStep);
+			}
+		}
+
+		apiKeyTextareaRef.current?.setText("");
+	}, [
+		onboardingStep,
+		persistPreferences,
+		loadedPreferences,
+		completeOnboarding,
+		setOnboardingStep,
+		apiKeyTextareaRef,
+	]);
+
+	return {
+		handleDeviceSelect,
+		handleOutputDeviceSelect,
+		handleModelSelect,
+		handleProviderSelect,
+		toggleInteractionMode,
+		completeOnboarding,
+		handleApiKeySubmit,
+	};
+}

package/src/hooks/use-app-context-builder.ts

@@ -0,0 +1,159 @@
+import type { TextareaRenderable } from "@opentui/core";
+import { type MutableRefObject, useMemo } from "react";
+import type { ProviderMenuItem } from "../components/ProviderMenu";
+import type {
+	AppContextValue,
+	DeviceCallbacks,
+	GroundingCallbacks,
+	ModelCallbacks,
+	OnboardingCallbacks,
+	SessionCallbacks,
+	SettingsCallbacks,
+} from "../state/app-context";
+import type {
+	AppPreferences,
+	AudioDevice,
+	BashApprovalLevel,
+	GroundingMap,
+	ModelOption,
+	OnboardingStep,
+	ReasoningEffort,
+	SessionInfo,
+	SpeechSpeed,
+	VoiceInteractionType,
+} from "../types";
+
+export interface UseAppContextBuilderParams {
+	menus: {
+		showDeviceMenu: boolean;
+		setShowDeviceMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showSettingsMenu: boolean;
+		setShowSettingsMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showModelMenu: boolean;
+		setShowModelMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showProviderMenu: boolean;
+		setShowProviderMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showSessionMenu: boolean;
+		setShowSessionMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showHotkeysPane: boolean;
+		setShowHotkeysPane: React.Dispatch<React.SetStateAction<boolean>>;
+		showGroundingMenu: boolean;
+		setShowGroundingMenu: React.Dispatch<React.SetStateAction<boolean>>;
+	};
+
+	device: {
+		devices: AudioDevice[];
+		currentDevice: string | undefined;
+		setCurrentDevice: (deviceName: string | undefined) => void;
+		currentOutputDevice: string | undefined;
+		setCurrentOutputDevice: (deviceName: string | undefined) => void;
+		deviceLoadTimedOut: boolean;
+		soxAvailable: boolean;
+		soxInstallHint: string;
+	};
+
+	settings: {
+		interactionMode: "text" | "voice";
+		voiceInteractionType: VoiceInteractionType;
+		speechSpeed: SpeechSpeed;
+		reasoningEffort: ReasoningEffort;
+		bashApprovalLevel: BashApprovalLevel;
+		supportsReasoning: boolean;
+		canEnableVoiceOutput: boolean;
+		showFullReasoning: boolean;
+		setShowFullReasoning: (show: boolean) => void;
+		showToolOutput: boolean;
+		setShowToolOutput: (show: boolean) => void;
+		setBashApprovalLevel: (level: BashApprovalLevel) => void;
+		persistPreferences: (updates: Partial<AppPreferences>) => void;
+	};
+
+	model: {
+		curatedModels: ModelOption[];
+		openRouterModels: ModelOption[];
+		openRouterModelsLoading: boolean;
+		openRouterModelsUpdatedAt: number | null;
+		currentModelId: string;
+		setCurrentModelId: (modelId: string) => void;
+		providerMenuItems: ProviderMenuItem[];
+		currentOpenRouterProviderTag: string | undefined;
+	};
+
+	session: {
+		sessionMenuItems: Array<SessionInfo & { isNew: boolean }>;
+		currentSessionId: string | null;
+	};
+
+	grounding: {
+		latestGroundingMap: GroundingMap | null;
+		groundingInitialIndex: number;
+		groundingSelectedIndex: number;
+		setGroundingSelectedIndex: (index: number) => void;
+	};
+
+	onboarding: {
+		onboardingActive: boolean;
+		onboardingStep: OnboardingStep;
+		setOnboardingStep: (step: OnboardingStep) => void;
+		onboardingPreferences: AppPreferences | null;
+		apiKeyTextareaRef: MutableRefObject<TextareaRenderable | null>;
+	};
+
+	deviceCallbacks: DeviceCallbacks;
+	settingsCallbacks: SettingsCallbacks;
+	modelCallbacks: ModelCallbacks;
+	sessionCallbacks: SessionCallbacks;
+	groundingCallbacks: GroundingCallbacks;
+	onboardingCallbacks: OnboardingCallbacks;
+}
+
+export function useAppContextBuilder(params: UseAppContextBuilderParams): AppContextValue {
+	const {
+		menus,
+		device,
+		settings,
+		model,
+		session,
+		grounding,
+		onboarding,
+		deviceCallbacks,
+		settingsCallbacks,
+		modelCallbacks,
+		sessionCallbacks,
+		groundingCallbacks,
+		onboardingCallbacks,
+	} = params;
+
+	return useMemo(
+		(): AppContextValue => ({
+			menus,
+			device,
+			settings,
+			model,
+			session,
+			grounding,
+			onboarding,
+			deviceCallbacks,
+			settingsCallbacks,
+			modelCallbacks,
+			sessionCallbacks,
+			groundingCallbacks,
+			onboardingCallbacks,
+		}),
+		[
+			menus,
+			device,
+			settings,
+			model,
+			session,
+			grounding,
+			onboarding,
+			deviceCallbacks,
+			settingsCallbacks,
+			modelCallbacks,
+			sessionCallbacks,
+			groundingCallbacks,
+			onboardingCallbacks,
+		]
+	);
+}

package/src/hooks/use-app-display-state.ts

@@ -0,0 +1,162 @@
+import { useMemo } from "react";
+import { DaemonState } from "../types";
+import type { ContentBlock, SessionInfo } from "../types";
+import type { ModelMetadata } from "../utils/model-metadata";
+import { COLORS, STATE_COLOR_HEX, STATUS_TEXT } from "../ui/constants";
+import { formatElapsedTime } from "../utils/formatters";
+
+export interface UseAppDisplayStateParams {
+	daemonState: DaemonState;
+	currentContentBlocks: ContentBlock[];
+	currentResponse: string;
+	reasoningDisplay: string;
+	reasoningQueue: string;
+	responseElapsedMs: number;
+	hasInteracted: boolean;
+
+	currentModelId: string;
+	modelMetadata: ModelMetadata | null;
+	preferencesLoaded: boolean;
+
+	currentSessionId: string | null;
+	sessionMenuItems: Array<SessionInfo & { isNew: boolean }>;
+
+	terminalWidth: number;
+	terminalHeight: number;
+}
+
+export interface UseAppDisplayStateReturn {
+	isToolCalling: boolean;
+	isReasoning: boolean;
+	statusText: string;
+	statusColor: string;
+	showWorkingSpinner: boolean;
+	workingSpinnerLabel: string;
+	modelName: string | undefined;
+	sessionTitle: string | undefined;
+	avatarWidth: number;
+	avatarHeight: number;
+	frostColor: string;
+	isListening: boolean;
+	isListeningDim: boolean;
+}
+
+const AVATAR_WIDTH_PERCENT = 0.8;
+const AVATAR_HEIGHT_PERCENT = 0.8;
+const AVATAR_MIN_WIDTH = 80;
+const AVATAR_MAX_WIDTH = 500;
+const AVATAR_MIN_HEIGHT = 40;
+const AVATAR_MAX_HEIGHT = 300;
+
+export function useAppDisplayState(params: UseAppDisplayStateParams): UseAppDisplayStateReturn {
+	const {
+		daemonState,
+		currentContentBlocks,
+		currentResponse,
+		reasoningDisplay,
+		reasoningQueue,
+		responseElapsedMs,
+		hasInteracted,
+		currentModelId,
+		modelMetadata,
+		preferencesLoaded,
+		currentSessionId,
+		sessionMenuItems,
+		terminalWidth,
+		terminalHeight,
+	} = params;
+
+	const isToolCalling = useMemo(() => {
+		if (daemonState !== DaemonState.RESPONDING) return false;
+		return currentContentBlocks.some((b) => b.type === "tool" && b.call.status === "running");
+	}, [daemonState, currentContentBlocks]);
+
+	const isReasoning =
+		daemonState === DaemonState.RESPONDING &&
+		!isToolCalling &&
+		(!currentResponse || !!reasoningDisplay || !!reasoningQueue);
+
+	const statusText = useMemo(() => {
+		if (daemonState === DaemonState.RESPONDING) {
+			if (isToolCalling) {
+				return "DAEMON INVOKES TOOL... · ESC cancel · T reasoning";
+			}
+			return isReasoning
+				? "DAEMON REASONING... · ESC cancel · T reasoning"
+				: "DAEMON SPEAKS... · ESC cancel · T reasoning";
+		}
+		let baseStatus = STATUS_TEXT[daemonState];
+		if (daemonState === DaemonState.IDLE) {
+			if (hasInteracted) {
+				baseStatus = "SPACE speak · SHIFT+TAB type · N new · ? hotkeys";
+			}
+		}
+		return baseStatus;
+	}, [daemonState, isToolCalling, isReasoning, hasInteracted]);
+
+	const statusColor = isToolCalling
+		? COLORS.STATUS_RUNNING
+		: isReasoning
+			? COLORS.REASONING
+			: STATE_COLOR_HEX[daemonState];
+
+	const showWorkingSpinner = hasInteracted && daemonState === DaemonState.RESPONDING;
+	const responseElapsedLabel = formatElapsedTime(responseElapsedMs);
+	const workingSpinnerLabel = isToolCalling
+		? `CALLING TOOL... · ${responseElapsedLabel}`
+		: isReasoning
+			? `REASONING... · ${responseElapsedLabel}`
+			: `RESPONDING... · ${responseElapsedLabel}`;
+
+	const modelName = useMemo(() => {
+		if (!preferencesLoaded) return undefined;
+		if (modelMetadata?.name && modelMetadata.id === currentModelId) {
+			return modelMetadata.name;
+		}
+		return undefined;
+	}, [modelMetadata, currentModelId, preferencesLoaded]);
+
+	const sessionTitle = useMemo(() => {
+		if (!currentSessionId) return undefined;
+		const session = sessionMenuItems.find((s) => s.id === currentSessionId);
+		return session?.title;
+	}, [currentSessionId, sessionMenuItems]);
+
+	const avatarWidth = useMemo(
+		() =>
+			Math.max(
+				AVATAR_MIN_WIDTH,
+				Math.min(AVATAR_MAX_WIDTH, Math.floor(terminalWidth * AVATAR_WIDTH_PERCENT))
+			),
+		[terminalWidth]
+	);
+
+	const avatarHeight = useMemo(
+		() =>
+			Math.max(
+				AVATAR_MIN_HEIGHT,
+				Math.min(AVATAR_MAX_HEIGHT, Math.floor(terminalHeight * AVATAR_HEIGHT_PERCENT))
+			),
+		[terminalHeight]
+	);
+
+	const frostColor = hasInteracted ? "#05050940" : COLORS.BACKGROUND;
+	const isListening = daemonState === DaemonState.LISTENING || daemonState === DaemonState.TRANSCRIBING;
+	const isListeningDim = isListening && hasInteracted;
+
+	return {
+		isToolCalling,
+		isReasoning,
+		statusText,
+		statusColor,
+		showWorkingSpinner,
+		workingSpinnerLabel,
+		modelName,
+		sessionTitle,
+		avatarWidth,
+		avatarHeight,
+		frostColor,
+		isListening,
+		isListeningDim,
+	};
+}

package/src/hooks/use-app-menus.ts

@@ -0,0 +1,51 @@
+import { useState } from "react";
+
+export interface UseAppMenusReturn {
+	showDeviceMenu: boolean;
+	setShowDeviceMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showSettingsMenu: boolean;
+	setShowSettingsMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showModelMenu: boolean;
+	setShowModelMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showProviderMenu: boolean;
+	setShowProviderMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showSessionMenu: boolean;
+	setShowSessionMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showHotkeysPane: boolean;
+	setShowHotkeysPane: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showGroundingMenu: boolean;
+	setShowGroundingMenu: React.Dispatch<React.SetStateAction<boolean>>;
+}
+
+export function useAppMenus(): UseAppMenusReturn {
+	const [showDeviceMenu, setShowDeviceMenu] = useState(false);
+	const [showSettingsMenu, setShowSettingsMenu] = useState(false);
+	const [showModelMenu, setShowModelMenu] = useState(false);
+	const [showProviderMenu, setShowProviderMenu] = useState(false);
+	const [showSessionMenu, setShowSessionMenu] = useState(false);
+	const [showHotkeysPane, setShowHotkeysPane] = useState(false);
+	const [showGroundingMenu, setShowGroundingMenu] = useState(false);
+
+	return {
+		showDeviceMenu,
+		setShowDeviceMenu,
+		showSettingsMenu,
+		setShowSettingsMenu,
+		showModelMenu,
+		setShowModelMenu,
+		showProviderMenu,
+		setShowProviderMenu,
+		showSessionMenu,
+		setShowSessionMenu,
+		showHotkeysPane,
+		setShowHotkeysPane,
+		showGroundingMenu,
+		setShowGroundingMenu,
+	};
+}

package/src/hooks/use-app-model-pricing-loader.ts

@@ -0,0 +1,45 @@
+import { useEffect } from "react";
+import type { ModelOption } from "../types";
+import { AVAILABLE_MODELS } from "../ai/model-config";
+import { getModelsMetadata } from "../utils/model-metadata";
+
+export interface UseAppModelPricingLoaderParams {
+	preferencesLoaded: boolean;
+	setModelsWithPricing: React.Dispatch<React.SetStateAction<ModelOption[]>>;
+}
+
+export function useAppModelPricingLoader(params: UseAppModelPricingLoaderParams): void {
+	const { preferencesLoaded, setModelsWithPricing } = params;
+
+	useEffect(() => {
+		if (!preferencesLoaded) return;
+
+		let cancelled = false;
+
+		(async () => {
+			try {
+				const modelIds = AVAILABLE_MODELS.map((m) => m.id);
+				const metadata = await getModelsMetadata(modelIds);
+				if (cancelled) return;
+
+				const modelsWithPrices: ModelOption[] = AVAILABLE_MODELS.map((model) => {
+					const meta = metadata.get(model.id);
+					return {
+						...model,
+						name: meta?.name ?? model.name,
+						pricing: meta?.pricing,
+						contextLength: meta?.contextLength,
+						supportsCaching: meta?.supportsCaching,
+					};
+				});
+				setModelsWithPricing(modelsWithPrices);
+			} catch (_err: unknown) {
+				// Silently fail - models will just not show pricing.
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, [preferencesLoaded, setModelsWithPricing]);
+}