@makefinks/daemon 0.9.0 → 0.10.0

package/package.json

@@ -28,7 +28,7 @@
 	},
 	"module": "src/index.tsx",
 	"type": "module",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"bin": {
 		"daemon": "dist/cli.js"
 	},
@@ -77,13 +77,21 @@
 		"@ai-sdk/openai": "^3.0.0",
 		"@openrouter/ai-sdk-provider": "^2.1.0",
 		"@opentui-ui/toast": "^0.0.3",
-		"@opentui/core": "^0.1.63",
-		"@opentui/react": "^0.1.63",
+		"@opentui/core": "0.1.75",
+		"@opentui/react": "0.1.75",
 		"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"
+	},
+	"optionalDependencies": {
+		"@opentui/core-win32-x64": "0.1.75",
+		"@opentui/core-win32-arm64": "0.1.75",
+		"@opentui/core-darwin-x64": "0.1.75",
+		"@opentui/core-darwin-arm64": "0.1.75",
+		"@opentui/core-linux-x64": "0.1.75",
+		"@opentui/core-linux-arm64": "0.1.75"
 	}
 }

package/src/ai/daemon-ai.ts

@@ -15,14 +15,14 @@ import {
 import { getDaemonManager } from "../state/daemon-state";
 import { getRuntimeContext } from "../state/runtime-context";
 import type {
+	MemoryToastOperation,
+	MemoryToastPreview,
 	ReasoningEffort,
 	StreamCallbacks,
 	TokenUsage,
 	ToolApprovalRequest,
 	ToolApprovalResponse,
 	TranscriptionResult,
-	MemoryToastPreview,
-	MemoryToastOperation,
 } from "../types";
 import { debug, toolDebug } from "../utils/debug-logger";
 import { getOpenRouterReportedCost } from "../utils/openrouter-reported-cost";
@@ -321,7 +321,7 @@ export async function generateResponse(
 async function persistConversationMemory(
 	userMessage: string,
 	assistantMessage: string
-): Promise<string | null> {
+): Promise<MemoryToastPreview | null> {
 	const userTextForMemory = userMessage.trim();
 	const assistantTextForMemory = assistantMessage.trim();
 

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

@@ -302,9 +302,13 @@ Rules:
 		})) as Mem0RawAddResult;
 
 		const extracted = result.results.map((r) => {
-			const event =
+			const rawEvent =
 				(r as unknown as { metadata?: { event?: string } }).metadata?.event ??
 				(r as { event?: string }).event;
+			const validEvents = ["ADD", "UPDATE", "DELETE", "NONE"] as const;
+			const event = validEvents.includes(rawEvent as (typeof validEvents)[number])
+				? (rawEvent as (typeof validEvents)[number])
+				: "NONE";
 			return {
 				id: r.id,
 				memory: r.memory,

package/src/ai/model-config.ts

@@ -9,14 +9,14 @@ import { loadManualConfig } from "../utils/config";
 // Available models for selection (OpenRouter format)
 export const AVAILABLE_MODELS: ModelOption[] = [
 	{ id: "x-ai/grok-4.1-fast", name: "Grok 4.1 Fast" },
+	{ id: "arcee-ai/trinity-large-preview:free", name: "Trinity Large Preview" },
 	{ id: "z-ai/glm-4.7", name: "GLM 4.7" },
 	{ id: "minimax/minimax-m2.1", name: "Minimax M2.1" },
 	{ id: "google/gemini-3-flash-preview", name: "Gemini 3 Flash" },
 	{ id: "google/gemini-3-pro-preview", name: "Gemini 3 Pro" },
 	{ id: "openai/gpt-5.2", name: "GPT 5.2" },
-	{ id: "moonshotai/kimi-k2-thinking", name: "Kimi K2 Thinking" },
+	{ id: "moonshotai/kimi-k2.5", name: "Kimi K2.5" },
 	{ id: "openai/gpt-oss-120b:exacto", name: "GPT-OSS-120" },
-	{ id: "mistralai/devstral-2512:free", name: "Mistral Devstral" },
 	{ id: "nvidia/nemotron-3-nano-30b-a3b:free", name: "Nemotron 3 Nano" },
 ];
 

package/src/ai/system-prompt.ts

@@ -9,6 +9,7 @@ export type InteractionMode = "text" | "voice";
 
 export interface ToolAvailability {
 	readFile: boolean;
+	writeFile: boolean;
 	runBash: boolean;
 	webSearch: boolean;
 	fetchUrls: boolean;
@@ -64,6 +65,7 @@ export function buildDaemonSystemPrompt(options: SystemPromptOptions = {}): stri
 function normalizeToolAvailability(toolAvailability?: Partial<ToolAvailability>): ToolAvailability {
 	return {
 		readFile: toolAvailability?.readFile ?? true,
+		writeFile: toolAvailability?.writeFile ?? true,
 		runBash: toolAvailability?.runBash ?? true,
 		webSearch: toolAvailability?.webSearch ?? true,
 		fetchUrls: toolAvailability?.fetchUrls ?? true,
@@ -243,6 +245,19 @@ Fetch multiple URLs in one call:
   By default it reads up to 2000 lines from the start when no offset/limit are provided.
   For partial reads, you must provide both a 0-based line offset and a line limit.
 `,
+	writeFile: `
+  ### 'writeFile' (local file writer)
+  Use this to write content to files. Creates new files or overwrites existing ones.
+  Automatically creates parent directories if they don't exist.
+
+  **CRITICAL: Always report the correct file location to the user**
+  - When you write a file, explicitly tell the user the full path where it was saved
+  - If the file is in the workspace, say "I have saved it to my workspace at: [full path]"
+  - If the file is in the current working directory, say "I have saved it to: [path]"
+  - Do NOT give commands like "cat filename" or "open filename" unless the file is actually in the current working directory
+  - For files in the workspace, give the full path: "cat /full/path/to/file" or tell the user to navigate there first
+`,
+
 	subagent: `
   ### 'subagent'
   Call this tool to spawn subagents for specific tasks.
@@ -260,6 +275,7 @@ function buildToolDefinitions(availability: ToolAvailability): string {
 	if (availability.groundingManager) blocks.push(TOOL_SECTIONS.groundingManager);
 	if (availability.runBash) blocks.push(TOOL_SECTIONS.runBash);
 	if (availability.readFile) blocks.push(TOOL_SECTIONS.readFile);
+	if (availability.writeFile) blocks.push(TOOL_SECTIONS.writeFile);
 	if (availability.subagent) blocks.push(TOOL_SECTIONS.subagent);
 
 	const webNote =

package/src/ai/tools/fetch-urls.ts

@@ -63,15 +63,28 @@ export const fetchUrls = tool({
 			return `<fetchUrls error="${escapeXmlAttribute(exaClientResult.error)}" />`;
 		}
 
-		const normalizedRequests = requests.map((request) => {
-			const hasLineOffset = typeof request.lineOffset === "number";
-			const hasLineLimit = typeof request.lineLimit === "number";
-			const invalidPagination = hasLineOffset && !hasLineLimit && (request.lineOffset ?? 0) > 0;
+		interface NormalizedRequest {
+			url: string;
+			lineOffset?: number;
+			lineLimit?: number;
+			invalidPagination: boolean;
+			effectiveLineOffset: number;
+			effectiveLineLimit: number;
+		}
+
+		const normalizedRequests = requests.map((request): NormalizedRequest => {
+			const lineOffset = request.lineOffset;
+			const lineLimit = request.lineLimit;
+			const hasLineOffset = typeof lineOffset === "number";
+			const hasLineLimit = typeof lineLimit === "number";
+			const invalidPagination = hasLineOffset && !hasLineLimit && (lineOffset ?? 0) > 0;
 			return {
-				...request,
+				url: request.url,
+				lineOffset,
+				lineLimit,
 				invalidPagination,
-				effectiveLineOffset: hasLineOffset ? request.lineOffset : 0,
-				effectiveLineLimit: hasLineLimit ? request.lineLimit : DEFAULT_LINE_LIMIT,
+				effectiveLineOffset: hasLineOffset ? lineOffset : 0,
+				effectiveLineLimit: hasLineLimit ? lineLimit : DEFAULT_LINE_LIMIT,
 			};
 		});
 

package/src/ai/tools/tool-registry.ts

@@ -8,6 +8,7 @@ import { runBash } from "./run-bash";
 import { subagent } from "./subagents";
 import { todoManager } from "./todo-manager";
 import { webSearch } from "./web-search";
+import { writeFile } from "./write-file";
 
 import type { ToolToggleId, ToolToggles } from "../../types";
 import { detectLocalPlaywrightChromium } from "../../utils/js-rendering";
@@ -40,6 +41,7 @@ type ToolGateResult = {
 
 const TOOL_REGISTRY: ToolEntry[] = [
 	{ id: "readFile", toggleKey: "readFile", tool: readFile },
+	{ id: "writeFile", toggleKey: "writeFile", tool: writeFile },
 	{ id: "runBash", toggleKey: "runBash", tool: runBash },
 	{ id: "webSearch", toggleKey: "webSearch", tool: webSearch, gate: gateExa },
 	{ id: "fetchUrls", toggleKey: "fetchUrls", tool: fetchUrls, gate: gateExa },
@@ -68,6 +70,7 @@ async function gateRenderUrl(): Promise<ToolGateResult> {
 function normalizeToggles(toggles?: ToolToggles): ToolToggles {
 	return {
 		readFile: toggles?.readFile ?? true,
+		writeFile: toggles?.writeFile ?? true,
 		runBash: toggles?.runBash ?? true,
 		webSearch: toggles?.webSearch ?? true,
 		fetchUrls: toggles?.fetchUrls ?? true,
@@ -166,6 +169,7 @@ export async function buildToolSet(
 export function getToolLabels(): Record<ToolId, string> {
 	return {
 		readFile: "readFile",
+		writeFile: "writeFile",
 		runBash: "runBash",
 		webSearch: "webSearch",
 		fetchUrls: "fetchUrls",
@@ -179,6 +183,7 @@ export function getToolLabels(): Record<ToolId, string> {
 export function getDefaultToolOrder(): ToolId[] {
 	return [
 		"readFile",
+		"writeFile",
 		"runBash",
 		"webSearch",
 		"fetchUrls",
@@ -192,6 +197,7 @@ export function getDefaultToolOrder(): ToolId[] {
 export function createToolAvailabilitySnapshot(availability: ToolAvailabilityMap): Record<ToolId, boolean> {
 	return {
 		readFile: availability.readFile?.enabled ?? false,
+		writeFile: availability.writeFile?.enabled ?? false,
 		runBash: availability.runBash?.enabled ?? false,
 		webSearch: availability.webSearch?.enabled ?? false,
 		fetchUrls: availability.fetchUrls?.enabled ?? false,

package/src/ai/tools/write-file.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+
+export const writeFile = tool({
+	description:
+		"Write content to a file. Creates the file if it doesn't exist, or overwrites it if it does. Supports append mode to add content to existing files. Use this to create scripts, save outputs, write configuration files, or generate any text-based file.",
+	inputSchema: z.object({
+		path: z
+			.string()
+			.describe("Path to the file to write. Can be absolute or relative to the current working directory."),
+		content: z.string().describe("The content to write to the file."),
+		append: z
+			.boolean()
+			.optional()
+			.default(false)
+			.describe("If true, append to the file instead of overwriting. Creates the file if it doesn't exist."),
+	}),
+	execute: async ({ path: filePath, content, append }) => {
+		try {
+			const resolvedPath = path.resolve(filePath);
+			const dir = path.dirname(resolvedPath);
+
+			// Create parent directories if they don't exist
+			if (!fs.existsSync(dir)) {
+				fs.mkdirSync(dir, { recursive: true });
+			}
+
+			// Write or append to the file
+			if (append) {
+				fs.appendFileSync(resolvedPath, content, "utf8");
+			} else {
+				fs.writeFileSync(resolvedPath, content, "utf8");
+			}
+
+			return {
+				success: true,
+				path: resolvedPath,
+				bytesWritten: Buffer.byteLength(content, "utf8"),
+			};
+		} catch (error: unknown) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			return {
+				success: false,
+				path: filePath,
+				error: err.message,
+			};
+		}
+	},
+});

package/src/components/tool-layouts/layouts/index.ts

@@ -2,6 +2,7 @@ import "./bash";
 import "./web-search";
 import "./url-tools";
 import "./read-file";
+import "./write-file.tsx";
 import "./subagent";
 import "./todo";
 import "./system-info";

package/src/components/tool-layouts/layouts/url-tools.ts

@@ -1,6 +1,7 @@
-import type { ToolLayoutConfig, ToolHeader } from "../types";
 import { COLORS } from "../../../ui/constants";
 import { registerToolLayout } from "../registry";
+import type { ToolBody } from "../types";
+import type { ToolHeader, ToolLayoutConfig } from "../types";
 
 type UnknownRecord = Record<string, unknown>;
 
@@ -106,6 +107,7 @@ type ExaLikeItem = {
 	remainingLines?: unknown;
 	totalLines?: unknown;
 	error?: unknown;
+	success?: unknown;
 };
 
 function formatExaItemLabel(item: ExaLikeItem): string {

package/src/components/tool-layouts/layouts/write-file.tsx

@@ -0,0 +1,117 @@
+import { pathToFiletype } from "@opentui/core";
+import React from "react";
+import { COLORS, REASONING_MARKDOWN_STYLE } from "../../../ui/constants";
+import { registerToolLayout } from "../registry";
+import type { ToolHeader, ToolLayoutConfig, ToolLayoutRenderProps } from "../types";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function extractPath(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("path" in input && typeof input.path === "string") {
+		return input.path;
+	}
+	return null;
+}
+
+function extractContent(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("content" in input && typeof input.content === "string") {
+		return input.content;
+	}
+	return null;
+}
+
+function extractAppend(input: unknown): boolean {
+	if (!isRecord(input)) return false;
+	if ("append" in input && typeof input.append === "boolean") {
+		return input.append;
+	}
+	return false;
+}
+
+function WriteFileBody({ call, result }: ToolLayoutRenderProps) {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return (
+			<box paddingLeft={2}>
+				<text>
+					<span fg={COLORS.STATUS_FAILED}>{`error: ${result.error}`}</span>
+				</text>
+			</box>
+		);
+	}
+	if (result.success !== true) return null;
+
+	const content = extractContent(call.input) ?? "";
+	const path = extractPath(call.input) ?? "";
+
+	// Detect filetype from path for syntax highlighting
+	const filetype = pathToFiletype(path);
+
+	// Format content preview
+	let previewContent = "";
+	if (content.trim()) {
+		const MAX_LINES = 4;
+		const MAX_CHARS = 160;
+		const contentLines = content
+			.split("\n")
+			.slice(0, MAX_LINES)
+			.map((line) => (line.length > MAX_CHARS ? `${line.slice(0, MAX_CHARS - 1)}…` : line));
+
+		const totalLines = content.split("\n").length;
+		if (totalLines > MAX_LINES) {
+			contentLines.push(`... (${totalLines - MAX_LINES} more lines)`);
+		}
+		previewContent = contentLines.join("\n");
+	} else {
+		previewContent = "(empty file)";
+	}
+
+	return (
+		<box flexDirection="column" paddingLeft={2} marginTop={0}>
+			<box
+				borderStyle="single"
+				borderColor={COLORS.TOOL_INPUT_BORDER}
+				paddingLeft={1}
+				paddingRight={1}
+				paddingTop={0}
+				paddingBottom={0}
+			>
+				<code
+					content={previewContent}
+					filetype={filetype}
+					syntaxStyle={REASONING_MARKDOWN_STYLE}
+					conceal={true}
+					drawUnstyledText={false}
+				/>
+			</box>
+		</box>
+	);
+}
+
+export const writeFileLayout: ToolLayoutConfig = {
+	abbreviation: "write",
+
+	getHeader: (input): ToolHeader | null => {
+		const path = extractPath(input);
+		if (!path) return null;
+		const append = extractAppend(input);
+		const filetype = pathToFiletype(path);
+
+		const parts: string[] = [];
+		if (filetype) parts.push(filetype);
+		if (append) parts.push("append");
+
+		const secondary = parts.length > 0 ? parts.join(" · ") : undefined;
+		return { primary: path, secondary, secondaryStyle: "dim" };
+	},
+
+	renderBody: WriteFileBody,
+};
+
+registerToolLayout("writeFile", writeFileLayout);

package/src/types/index.ts

@@ -269,6 +269,7 @@ export type VoiceInteractionType = "direct" | "review";
 
 export type ToolToggleId =
 	| "readFile"
+	| "writeFile"
 	| "runBash"
 	| "webSearch"
 	| "fetchUrls"
@@ -281,6 +282,7 @@ export type ToolToggles = Record<ToolToggleId, boolean>;
 
 export const DEFAULT_TOOL_TOGGLES: ToolToggles = {
 	readFile: true,
+	writeFile: true,
 	runBash: true,
 	webSearch: true,
 	fetchUrls: true,

package/src/utils/derive-url-menu-items.ts

@@ -53,6 +53,7 @@ function parseFetchUrlsXml(result: string): {
 		const attrs: Record<string, string> = {};
 		for (const attr of attrText.matchAll(/(\w+)="([^"]*)"/g)) {
 			const key = attr[1];
+			if (!key) continue;
 			const value = attr[2] ?? "";
 			attrs[key] = unescapeXmlAttribute(value);
 		}

package/src/utils/tool-output-preview.ts

@@ -65,6 +65,10 @@ type ExaLikeItem = {
 	text?: unknown;
 	lineOffset?: unknown;
 	lineLimit?: unknown;
+	success?: unknown;
+	error?: unknown;
+	remainingLines?: unknown;
+	totalLines?: unknown;
 };
 
 function extractExaItems(data: unknown): ExaLikeItem[] | null {
@@ -146,8 +150,9 @@ function formatExaFetchResult(result: unknown): string | null {
 		if (headerLine) lines.push(headerLine);
 		if (normalLines[0]) lines.push(normalLines[0]);
 
-		if (errorLines.length > 0) {
-			lines.push(errorLines[0]);
+		const firstErrorLine = errorLines[0];
+		if (firstErrorLine) {
+			lines.push(firstErrorLine);
 		} else if (contentLine) {
 			lines.push(contentLine);
 		}