@makefinks/daemon 0.1.0

package/src/hooks/use-reasoning-animation.ts

@@ -0,0 +1,97 @@
+import { useState, useEffect, useRef } from "react";
+import { REASONING_ANIMATION } from "../ui/constants";
+
+export interface ReasoningState {
+	reasoningQueue: string;
+	reasoningDisplay: string;
+	fullReasoning: string;
+}
+
+export interface UseReasoningAnimationReturn {
+	reasoningQueue: string;
+	reasoningDisplay: string;
+	fullReasoning: string;
+	setReasoningQueue: (queue: string | ((prev: string) => string)) => void;
+	setFullReasoning: (full: string | ((prev: string) => string)) => void;
+	fullReasoningRef: React.RefObject<string>;
+	clearReasoningState: () => void;
+	clearReasoningTicker: () => void;
+}
+
+export function useReasoningAnimation(): UseReasoningAnimationReturn {
+	const [reasoningQueue, setReasoningQueue] = useState<string>("");
+	const [reasoningDisplay, setReasoningDisplay] = useState<string>("");
+	const [fullReasoning, setFullReasoning] = useState<string>("");
+	const reasoningAnimRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+	const fullReasoningRef = useRef<string>("");
+
+	const clearReasoningState = () => {
+		setReasoningQueue("");
+		setReasoningDisplay("");
+		setFullReasoning("");
+		fullReasoningRef.current = "";
+	};
+	const clearReasoningTicker = () => {
+		setReasoningQueue("");
+		setReasoningDisplay("");
+	};
+
+	// Smooth flowing animation for reasoning text
+	// This creates a "ticker" effect where text flows through the single line
+	useEffect(() => {
+		// Clear any existing animation
+		if (reasoningAnimRef.current) {
+			clearTimeout(reasoningAnimRef.current);
+			reasoningAnimRef.current = null;
+		}
+
+		// If no queue content, nothing to animate
+		if (!reasoningQueue) return;
+
+		const tick = () => {
+			setReasoningQueue((queue: string) => {
+				if (!queue) return queue;
+
+				// Take characters from the front of the queue
+				const charsToMove = Math.min(REASONING_ANIMATION.CHARS_PER_TICK, queue.length);
+				const movedChars = queue.slice(0, charsToMove);
+				const remainingQueue = queue.slice(charsToMove);
+
+				// Add to display, keeping it at max width by trimming from the left
+				setReasoningDisplay((display: string) => {
+					const newDisplay = display + movedChars;
+					if (newDisplay.length > REASONING_ANIMATION.LINE_WIDTH) {
+						return newDisplay.slice(-REASONING_ANIMATION.LINE_WIDTH);
+					}
+					return newDisplay;
+				});
+
+				return remainingQueue;
+			});
+
+			// Schedule next tick if there's still content in the queue
+			reasoningAnimRef.current = setTimeout(tick, REASONING_ANIMATION.TICK_INTERVAL_MS);
+		};
+
+		// Start the animation
+		reasoningAnimRef.current = setTimeout(tick, REASONING_ANIMATION.TICK_INTERVAL_MS);
+
+		return () => {
+			if (reasoningAnimRef.current) {
+				clearTimeout(reasoningAnimRef.current);
+				reasoningAnimRef.current = null;
+			}
+		};
+	}, [reasoningQueue]);
+
+	return {
+		reasoningQueue,
+		reasoningDisplay,
+		fullReasoning,
+		setReasoningQueue,
+		setFullReasoning,
+		fullReasoningRef,
+		clearReasoningState,
+		clearReasoningTicker,
+	};
+}

package/src/hooks/use-response-timer.ts

