@makefinks/daemon 0.1.4 → 0.2.0

package/package.json

@@ -28,7 +28,7 @@
 	},
 	"module": "src/index.tsx",
 	"type": "module",
-	"version": "0.1.4",
+	"version": "0.2.0",
 	"bin": {
 		"daemon": "dist/cli.js"
 	},
@@ -54,12 +54,13 @@
 		"preview:avatar": "bun run src/avatar-preview.ts",
 		"preview:avatar:mp4": "bun run src/avatar-preview.ts --mp4 tmp/avatar-preview.mp4",
 		"setup:browsers": "bun run src/scripts/setup-browsers.ts",
+		"setup:hooks": "bash .githooks/setup.sh",
 		"test": "bun test",
 		"test:watch": "bun test --watch",
 		"prepublishOnly": "bun run build:cli",
-		"release:patch": "npm version patch && git push && git push --tags && npm publish",
-		"release:minor": "npm version minor && git push && git push --tags && npm publish",
-		"release:major": "npm version major && git push && git push --tags && npm publish"
+		"release:patch": "npm version patch && git push && git push --tags && gh release create v$(node -p \"require('./package.json').version\") --generate-notes && npm publish",
+		"release:minor": "npm version minor && git push && git push --tags && gh release create v$(node -p \"require('./package.json').version\") --generate-notes && npm publish",
+		"release:major": "npm version major && git push && git push --tags && gh release create v$(node -p \"require('./package.json').version\") --generate-notes && npm publish"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",

package/src/app/App.tsx

@@ -19,7 +19,9 @@ import { useCopyOnSelect } from "../hooks/use-copy-on-select";
 import { useDaemonEvents } from "../hooks/use-daemon-events";
 import { useDaemonKeyboard } from "../hooks/use-daemon-keyboard";
 import { useGrounding } from "../hooks/use-grounding";
+import { useGroundingMenuController } from "../hooks/use-grounding-menu-controller";
 import { useInputHistory } from "../hooks/use-input-history";
+import { useOverlayController } from "../hooks/use-overlay-controller";
 import { usePlaywrightNotification } from "../hooks/use-playwright-notification";
 import { useReasoningAnimation } from "../hooks/use-reasoning-animation";
 import { useResponseTimer } from "../hooks/use-response-timer";
@@ -30,11 +32,9 @@ import { AppProvider } from "../state/app-context";
 import { daemonEvents } from "../state/daemon-events";
 import { getDaemonManager } from "../state/daemon-state";
 import { deleteSession } from "../state/session-store";
-import { DaemonState } from "../types";
 import type { AppPreferences, AudioDevice, OnboardingStep } from "../types";
+import { DaemonState } from "../types";
 import { COLORS } from "../ui/constants";
-import { openUrlInBrowser } from "../utils/preferences";
-import { buildTextFragmentUrl } from "../utils/text-fragment";
 import { getSoxInstallHint, isSoxAvailable, setAudioDevice } from "../voice/audio-recorder";
 import { AppOverlays } from "./components/AppOverlays";
 import { AvatarLayer } from "./components/AvatarLayer";
