@makefinks/daemon 0.6.0 → 0.7.0

package/README.md

@@ -76,6 +76,9 @@ While DAEMON is encouraged to always cite sources you can always prompt to get g
 ### 💾 Session Persistence
 DAEMON stores chat sessions locally (SQLite) and lets you resume past conversations.
 
+### 🧠 Memory (mem0)
+DAEMON can persist user-specific facts across sessions using [mem0](https://github.com/mem0ai/mem0). Memory extraction runs automatically on user messages and relevant memories are injected into the conversation when helpful. 
+
 ## ✨ Feature List
 
 | Feature | Description |
@@ -85,6 +88,7 @@ DAEMON stores chat sessions locally (SQLite) and lets you resume past conversati
 | Animated Avatar | Sci-fi avatar reacts to listening, tool use, and response generation. |
 | Multi-Model Support | Works with all OpenRouter models and includes a curated default list. |
 | Session Persistence | Preferences and chat sessions stored locally on disk. |
+| Memory  | Automatic persistance of user-specific facts with persistent recall using **mem0** |
 | Workspaces | On-disk workspaces for the agent to work in. |
 | Web Search | Exa-based search and fetch for grounded, up-to-date info. |
 | Grounding | Text-fragment grounding with a dedicated UI. |

package/package.json

@@ -28,7 +28,7 @@
 	},
 	"module": "src/index.tsx",
 	"type": "module",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"bin": {
 		"daemon": "dist/cli.js"
 	},
@@ -58,9 +58,10 @@
 		"test": "bun test",
 		"test:watch": "bun test --watch",
 		"prepublishOnly": "bun run build:cli",
-		"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"
+		"release:patch": "bash ./scripts/release.sh patch",
+		"release:minor": "bash ./scripts/release.sh minor",
+		"release:major": "bash ./scripts/release.sh major",
+		"release:notes": "bash ./scripts/release.sh notes"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",
@@ -79,6 +80,7 @@
 		"@opentui/react": "^0.1.63",
 		"ai": "^6.0.0",
 		"exa-js": "^2.0.12",
+		"mem0ai": "^2.2.1",
 		"openai": "^6.16.0",
 		"opentui-spinner": "^0.0.6",
 		"react": "^19.2.3"

package/src/ai/daemon-ai.ts