@@ -0,0 +1,55 @@
+/**
+ * Hook for tracking response elapsed time during RESPONDING state.
+ */
+
+import { useEffect, useRef, useState } from "react";
+import { DaemonState } from "../types";
+
+export interface UseResponseTimerParams {
+	daemonState: DaemonState;
+}
+
+export interface UseResponseTimerReturn {
+	responseElapsedMs: number;
+}
+
+export function useResponseTimer(params: UseResponseTimerParams): UseResponseTimerReturn {
+	const { daemonState } = params;
+
+	const prevDaemonStateRef = useRef<DaemonState>(DaemonState.IDLE);
+	const [responseStartAt, setResponseStartAt] = useState<number | null>(null);
+	const [responseElapsedMs, setResponseElapsedMs] = useState(0);
+
+	// Track state transitions to start/stop timer
+	useEffect(() => {
+		const prevState = prevDaemonStateRef.current;
+		if (daemonState === DaemonState.RESPONDING && prevState !== DaemonState.RESPONDING) {
+			setResponseStartAt(Date.now());
+			setResponseElapsedMs(0);
+		} else if (daemonState !== DaemonState.RESPONDING && prevState === DaemonState.RESPONDING) {
+			setResponseStartAt(null);
+			setResponseElapsedMs(0);
+		}
+		prevDaemonStateRef.current = daemonState;
+	}, [daemonState]);
+
+	// Update elapsed time while responding
+	useEffect(() => {
+		if (daemonState !== DaemonState.RESPONDING || responseStartAt === null) return;
+		const tick = () => {
+			setResponseStartAt((start) => {
+				if (start !== null) {
+					setResponseElapsedMs(Date.now() - start);
+				}
+				return start;
+			});
+		};
+		tick();
+		const interval = setInterval(tick, 250);
+		return () => clearInterval(interval);
+	}, [daemonState, responseStartAt]);
+
+	return {
+		responseElapsedMs,
+	};
+}

package/src/hooks/use-tool-approval.tsx

