@makefinks/daemon 0.2.0 → 0.3.0

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

@@ -24,6 +24,7 @@ export interface KeyboardHandlerActions {
 	setShowHotkeysPane: (show: boolean) => void;
 	setShowGroundingMenu: (show: boolean) => void;
 	setShowUrlMenu: (show: boolean) => void;
+	setShowToolsMenu: (show: boolean) => void;
 	setTypingInput: (input: string | ((prev: string) => string)) => void;
 	setCurrentTranscription: (text: string) => void;
 	setCurrentResponse: (text: string) => void;
@@ -41,7 +42,7 @@ export interface KeyboardHandlerActions {
 
 export function useDaemonKeyboard(state: KeyboardHandlerState, actions: KeyboardHandlerActions) {
 	const manager = getDaemonManager();
-	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding } = state;
+	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding, showFullReasoning } = state;
 
 	const closeAllMenus = useCallback(() => {
 		actions.setShowDeviceMenu(false);
@@ -52,6 +53,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 		actions.setShowHotkeysPane(false);
 		actions.setShowGroundingMenu(false);
 		actions.setShowUrlMenu(false);
+		actions.setShowToolsMenu(false);
 	}, [actions]);
 
 	const handleKeyPress = useCallback(
@@ -163,11 +165,13 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				return;
 			}
 
-			// 'G' key to open grounding menu (in IDLE or SPEAKING state when grounding exists)
+			// 'G' key to open grounding menu (in IDLE, SPEAKING, or RESPONDING state when grounding exists)
 			if (
 				(key.sequence === "g" || key.sequence === "G") &&
 				key.eventType === "press" &&
-				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING) &&
 				hasGrounding
 			) {
 				closeAllMenus();
@@ -176,11 +180,13 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				return;
 			}
 
-			// 'U' key to open URL menu (in IDLE or SPEAKING state when hasInteracted)
+			// 'U' key to open URL menu (in IDLE, SPEAKING, or RESPONDING state when hasInteracted)
 			if (
 				(key.sequence === "u" || key.sequence === "U") &&
 				key.eventType === "press" &&
-				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING) &&
 				hasInteracted
 			) {
 				closeAllMenus();
@@ -212,7 +218,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				return;
 			}
 