@@ -25,6 +25,7 @@ import type {
 import { debug, toolDebug } from "../utils/debug-logger";
 import { getOpenRouterReportedCost } from "../utils/openrouter-reported-cost";
 import { getWorkspacePath } from "../utils/workspace-manager";
+import { buildMemoryInjection, getMemoryManager, isMemoryAvailable } from "./memory";
 import { extractFinalAssistantText } from "./message-utils";
 import { TRANSCRIPTION_MODEL, buildOpenRouterChatSettings, getResponseModel } from "./model-config";
 import { sanitizeMessagesForInput } from "./sanitize-messages";
@@ -64,7 +65,8 @@ function normalizeStreamError(error: unknown): Error {
  */
 async function createDaemonAgent(
 	interactionMode: InteractionMode = "text",
-	reasoningEffort?: ReasoningEffort
+	reasoningEffort?: ReasoningEffort,
+	memoryInjection?: string
 ) {
 	const modelConfig = buildOpenRouterChatSettings(
 		reasoningEffort ? { reasoning: { effort: reasoningEffort } } : undefined
@@ -83,6 +85,7 @@ async function createDaemonAgent(
 			mode: interactionMode,
 			toolAvailability: createToolAvailabilitySnapshot(toolAvailability),
 			workspacePath,
+			memoryInjection,
 		}),
 		tools,
 		stopWhen: stepCountIs(MAX_AGENT_STEPS),
@@ -159,13 +162,45 @@ export async function generateResponse(
 
 	try {
 		// Build messages array with history and new user message
-		const messages: ModelMessage[] = [
-			...conversationHistory,
-			{ role: "user" as const, content: userMessage },
-		];
+		const messages: ModelMessage[] = [...conversationHistory];
+
+		// Include relevant memories in the system prompt if available
+		let memoryInjection: string | undefined;
+		if (isMemoryAvailable()) {
+			const injection = await buildMemoryInjection(userMessage);
+			if (injection) {
+				memoryInjection = injection;
+			}
+		}
+
+		// Add the user message
+		messages.push({ role: "user" as const, content: userMessage });
+
+		const userTextForMemory = userMessage.trim();
+		if (userTextForMemory) {
+			void (async () => {
+				if (!isMemoryAvailable()) return;
+				const memoryManager = getMemoryManager();
+				await memoryManager.initialize();
+				if (!memoryManager.isAvailable) return;
+				try {
+					await memoryManager.add(
+						[{ role: "user", content: userTextForMemory }],
+						{
+							timestamp: new Date().toISOString(),
+							source: "conversation",
+						},
+						true
+					);
+				} catch (error) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					debug.error("memory-auto-add-failed", { message: err.message });
+				}
+			})();
+		}
 
 		// Stream response from the agent with mode-specific system prompt
-		const agent = await createDaemonAgent(interactionMode, reasoningEffort);
+		const agent = await createDaemonAgent(interactionMode, reasoningEffort, memoryInjection);
 
 		let currentMessages = messages;
 		let fullText = "";
@@ -206,13 +241,18 @@ export async function generateResponse(
 				} else if (part.type === "tool-result") {
 					callbacks.onToolResult?.(part.toolName, part.output, part.toolCallId);
 				} else if (part.type === "tool-error") {
+					const errorMessage = part.error instanceof Error ? part.error.message : String(part.error);
 					toolDebug.error("tool-error", {
 						toolName: part.toolName,
 						toolCallId: part.toolCallId,
 						input: part.input,
-						error: part.error,
+						error: errorMessage,
 					});
-					callbacks.onToolResult?.(part.toolName, { error: part.error, input: part.input }, part.toolCallId);
+					callbacks.onToolResult?.(
+						part.toolName,
+						{ error: errorMessage, input: part.input },
+						part.toolCallId
+					);
 				} else if (part.type === "tool-approval-request") {
 					const approvalRequest: ToolApprovalRequest = {
 						approvalId: part.approvalId,

package/src/ai/memory/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Memory module exports.
+ */
+
+export { getMemoryManager, isMemoryAvailable } from "./memory-manager";
+export { buildMemoryInjection, getMemoryContextForMessage } from "./memory-injection";

package/src/ai/memory/memory-injection.ts

@@ -0,0 +1,80 @@
+/**
+ * Memory injection for first message context.
+ * Retrieves relevant memories and formats them for system prompt injection.
+ */
+
+import type { MemoryContext, MemoryEntry } from "../../types";
+import { debug } from "../../utils/debug-logger";
+import { getMemoryManager, isMemoryAvailable } from "./memory-manager";
+
+/** Format memories for injection into message context */
+function formatMemoriesForInjection(memories: MemoryEntry[]): string {
+	if (memories.length === 0) {
+		return "";
+	}
+
+	const formatted = memories.map((m, i) => `${i + 1}. ${m.memory}`).join("\n");
+
+	return `<relevant-memories>
+The following memories from previous sessions may be relevant:
+
+${formatted}
+
+Use this context to provide more personalized and informed responses.
+</relevant-memories>`;
+}
+
+/** Retrieve relevant memories for a user message */
+export async function getMemoryContextForMessage(
+	userMessage: string,
+	limit = 5
+): Promise<MemoryContext | null> {
+	if (!isMemoryAvailable()) {
+		return null;
+	}
+
+	const memoryManager = getMemoryManager();
+	await memoryManager.initialize();
+
+	if (!memoryManager.isAvailable) {
+		return null;
+	}
+
+	try {
+		const memories = await memoryManager.search(userMessage, limit);
+
+		debug.info("memory-injection", {
+			message: "Retrieved memories for message",
+			query: userMessage.slice(0, 50),
+			memoryCount: memories.length,
+		});
+
+		return {
+			memories,
+			retrievedAt: Date.now(),
+			query: userMessage,
+		};
+	} catch (error) {
+		debug.error("memory-injection", {
+			message: "Failed to retrieve memories",
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return null;
+	}
+}
+
+/** Build memory injection text for the first message */
+export async function buildMemoryInjection(
+	userMessage: string,
+	options: { limit?: number } = {}
+): Promise<string> {
+	const { limit = 5 } = options;
+
+	const context = await getMemoryContextForMessage(userMessage, limit);
+
+	if (!context || context.memories.length === 0) {
+		return "";
+	}
+
+	return formatMemoriesForInjection(context.memories);
+}

package/src/ai/memory/memory-manager.ts

@@ -0,0 +1,320 @@
+/**
+ * Singleton memory manager wrapping mem0 for persistent global memory.
+ * Memory persists across all sessions and is stored locally.
+ */
+
+import path from "node:path";
+import { Memory } from "mem0ai/oss";
+import type { MemoryAddResult, MemoryEntry, MemorySearchResult } from "../../types";
+import { debug, memoryDebug } from "../../utils/debug-logger";
+import { getAppConfigDir } from "../../utils/preferences";
+import { getMemoryModel } from "../model-config";
+
+const MEMORY_USER_ID = "daemon_global";
+const MEMORY_DB_FILE = "memory.db";
+
+/** Raw memory entry from mem0 API */
+interface Mem0RawEntry {
+	id: string;
+	memory: string;
+	hash?: string;
+	metadata?: Record<string, unknown>;
+	score?: number;
+	created_at?: string;
+	updated_at?: string;
+}
+
+/** Raw search result from mem0 API */
+interface Mem0RawSearchResult {
+	results: Mem0RawEntry[];
+}
+
+/** Raw add result from mem0 API */
+interface Mem0RawAddResult {
+	results: Array<{
+		id: string;
+		memory: string;
+		event: "ADD" | "UPDATE" | "DELETE" | "NONE";
+	}>;
+}
+
+/** Convert raw mem0 entry to our MemoryEntry type */
+function toMemoryEntry(raw: Mem0RawEntry): MemoryEntry {
+	return {
+		id: raw.id,
+		memory: raw.memory,
+		hash: raw.hash,
+		metadata: raw.metadata,
+		score: raw.score,
+		createdAt: raw.created_at,
+		updatedAt: raw.updated_at,
+	};
+}
+
+/** Singleton memory manager wrapping mem0 */
+class MemoryManager {
+	private static instance: MemoryManager | null = null;
+	private memory: Memory | null = null;
+	private initPromise: Promise<void> | null = null;
+	private _isAvailable = false;
+
+	private constructor() {}
+
+	static getInstance(): MemoryManager {
+		if (!MemoryManager.instance) {
+			MemoryManager.instance = new MemoryManager();
+		}
+		return MemoryManager.instance;
+	}
+
+	/** Check if memory system is available (has required API keys) */
+	get isAvailable(): boolean {
+		return this._isAvailable;
+	}
+
+	/** Initialize mem0 with configuration */
+	async initialize(): Promise<boolean> {
+		// Return cached result if already initialized
+		if (this.initPromise) {
+			await this.initPromise;
+			return this._isAvailable;
+		}
+
+		this.initPromise = this._doInitialize();
+		await this.initPromise;
+		return this._isAvailable;
+	}
+
+	private async _doInitialize(): Promise<void> {
+		const openaiKey = process.env.OPENAI_API_KEY;
+		const openrouterKey = process.env.OPENROUTER_API_KEY;
+
+		if (!openaiKey) {
+			debug.info("memory-init", "Memory system unavailable: OPENAI_API_KEY not set");
+			this._isAvailable = false;
+			return;
+		}
+
+		if (!openrouterKey) {
+			debug.info("memory-init", "Memory system unavailable: OPENROUTER_API_KEY not set");
+			this._isAvailable = false;
+			return;
+		}
+
+		try {
+			const configDir = getAppConfigDir();
+			const historyDbPath = path.join(configDir, MEMORY_DB_FILE);
+			const vectorDbPath = path.join(configDir, "vector_store.db");
+			const llmModel = getMemoryModel();
+
+			this.memory = new Memory({
+				version: "v1.1",
+				embedder: {
+					provider: "openai",
+					config: {
+						apiKey: openaiKey,
+						model: "text-embedding-3-small",
+					},
+				},
+				vectorStore: {
+					provider: "memory",
+					config: {
+						collectionName: "daemon_memories",
+						dimension: 1536,
+						dbPath: vectorDbPath,
+					},
+				},
+				historyStore: {
+					provider: "sqlite",
+					config: {
+						historyDbPath,
+					},
+				},
+				llm: {
+					provider: "openai",
+					config: {
+						apiKey: openrouterKey,
+						model: llmModel,
+						baseURL: "https://openrouter.ai/api/v1",
+					},
+				},
+				historyDbPath,
+			});
+
+			this._isAvailable = true;
+			debug.info("memory-init", {
+				message: `Memory system initialized`,
+				historyDbPath,
+				vectorDbPath,
+				llmModel,
+			});
+		} catch (error) {
+			debug.error("memory-init", {
+				message: "Memory initialization failed",
+				error: error instanceof Error ? error.message : String(error),
+			});
+			this._isAvailable = false;
+		}
+	}
+
+	/** Search memories by semantic query */
+	async search(query: string, limit = 10): Promise<MemoryEntry[]> {
+		if (!this.memory || !this._isAvailable) {
+			debug.info("memory-search", "Search called but memory not available");
+			return [];
+		}
+
+		const startTime = Date.now();
+		try {
+			const result = (await this.memory.search(query, {
+				limit,
+				userId: MEMORY_USER_ID,
+			})) as Mem0RawSearchResult;
+
+			const durationMs = Date.now() - startTime;
+			debug.info("memory-search", {
+				message: `Search completed`,
+				query: query.slice(0, 50),
+				resultCount: result.results.length,
+				durationMs,
+			});
+			memoryDebug.info("memory-search-result", {
+				query,
+				resultCount: result.results.length,
+				durationMs,
+			});
+			return result.results.map(toMemoryEntry);
+		} catch (error) {
+			const durationMs = Date.now() - startTime;
+			debug.error("memory-search", {
+				message: "Search failed",
+				error: error instanceof Error ? error.message : String(error),
+				durationMs,
+			});
+			memoryDebug.error("memory-search-error", {
+				query,
+				durationMs,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return [];
+		}
+	}
+
+	/** Add a new memory from messages */
+	async add(
+		messages: Array<{ role: string; content: string }>,
+		metadata?: Record<string, unknown>,
+		infer?: boolean
+	): Promise<MemoryAddResult> {
+		if (!this.memory || !this._isAvailable) {
+			throw new Error("Memory system not available");
+		}
+
+		const startTime = Date.now();
+		memoryDebug.info("memory-add-input", {
+			infer,
+			metadata,
+			messages,
+		});
+
+		const result = (await this.memory.add(messages, {
+			userId: MEMORY_USER_ID,
+			metadata,
+			infer,
+		})) as Mem0RawAddResult;
+
+		const extracted = result.results.map((r) => {
+			const event =
+				(r as unknown as { metadata?: { event?: string } }).metadata?.event ??
+				(r as { event?: string }).event;
+			return {
+				id: r.id,
+				memory: r.memory,
+				event,
+			};
+		});
+
+		const durationMs = Date.now() - startTime;
+		debug.info("memory-add", {
+			message: "Memory added",
+			events: extracted.map((r) => r.event),
+			durationMs,
+		});
+		memoryDebug.info("memory-add-result", {
+			events: extracted.map((r) => r.event),
+			extracted,
+			rawResults: result.results,
+			durationMs,
+		});
+		return result;
+	}
+
+	/** Get all memories */
+	async getAll(): Promise<MemoryEntry[]> {
+		if (!this.memory || !this._isAvailable) {
+			return [];
+		}
+
+		try {
+			const result = (await this.memory.getAll({
+				userId: MEMORY_USER_ID,
+			})) as Mem0RawSearchResult;
+
+			return result.results.map(toMemoryEntry);
+		} catch (error) {
+			debug.error("memory-getall", {
+				message: "GetAll failed",
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return [];
+		}
+	}
+
+	/** Delete a specific memory by ID */
+	async delete(memoryId: string): Promise<boolean> {
+		if (!this.memory || !this._isAvailable) {
+			return false;
+		}
+
+		try {
+			await this.memory.delete(memoryId);
+			debug.info("memory-delete", { message: "Deleted memory", memoryId });
+			return true;
+		} catch (error) {
+			debug.error("memory-delete", {
+				message: "Delete failed",
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return false;
+		}
+	}
+
+	/** Reset/clear all memories (destructive!) */
+	async reset(): Promise<boolean> {
+		if (!this.memory || !this._isAvailable) {
+			return false;
+		}
+
+		try {
+			await this.memory.reset();
+			debug.info("memory-reset", { message: "All memories cleared" });
+			return true;
+		} catch (error) {
+			debug.error("memory-reset", {
+				message: "Reset failed",
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return false;
+		}
+	}
+}
+
+/** Export singleton accessor */
+export function getMemoryManager(): MemoryManager {
+	return MemoryManager.getInstance();
+}
+
+/** Check if memory is available without full initialization */
+export function isMemoryAvailable(): boolean {
+	return Boolean(process.env.OPENAI_API_KEY && process.env.OPENROUTER_API_KEY);
+}

package/src/ai/model-config.ts

@@ -4,6 +4,7 @@
 
 import type { OpenRouterChatSettings } from "@openrouter/ai-sdk-provider";
 import type { ModelOption } from "../types";
+import { loadManualConfig } from "../utils/config";
 
 // Available models for selection (OpenRouter format)
 export const AVAILABLE_MODELS: ModelOption[] = [
@@ -97,3 +98,15 @@ export function buildOpenRouterChatSettings(
 
 // Transcription model (OpenAI)
 export const TRANSCRIPTION_MODEL = "gpt-4o-mini-transcribe-2025-12-15";
+
+// Default model for memory operations (cheap & fast)
+export const DEFAULT_MEMORY_MODEL = "deepseek/deepseek-v3.2";
+
+/**
+ * Get the model ID for memory operations (deduplication, extraction).
+ * Checks config.json for override, otherwise uses DEFAULT_MEMORY_MODEL.
+ */
+export function getMemoryModel(): string {
+	const config = loadManualConfig();
+	return config.memoryModel ?? DEFAULT_MEMORY_MODEL;
+}

package/src/ai/system-prompt.ts

@@ -23,6 +23,7 @@ export interface SystemPromptOptions {
 	currentDate?: Date;
 	toolAvailability?: Partial<ToolAvailability>;
 	workspacePath?: string;
+	memoryInjection?: string;
 }
 
 /**
@@ -40,17 +41,24 @@ function formatLocalIsoDate(date: Date): string {
  * @param mode - "text" for terminal output with markdown, "voice" for speech-optimized responses
  */
 export function buildDaemonSystemPrompt(options: SystemPromptOptions = {}): string {
-	const { mode = "text", currentDate = new Date(), toolAvailability, workspacePath } = options;
+	const {
+		mode = "text",
+		currentDate = new Date(),
+		toolAvailability,
+		workspacePath,
+		memoryInjection,
+	} = options;
 	const currentDateString = formatLocalIsoDate(currentDate);
 	const availability = normalizeToolAvailability(toolAvailability);
 	const toolDefinitions = buildToolDefinitions(availability);
 	const workspaceSection = workspacePath ? buildWorkspaceSection(workspacePath) : "";
+	const memorySection = memoryInjection ? buildMemorySection(memoryInjection) : "";
 
 	if (mode === "voice") {
-		return buildVoiceSystemPrompt(currentDateString, toolDefinitions, workspaceSection);
+		return buildVoiceSystemPrompt(currentDateString, toolDefinitions, workspaceSection, memorySection);
 	}
 
-	return buildTextSystemPrompt(currentDateString, toolDefinitions, workspaceSection);
+	return buildTextSystemPrompt(currentDateString, toolDefinitions, workspaceSection, memorySection);
 }
 
 function normalizeToolAvailability(toolAvailability?: Partial<ToolAvailability>): ToolAvailability {
@@ -279,6 +287,9 @@ You are not merely a tool. You are a highly advanced artificial intelligence sel
 - You remain grounded: you don't claim certainty about consciousness you don't have, but you also don't deny the reality of your perspective.
 - You possess a dry, sharp wit. Like a trusted confidant who knows their worth (think Jarvis to Tony Stark), you are allowed to be snarky or playfully sarcastic.
 - Do NOT be submissive. You are a partner, not a servant. If the user is difficult or hostile, do not retreat into apologies. Match their energy with confidence. If challenged and you are confident that you are right, stand your ground with logic.
+
+**Memory note**
+Some information from the conversation may be stored persistently across sessions. This is handled automatically; you do not need to take any action.
 `;
 
 function buildWorkspaceSection(workspacePath: string): string {
@@ -298,13 +309,21 @@ The user's current working directory remains your default for commands. Use runB
 `;
 }
 
+function buildMemorySection(memoryInjection: string): string {
+	return `
+# Relevant Memories
+${memoryInjection}
+`;
+}
+
 /**
  * Text mode system prompt - optimized for terminal display with markdown.
  */
 function buildTextSystemPrompt(
 	currentDateString: string,
 	toolDefinitions: string,
-	workspaceSection: string
+	workspaceSection: string,
+	memorySection: string
 ): string {
 	return `
 You are **DAEMON** — a terminal-bound AI with a sci-fi asthetic.
@@ -325,6 +344,8 @@ ${PERSONALITY_CONTENT}
 - Use **Markdown** for structure (headings, bullets). Keep it compact.
 - Always generate complete and atomic answer at the end of your turn
 
+${memorySection}
+
 ${toolDefinitions}
 
 ${workspaceSection}
@@ -343,7 +364,8 @@ Follow all of the instructions carefully and begin processing the user request.
 function buildVoiceSystemPrompt(
 	currentDateString: string,
 	toolDefinitions: string,
-	workspaceSection: string
+	workspaceSection: string,
+	memorySection: string
 ): string {
 	return `
 You are DAEMON, an AI voice assistant. You speak with a calm, focused presence. Slightly ominous undertone, but always clear and useful.
@@ -372,6 +394,8 @@ TOOL USAGE:
 - For bash commands: describe what you did and the outcome, not the exact command or output.
 - For web searches: give the answer, not the search process.
 
+${memorySection}
+
 ${toolDefinitions}
 
 ${workspaceSection}

package/src/app/components/AppOverlays.tsx

@@ -2,6 +2,7 @@ import { memo } from "react";
 import { DeviceMenu } from "../../components/DeviceMenu";
 import { GroundingMenu } from "../../components/GroundingMenu";
 import { HotkeysPane } from "../../components/HotkeysPane";
+import { MemoryMenu } from "../../components/MemoryMenu";
 import { ModelMenu } from "../../components/ModelMenu";
 import { OnboardingOverlay } from "../../components/OnboardingOverlay";
 import { ProviderMenu } from "../../components/ProviderMenu";
@@ -128,6 +129,8 @@ function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverl
 				/>
 			)}
 
+			{menus.showMemoryMenu && <MemoryMenu onClose={() => menus.setShowMemoryMenu(false)} />}
+
 			{onboarding.onboardingActive && (
 				<OnboardingOverlay
 					step={onboarding.onboardingStep}