@@ -0,0 +1,202 @@
+import { createContext, useContext, useState, useCallback, useEffect, type ReactNode } from "react";
+import { daemonEvents } from "../state/daemon-events";
+import type { ToolApprovalRequest, ToolApprovalResponse } from "../types";
+
+interface PendingApproval {
+	request: ToolApprovalRequest;
+	respond: (response: ToolApprovalResponse) => void;
+}
+
+interface ToolApprovalContextValue {
+	pendingApprovals: Map<string, PendingApproval>;
+	activeApprovalId: string | null;
+	approveRequest: (toolCallId: string) => void;
+	denyRequest: (toolCallId: string, reason?: string) => void;
+	approveAll: () => void;
+	denyAll: (reason?: string) => void;
+}
+
+const ToolApprovalContext = createContext<ToolApprovalContextValue | null>(null);
+
+export function useToolApproval(): ToolApprovalContextValue {
+	const context = useContext(ToolApprovalContext);
+	if (!context) {
+		throw new Error("useToolApproval must be used within ToolApprovalProvider");
+	}
+	return context;
+}
+
+export function useToolApprovalForCall(toolCallId: string | undefined): {
+	needsApproval: boolean;
+	isActive: boolean;
+	approve: () => void;
+	deny: () => void;
+	approveAll: () => void;
+	denyAll: () => void;
+} {
+	const context = useContext(ToolApprovalContext);
+
+	const approval = toolCallId ? context?.pendingApprovals.get(toolCallId) : undefined;
+	const isActive = toolCallId !== undefined && context?.activeApprovalId === toolCallId;
+
+	const approve = useCallback(() => {
+		if (toolCallId && context) {
+			context.approveRequest(toolCallId);
+		}
+	}, [toolCallId, context]);
+
+	const deny = useCallback(() => {
+		if (toolCallId && context) {
+			context.denyRequest(toolCallId, "User denied tool execution");
+		}
+	}, [toolCallId, context]);
+
+	const approveAll = useCallback(() => {
+		context?.approveAll();
+	}, [context]);
+
+	const denyAll = useCallback(() => {
+		context?.denyAll("User denied tool execution");
+	}, [context]);
+
+	return {
+		needsApproval: !!approval,
+		isActive,
+		approve,
+		deny,
+		approveAll,
+		denyAll,
+	};
+}
+
+interface ToolApprovalProviderProps {
+	children: ReactNode;
+}
+
+export function ToolApprovalProvider({ children }: ToolApprovalProviderProps) {
+	const [pendingApprovals, setPendingApprovals] = useState<Map<string, PendingApproval>>(new Map());
+	const [activeApprovalId, setActiveApprovalId] = useState<string | null>(null);
+
+	const getFirstPendingId = useCallback((approvals: Map<string, PendingApproval>): string | null => {
+		const first = approvals.keys().next();
+		return first.done ? null : first.value;
+	}, []);
+
+	useEffect(() => {
+		const handleAwaitingApprovals = (
+			requests: ToolApprovalRequest[],
+			respondToApprovals: (responses: ToolApprovalResponse[]) => void
+		) => {
+			const responseCollector = new Map<string, ToolApprovalResponse>();
+			const expectedCount = requests.length;
+
+			const checkAndRespond = () => {
+				if (responseCollector.size === expectedCount) {
+					respondToApprovals(Array.from(responseCollector.values()));
+					setPendingApprovals(new Map());
+					setActiveApprovalId(null);
+				}
+			};
+
+			const newApprovals = new Map<string, PendingApproval>();
+			for (const request of requests) {
+				newApprovals.set(request.toolCallId, {
+					request,
+					respond: (response) => {
+						responseCollector.set(request.approvalId, response);
+						checkAndRespond();
+					},
+				});
+			}
+
+			setPendingApprovals(newApprovals);
+			const firstId = requests[0]?.toolCallId ?? null;
+			setActiveApprovalId(firstId);
+		};
+
+		daemonEvents.on("awaitingApprovals", handleAwaitingApprovals);
+		return () => {
+			daemonEvents.off("awaitingApprovals", handleAwaitingApprovals);
+		};
+	}, []);
+
+	const approveRequest = useCallback(
+		(toolCallId: string) => {
+			setPendingApprovals((prev) => {
+				const approval = prev.get(toolCallId);
+				if (approval) {
+					approval.respond({
+						approvalId: approval.request.approvalId,
+						approved: true,
+					});
+					daemonEvents.emit("toolApprovalResolved", toolCallId, true);
+					const next = new Map(prev);
+					next.delete(toolCallId);
+					setActiveApprovalId(getFirstPendingId(next));
+					return next;
+				}
+				return prev;
+			});
+		},
+		[getFirstPendingId]
+	);
+
+	const denyRequest = useCallback(
+		(toolCallId: string, reason?: string) => {
+			setPendingApprovals((prev) => {
+				const approval = prev.get(toolCallId);
+				if (approval) {
+					approval.respond({
+						approvalId: approval.request.approvalId,
+						approved: false,
+						reason,
+					});
+					daemonEvents.emit("toolApprovalResolved", toolCallId, false);
+					const next = new Map(prev);
+					next.delete(toolCallId);
+					setActiveApprovalId(getFirstPendingId(next));
+					return next;
+				}
+				return prev;
+			});
+		},
+		[getFirstPendingId]
+	);
+
+	const approveAll = useCallback(() => {
+		setPendingApprovals((prev) => {
+			for (const [toolCallId, approval] of prev.entries()) {
+				approval.respond({
+					approvalId: approval.request.approvalId,
+					approved: true,
+				});
+				daemonEvents.emit("toolApprovalResolved", toolCallId, true);
+			}
+			setActiveApprovalId(null);
+			return new Map();
+		});
+	}, []);
+
+	const denyAll = useCallback((reason?: string) => {
+		setPendingApprovals((prev) => {
+			for (const [toolCallId, approval] of prev.entries()) {
+				approval.respond({
+					approvalId: approval.request.approvalId,
+					approved: false,
+					reason,
+				});
+				daemonEvents.emit("toolApprovalResolved", toolCallId, false);
+			}
+			setActiveApprovalId(null);
+			return new Map();
+		});
+	}, []);
+
+	return (
+		<ToolApprovalContext.Provider
+			value={{ pendingApprovals, activeApprovalId, approveRequest, denyRequest, approveAll, denyAll }}
+		>
+			{children}
+		</ToolApprovalContext.Provider>
+	);
+}

package/src/hooks/use-typing-mode.ts