-			// 'T' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
+			// 'T' key to open tools menu (in IDLE, SPEAKING, or RESPONDING state)
 			if (
 				(key.sequence === "t" || key.sequence === "T") &&
 				key.eventType === "press" &&
@@ -220,7 +226,21 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 					currentState === DaemonState.SPEAKING ||
 					currentState === DaemonState.RESPONDING)
 			) {
-				const next = !state.showFullReasoning;
+				closeAllMenus();
+				actions.setShowToolsMenu(true);
+				key.preventDefault();
+				return;
+			}
+
+			// 'R' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "r" || key.sequence === "R") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				const next = !showFullReasoning;
 				actions.setShowFullReasoning(next);
 				actions.persistPreferences({ showFullReasoning: next });
 				toast.info(`FULL PREVIEWS: ${next ? "ON" : "OFF"}`, {
@@ -373,7 +393,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 			escPendingCancel,
 			hasInteracted,
 			hasGrounding,
-			state.showFullReasoning,
+			showFullReasoning,
 			state.showToolOutput,
 			actions,
 		]

package/src/hooks/use-daemon-runtime-controller.ts

@@ -0,0 +1,147 @@
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { useCallback, useEffect, useRef } from "react";
+import type { MutableRefObject } from "react";
+
+import { useDaemonEvents } from "./use-daemon-events";
+import { useInputHistory } from "./use-input-history";
+import { useReasoningAnimation } from "./use-reasoning-animation";
+import { useResponseTimer } from "./use-response-timer";
+import { useTypingMode } from "./use-typing-mode";
+
+import { daemonEvents } from "../state/daemon-events";
+
+export interface DaemonRuntimeControllerResult {
+	reasoning: ReturnType<typeof useReasoningAnimation>;
+
+	daemonState: ReturnType<typeof useDaemonEvents>["daemonState"];
+	conversationHistory: ReturnType<typeof useDaemonEvents>["conversationHistory"];
+	currentTranscription: ReturnType<typeof useDaemonEvents>["currentTranscription"];
+	currentResponse: ReturnType<typeof useDaemonEvents>["currentResponse"];
+	currentContentBlocks: ReturnType<typeof useDaemonEvents>["currentContentBlocks"];
+	error: ReturnType<typeof useDaemonEvents>["error"];
+	sessionUsage: ReturnType<typeof useDaemonEvents>["sessionUsage"];
+	modelMetadata: ReturnType<typeof useDaemonEvents>["modelMetadata"];
+	avatarRef: ReturnType<typeof useDaemonEvents>["avatarRef"];
+	currentUserInputRef: ReturnType<typeof useDaemonEvents>["currentUserInputRef"];
+	hydrateConversationHistory: ReturnType<typeof useDaemonEvents>["hydrateConversationHistory"];
+	setCurrentTranscription: ReturnType<typeof useDaemonEvents>["setCurrentTranscription"];
+	setCurrentResponse: ReturnType<typeof useDaemonEvents>["setCurrentResponse"];
+	clearCurrentContentBlocks: ReturnType<typeof useDaemonEvents>["clearCurrentContentBlocks"];
+	resetSessionUsage: ReturnType<typeof useDaemonEvents>["resetSessionUsage"];
+	setSessionUsage: ReturnType<typeof useDaemonEvents>["setSessionUsage"];
+	applyAvatarForState: ReturnType<typeof useDaemonEvents>["applyAvatarForState"];
+
+	typing: ReturnType<typeof useTypingMode>;
+
+	responseElapsedMs: number;
+
+	conversationScrollRef: MutableRefObject<ScrollBoxRenderable | null>;
+
+	hasInteracted: boolean;
+}
+
+export function useDaemonRuntimeController({
+	currentModelId,
+	preferencesLoaded,
+	sessionId,
+	sessionIdRef,
+	ensureSessionId,
+	onFirstMessage,
+}: {
+	currentModelId: string;
+	preferencesLoaded: boolean;
+	sessionId: string | null;
+	sessionIdRef: MutableRefObject<string | null>;
+	ensureSessionId: () => Promise<string>;
+	onFirstMessage: (sessionId: string, message: string) => void;
+}): DaemonRuntimeControllerResult {
+	const reasoning = useReasoningAnimation();
+	const { addToHistory, navigateUp, navigateDown, resetNavigation } = useInputHistory();
+
+	const {
+		daemonState,
+		conversationHistory,
+		currentTranscription,
+		currentResponse,
+		currentContentBlocks,
+		error,
+		sessionUsage,
+		modelMetadata,
+		avatarRef,
+		currentUserInputRef,
+		hydrateConversationHistory,
+		setCurrentTranscription,
+		setCurrentResponse,
+		clearCurrentContentBlocks,
+		resetSessionUsage,
+		setSessionUsage,
+		applyAvatarForState,
+	} = useDaemonEvents({
+		currentModelId,
+		preferencesLoaded,
+		setReasoningQueue: reasoning.setReasoningQueue,
+		setFullReasoning: reasoning.setFullReasoning,
+		clearReasoningState: reasoning.clearReasoningState,
+		clearReasoningTicker: reasoning.clearReasoningTicker,
+		fullReasoningRef: reasoning.fullReasoningRef,
+		sessionId,
+		sessionIdRef,
+		ensureSessionId,
+		addToHistory,
+		onFirstMessage,
+	});
+
+	const typing = useTypingMode({
+		daemonState,
+		currentUserInputRef,
+		setCurrentTranscription,
+		onTypingActivity: useCallback(() => {
+			avatarRef.current?.triggerTypingPulse();
+		}, [avatarRef]),
+		navigateUp,
+		navigateDown,
+		resetNavigation,
+	});
+
+	useEffect(() => {
+		const handleTranscriptionReady = (text: string) => {
+			typing.prefillTypingInput(text);
+		};
+		daemonEvents.on("transcriptionReady", handleTranscriptionReady);
+		return () => {
+			daemonEvents.off("transcriptionReady", handleTranscriptionReady);
+		};
+	}, [typing.prefillTypingInput]);
+
+	const { responseElapsedMs } = useResponseTimer({ daemonState });
+
+	const conversationScrollRef = useRef<ScrollBoxRenderable | null>(null);
+
+	const hasInteracted =
+		conversationHistory.length > 0 || currentTranscription.length > 0 || currentContentBlocks.length > 0;
+
+	return {
+		reasoning,
+		daemonState,
+		conversationHistory,
+		currentTranscription,
+		currentResponse,
+		currentContentBlocks,
+		error,
+		sessionUsage,
+		modelMetadata,
+		avatarRef,
+		currentUserInputRef,
+		hydrateConversationHistory,
+		setCurrentTranscription,
+		setCurrentResponse,
+		clearCurrentContentBlocks,
+		resetSessionUsage,
+		setSessionUsage,
+		applyAvatarForState,
+		typing,
+		responseElapsedMs,
+		conversationScrollRef,
+		hasInteracted,
+	};
+}

package/src/hooks/use-overlay-controller.ts

@@ -9,6 +9,7 @@ export interface OverlayControllerState {
 	showHotkeysPane: boolean;
 	showGroundingMenu: boolean;
 	showUrlMenu: boolean;
+	showToolsMenu: boolean;
 	onboardingActive: boolean;
 }
 
@@ -21,6 +22,7 @@ export interface OverlayControllerActions {
 	setShowHotkeysPane: (show: boolean) => void;
 	setShowGroundingMenu: (show: boolean) => void;
 	setShowUrlMenu: (show: boolean) => void;
+	setShowToolsMenu: (show: boolean) => void;
 }
 
 export function useOverlayController(state: OverlayControllerState, actions: OverlayControllerActions) {
@@ -33,6 +35,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		showHotkeysPane,
 		showGroundingMenu,
 		showUrlMenu,
+		showToolsMenu,
 		onboardingActive,
 	} = state;
 
@@ -46,6 +49,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 			showHotkeysPane ||
 			showGroundingMenu ||
 			showUrlMenu ||
+			showToolsMenu ||
 			onboardingActive
 		);
 	}, [
@@ -57,6 +61,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		showHotkeysPane,
 		showGroundingMenu,
 		showUrlMenu,
+		showToolsMenu,
 		onboardingActive,
 	]);
 