@@ -115,6 +115,8 @@ export function App() {
 		setShowHotkeysPane,
 		showGroundingMenu,
 		setShowGroundingMenu,
+		showUrlMenu,
+		setShowUrlMenu,
 	} = menus;
 
 	const {
@@ -128,7 +130,13 @@ export function App() {
 	} = useAppSessions({ showSessionMenu });
 
 	const { latestGroundingMap, hasGrounding } = useGrounding(currentSessionId);
-	const [groundingSelectedIndex, setGroundingSelectedIndex] = useState(0);
+	const {
+		groundingInitialIndex,
+		groundingSelectedIndex,
+		setGroundingSelectedIndex,
+		onGroundingSelect,
+		onGroundingIndexChange,
+	} = useGroundingMenuController({ sessionId: currentSessionId, latestGroundingMap });
 
 	const appSettings = useAppSettings();
 	const {
@@ -379,6 +387,7 @@ export function App() {
 			setShowSessionMenu,
 			setShowHotkeysPane,
 			setShowGroundingMenu,
+			setShowUrlMenu,
 			setTypingInput,
 			setCurrentTranscription,
 			setCurrentResponse,
@@ -401,6 +410,7 @@ export function App() {
 			setShowSessionMenu,
 			setShowHotkeysPane,
 			setShowGroundingMenu,
+			setShowUrlMenu,
 			setTypingInput,
 			setCurrentTranscription,
 			setCurrentResponse,
@@ -420,17 +430,33 @@ export function App() {
 	const hasInteracted =
 		conversationHistory.length > 0 || currentTranscription.length > 0 || currentContentBlocks.length > 0;
 
+	const { isOverlayOpen } = useOverlayController(
+		{
+			showDeviceMenu,
+			showSettingsMenu,
+			showModelMenu,
+			showProviderMenu,
+			showSessionMenu,
+			showHotkeysPane,
+			showGroundingMenu,
+			showUrlMenu,
+			onboardingActive,
+		},
+		{
+			setShowDeviceMenu,
+			setShowSettingsMenu,
+			setShowModelMenu,
+			setShowProviderMenu,
+			setShowSessionMenu,
+			setShowHotkeysPane,
+			setShowGroundingMenu,
+			setShowUrlMenu,
+		}
+	);
+
 	useDaemonKeyboard(
 		{
-			isOverlayOpen:
-				showDeviceMenu ||
-				showSettingsMenu ||
-				showModelMenu ||
-				showProviderMenu ||
-				showSessionMenu ||
-				showHotkeysPane ||
-				showGroundingMenu ||
-				onboardingActive,
+			isOverlayOpen,
 			escPendingCancel,
 			hasInteracted,
 			hasGrounding,
@@ -481,24 +507,6 @@ export function App() {
 		}
 	}, [daemonState]);
 
-	const openGroundingSource = useCallback(
-		(idx: number) => {
-			if (!latestGroundingMap) return;
-			const item = latestGroundingMap.items[idx];
-			if (!item) return;
-			const { source } = item;
-			const url = source.textFragment
-				? buildTextFragmentUrl(source.url, { fragmentText: source.textFragment })
-				: source.url;
-			openUrlInBrowser(url);
-		},
-		[latestGroundingMap]
-	);
-
-	const groundingInitialIndex = latestGroundingMap
-		? Math.min(groundingSelectedIndex, Math.max(0, latestGroundingMap.items.length - 1))
-		: 0;
-
 	const conversationDisplayState: ConversationDisplayState = {
 		conversationHistory,
 		currentTranscription,
@@ -556,6 +564,8 @@ export function App() {
 			setShowHotkeysPane,
 			showGroundingMenu,
 			setShowGroundingMenu,
+			showUrlMenu,
+			setShowUrlMenu,
 		},
 		device: {
 			devices,
@@ -630,11 +640,8 @@ export function App() {
 			onSessionDelete: handleSessionDelete,
 		},
 		groundingCallbacks: {
-			onGroundingSelect: (index: number) => {
-				setGroundingSelectedIndex(index);
-				openGroundingSource(index);
-			},
-			onGroundingIndexChange: setGroundingSelectedIndex,
+			onGroundingSelect,
+			onGroundingIndexChange,
 		},
 		onboardingCallbacks: {
 			onKeySubmit: handleApiKeySubmit,
@@ -702,7 +709,10 @@ export function App() {
 					</box>
 
 					<AppProvider value={appContextValue}>
-						<AppOverlays />
+						<AppOverlays
+							conversationHistory={conversationHistory}
+							currentContentBlocks={currentContentBlocks}
+						/>
 					</AppProvider>
 				</>
 			</box>

package/src/app/components/AppOverlays.tsx

@@ -7,11 +7,25 @@ import { OnboardingOverlay } from "../../components/OnboardingOverlay";
 import { ProviderMenu } from "../../components/ProviderMenu";
 import { SessionMenu } from "../../components/SessionMenu";
 import { SettingsMenu } from "../../components/SettingsMenu";
+import { UrlMenu } from "../../components/UrlMenu";
+import { useUrlMenuItems } from "../../hooks/use-url-menu-items";
 import { useAppContext } from "../../state/app-context";
+import type { ContentBlock, ConversationMessage } from "../../types";
 
-function AppOverlaysImpl() {
+interface AppOverlaysProps {
+	conversationHistory: ConversationMessage[];
+	currentContentBlocks: ContentBlock[];
+}
+
+function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverlaysProps) {
 	const ctx = useAppContext();
 	const { menus, device, settings, model, session, grounding, onboarding } = ctx;
+
+	const urlMenuItems = useUrlMenuItems({
+		conversationHistory,
+		currentContentBlocks,
+		latestGroundingMap: grounding.latestGroundingMap,
+	});
 	const {
 		deviceCallbacks,
 		settingsCallbacks,
@@ -104,6 +118,8 @@ function AppOverlaysImpl() {
 				/>
 			)}
 
+			{menus.showUrlMenu && <UrlMenu items={urlMenuItems} onClose={() => menus.setShowUrlMenu(false)} />}
+
 			{onboarding.onboardingActive && (
 				<OnboardingOverlay
 					step={onboarding.onboardingStep}

package/src/app/components/ConversationPane.tsx

@@ -428,9 +428,11 @@ function ConversationPaneImpl(props: ConversationPaneProps) {
 							</box>
 						)}
 
-						{hasGrounding && groundingCount && daemonState === DaemonState.IDLE && (
-							<GroundingBadge count={groundingCount} />
-						)}
+						{hasGrounding &&
+							groundingCount &&
+							(daemonState === DaemonState.IDLE || daemonState === DaemonState.SPEAKING) && (
+								<GroundingBadge count={groundingCount} />
+							)}
 
 						{showWorkingSpinner && (
 							<InlineStatusIndicator

package/src/components/HotkeysPane.tsx

@@ -40,6 +40,7 @@ export function HotkeysPane({ onClose }: HotkeysPaneProps) {
 				{ key: "O", label: "Toggle tool output previews" },
 				{ key: "N", label: "New session" },
 				{ key: "G", label: "Open Grounding Menu" },
+				{ key: "U", label: "Open URL Menu" },
 				{ key: "CTRL+X", label: "Undo last message" },
 			],
 		},

package/src/components/TokenUsageDisplay.tsx

@@ -2,10 +2,10 @@
  * Component for displaying token usage statistics.
  */
 
+import type { TokenUsage } from "../types";
 import { COLORS } from "../ui/constants";
 import { formatTokenCount } from "../utils/formatters";
-import { calculateCost, formatCost, formatContextUsage, type ModelMetadata } from "../utils/model-metadata";
-import type { TokenUsage } from "../types";
+import { type ModelMetadata, calculateCost, formatContextUsage, formatCost } from "../utils/model-metadata";
 
 interface TokenUsageDisplayProps {
 	usage: TokenUsage;
@@ -15,7 +15,6 @@ interface TokenUsageDisplayProps {
 export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayProps) {
 	const mainPromptTokens = usage.promptTokens;
 	const mainCompletionTokens = usage.completionTokens;
-	const mainTotalTokens = mainPromptTokens + mainCompletionTokens;
 
 	// Calculate cost if we have pricing info
 	const cost =
@@ -30,11 +29,12 @@ export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayPro
 					)
 				: null;
 
-	// Calculate context usage percentage
-	const contextTotalTokens = mainTotalTokens;
-	const contextUsage = modelMetadata?.contextLength
-		? formatContextUsage(contextTotalTokens, modelMetadata.contextLength)
-		: null;
+	// Context % uses latest turn only (prompt already includes full history, completion is that turn's output)
+	const latestTurnTotal = (usage.latestTurnPromptTokens ?? 0) + (usage.latestTurnCompletionTokens ?? 0);
+	const contextUsage =
+		modelMetadata?.contextLength && latestTurnTotal > 0
+			? formatContextUsage(latestTurnTotal, modelMetadata.contextLength)
+			: null;
 
 	return (
 		<box
@@ -47,12 +47,12 @@ export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayPro
 		>
 			<text>
 				{/* Context usage: X/Y (Z%) */}
-				{modelMetadata?.contextLength && (
+				{contextUsage && (
 					<>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}>Tokens: </span>
-						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(contextTotalTokens)}</span>
+						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(latestTurnTotal)}</span>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}>/</span>
-						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(modelMetadata.contextLength)}</span>
+						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(modelMetadata!.contextLength)}</span>
 						<span fg={COLORS.REASONING_DIM}> ({contextUsage})</span>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}> · </span>
 					</>

package/src/components/UrlMenu.tsx

@@ -0,0 +1,182 @@
+import type { KeyEvent, ScrollBoxRenderable } from "@opentui/core";
+import { useKeyboard, useRenderer } from "@opentui/react";
+import { useCallback, useMemo, useRef } from "react";
+import { COLORS } from "../ui/constants";
+
+import type { UrlMenuItem } from "../types";
+
+interface UrlMenuProps {
+	items: UrlMenuItem[];
+	onClose: () => void;
+}
+
+const SCROLL_AMOUNT = 1;
+
+function splitUrl(url: string): { origin: string; path: string } {
+	try {
+		const parsed = new URL(url);
+		return { origin: parsed.origin, path: parsed.pathname + parsed.search + parsed.hash };
+	} catch {
+		const match = url.match(/^(https?:\/\/[^/]+)(\/.*)?$/);
+		if (match) {
+			return { origin: match[1] ?? url, path: match[2] ?? "" };
+		}
+		return { origin: url, path: "" };
+	}
+}
+
+export function UrlMenu({ items, onClose }: UrlMenuProps) {
+	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+	const renderer = useRenderer();
+
+	const sortedItems = useMemo(() => {
+		const next = [...items];
+		next.sort((a, b) => {
+			const groundedDelta = b.groundedCount - a.groundedCount;
+			if (groundedDelta !== 0) return groundedDelta;
+
+			const aPercent = a.readPercent ?? -1;
+			const bPercent = b.readPercent ?? -1;
+			if (aPercent !== bPercent) return bPercent - aPercent;
+
+			return b.lastSeenIndex - a.lastSeenIndex;
+		});
+		return next;
+	}, [items]);
+
+	const menuWidth = useMemo(() => {
+		return Math.max(80, Math.min(220, Math.floor(renderer.terminalWidth * 0.8)));
+	}, [renderer.terminalWidth]);
+
+	const menuHeight = useMemo(() => {
+		const headerHeight = 4;
+		const rowCount = sortedItems.length;
+		const contentHeight = rowCount > 0 ? rowCount : 1;
+		const minHeight = Math.floor(renderer.terminalHeight * 0.5);
+		const maxHeight = Math.floor(renderer.terminalHeight * 0.8);
+		return Math.max(minHeight, Math.min(headerHeight + contentHeight + 2, maxHeight));
+	}, [sortedItems.length, renderer.terminalHeight]);
+
+	const scrollBy = useCallback((delta: number) => {
+		const scrollbox = scrollRef.current;
+		if (!scrollbox) return;
+		const viewportHeight = scrollbox.viewport?.height ?? 0;
+		const maxScrollTop = Math.max(0, scrollbox.scrollHeight - viewportHeight);
+		const nextScrollTop = Math.max(0, Math.min(scrollbox.scrollTop + delta, maxScrollTop));
+		scrollbox.scrollTop = nextScrollTop;
+	}, []);
+
+	const handleKeyPress = useCallback(
+		(key: KeyEvent) => {
+			if (key.eventType !== "press") return;
+
+			if (key.name === "escape" || key.sequence === "u" || key.sequence === "U") {
+				onClose();
+				key.preventDefault();
+				return;
+			}
+
+			if (key.sequence === "j" || key.sequence === "J" || key.name === "down") {
+				scrollBy(SCROLL_AMOUNT);
+				key.preventDefault();
+				return;
+			}
+
+			if (key.sequence === "k" || key.sequence === "K" || key.name === "up") {
+				scrollBy(-SCROLL_AMOUNT);
+				key.preventDefault();
+				return;
+			}
+		},
+		[onClose, scrollBy]
+	);
+
+	useKeyboard(handleKeyPress);
+
+	return (
+		<box
+			position="absolute"
+			left={0}
+			top={0}
+			width="100%"
+			height="100%"
+			flexDirection="column"
+			alignItems="center"
+			justifyContent="center"
+			zIndex={100}
+		>
+			<box
+				flexDirection="column"
+				backgroundColor={COLORS.MENU_BG}
+				borderStyle="single"
+				borderColor={COLORS.MENU_BORDER}
+				paddingLeft={2}
+				paddingRight={2}
+				paddingTop={1}
+				paddingBottom={1}
+				width={menuWidth}
+				height={menuHeight}
+			>
+				<box marginBottom={1} flexDirection="row" width="100%">
+					<text>
+						<span fg={COLORS.DAEMON_LABEL}>[ URLS ]</span>
+						<span fg={COLORS.REASONING_DIM}> — {sortedItems.length} fetched</span>
+					</text>
+					<box flexGrow={1} />
+					<text>
+						<span fg={COLORS.USER_LABEL}>
+							<span fg={COLORS.DAEMON_LABEL}>j/k</span> scroll · <span fg={COLORS.DAEMON_LABEL}>ESC</span>{" "}
+							close
+						</span>
+					</text>
+				</box>
+
+				<box marginBottom={1} flexDirection="row" width="100%" justifyContent="space-between">
+					<text>
+						<span fg={COLORS.REASONING_DIM}>
+							{"G".padEnd(2)}
+							{"READ".padEnd(6)}URL
+						</span>
+					</text>
+					<text>
+						<span fg={COLORS.REASONING_DIM}>(G=grounded, READ=% or HL=highlights)</span>
+					</text>
+				</box>
+
+				<scrollbox ref={scrollRef} flexGrow={1} width="100%" overflow="scroll">
+					{sortedItems.length === 0 ? (
+						<text>
+							<span fg={COLORS.REASONING_DIM}>No URLs fetched yet</span>
+						</text>
+					) : (
+						sortedItems.map((item, idx) => {
+							const { origin, path } = splitUrl(item.url);
+							const grounded = item.groundedCount > 0;
+							const readLabel =
+								item.readPercent !== undefined
+									? `${item.readPercent}%`
+									: item.highlightsCount !== undefined
+										? `HL:${item.highlightsCount}`
+										: "—";
+
+							return (
+								<box key={idx} flexDirection="row" marginBottom={0}>
+									<text>
+										<span fg={grounded ? COLORS.DAEMON_TEXT : COLORS.REASONING_DIM}>
+											{grounded ? "G" : "·"}
+										</span>
+										<span fg={COLORS.REASONING_DIM}> </span>
+										<span fg={COLORS.REASONING_DIM}>{readLabel.padStart(4, " ")}</span>
+										<span fg={COLORS.REASONING_DIM}> </span>
+										<span fg={item.status === "error" ? COLORS.ERROR : COLORS.DAEMON_LABEL}>{origin}</span>
+										<span fg={COLORS.REASONING_DIM}>{path}</span>
+									</text>
+								</box>
+							);
+						})
+					)}
+				</scrollbox>
+			</box>
+		</box>
+	);
+}

package/src/hooks/daemon-event-handlers/interrupted-turn.ts

@@ -0,0 +1,148 @@
+import type { ContentBlock, ModelMessage, ToolResultOutput } from "../../types";
+
+export const INTERRUPTED_TOOL_RESULT = "Tool execution interrupted by user";
+
+export function normalizeInterruptedToolBlockResult(result: unknown): unknown {
+	if (result !== undefined) return result;
+	return { success: false, error: INTERRUPTED_TOOL_RESULT };
+}
+
+export function normalizeInterruptedToolResultOutput(result: unknown): ToolResultOutput {
+	if (result === undefined) {
+		return { type: "error-text", value: INTERRUPTED_TOOL_RESULT };
+	}
+
+	if (typeof result === "string") {
+		return { type: "text", value: result };
+	}
+
+	try {
+		JSON.stringify(result);
+		return { type: "json", value: result as ToolResultOutput["value"] };
+	} catch {
+		return { type: "text", value: String(result) };
+	}
+}
+
+export function buildInterruptedContentBlocks(contentBlocks: ContentBlock[]): ContentBlock[] {
+	return contentBlocks.map((block) => {
+		if (block.type !== "tool") return { ...block };
+
+		const call = { ...block.call };
+		if (call.status === "running") {
+			call.status = "failed";
+			call.error = INTERRUPTED_TOOL_RESULT;
+		}
+		if (call.subagentSteps) {
+			call.subagentSteps = call.subagentSteps.map((step) =>
+				step.status === "running" ? { ...step, status: "failed" } : step
+			);
+		}
+
+		return {
+			...block,
+			call,
+			result: normalizeInterruptedToolBlockResult(block.result),
+		};
+	});
+}
+
+export function buildInterruptedModelMessages(contentBlocks: ContentBlock[]): ModelMessage[] {
+	const messages: ModelMessage[] = [];
+
+	type AssistantPart =
+		| { type: "text"; text: string }
+		| { type: "reasoning"; text: string }
+		| { type: "tool-call"; toolCallId: string; toolName: string; input: unknown };
+
+	type ToolResultPart = {
+		type: "tool-result";
+		toolCallId: string;
+		toolName: string;
+		output: ToolResultOutput;
+	};
+
+	let assistantParts: AssistantPart[] = [];
+	let toolResults: ToolResultPart[] = [];
+
+	for (const block of contentBlocks) {
+		if (block.type === "reasoning" && block.content) {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			assistantParts.push({ type: "reasoning", text: block.content });
+			continue;
+		}
+
+		if (block.type === "text" && block.content) {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			assistantParts.push({ type: "text", text: block.content });
+			continue;
+		}
+
+		if (block.type === "tool") {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			const toolCallId = block.call.toolCallId;
+			if (!toolCallId) {
+				continue;
+			}
+
+			assistantParts.push({
+				type: "tool-call",
+				toolCallId,
+				toolName: block.call.name,
+				input: block.call.input ?? {},
+			});
+
+			if (assistantParts.length > 0) {
+				messages.push({
+					role: "assistant",
+					content: [...assistantParts],
+				} as unknown as ModelMessage);
+				assistantParts = [];
+			}
+
+			toolResults.push({
+				type: "tool-result",
+				toolCallId,
+				toolName: block.call.name,
+				output: normalizeInterruptedToolResultOutput(block.result),
+			});
+		}
+	}
+
+	if (assistantParts.length > 0) {
+		messages.push({
+			role: "assistant",
+			content: [...assistantParts],
+		} as unknown as ModelMessage);
+	}
+
+	if (toolResults.length > 0) {
+		messages.push({
+			role: "tool",
+			content: [...toolResults],
+		} as unknown as ModelMessage);
+	}
+
+	return messages;
+}