@@ -0,0 +1,137 @@
+/**
+ * Hook for managing typing mode state and handlers.
+ */
+
+import type { TextareaRenderable } from "@opentui/core";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { getDaemonManager } from "../state/daemon-state";
+import { DaemonState } from "../types";
+
+export interface UseTypingModeParams {
+	daemonState: DaemonState;
+	currentUserInputRef: React.MutableRefObject<string>;
+	setCurrentTranscription: (text: string) => void;
+	onTypingActivity?: () => void;
+	navigateUp: (currentInput: string) => string | null;
+	navigateDown: () => string | null;
+	resetNavigation: () => void;
+}
+
+export interface UseTypingModeReturn {
+	typingInput: string;
+	setTypingInput: React.Dispatch<React.SetStateAction<string>>;
+	typingTextareaRef: React.RefObject<TextareaRenderable | null>;
+	handleTypingContentChange: (value: string) => void;
+	handleTypingSubmit: () => void;
+	prefillTypingInput: (text: string) => void;
+	handleHistoryUp: () => void;
+	handleHistoryDown: () => void;
+}
+
+export function useTypingMode(params: UseTypingModeParams): UseTypingModeReturn {
+	const {
+		daemonState,
+		currentUserInputRef,
+		setCurrentTranscription,
+		onTypingActivity,
+		navigateUp,
+		navigateDown,
+		resetNavigation,
+	} = params;
+
+	const [typingInput, setTypingInput] = useState<string>("");
+	const typingTextareaRef = useRef<TextareaRenderable | null>(null);
+	const pendingPrefillRef = useRef<string | null>(null);
+
+	useEffect(() => {
+		if (daemonState === DaemonState.TYPING && pendingPrefillRef.current !== null) {
+			const text = pendingPrefillRef.current;
+			const tryApplyPrefill = () => {
+				if (typingTextareaRef.current) {
+					typingTextareaRef.current.setText(text);
+					typingTextareaRef.current.gotoBufferEnd();
+					pendingPrefillRef.current = null;
+				} else {
+					setTimeout(tryApplyPrefill, 10);
+				}
+			};
+			tryApplyPrefill();
+		}
+	}, [daemonState]);
+
+	useEffect(() => {
+		if (daemonState !== DaemonState.TYPING) {
+			if (typingTextareaRef.current?.plainText) {
+				typingTextareaRef.current.setText("");
+			}
+			setTypingInput("");
+			pendingPrefillRef.current = null;
+			resetNavigation();
+		}
+	}, [daemonState, resetNavigation]);
+
+	const handleTypingContentChange = useCallback(
+		(value: string) => {
+			setTypingInput(value);
+			onTypingActivity?.();
+		},
+		[onTypingActivity]
+	);
+
+	const handleTypingSubmit = useCallback(() => {
+		const rawInput = typingTextareaRef.current?.plainText ?? typingInput;
+		const input = rawInput.trim();
+		if (input) {
+			const manager = getDaemonManager();
+			currentUserInputRef.current = input;
+			setCurrentTranscription(input);
+			manager.submitText(input);
+		}
+		typingTextareaRef.current?.setText("");
+		setTypingInput("");
+	}, [typingInput, setCurrentTranscription, currentUserInputRef]);
+
+	const prefillTypingInput = useCallback((text: string) => {
+		setTypingInput(text);
+		pendingPrefillRef.current = text;
+		if (typingTextareaRef.current) {
+			typingTextareaRef.current.setText(text);
+			typingTextareaRef.current.gotoBufferEnd();
+			pendingPrefillRef.current = null;
+		}
+	}, []);
+
+	const setTextareaValue = useCallback((value: string) => {
+		setTypingInput(value);
+		if (typingTextareaRef.current) {
+			typingTextareaRef.current.setText(value);
+			typingTextareaRef.current.gotoBufferEnd();
+		}
+	}, []);
+
+	const handleHistoryUp = useCallback(() => {
+		const currentInput = typingTextareaRef.current?.plainText ?? typingInput;
+		const historyItem = navigateUp(currentInput);
+		if (historyItem !== null) {
+			setTextareaValue(historyItem);
+		}
+	}, [typingInput, navigateUp, setTextareaValue]);
+
+	const handleHistoryDown = useCallback(() => {
+		const historyItem = navigateDown();
+		if (historyItem !== null) {
+			setTextareaValue(historyItem);
+		}
+	}, [navigateDown, setTextareaValue]);
+
+	return {
+		typingInput,
+		setTypingInput,
+		typingTextareaRef,
+		handleTypingContentChange,
+		handleTypingSubmit,
+		prefillTypingInput,
+		handleHistoryUp,
+		handleHistoryDown,
+	};
+}

