@makefinks/daemon 0.7.2 → 0.9.0

package/package.json

@@ -28,7 +28,7 @@
 	},
 	"module": "src/index.tsx",
 	"type": "module",
-	"version": "0.7.2",
+	"version": "0.9.0",
 	"bin": {
 		"daemon": "dist/cli.js"
 	},
@@ -73,6 +73,7 @@
 		"typescript": "^5.9.2"
 	},
 	"dependencies": {
+		"@ai-sdk/mcp": "^1.0.14",
 		"@ai-sdk/openai": "^3.0.0",
 		"@openrouter/ai-sdk-provider": "^2.1.0",
 		"@opentui-ui/toast": "^0.0.3",

package/src/ai/agent-turn-runner.ts

@@ -40,6 +40,7 @@ export class AgentTurnRunner {
 		this.abortController = new AbortController();
 
 		const isActive = () => runId === this.activeRunId && this.abortController !== null;
+		const isCurrent = () => runId === this.activeRunId;
 
 		let result: AgentTurnResult | null = null;
 		let error: Error | null = null;
@@ -93,6 +94,10 @@ export class AgentTurnRunner {
 				if (!isActive()) return;
 				callbacks.onStepUsage?.(usage);
 			},
+			onMemorySaved: (preview) => {
+				if (!isCurrent()) return;
+				callbacks.onMemorySaved?.(preview);
+			},
 			onComplete: (fullText, responseMessages, usage, finalText) => {
 				if (!isActive()) return;
 				result = { fullText, responseMessages, usage, finalText };

package/src/ai/daemon-ai.ts

@@ -21,6 +21,8 @@ import type {
 	ToolApprovalRequest,
 	ToolApprovalResponse,
 	TranscriptionResult,
+	MemoryToastPreview,
+	MemoryToastOperation,
 } from "../types";
 import { debug, toolDebug } from "../utils/debug-logger";
 import { getOpenRouterReportedCost } from "../utils/openrouter-reported-cost";
@@ -166,7 +168,7 @@ export async function generateResponse(
 
 		// Include relevant memories in the system prompt if available
 		let memoryInjection: string | undefined;
-		if (isMemoryAvailable()) {
+		if (getDaemonManager().memoryEnabled && isMemoryAvailable()) {
 			const injection = await buildMemoryInjection(userMessage);
 			if (injection) {
 				memoryInjection = injection;
@@ -176,29 +178,6 @@ export async function generateResponse(
 		// 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, memoryInjection);
 
@@ -317,6 +296,11 @@ export async function generateResponse(
 		}
 
 		callbacks.onComplete?.(fullText, allResponseMessages, undefined, finalText);
+
+		void persistConversationMemory(userMessage, finalText ?? fullText).then((preview) => {
+			if (!preview) return;
+			callbacks.onMemorySaved?.(preview);
+		});
 	} catch (error) {
 		// Check if this was an abort - don't treat as error
 		if (abortSignal?.aborted) {
@@ -334,6 +318,72 @@ export async function generateResponse(
 	}
 }
 
+async function persistConversationMemory(
+	userMessage: string,
+	assistantMessage: string
+): Promise<string | null> {
+	const userTextForMemory = userMessage.trim();
+	const assistantTextForMemory = assistantMessage.trim();
+
+	if (!userTextForMemory || !assistantTextForMemory) return null;
+	if (!getDaemonManager().memoryEnabled) return null;
+	if (!isMemoryAvailable()) return null;
+
+	const memoryManager = getMemoryManager();
+	await memoryManager.initialize();
+	if (!memoryManager.isAvailable) return null;
+
+	try {
+		const memoryMessages = [
+			{ role: "user", content: `<user>${userTextForMemory}</user>` },
+			{ role: "assistant", content: `<assistant>${assistantTextForMemory}</assistant>` },
+		];
+		const result = await memoryManager.add(
+			memoryMessages,
+			{
+				timestamp: new Date().toISOString(),
+				source: "conversation",
+			},
+			true
+		);
+		return buildMemoryToastPreview(result.results);
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		debug.error("memory-auto-add-failed", { message: err.message });
+		return null;
+	}
+}
+
+function buildMemoryToastPreview(
+	results: Array<{ memory: string; event: "ADD" | "UPDATE" | "DELETE" | "NONE" }>
+): MemoryToastPreview | null {
+	if (results.length === 0) return null;
+
+	const saved = results.filter((entry) => entry.event === "ADD" || entry.event === "UPDATE");
+	if (saved.length === 0) return null;
+
+	const previewEntries = saved.length > 2 ? saved.slice(-2) : saved;
+	const lines = previewEntries.map((entry) => `• ${truncatePreview(entry.memory, 52)}`);
+	if (saved.length > previewEntries.length) {
+		lines.push(`• +${saved.length - previewEntries.length} more`);
+	}
+
+	const hasUpdate = saved.some((entry) => entry.event === "UPDATE");
+	const operation: MemoryToastOperation = hasUpdate ? "UPDATE" : "ADD";
+
+	return {
+		operation,
+		description: lines.join("\n"),
+	};
+}
+
+function truncatePreview(text: string, maxChars: number): string {
+	const trimmed = text.trim();
+	if (trimmed.length <= maxChars) return trimmed;
+	if (maxChars <= 1) return "…";
+	return `${trimmed.slice(0, maxChars - 1)}…`;
+}
+
 /**
  * Generate a short descriptive title for a session based on the first user message.
  * Uses the currently selected model.

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

@@ -0,0 +1,348 @@
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+import { type MCPClient, createMCPClient } from "@ai-sdk/mcp";
+import type { ToolSet } from "ai";
+
+import { type McpServerConfig, type McpTransportType, loadManualConfig } from "../../utils/config";
+import { debug } from "../../utils/debug-logger";
+
+export type McpServerLifecycleStatus = "idle" | "loading" | "ready" | "error";
+
+export interface McpServerStatus {
+	id: string;
+	type: McpTransportType;
+	url: string;
+	status: McpServerLifecycleStatus;
+	toolCount: number;
+	error?: string;
+}
+
+export interface McpToolMeta {
+	internalName: string;
+	serverId: string;
+	originalToolName: string;
+}
+
+type McpServerResolvedConfig = {
+	id: string;
+	type: McpTransportType;
+	url: string;
+};
+
+const MAX_TOOL_NAME_LENGTH = 64;
+
+function sanitizeNamePart(raw: string): string {
+	const cleaned = raw
+		.replace(/[^a-zA-Z0-9_-]/g, "_")
+		.replace(/_+/g, "_")
+		.replace(/^_+/, "")
+		.replace(/_+$/, "");
+	return cleaned.length > 0 ? cleaned : "x";
+}
+
+function shortHash(input: string): string {
+	return createHash("sha1").update(input).digest("hex").slice(0, 8);
+}
+
+function deriveServerIdFromUrl(url: string): string | null {
+	try {
+		const parsed = new URL(url);
+		const host = parsed.hostname;
+		if (!host) return null;
+		const port = parsed.port ? `_${parsed.port}` : "";
+		return `${host}${port}`;
+	} catch {
+		return null;
+	}
+}
+
+function ensureUniqueId(base: string, used: Set<string>): string {
+	let candidate = base;
+	let i = 2;
+	while (used.has(candidate)) {
+		candidate = `${base}-${i}`;
+		i++;
+	}
+	used.add(candidate);
+	return candidate;
+}
+
+function buildInternalToolName(serverId: string, toolName: string, used: Set<string>): string {
+	const serverPart = sanitizeNamePart(serverId);
+	const toolPart = sanitizeNamePart(toolName);
+	const base = `mcp_${serverPart}__${toolPart}`;
+	if (base.length <= MAX_TOOL_NAME_LENGTH && !used.has(base)) {
+		used.add(base);
+		return base;
+	}
+
+	const hash = shortHash(`${serverId}\0${toolName}`);
+	let left = serverPart;
+	let right = toolPart;
+	let candidate = `mcp_${left}__${right}__${hash}`;
+	if (candidate.length > MAX_TOOL_NAME_LENGTH) {
+		const maxRight = Math.max(8, MAX_TOOL_NAME_LENGTH - `mcp_${left}____${hash}`.length);
+		right = right.slice(0, maxRight);
+		candidate = `mcp_${left}__${right}__${hash}`;
+	}
+
+	if (candidate.length > MAX_TOOL_NAME_LENGTH) {
+		candidate = candidate.slice(0, MAX_TOOL_NAME_LENGTH);
+	}
+
+	if (!used.has(candidate)) {
+		used.add(candidate);
+		return candidate;
+	}
+
+	let counter = 2;
+	let next = candidate;
+	while (used.has(next)) {
+		const counterHash = shortHash(`${serverId}\0${toolName}\0${counter}`);
+		next = `mcp_${left}__${right}__${counterHash}`;
+		if (next.length > MAX_TOOL_NAME_LENGTH) {
+			next = next.slice(0, MAX_TOOL_NAME_LENGTH);
+		}
+		counter++;
+	}
+	used.add(next);
+	return next;
+}
+
+function resolveServerConfigs(raw: McpServerConfig[] | undefined): McpServerResolvedConfig[] {
+	if (!raw || raw.length === 0) return [];
+	const usedIds = new Set<string>();
+	const out: McpServerResolvedConfig[] = [];
+
+	for (const entry of raw) {
+		if (!entry || typeof entry !== "object") continue;
+		const type = entry.type;
+		const url = entry.url;
+		if ((type !== "http" && type !== "sse") || typeof url !== "string" || url.trim().length === 0) continue;
+		const derivedId = entry.id?.trim() ? entry.id.trim() : deriveServerIdFromUrl(url.trim());
+		const id = derivedId
+			? ensureUniqueId(derivedId, usedIds)
+			: ensureUniqueId(`server-${out.length + 1}`, usedIds);
+		out.push({ id, type, url: url.trim() });
+	}
+
+	return out;
+}
+
+class McpManager extends EventEmitter {
+	private started = false;
+	private loadRunId = 0;
+
+	private servers: McpServerStatus[] = [];
+	private mergedTools: ToolSet = {};
+	private toolMetaByName = new Map<string, McpToolMeta>();
+	private internalNamesByServer = new Map<string, Set<string>>();
+
+	private clientsByServer = new Map<string, MCPClient>();
+	private toolsByServer = new Map<string, ToolSet>();
+
+	start(): void {
+		if (this.started) return;
+		this.started = true;
+		setImmediate(() => {
+			void this.loadFromConfig();
+		});
+	}
+
+	getServersSnapshot(): McpServerStatus[] {
+		return this.servers.map((s) => ({ ...s }));
+	}
+
+	getToolsSnapshot(): ToolSet {
+		return this.mergedTools;
+	}
+
+	getToolMeta(toolName: string): McpToolMeta | null {
+		return this.toolMetaByName.get(toolName) ?? null;
+	}
+
+	async closeAll(): Promise<void> {
+		const clients = [...this.clientsByServer.values()];
+		this.clientsByServer.clear();
+		await Promise.allSettled(clients.map((client) => client.close()));
+	}
+
+	private emitUpdate(): void {
+		this.emit("update");
+	}
+
+	private rebuildMergedTools(): void {
+		const merged: ToolSet = {};
+		for (const tools of this.toolsByServer.values()) {
+			Object.assign(merged, tools);
+		}
+		this.mergedTools = merged;
+	}
+
+	private clearServerTools(serverId: string): void {
+		const internalNames = this.internalNamesByServer.get(serverId);
+		if (internalNames) {
+			for (const internalName of internalNames) {
+				this.toolMetaByName.delete(internalName);
+			}
+		}
+		this.internalNamesByServer.delete(serverId);
+		this.toolsByServer.delete(serverId);
+	}
+
+	private setServerStatus(next: McpServerStatus): void {
+		const idx = this.servers.findIndex((s) => s.id === next.id);
+		if (idx >= 0) {
+			const copy = [...this.servers];
+			copy[idx] = next;
+			this.servers = copy;
+		} else {
+			this.servers = [...this.servers, next];
+		}
+		this.emitUpdate();
+	}
+
+	private async loadFromConfig(): Promise<void> {
+		const runId = ++this.loadRunId;
+		const config = loadManualConfig();
+		const servers = resolveServerConfigs(config.mcpServers);
+
+		this.servers = servers.map((server) => ({
+			id: server.id,
+			type: server.type,
+			url: server.url,
+			status: "loading" as const,
+			toolCount: 0,
+		}));
+		this.emitUpdate();
+
+		if (servers.length === 0) {
+			this.mergedTools = {};
+			this.toolMetaByName.clear();
+			this.internalNamesByServer.clear();
+			this.toolsByServer.clear();
+			this.emitUpdate();
+			return;
+		}
+
+		await Promise.allSettled(
+			servers.map(async (server) => {
+				if (runId !== this.loadRunId) return;
+				await this.loadSingleServer(server, runId);
+			})
+		);
+	}
+
+	private async loadSingleServer(server: McpServerResolvedConfig, runId: number): Promise<void> {
+		const startedAt = Date.now();
+		const currentStatus = this.servers.find((s) => s.id === server.id);
+		if (!currentStatus || runId !== this.loadRunId) return;
+
+		this.setServerStatus({
+			id: server.id,
+			type: server.type,
+			url: server.url,
+			status: "loading",
+			toolCount: 0,
+		});
+
+		let client: MCPClient | null = null;
+		try {
+			client = await createMCPClient({
+				transport: {
+					type: server.type,
+					url: server.url,
+				},
+			});
+
+			const tools = await client.tools();
+			const usedNames = new Set<string>(this.toolMetaByName.keys());
+			const remapped: Record<string, unknown> = {};
+			const internalNames = new Set<string>();
+
+			for (const [toolName, toolValue] of Object.entries(tools)) {
+				const internalName = buildInternalToolName(server.id, toolName, usedNames);
+				(remapped as Record<string, unknown>)[internalName] = toolValue;
+				internalNames.add(internalName);
+				this.toolMetaByName.set(internalName, {
+					internalName,
+					serverId: server.id,
+					originalToolName: toolName,
+				});
+			}
+
+			// Replace existing server registration atomically
+			this.clearServerTools(server.id);
+			this.internalNamesByServer.set(server.id, internalNames);
+			this.toolsByServer.set(server.id, remapped as ToolSet);
+			this.clientsByServer
+				.get(server.id)
+				?.close()
+				.catch(() => {});
+			this.clientsByServer.set(server.id, client);
+			client = null;
+
+			this.rebuildMergedTools();
+			this.setServerStatus({
+				id: server.id,
+				type: server.type,
+				url: server.url,
+				status: "ready",
+				toolCount: internalNames.size,
+			});
+			debug.info("mcp-server-ready", {
+				id: server.id,
+				type: server.type,
+				url: server.url,
+				toolCount: internalNames.size,
+				ms: Date.now() - startedAt,
+			});
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.clearServerTools(server.id);
+			this.rebuildMergedTools();
+			this.setServerStatus({
+				id: server.id,
+				type: server.type,
+				url: server.url,
+				status: "error",
+				toolCount: 0,
+				error: err.message,
+			});
+			debug.warn("mcp-server-error", {
+				id: server.id,
+				type: server.type,
+				url: server.url,
+				message: err.message,
+			});
+			if (client) {
+				try {
+					await client.close();
+				} catch {
+					// Ignore close failures
+				}
+			}
+		}
+	}
+}
+
+let singleton: McpManager | null = null;
+
+export function getMcpManager(): McpManager {
+	if (!singleton) {
+		singleton = new McpManager();
+	}
+	return singleton;
+}
+
+export function startMcpManager(): void {
+	getMcpManager().start();
+}
+
+export function destroyMcpManager(): void {
+	if (!singleton) return;
+	void singleton.closeAll();
+	singleton.removeAllListeners();
+	singleton = null;
+}

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

@@ -11,6 +11,7 @@ import { getAppConfigDir } from "../../utils/preferences";
 import { getMemoryModel } from "../model-config";
 
 const MEMORY_USER_ID = "daemon_global";
+const MAX_MEMORY_INPUT_CHARS = 10_000;
 /** Raw memory entry from mem0 API */
 interface Mem0RawEntry {
 	id: string;
@@ -106,6 +107,71 @@ class MemoryManager {
 
 			this.memory = new Memory({
 				version: "v1.1",
+				customPrompt: `You are a Personal Information Organizer, specialized in extracting **enduring** facts, user memories, and preferences.
+Your role is to extract **only** information that would be useful to recall in a conversation two weeks from now.
+
+# [IMPORTANT]: GENERATE FACTS SOLELY BASED ON THE USER'S MESSAGES.
+# [IMPORTANT]: DO NOT INCLUDE INFORMATION FROM ASSISTANT OR SYSTEM MESSAGES.
+
+### WHAT TO STORE (The "Two-Week Test"):
+1. **Biographical Details:** Names, age, job title, company, location.
+2. **Relationships:** Names of partners, family members, pets, or colleagues.
+3. **Enduring Preferences:** Strong likes/dislikes (e.g., food, hobbies, style).
+4. **Long-term Plans:** Upcoming trips, long-term projects, or goals.
+5. **Direct Instructions:** How the user wants to be addressed or formatted (e.g., "Call me X").
+6. **Multi-True Facts:** If multiple preferences or details can all be true (e.g., likes multiple languages, foods, hobbies), store each as a separate fact rather than updating/overwriting an existing one.
+
+### WHAT TO IGNORE (Do NOT store these):
+1. **Transient Commands & Questions:** Do not store that the user asked to "summarize a PDF," "translate a sentence," or "write code."
+2. **Immediate Context:** Do not store "User said 'continue'" or "User said 'yes'."
+3. **General Opinions on News/Politics:** Unless the user explicitly identifies with a stance, avoid summarizing general questions (e.g., ignore "What is the capital of France?").
+4. **Meta-Commentary:** Do not store compliments or insults to the bot (e.g., "You are smart") unless it alters how you should behave.
+
+### Examples:
+
+User: Hi there.
+Assistant: Hello! How can I help you today?
+Output: {{"facts" : []}}
+
+User: Can you summarize this article for me?
+Assistant: Sure, please paste the text.
+Output: {{"facts" : []}}
+(Reasoning: This is a transient task, not a fact about the user.)
+
+User: I am a vegetarian, so please don't suggest any meat dishes.
+Assistant: Noted, I will provide vegetarian options only.
+Output: {{"facts" : ["Is a vegetarian", "Does not eat meat"]}}
+
+User: I'm planning a hiking trip to Patagonia next November.
+Assistant: That sounds amazing!
+Output: {{"facts" : ["Planning a hiking trip to Patagonia in November"]}}
+
+User: Who is the president of the US?
+Assistant: The current president is...
+Output: {{"facts" : []}}
+
+User: My dog's name is Buster. He's a golden retriever.
+Assistant: Buster sounds adorable.
+Output: {{"facts" : ["Has a dog named Buster", "Dog is a golden retriever"]}}
+
+User: Actually, I moved. I live in Chicago now, not New York.
+Assistant: Got it, updated your location.
+Output: {{"facts" : ["Lives in Chicago", "No longer lives in New York"]}}
+
+User: I hate Python, I prefer coding in Rust.
+Assistant: Understood.
+Output: {{"facts" : ["Dislikes Python", "Prefers coding in Rust"]}}
+
+User: test
+Assistant: System operational.
+Output: {{"facts" : []}}
+
+Return the facts in JSON format as shown above.
+
+Rules:
+- If no *enduring* facts are found, return an empty list for "facts".
+- Detect the language of the user input and record facts in that same language.
+- Write fully self-contained facts (e.g., "Lives in Chicago" instead of "Lives there").`,
 				embedder: {
 					provider: "openai",
 					config: {
@@ -200,6 +266,28 @@ class MemoryManager {
 			throw new Error("Memory system not available");
 		}
 
+		const sanitizedMessages = messages.map((message) => {
+			if (message.role !== "user") return message;
+			if (message.content.length <= MAX_MEMORY_INPUT_CHARS) return message;
+			return {
+				...message,
+				content: message.content.slice(0, MAX_MEMORY_INPUT_CHARS),
+			};
+		});
+
+		if (sanitizedMessages !== messages) {
+			const truncated = sanitizedMessages.some((message, index) => {
+				return message.role === "user" && messages[index]?.content.length !== message.content.length;
+			});
+			if (truncated) {
+				memoryDebug.info("memory-add-truncate", {
+					maxChars: MAX_MEMORY_INPUT_CHARS,
+					originalLengths: messages.map((message) => message.content.length),
+					truncatedLengths: sanitizedMessages.map((message) => message.content.length),
+				});
+			}
+		}
+
 		const startTime = Date.now();
 		memoryDebug.info("memory-add-input", {
 			infer,
@@ -207,7 +295,7 @@ class MemoryManager {
 			messages,
 		});
 
-		const result = (await this.memory.add(messages, {
+		const result = (await this.memory.add(sanitizedMessages, {
 			userId: MEMORY_USER_ID,
 			metadata,
 			infer,
@@ -236,7 +324,7 @@ class MemoryManager {
 			rawResults: result.results,
 			durationMs,
 		});
-		return result;
+		return { results: extracted };
 	}
 
 	/** Get all memories */

package/src/ai/model-config.ts

@@ -100,7 +100,7 @@ export function buildOpenRouterChatSettings(
 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";
+export const DEFAULT_MEMORY_MODEL = "x-ai/grok-4.1-fast";
 
 /**
  * Get the model ID for memory operations (deduplication, extraction).