@makefinks/daemon 0.6.0 → 0.7.0

package/src/avatar/DaemonAvatarRenderable.ts

@@ -241,28 +241,6 @@ export class DaemonAvatarRenderable extends FrameBufferRenderable {
 			const w = fb.width;
 			const h = fb.height;
 			fb.clear(RGBA.fromValues(0, 0, 0, 0));
-
-			const glyph = w >= 18 ? "⟡  SUMMONING  ⟡" : "SUMMONING";
-			const gx = Math.max(0, Math.floor(w / 2) - Math.floor(glyph.length / 2));
-			const gy = Math.floor(h / 2);
-			fb.drawText(
-				glyph,
-				gx,
-				Math.max(0, Math.min(h - 1, gy)),
-				RGBA.fromInts(180, 255, 245, 230),
-				RGBA.fromInts(0, 0, 0, 0),
-				TextAttributes.DIM
-			);
-			if (h >= 2) {
-				fb.drawText(
-					"DAEMON",
-					Math.max(0, Math.floor(w / 2) - 3),
-					Math.max(0, Math.min(h - 1, gy + 1)),
-					RGBA.fromInts(130, 190, 255, 200),
-					RGBA.fromInts(0, 0, 0, 0),
-					TextAttributes.BOLD
-				);
-			}
 		} else {
 			this.kickRenderFrame();
 		}

package/src/components/HotkeysPane.tsx