@@ -69,6 +74,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		actions.setShowHotkeysPane(false);
 		actions.setShowGroundingMenu(false);
 		actions.setShowUrlMenu(false);
+		actions.setShowToolsMenu(false);
 	}, [actions]);
 
 	return {

package/src/hooks/use-session-controller.ts

@@ -0,0 +1,79 @@
+import { useEffect } from "react";
+import type { MutableRefObject } from "react";
+
+import { useAppSessions } from "./use-app-sessions";
+import { useGrounding } from "./use-grounding";
+import { useGroundingMenuController } from "./use-grounding-menu-controller";
+
+import { getDaemonManager } from "../state/daemon-state";
+
+export interface SessionControllerResult {
+	currentSessionId: string | null;
+	setCurrentSessionIdSafe: (id: string | null) => void;
+	currentSessionIdRef: MutableRefObject<string | null>;
+	ensureSessionId: () => Promise<string>;
+	setSessions: ReturnType<typeof useAppSessions>["setSessions"];
+	sessionMenuItems: ReturnType<typeof useAppSessions>["sessionMenuItems"];
+	handleFirstMessage: ReturnType<typeof useAppSessions>["handleFirstMessage"];
+
+	latestGroundingMap: ReturnType<typeof useGrounding>["latestGroundingMap"];
+	hasGrounding: boolean;
+
+	groundingInitialIndex: number;
+	groundingSelectedIndex: number;
+	setGroundingSelectedIndex: (idx: number) => void;
+	onGroundingSelect: (idx: number) => void;
+	onGroundingIndexChange: (idx: number) => void;
+}
+
+export function useSessionController({
+	showSessionMenu,
+}: {
+	showSessionMenu: boolean;
+}): SessionControllerResult {
+	const {
+		currentSessionId,
+		setCurrentSessionIdSafe,
+		currentSessionIdRef,
+		ensureSessionId,
+		setSessions,
+		sessionMenuItems,
+		handleFirstMessage,
+	} = useAppSessions({ showSessionMenu });
+
+	useEffect(() => {
+		const manager = getDaemonManager();
+		manager.setEnsureSessionId(() => ensureSessionId());
+		return () => manager.setEnsureSessionId(null);
+	}, [ensureSessionId]);
+
+	const { latestGroundingMap, hasGrounding } = useGrounding(currentSessionId);
+	const {
+		groundingInitialIndex,
+		groundingSelectedIndex,
+		setGroundingSelectedIndex,
+		onGroundingSelect,
+		onGroundingIndexChange,
+	} = useGroundingMenuController({ sessionId: currentSessionId, latestGroundingMap });
+
+	useEffect(() => {
+		setGroundingSelectedIndex(0);
+	}, [currentSessionId, setGroundingSelectedIndex]);
+
+	return {
+		currentSessionId,
+		setCurrentSessionIdSafe,
+		currentSessionIdRef,
+		ensureSessionId,
+		setSessions,
+		sessionMenuItems,
+		handleFirstMessage,
+		latestGroundingMap,
+		hasGrounding,
+		groundingInitialIndex,
+		groundingSelectedIndex,
+		setGroundingSelectedIndex,
+		onGroundingSelect,
+		onGroundingIndexChange,
+	};
+}

package/src/state/app-context.tsx

@@ -31,6 +31,8 @@ export interface MenuState {
 	setShowGroundingMenu: React.Dispatch<React.SetStateAction<boolean>>;
 	showUrlMenu: boolean;
 	setShowUrlMenu: React.Dispatch<React.SetStateAction<boolean>>;
+	showToolsMenu: boolean;
+	setShowToolsMenu: React.Dispatch<React.SetStateAction<boolean>>;
 }
 
 export interface DeviceState {

package/src/state/daemon-state.ts

@@ -5,19 +5,21 @@
 
 import { AgentTurnRunner } from "../ai/agent-turn-runner";
 import { transcribeAudio } from "../ai/daemon-ai";
-import { debug } from "../utils/debug-logger";
-import { SpeechController } from "../voice/tts/speech-controller";
-import { VoiceInputController } from "../voice/voice-input-controller";
 import type {
-	ModelMessage,
+	BashApprovalLevel,
 	InteractionMode,
-	VoiceInteractionType,
-	SpeechSpeed,
+	ModelMessage,
 	ReasoningEffort,
-	BashApprovalLevel,
+	SpeechSpeed,
+	ToolToggles,
+	VoiceInteractionType,
 } from "../types";
+import { DEFAULT_TOOL_TOGGLES } from "../types";
 import { DaemonState } from "../types";
-import { daemonEvents, type DaemonStateEvents } from "./daemon-events";
+import { debug } from "../utils/debug-logger";
+import { SpeechController } from "../voice/tts/speech-controller";
+import { VoiceInputController } from "../voice/voice-input-controller";
+import { type DaemonStateEvents, daemonEvents } from "./daemon-events";
 import { ModelHistoryStore } from "./model-history-store";
 
 /**
@@ -39,6 +41,7 @@ class DaemonStateManager {
 	private _speechSpeed: SpeechSpeed = 1.25;
 	private _reasoningEffort: ReasoningEffort = "medium";
 	private _bashApprovalLevel: BashApprovalLevel = "dangerous";
+	private _toolToggles: ToolToggles = { ...DEFAULT_TOOL_TOGGLES };
 	private _outputDeviceName: string | undefined = undefined;
 	private _turnId = 0;
 	private speechRunId = 0;
@@ -136,6 +139,14 @@ class DaemonStateManager {
 		this._bashApprovalLevel = level;
 	}
 
+	get toolToggles(): ToolToggles {
+		return this._toolToggles;
+	}
+
+	set toolToggles(toggles: ToolToggles) {
+		this._toolToggles = toggles;
+	}
+
 	get outputDeviceName(): string | undefined {
 		return this._outputDeviceName;
 	}

package/src/types/index.ts

@@ -259,6 +259,29 @@ export type OnboardingStep =
 
 export type VoiceInteractionType = "direct" | "review";
 
+export type ToolToggleId =
+	| "readFile"
+	| "runBash"
+	| "webSearch"
+	| "fetchUrls"
+	| "renderUrl"
+	| "todoManager"
+	| "groundingManager"
+	| "subagent";
+
+export type ToolToggles = Record<ToolToggleId, boolean>;
+
+export const DEFAULT_TOOL_TOGGLES: ToolToggles = {
+	readFile: true,
+	runBash: true,
+	webSearch: true,
+	fetchUrls: true,
+	renderUrl: true,
+	todoManager: true,
+	groundingManager: true,
+	subagent: true,
+};
+
 /**
  * Persisted user preferences.
  */
@@ -291,6 +314,8 @@ export interface AppPreferences {
 	showToolOutput?: boolean;
 	/** Bash command approval level */
 	bashApprovalLevel?: BashApprovalLevel;
+	/** Tool toggles (on/off) */
+	toolToggles?: ToolToggles;
 	/** Recent user inputs for up/down history navigation (max 20) */
 	inputHistory?: string[];
 }

package/src/utils/preferences.ts

@@ -109,6 +109,16 @@ export function parsePreferences(raw: unknown): AppPreferences | null {
 	if (typeof raw.showToolOutput === "boolean") {
 		prefs.showToolOutput = raw.showToolOutput;
 	}
+	if (isRecord(raw.toolToggles)) {
+		const record = raw.toolToggles;
+		const next: Record<string, boolean> = {};
+		for (const [k, v] of Object.entries(record)) {
+			if (typeof v === "boolean") {
+				next[k] = v;
+			}
+		}
+		prefs.toolToggles = next as AppPreferences["toolToggles"];
+	}
 	if (
 		raw.bashApprovalLevel === "none" ||
 		raw.bashApprovalLevel === "dangerous" ||