package/src/hooks/use-voice-dependencies-notification.ts

@@ -0,0 +1,37 @@
+import { useEffect } from "react";
+import { toast } from "@opentui-ui/toast/react";
+import { detectVoiceDependencies, type VoiceDependencies } from "../utils/voice-dependencies";
+
+export function useVoiceDependenciesNotification(): void {
+	useEffect(() => {
+		let cancelled = false;
+
+		void (async () => {
+			let deps: VoiceDependencies;
+			try {
+				deps = await detectVoiceDependencies();
+			} catch (error) {
+				if (cancelled) return;
+				const err = error instanceof Error ? error : new Error(String(error));
+				toast.warning("Voice dependency check failed", {
+					description: err.message,
+				});
+				return;
+			}
+
+			if (cancelled) return;
+
+			if (!deps.sox.available) {
+				const hint =
+					deps.sox.hint ?? (process.platform === "darwin" ? "Run: brew install sox" : "Install sox");
+				toast.warning("Voice features unavailable", {
+					description: `sox is not installed. ${hint}`,
+				});
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+}

package/src/index.tsx

@@ -0,0 +1,48 @@
+/**
+ * DAEMON - Terminal-based AI with alien/cultic aesthetics.
+ * Main application entry point.
+ */
+
+import { ConsolePosition, createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { App } from "./app/App";
+import { destroyDaemonManager } from "./state/daemon-state";
+import { COLORS } from "./ui/constants";
+import { debug } from "./utils/debug-logger";
+
+// Main entry point
+const renderer = await createCliRenderer({
+	exitOnCtrlC: true,
+	targetFps: 60,
+	maxFps: 60,
+	useMouse: true,
+	enableMouseMovement: false,
+	useKittyKeyboard: {},
+	openConsoleOnError: true,
+	backgroundColor: COLORS.BACKGROUND,
+	consoleOptions: {
+		position: ConsolePosition.BOTTOM,
+		sizePercent: 30,
+		startInDebugMode: false,
+	},
+});
+
+// Debug: Log all paste events at the renderer level
+renderer.keyInput.on("paste", (event) => {
+	debug.log("[Renderer] Paste event received", {
+		textLength: event.text.length,
+		textPreview: event.text.slice(0, 50),
+	});
+});
+
+// Cleanup on exit
+process.on("exit", () => {
+	destroyDaemonManager();
+});
+
+process.on("SIGINT", () => {
+	destroyDaemonManager();
+	process.exit(0);
+});
+
+createRoot(renderer).render(<App />);

package/src/scripts/setup-browsers.ts

@@ -0,0 +1,42 @@
+import { fileURLToPath } from "node:url";
+
+function normalizeError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function logError(message: string): void {
+	console.error(message);
+}
+
+async function main(): Promise<void> {
+	let playwrightEntryUrl: string;
+	try {
+		playwrightEntryUrl = import.meta.resolve("playwright");
+	} catch (error) {
+		logError("Playwright is not installed.");
+		logError("Install it first, then retry:");
+		logError("");
+		logError("  bun add -d playwright");
+		logError("  bun run setup:browsers");
+		process.exit(1);
+		return;
+	}
+
+	const cliPath = fileURLToPath(new URL("./cli.js", playwrightEntryUrl));
+	const proc = Bun.spawn([process.execPath, cliPath, "install", "chromium"], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	const code = await proc.exited;
+	if (code !== 0) {
+		process.exit(code);
+	}
+}
+
+try {
+	await main();
+} catch (error) {
+	const err = normalizeError(error);
+	logError(`setup:browsers failed: ${err.message}`);
+	process.exit(1);
+}