@@ -47,6 +47,7 @@ export function HotkeysPane({ onClose }: HotkeysPaneProps) {
 		{
 			title: "MENUS",
 			items: [
+				{ key: "B", label: "Memories" },
 				{ key: "D", label: "Devices" },
 				{ key: "M", label: "Models" },
 				{ key: "P", label: "Providers" },

package/src/components/MemoryMenu.tsx

@@ -0,0 +1,338 @@
+import type { ScrollBoxRenderable, TextareaRenderable } from "@opentui/core";
+import { useKeyboard } from "@opentui/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { getMemoryManager, isMemoryAvailable } from "../ai/memory";
+import { useMenuKeyboard } from "../hooks/use-menu-keyboard";
+import type { MemoryEntry } from "../types";
+import { COLORS } from "../ui/constants";
+
+interface MemoryMenuProps {
+	onClose: () => void;
+}
+
+const MEMORY_ITEM_HEIGHT = 2;
+const MAX_SCROLLBOX_HEIGHT = 16;
+
+function formatTimestamp(value: string | undefined): string {
+	if (!value) return "";
+	return value.replace("T", " ").slice(0, 16);
+}
+
+function truncateText(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	if (maxLen <= 3) return text.slice(0, Math.max(0, maxLen));
+	return text.slice(0, Math.max(0, maxLen - 3)) + "...";
+}
+
+export function MemoryMenu({ onClose }: MemoryMenuProps) {
+	const [searchQuery, setSearchQuery] = useState("");
+	const [isSearchFocused, setIsSearchFocused] = useState(false);
+	const [memories, setMemories] = useState<MemoryEntry[]>([]);
+	const [isLoading, setIsLoading] = useState(true);
+	const [error, setError] = useState<string | null>(null);
+	const searchInputRef = useRef<TextareaRenderable | null>(null);
+	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+
+	// Load all memories on mount
+	useEffect(() => {
+		let cancelled = false;
+
+		const loadMemories = async () => {
+			if (!isMemoryAvailable()) {
+				setError("Memory system not available (requires OPENAI_API_KEY and OPENROUTER_API_KEY)");
+				setIsLoading(false);
+				return;
+			}
+
+			try {
+				const manager = getMemoryManager();
+				await manager.initialize();
+
+				if (!manager.isAvailable) {
+					setError("Memory system not available (check API keys and configuration)");
+					setIsLoading(false);
+					return;
+				}
+
+				const allMemories = await manager.getAll();
+				if (!cancelled) {
+					setMemories(allMemories);
+					setIsLoading(false);
+				}
+			} catch (err) {
+				if (!cancelled) {
+					setError(err instanceof Error ? err.message : String(err));
+					setIsLoading(false);
+				}
+			}
+		};
+
+		void loadMemories();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	const filteredMemories = useMemo(() => {
+		const query = searchQuery.trim().toLowerCase();
+		if (!query) return memories;
+		return memories.filter((memory) => memory.memory.toLowerCase().includes(query));
+	}, [memories, searchQuery]);
+
+	const handleDelete = useCallback(
+		async (index: number) => {
+			const memory = filteredMemories[index];
+			if (!memory) return;
+
+			try {
+				const manager = getMemoryManager();
+				const success = await manager.delete(memory.id);
+				if (success) {
+					setMemories((prev) => prev.filter((entry) => entry.id !== memory.id));
+				}
+			} catch {
+				// Silently fail delete
+			}
+		},
+		[filteredMemories]
+	);
+
+	const { selectedIndex } = useMenuKeyboard({
+		itemCount: filteredMemories.length,
+		onClose,
+		onSelect: () => {}, // No action on select, just navigation
+		enableViKeys: !isSearchFocused,
+		ignoreEscape: isSearchFocused,
+		closeOnSelect: false,
+	});
+
+	useKeyboard((key) => {
+		if (key.eventType !== "press") return;
+
+		// X to delete selected memory
+		if (!isSearchFocused && (key.name === "x" || key.sequence?.toLowerCase() === "x")) {
+			void handleDelete(selectedIndex);
+			key.preventDefault();
+			return;
+		}
+
+		// / or Shift+Tab to focus search
+		if ((key.name === "tab" && key.shift) || (!isSearchFocused && key.name === "/")) {
+			setIsSearchFocused(true);
+			searchInputRef.current?.focus();
+			key.preventDefault();
+		}
+	});
+
+	const scrollboxHeight = Math.min(
+		MAX_SCROLLBOX_HEIGHT,
+		Math.max(MEMORY_ITEM_HEIGHT, filteredMemories.length * MEMORY_ITEM_HEIGHT)
+	);
+
+	// Auto-scroll to selected item
+	useEffect(() => {
+		const scrollbox = scrollRef.current;
+		if (!scrollbox) return;
+		const viewportHeight = scrollbox.viewport?.height ?? 0;
+		if (viewportHeight <= 0) return;
+
+		const maxScrollTop = Math.max(0, scrollbox.scrollHeight - viewportHeight);
+		const itemTop = selectedIndex * MEMORY_ITEM_HEIGHT;
+		const itemBottom = itemTop + MEMORY_ITEM_HEIGHT;
+		const currentTop = scrollbox.scrollTop;
+		const currentBottom = currentTop + viewportHeight;
+		let nextTop = currentTop;
+
+		if (itemTop < currentTop) {
+			nextTop = itemTop;
+		} else if (itemBottom > currentBottom) {
+			nextTop = itemBottom - viewportHeight;
+		}
+
+		nextTop = Math.max(0, Math.min(nextTop, maxScrollTop));
+		if (nextTop !== currentTop) {
+			scrollbox.scrollTop = nextTop;
+		}
+	}, [filteredMemories.length, selectedIndex]);
+
+	return (
+		<box
+			position="absolute"
+			left={0}
+			top={0}
+			width="100%"
+			height="100%"
+			flexDirection="column"
+			alignItems="center"
+			justifyContent="center"
+			zIndex={100}
+		>
+			<box
+				flexDirection="column"
+				alignItems="flex-start"
+				backgroundColor={COLORS.MENU_BG}
+				borderStyle="single"
+				borderColor={COLORS.MENU_BORDER}
+				paddingLeft={2}
+				paddingRight={2}
+				paddingTop={1}
+				paddingBottom={1}
+				width="80%"
+				minWidth={60}
+				maxWidth={140}
+			>
+				<box marginBottom={1}>
+					<text>
+						<span fg={COLORS.DAEMON_LABEL}>[ MEMORIES ]</span>
+					</text>
+				</box>
+
+				<box marginBottom={1}>
+					<text>
+						<span fg={COLORS.REASONING_DIM}>↑/↓ j/k navigate · X delete · / search · ESC close</span>
+					</text>
+				</box>
+
+				<box marginBottom={0}>
+					<text>
+						<span fg={COLORS.USER_LABEL}>— SEARCH —</span>
+					</text>
+				</box>
+
+				<box
+					marginBottom={1}
+					marginTop={0}
+					width="100%"
+					height={1}
+					flexDirection="row"
+					alignItems="center"
+					paddingLeft={1}
+					backgroundColor={isSearchFocused ? COLORS.MENU_SELECTED_BG : COLORS.MENU_BG}
+				>
+					<box width={2}>
+						<text>
+							<span fg={isSearchFocused ? COLORS.TYPING_PROMPT : COLORS.REASONING_DIM}>/ </span>
+						</text>
+					</box>
+					<box flexGrow={1} height={1}>
+						<textarea
+							ref={searchInputRef}
+							focused={isSearchFocused}
+							width="100%"
+							height={1}
+							placeholder="Type to search memories... (/ or Shift+Tab)"
+							style={{
+								backgroundColor: "transparent",
+								focusedBackgroundColor: "transparent",
+								textColor: COLORS.MENU_TEXT,
+								focusedTextColor: COLORS.TYPING_PROMPT,
+								cursorColor: COLORS.TYPING_PROMPT,
+							}}
+							onContentChange={() => {
+								const text = searchInputRef.current?.plainText ?? "";
+								const cleaned = text.replace(/[\r\n]/g, "");
+								if (cleaned !== text) {
+									searchInputRef.current?.setText(cleaned);
+								}
+								setSearchQuery(cleaned);
+							}}
+							onKeyDown={(key) => {
+								if (key.eventType === "press") {
+									if (key.name === "escape") {
+										setIsSearchFocused(false);
+										key.preventDefault();
+									}
+									if (key.name === "return") {
+										key.preventDefault();
+									}
+								}
+							}}
+						/>
+					</box>
+				</box>
+
+				<box marginBottom={0}>
+					<text>
+						<span fg={COLORS.USER_LABEL}>— MEMORIES ({filteredMemories.length}) —</span>
+					</text>
+				</box>
+
+				{isLoading ? (
+					<box marginTop={1} paddingLeft={1}>
+						<text>
+							<span fg={COLORS.REASONING_DIM}>Loading memories...</span>
+						</text>
+					</box>
+				) : error ? (
+					<box marginTop={1} paddingLeft={1}>
+						<text>
+							<span fg={COLORS.STATUS_FAILED}>{error}</span>
+						</text>
+					</box>
+				) : filteredMemories.length === 0 ? (
+					<box marginTop={1} paddingLeft={1}>
+						<text>
+							<span fg={COLORS.REASONING_DIM}>
+								{searchQuery ? "No memories match your search" : "No memories stored yet"}
+							</span>
+						</text>
+					</box>
+				) : (
+					<scrollbox
+						ref={scrollRef}
+						height={scrollboxHeight}
+						alignSelf="flex-start"
+						focused={false}
+						scrollY={true}
+						scrollX={false}
+						style={{
+							rootOptions: { backgroundColor: COLORS.MENU_BG },
+							wrapperOptions: { backgroundColor: COLORS.MENU_BG },
+							viewportOptions: { backgroundColor: COLORS.MENU_BG },
+							contentOptions: { backgroundColor: COLORS.MENU_BG },
+						}}
+					>
+						<box flexDirection="column" width="100%">
+							{filteredMemories.map((memory, idx) => {
+								const isSelected = idx === selectedIndex;
+								const labelColor = isSelected ? COLORS.DAEMON_LABEL : COLORS.MENU_TEXT;
+								const detailColor = COLORS.REASONING_DIM;
+								const scoreText = memory.score !== undefined ? ` (${(memory.score * 100).toFixed(0)}%)` : "";
+								const dateText = formatTimestamp(memory.createdAt || memory.updatedAt);
+
+								return (
+									<box
+										key={memory.id}
+										backgroundColor={isSelected ? COLORS.MENU_SELECTED_BG : COLORS.MENU_BG}
+										paddingLeft={1}
+										paddingRight={1}
+										flexDirection="column"
+										width="100%"
+									>
+										<box>
+											<text>
+												<span fg={labelColor}>
+													{isSelected ? "▶ " : "  "}
+													{truncateText(memory.memory, 80)}
+												</span>
+												{scoreText && <span fg={COLORS.STATUS_COMPLETED}>{scoreText}</span>}
+											</text>
+										</box>
+										<box marginLeft={4}>
+											<text>
+												<span fg={detailColor}>
+													{dateText}
+													{memory.metadata?.category ? ` · ${memory.metadata.category}` : ""}
+												</span>
+											</text>
+										</box>
+									</box>
+								);
+							})}
+						</box>
+					</scrollbox>
+				)}
+			</box>
+		</box>
+	);
+}

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

@@ -43,6 +43,8 @@ export interface UseAppContextBuilderParams {
 		setShowUrlMenu: React.Dispatch<React.SetStateAction<boolean>>;
 		showToolsMenu: boolean;
 		setShowToolsMenu: React.Dispatch<React.SetStateAction<boolean>>;
+		showMemoryMenu: boolean;
+		setShowMemoryMenu: React.Dispatch<React.SetStateAction<boolean>>;
 	};
 
 	device: {

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

@@ -91,6 +91,8 @@ export function useAppController({
 		setShowUrlMenu,
 		showToolsMenu,
 		setShowToolsMenu,
+		showMemoryMenu,
+		setShowMemoryMenu,
 	} = menus;
 
 	const session = useSessionController({ showSessionMenu });
@@ -286,6 +288,7 @@ export function useAppController({
 			setShowGroundingMenu,
 			setShowUrlMenu,
 			setShowToolsMenu,
+			setShowMemoryMenu,
 			setTypingInput: daemon.typing.setTypingInput,
 			setCurrentTranscription: daemon.setCurrentTranscription,
 			setCurrentResponse: daemon.setCurrentResponse,
@@ -310,6 +313,7 @@ export function useAppController({
 			setShowGroundingMenu,
 			setShowUrlMenu,
 			setShowToolsMenu,
+			setShowMemoryMenu,
 			daemon.typing.setTypingInput,
 			daemon.setCurrentTranscription,
 			daemon.setCurrentResponse,
@@ -335,6 +339,7 @@ export function useAppController({
 			showGroundingMenu,
 			showUrlMenu,
 			showToolsMenu,
+			showMemoryMenu,
 			onboardingActive: bootstrap.onboardingActive,
 		},
 		{
@@ -347,6 +352,7 @@ export function useAppController({
 			setShowGroundingMenu,
 			setShowUrlMenu,
 			setShowToolsMenu,
+			setShowMemoryMenu,
 		}
 	);
 
@@ -437,6 +443,8 @@ export function useAppController({
 			setShowUrlMenu,
 			showToolsMenu,
 			setShowToolsMenu,
+			showMemoryMenu,
+			setShowMemoryMenu,
 		},
 		device: {
 			devices: bootstrap.devices,

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

@@ -27,6 +27,9 @@ export interface UseAppMenusReturn {
 
 	showToolsMenu: boolean;
 	setShowToolsMenu: React.Dispatch<React.SetStateAction<boolean>>;
+
+	showMemoryMenu: boolean;
+	setShowMemoryMenu: React.Dispatch<React.SetStateAction<boolean>>;
 }
 
 export function useAppMenus(): UseAppMenusReturn {
@@ -39,6 +42,7 @@ export function useAppMenus(): UseAppMenusReturn {
 	const [showGroundingMenu, setShowGroundingMenu] = useState(false);
 	const [showUrlMenu, setShowUrlMenu] = useState(false);
 	const [showToolsMenu, setShowToolsMenu] = useState(false);
+	const [showMemoryMenu, setShowMemoryMenu] = useState(false);
 
 	return {
 		showDeviceMenu,
@@ -59,5 +63,7 @@ export function useAppMenus(): UseAppMenusReturn {
 		setShowUrlMenu,
 		showToolsMenu,
 		setShowToolsMenu,
+		showMemoryMenu,
+		setShowMemoryMenu,
 	};
 }

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

@@ -25,6 +25,7 @@ export interface KeyboardHandlerActions {
 	setShowGroundingMenu: (show: boolean) => void;
 	setShowUrlMenu: (show: boolean) => void;
 	setShowToolsMenu: (show: boolean) => void;
+	setShowMemoryMenu: (show: boolean) => void;
 	setTypingInput: (input: string | ((prev: string) => string)) => void;
 	setCurrentTranscription: (text: string) => void;
 	setCurrentResponse: (text: string) => void;
@@ -54,6 +55,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 		actions.setShowGroundingMenu(false);
 		actions.setShowUrlMenu(false);
 		actions.setShowToolsMenu(false);
+		actions.setShowMemoryMenu(false);
 	}, [actions]);
 
 	const handleKeyPress = useCallback(
@@ -232,6 +234,20 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				return;
 			}
 
+			// 'B' key to open memory menu (in IDLE, SPEAKING, or RESPONDING state)
+			if (
+				(key.sequence === "b" || key.sequence === "B") &&
+				key.eventType === "press" &&
+				(currentState === DaemonState.IDLE ||
+					currentState === DaemonState.SPEAKING ||
+					currentState === DaemonState.RESPONDING)
+			) {
+				closeAllMenus();
+				actions.setShowMemoryMenu(true);
+				key.preventDefault();
+				return;
+			}
+
 			// 'R' key to toggle full reasoning display (in IDLE, SPEAKING, or RESPONDING state)
 			if (
 				(key.sequence === "r" || key.sequence === "R") &&
@@ -293,7 +309,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				!key.meta &&
 				currentState !== DaemonState.TYPING
 			) {
-				if (currentState === DaemonState.IDLE) {
+				if (currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) {
 					// Check for OpenRouter API key first (needed for any AI response)
 					if (!process.env.OPENROUTER_API_KEY) {
 						actions.setApiKeyMissingError(

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

@@ -10,6 +10,7 @@ export interface OverlayControllerState {
 	showGroundingMenu: boolean;
 	showUrlMenu: boolean;
 	showToolsMenu: boolean;
+	showMemoryMenu: boolean;
 	onboardingActive: boolean;
 }
 
@@ -23,6 +24,7 @@ export interface OverlayControllerActions {
 	setShowGroundingMenu: (show: boolean) => void;
 	setShowUrlMenu: (show: boolean) => void;
 	setShowToolsMenu: (show: boolean) => void;
+	setShowMemoryMenu: (show: boolean) => void;
 }
 
 export function useOverlayController(state: OverlayControllerState, actions: OverlayControllerActions) {
@@ -36,6 +38,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		showGroundingMenu,
 		showUrlMenu,
 		showToolsMenu,
+		showMemoryMenu,
 		onboardingActive,
 	} = state;
 
@@ -50,6 +53,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 			showGroundingMenu ||
 			showUrlMenu ||
 			showToolsMenu ||
+			showMemoryMenu ||
 			onboardingActive
 		);
 	}, [
@@ -62,6 +66,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		showGroundingMenu,
 		showUrlMenu,
 		showToolsMenu,
+		showMemoryMenu,
 		onboardingActive,
 	]);
 
@@ -75,6 +80,7 @@ export function useOverlayController(state: OverlayControllerState, actions: Ove
 		actions.setShowGroundingMenu(false);
 		actions.setShowUrlMenu(false);
 		actions.setShowToolsMenu(false);
+		actions.setShowMemoryMenu(false);
 	}, [actions]);
 
 	return {

package/src/state/app-context.tsx

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

package/src/state/daemon-state.ts

@@ -183,10 +183,18 @@ class DaemonStateManager {
 	 * Start listening for voice input (called when space is pressed)
 	 */
 	startListening(): void {
-		if (this._state !== DaemonState.IDLE && this._state !== DaemonState.TYPING) {
+		if (
+			this._state !== DaemonState.IDLE &&
+			this._state !== DaemonState.TYPING &&
+			this._state !== DaemonState.SPEAKING
+		) {
 			return;
 		}
 
+		if (this._state === DaemonState.SPEAKING) {
+			this.stopSpeaking();
+		}
+
 		this._transcription = "";
 		this._response = "";
 		this.setState(DaemonState.LISTENING);

package/src/types/index.ts

@@ -442,3 +442,39 @@ export interface UrlMenuItem {
 	error?: string;
 	lastSeenIndex: number;
 }
+
+// ============================================================
+// Memory Types
+// ============================================================
+
+/** A single memory entry returned from mem0 */
+export interface MemoryEntry {
+	id: string;
+	memory: string;
+	hash?: string;
+	metadata?: Record<string, unknown>;
+	score?: number;
+	createdAt?: string;
+	updatedAt?: string;
+}
+
+/** Result from memory search operations */
+export interface MemorySearchResult {
+	results: MemoryEntry[];
+}
+
+/** Result from memory add operations */
+export interface MemoryAddResult {
+	results: Array<{
+		id: string;
+		memory: string;
+		event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+	}>;
+}
+
+/** Memory context injected into first message */
+export interface MemoryContext {
+	memories: MemoryEntry[];
+	retrievedAt: number;
+	query: string;
+}

package/src/utils/config.ts

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { getAppConfigDir } from "./preferences";
+
+const CONFIG_FILE = "config.json";
+
+export interface ManualConfig {
+	memoryModel?: string;
+}
+
+let cachedConfig: ManualConfig | null = null;
+let configLoadedAt: number | null = null;
+
+const CACHE_TTL_MS = 5000;
+
+function getConfigPath(): string {
+	return path.join(getAppConfigDir(), CONFIG_FILE);
+}
+
+export function loadManualConfig(): ManualConfig {
+	const now = Date.now();
+
+	if (cachedConfig !== null && configLoadedAt !== null && now - configLoadedAt < CACHE_TTL_MS) {
+		return cachedConfig;
+	}
+
+	const configPath = getConfigPath();
+
+	if (!existsSync(configPath)) {
+		cachedConfig = {};
+		configLoadedAt = now;
+		return cachedConfig;
+	}
+
+	try {
+		const contents = readFileSync(configPath, "utf8");
+		const parsed = JSON.parse(contents) as unknown;
+
+		if (typeof parsed !== "object" || parsed === null) {
+			cachedConfig = {};
+		} else {
+			cachedConfig = parseManualConfig(parsed as Record<string, unknown>);
+		}
+	} catch {
+		cachedConfig = {};
+	}
+
+	configLoadedAt = now;
+	return cachedConfig;
+}
+
+function parseManualConfig(raw: Record<string, unknown>): ManualConfig {
+	const config: ManualConfig = {};
+
+	if (typeof raw.memoryModel === "string" && raw.memoryModel.trim().length > 0) {
+		config.memoryModel = raw.memoryModel.trim();
+	}
+
+	return config;
+}
+
+export function clearConfigCache(): void {
+	cachedConfig = null;
+	configLoadedAt = null;
+}