code-ollama 0.21.0 → 0.21.1

package/README.md

@@ -21,6 +21,9 @@
 npx code-ollama
 ```
 
+> [!IMPORTANT]
+> If you see an error that says server/model is unavailable, then follow these [steps](https://github.com/ai-action/code-ollama/wiki/Ollama).
+
 ## Install
 
 Install the [CLI](https://www.npmjs.com/package/code-ollama) globally:

package/dist/assets/{tui-48fT4HLs.js → tui-BHkHnKUC.js}

@@ -1,4 +1,4 @@
-import { A as HEADER_PREFIX, B as AUTO, C as streamChat, D as saveClipboardImage, E as removeClipboardImage, F as SYSTEM, G as REJECT, H as PLAN, I as USER, J as LIST, K as NAME, L as PLAN_GENERATION_INSTRUCTION, M as LIST$1, N as getTheme, O as resetSystemMessage, P as ASSISTANT, R as BACK, S as pullModel, T as saveConfig, U as SAFE, V as LABEL, W as APPROVE, _ as reset, a as WRITE_TOOLS, b as deleteModel, c as write, d as deleteSession, f as deleteSessionIfEmpty, g as clear, h as updateSessionModel, i as TOOLS, j as WARNING, k as withSystemMessage, l as appendMessage, m as loadSession, n as executeTool, o as tick, p as listSessions, q as VERSION, r as READ_TOOLS, s as color, t as checkForUpdate, u as createSession, v as setClearHandler, w as loadConfig, x as listModels, y as checkHealth, z as CATALOG } from "../cli.js";
+import { A as saveClipboardImage, B as PLAN_GENERATION_INSTRUCTION, C as deleteModel, D as loadConfig, E as streamChat, F as LIST$1, G as PLAN, H as CATALOG, I as getTheme, J as REJECT, K as SAFE, L as ASSISTANT, M as withSystemMessage, N as HEADER_PREFIX, O as saveConfig, P as WARNING, R as SYSTEM, S as checkHealth, T as pullModel, U as AUTO, V as BACK, W as LABEL, X as VERSION, Y as NAME, Z as LIST, _ as loadSession, a as normalizeToolCall, b as reset, c as WRITE_TOOLS, d as write, f as appendMessage, g as listSessions, h as deleteSessionIfEmpty, i as formatToolResultContent, j as resetSystemMessage, k as removeClipboardImage, l as tick, m as deleteSession, n as executeTool, o as READ_TOOLS, p as createSession, q as APPROVE, r as executeToolCall, s as TOOLS, t as checkForUpdate, u as color, v as updateSessionModel, w as listModels, x as setClearHandler, y as clear, z as USER } from "../cli.js";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -1362,6 +1362,7 @@ function hasExecutablePlan(content) {
 }
 //#endregion
 //#region src/components/Chat/Chat.tsx
+var MAX_TOOL_TURNS = 25;
 function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onModeChange, sessionId, theme = getTheme() }) {
 	const sessionMessages = initialMessages ?? [];
 	const history = useMemo(() => sessionMessages.flatMap(({ role, content }) => role === "user" && !content.startsWith("/") ? [content] : []), [sessionMessages]);
@@ -1400,7 +1401,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		};
 		return {
 			role: SYSTEM,
-			content: `Tool ${toolName} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+			content: formatToolResultContent(toolName, result)
 		};
 	}, []);
 	const buildPlanModeCorrectionMessage = useCallback((toolName) => ({
@@ -1425,72 +1426,112 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		}]);
 	}, []);
 	const processStream = useCallback(async (currentMessages, executionMode = mode) => {
+		const modelName = model;
 		// v8 ignore next
-		if (!model) throw new Error("Model is required");
+		if (!modelName) throw new Error("Model is required");
 		const controller = new AbortController();
 		abortControllerRef.current = controller;
-		const assistantMessage = {
-			role: ASSISTANT,
-			content: ""
-		};
-		let committedMessages = currentMessages;
-		let assistantCommitted = false;
-		const commitAssistantMessage = () => {
-			if (assistantCommitted) {
-				// v8 ignore next
-				if (committedMessages.at(-1)?.role === "assistant") {
-					committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
-					setMessages(committedMessages);
-				}
-				return committedMessages;
-			}
-			assistantCommitted = true;
-			setStreamingMessage(null);
-			if (!assistantMessage.content) {
-				setMessages(committedMessages);
-				return committedMessages;
-			}
-			committedMessages = [...committedMessages, { ...assistantMessage }];
-			setMessages(committedMessages);
-			return committedMessages;
-		};
-		setStreamingMessage(assistantMessage);
+		let activeMessages = currentMessages;
+		let toolTurns = 0;
 		try {
-			for await (const chunk of streamChat(withSystemMessage(currentMessages), model, TOOLS, controller.signal)) {
-				// v8 ignore next 3
-				if (controller.signal.aborted) return;
-				if (chunk.type === "content") {
-					assistantMessage.content += chunk.content;
-					setStreamingMessage({ ...assistantMessage });
-				} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
-					const requiresApproval = WRITE_TOOLS.has(toolCall.function.name);
+			while (!controller.signal.aborted) {
+				const assistantMessage = {
+					role: ASSISTANT,
+					content: ""
+				};
+				let committedMessages = activeMessages;
+				let assistantCommitted = false;
+				const commitAssistantMessage = () => {
 					// v8 ignore start
-					const allowedTools = executionMode === "plan" ? READ_TOOLS : void 0;
+					if (assistantCommitted) {
+						if (committedMessages.at(-1)?.role === "assistant") {
+							committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
+							setMessages(committedMessages);
+						}
+						return committedMessages;
+					}
 					// v8 ignore stop
+					assistantCommitted = true;
+					setStreamingMessage(null);
+					if (!assistantMessage.content) {
+						setMessages(committedMessages);
+						return committedMessages;
+					}
+					committedMessages = [...committedMessages, { ...assistantMessage }];
+					setMessages(committedMessages);
+					return committedMessages;
+				};
+				setStreamingMessage(assistantMessage);
+				let nextMessages = null;
+				for await (const chunk of streamChat(withSystemMessage(activeMessages), modelName, TOOLS, controller.signal)) {
+					if (chunk.type === "content") {
+						assistantMessage.content += chunk.content;
+						setStreamingMessage({ ...assistantMessage });
+						continue;
+					}
+					if (chunk.tool_calls.length === 0) continue;
 					const updatedMessages = commitAssistantMessage();
-					if (executionMode === "safe" && requiresApproval) {
-						setPendingToolCall(toolCall);
-						setIsLoading(false);
-						return;
+					const toolResultMessages = [];
+					for (const toolCall of chunk.tool_calls) try {
+						const normalized = normalizeToolCall(toolCall);
+						if (executionMode === "safe" && normalized.requiresApproval) {
+							setPendingToolCall({
+								toolCall,
+								messages: [...updatedMessages, ...toolResultMessages],
+								executionMode
+							});
+							setIsLoading(false);
+							return;
+						}
+						// v8 ignore next
+						const allowedTools = executionMode === "plan" ? READ_TOOLS : void 0;
+						const result = await executeTool(normalized.name, normalized.arguments, { allowedTools });
+						toolResultMessages.push(buildToolResultMessage(normalized.name, result));
+					} catch (error) {
+						toolResultMessages.push(buildToolResultMessage(toolCall.function.name, {
+							content: "",
+							// v8 ignore next
+							error: error instanceof Error ? error.message : String(error)
+						}));
 					}
-					const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools });
-					const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
-					const newMessages = [...updatedMessages, toolResultMessage];
-					setMessages(newMessages);
-					await processStream(newMessages, executionMode);
+					nextMessages = [...updatedMessages, ...toolResultMessages];
+					setMessages(nextMessages);
+					break;
+				}
+				if (!nextMessages) {
+					await prewarmCodeBlocks(assistantMessage.content, theme);
+					commitAssistantMessage();
 					return;
 				}
+				toolTurns += 1;
+				/* v8 ignore start */
+				if (toolTurns >= MAX_TOOL_TURNS) {
+					setMessages([...nextMessages, {
+						role: SYSTEM,
+						content: [
+							"Tool execution stopped because the maximum tool turn limit was reached",
+							ACTION_NOT_PERFORMED,
+							"Summarize completed work and explain what remains without calling more tools."
+						].join("\n")
+					}]);
+					return;
+				}
+				/* v8 ignore stop */
+				activeMessages = nextMessages;
 			}
-			await prewarmCodeBlocks(assistantMessage.content, theme);
-			commitAssistantMessage();
 		} catch (error) {
 			// v8 ignore next
 			if (!controller.signal.aborted) {
-				assistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
-				await prewarmCodeBlocks(assistantMessage.content, theme);
-				commitAssistantMessage();
+				const errorMessage = {
+					role: ASSISTANT,
+					content: `Error: ${error instanceof Error ? error.message : String(error)}`
+				};
+				await prewarmCodeBlocks(errorMessage.content, theme);
+				setStreamingMessage(null);
+				setMessages([...activeMessages, errorMessage]);
 			}
 		} finally {
+			// v8 ignore next
 			if (abortControllerRef.current === controller) abortControllerRef.current = null;
 			setIsLoading(false);
 		}
@@ -1542,15 +1583,29 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					setStreamingMessage({ ...assistantMessage });
 				} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
 					const updatedMessages = commitAssistantMessage();
-					if (!READ_TOOLS.has(toolCall.function.name)) {
-						const correctionMessage = buildPlanModeCorrectionMessage(toolCall.function.name);
+					let normalized;
+					try {
+						normalized = normalizeToolCall(toolCall);
+					} catch (error) {
+						/* v8 ignore start */
+						const toolResultMessage = buildToolResultMessage(toolCall.function.name, {
+							content: "",
+							error: error instanceof Error ? error.message : String(error)
+						});
+						const newMessages = [...updatedMessages, toolResultMessage];
+						setMessages(newMessages);
+						await processStreamReadOnly(newMessages);
+						return;
+					}
+					if (!READ_TOOLS.has(normalized.name)) {
+						const correctionMessage = buildPlanModeCorrectionMessage(normalized.name);
 						const newMessages = [...updatedMessages, correctionMessage];
 						setMessages(newMessages);
 						await processStreamReadOnly(newMessages);
 						return;
 					}
-					const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools: READ_TOOLS });
-					const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
+					const result = await executeTool(normalized.name, normalized.arguments, { allowedTools: READ_TOOLS });
+					const toolResultMessage = buildToolResultMessage(normalized.name, result);
 					const newMessages = [...updatedMessages, toolResultMessage];
 					setMessages(newMessages);
 					await processStreamReadOnly(newMessages);
@@ -1641,35 +1696,36 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 	const handleToolApproval = useCallback(async (decision) => {
 		// v8 ignore next
 		if (!pendingToolCall) return;
-		const toolCall = pendingToolCall;
+		const { executionMode, messages: approvedMessages, toolCall } = pendingToolCall;
 		setPendingToolCall(null);
 		setIsLoading(true);
 		switch (decision) {
 			case APPROVE: {
-				const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
+				const result = await executeToolCall(toolCall);
 				const toolResultMessage = {
 					role: SYSTEM,
-					content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+					content: formatToolResultContent(toolCall.function.name, result)
 				};
-				const newMessages = [...messages, toolResultMessage];
-				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
-				await processStream(newMessages);
+				const newMessages = [...approvedMessages, toolResultMessage];
+				setMessages(newMessages);
+				await processStream(newMessages, executionMode);
 				break;
 			}
-			case REJECT:
-				setMessages((previousMessages) => [...previousMessages, {
-					role: USER,
-					content: TURN_ABORTED_MESSAGE
-				}]);
+			case REJECT: {
+				const toolResultMessage = {
+					role: SYSTEM,
+					content: formatToolResultContent(toolCall.function.name, {
+						content: "",
+						error: "Tool call rejected by user"
+					})
+				};
+				setMessages([...approvedMessages, toolResultMessage]);
 				setIsLoading(false);
 				setInterruptReason(InterruptReason.Rejected);
 				break;
+			}
 		}
-	}, [
-		pendingToolCall,
-		messages,
-		processStream
-	]);
+	}, [pendingToolCall, processStream]);
 	const handleSubmit = useCallback(async ({ content, images }) => {
 		setInterruptReason(null);
 		const userContent = content.trim();
@@ -1711,7 +1767,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				theme
 			}),
 			!pendingPlan && pendingToolCall && /* @__PURE__ */ jsx(ToolApproval, {
-				toolCall: pendingToolCall,
+				toolCall: pendingToolCall.toolCall,
 				onDecision: handleToolApproval,
 				theme
 			}),

package/dist/cli.js

@@ -8,6 +8,18 @@ import { randomUUID } from "node:crypto";
 import { Ollama } from "ollama";
 import { v7 } from "uuid";
 import { promisify } from "node:util";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/constants/command.ts
 var LIST$1 = [
 	{
@@ -38,7 +50,7 @@ var LIST$1 = [
 //#endregion
 //#region package.json
 var name = "code-ollama";
-var version = "0.21.0";
+var version = "0.21.1";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -280,6 +292,17 @@ function getTheme(themeId = DEFAULT_THEME_ID) {
 }
 //#endregion
 //#region src/constants/tool.ts
+var tool_exports = /* @__PURE__ */ __exportAll({
+	EDIT_FILE: () => EDIT_FILE,
+	GREP_SEARCH: () => GREP_SEARCH,
+	LIST_DIR: () => LIST_DIR,
+	READ_FILE: () => READ_FILE,
+	RUN_SHELL: () => RUN_SHELL,
+	VIEW_RANGE: () => VIEW_RANGE,
+	WEB_FETCH: () => WEB_FETCH,
+	WEB_SEARCH: () => WEB_SEARCH,
+	WRITE_FILE: () => WRITE_FILE
+});
 var READ_FILE = "read_file";
 var WRITE_FILE = "write_file";
 var EDIT_FILE = "edit_file";
@@ -1170,18 +1193,85 @@ var REQUIRED_STRING_ARGS = {
 	[WEB_SEARCH]: ["query"],
 	[WEB_FETCH]: ["url"]
 };
+var TOOL_NAMES = new Set(Object.values(tool_exports));
+function isToolName(name) {
+	return TOOL_NAMES.has(name);
+}
 function validateArgs(name, args) {
-	const required = REQUIRED_STRING_ARGS[name] ?? [];
+	const required = REQUIRED_STRING_ARGS[name];
 	const received = Object.keys(args).join(", ") || "none";
-	for (const key of required) if (typeof args[key] !== "string") return {
+	for (const key of required) if (typeof args[key] !== "string" || !args[key]) return {
 		content: "",
 		error: `Missing required argument: ${key} (received keys: ${received})`
 	};
+	if (name === "view_range") {
+		if (!Number.isInteger(args.start) || !Number.isInteger(args.end)) return {
+			content: "",
+			error: `Missing required numeric arguments: start, end (received keys: ${received})`
+		};
+		if (args.start < 1 || args.end < args.start) return {
+			content: "",
+			error: "Invalid line range: start must be >= 1 and end must be >= start"
+		};
+	}
+	if (name === "web_fetch") try {
+		const url = new URL(args.url);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return {
+			content: "",
+			error: "URL must use http or https"
+		};
+	} catch {
+		return {
+			content: "",
+			error: "Invalid URL"
+		};
+	}
+}
+function normalizeToolCall(toolCall) {
+	const name = toolCall.function.name;
+	const rawArguments = toolCall.function.arguments;
+	if (!isToolName(name)) throw new Error(`Unknown tool: ${name}`);
+	if (typeof rawArguments !== "object" || rawArguments === null || Array.isArray(rawArguments)) throw new Error(`Invalid arguments for tool: ${name}`);
+	const normalizedArguments = rawArguments;
+	const invalid = validateArgs(name, normalizedArguments);
+	if (invalid?.error) throw new Error(invalid.error);
+	return {
+		name,
+		arguments: normalizedArguments,
+		requiresApproval: WRITE_TOOLS.has(name)
+	};
+}
+function formatToolResultContent(toolName, result) {
+	const status = result.error ? "The requested action was NOT performed" : "";
+	const content = result.content ? `\n${result.content}` : "";
+	const error = result.error ? `\nError: ${result.error}` : "";
+	return [
+		`Tool ${toolName} result:`,
+		status,
+		content.trim(),
+		error.trim()
+	].filter(Boolean).join("\n");
+}
+async function executeToolCall(toolCall, options) {
+	try {
+		const normalized = normalizeToolCall(toolCall);
+		return await executeTool(normalized.name, normalized.arguments, options);
+	} catch (error) {
+		return {
+			content: "",
+			// v8 ignore next
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
 }
 /**
 * Execute a tool by name with arguments
 */
 async function executeTool(name, args, options) {
+	if (!isToolName(name)) return {
+		content: "",
+		error: `Unknown tool: ${name}`
+	};
 	if (options?.allowedTools && !options.allowedTools.has(name)) return {
 		content: "",
 		error: `Tool not allowed: ${name}`
@@ -1199,6 +1289,7 @@ async function executeTool(name, args, options) {
 		case VIEW_RANGE: return viewRange(stringArgs.path, args.start, args.end);
 		case WEB_SEARCH: return await webSearch(stringArgs.query);
 		case WEB_FETCH: return await webFetch(stringArgs.url);
+		// v8 ignore next 2
 		default: return {
 			content: "",
 			error: `Unknown tool: ${name}`
@@ -1240,6 +1331,7 @@ async function checkForUpdate() {
 //#endregion
 //#region src/cli.ts
 var cli = cac("code-ollama");
+var MAX_TOOL_TURNS = 25;
 cli.version(VERSION);
 cli.help();
 cli.command("run <model> <prompt>", "Run a one-off prompt").action(async (model, prompt) => {
@@ -1272,30 +1364,40 @@ async function runPrompt(model, prompt) {
 	write("\n");
 }
 async function processRunStream(messages, model) {
-	const assistantMessage = {
-		role: ASSISTANT,
-		content: ""
-	};
-	for await (const chunk of streamChat(messages, model, TOOLS)) {
-		if (chunk.type === "content") {
-			assistantMessage.content += chunk.content;
-			write(chunk.content);
-			continue;
-		}
-		for (const toolCall of chunk.tool_calls) {
-			const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
-			const toolResultMessage = {
-				role: SYSTEM,
-				content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
-			};
-			await processRunStream([
-				...messages,
-				assistantMessage,
-				toolResultMessage
-			], model);
-			return;
+	let activeMessages = messages;
+	let toolTurns = 0;
+	while (toolTurns < MAX_TOOL_TURNS) {
+		const assistantMessage = {
+			role: ASSISTANT,
+			content: ""
+		};
+		let nextMessages = null;
+		for await (const chunk of streamChat(activeMessages, model, TOOLS)) {
+			if (chunk.type === "content") {
+				assistantMessage.content += chunk.content;
+				write(chunk.content);
+				continue;
+			}
+			// v8 ignore next 3
+			if (chunk.tool_calls.length === 0) continue;
+			const committedMessages = [...activeMessages, assistantMessage];
+			const toolResultMessages = [];
+			for (const toolCall of chunk.tool_calls) {
+				const result = await executeToolCall(toolCall);
+				toolResultMessages.push({
+					role: SYSTEM,
+					content: formatToolResultContent(toolCall.function.name, result)
+				});
+			}
+			nextMessages = [...committedMessages, ...toolResultMessages];
+			break;
 		}
+		if (!nextMessages) return;
+		activeMessages = nextMessages;
+		toolTurns += 1;
 	}
+	// v8 ignore next 3
+	writeError("Tool execution stopped because the maximum tool turn limit was reached\n");
 }
 async function main(args = process.argv.slice(2)) {
 	if (args.length) cli.parse([
@@ -1306,7 +1408,7 @@ async function main(args = process.argv.slice(2)) {
 	else await launchTui();
 }
 async function launchTui(sessionId) {
-	const { renderApp } = await import("./assets/tui-48fT4HLs.js");
+	const { renderApp } = await import("./assets/tui-BHkHnKUC.js");
 	reset();
 	renderApp(sessionId);
 }
@@ -1322,4 +1424,4 @@ function isEntrypoint(argv1 = process.argv[1]) {
 if (isEntrypoint()) main();
 // v8 ignore stop
 //#endregion
-export { HEADER_PREFIX as A, AUTO as B, streamChat as C, saveClipboardImage as D, removeClipboardImage as E, SYSTEM as F, REJECT as G, PLAN as H, USER as I, LIST$1 as J, NAME as K, PLAN_GENERATION_INSTRUCTION as L, LIST as M, getTheme as N, resetSystemMessage as O, ASSISTANT as P, BACK as R, pullModel as S, saveConfig as T, SAFE as U, LABEL as V, APPROVE as W, reset as _, WRITE_TOOLS as a, deleteModel as b, write as c, deleteSession as d, deleteSessionIfEmpty as f, clear as g, updateSessionModel as h, TOOLS as i, WARNING as j, withSystemMessage as k, appendMessage as l, loadSession as m, main, executeTool as n, tick as o, listSessions as p, VERSION as q, READ_TOOLS as r, color as s, checkForUpdate as t, createSession as u, setClearHandler as v, loadConfig as w, listModels as x, checkHealth as y, CATALOG as z };
+export { saveClipboardImage as A, PLAN_GENERATION_INSTRUCTION as B, deleteModel as C, loadConfig as D, streamChat as E, LIST as F, PLAN as G, CATALOG as H, getTheme as I, REJECT as J, SAFE as K, ASSISTANT as L, withSystemMessage as M, HEADER_PREFIX as N, saveConfig as O, WARNING as P, SYSTEM as R, checkHealth as S, pullModel as T, AUTO as U, BACK as V, LABEL as W, VERSION as X, NAME as Y, LIST$1 as Z, loadSession as _, normalizeToolCall as a, reset as b, WRITE_TOOLS as c, write as d, appendMessage as f, listSessions as g, deleteSessionIfEmpty as h, formatToolResultContent as i, resetSystemMessage as j, removeClipboardImage as k, tick as l, deleteSession as m, main, executeTool as n, READ_TOOLS as o, createSession as p, APPROVE as q, executeToolCall as r, TOOLS as s, checkForUpdate as t, color as u, updateSessionModel as v, listModels as w, setClearHandler as x, clear as y, USER as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",
@@ -42,34 +42,34 @@
     "@inkjs/ui": "2.0.0",
     "@shikijs/cli": "4.1.0",
     "cac": "7.0.0",
-    "ink": "7.0.3",
+    "ink": "7.0.5",
     "marked": "15.0.12",
     "marked-terminal": "7.3.0",
     "ollama": "0.6.3",
-    "react": "19.2.6",
+    "react": "19.2.7",
     "uuid": "14.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "21.0.1",
-    "@commitlint/config-conventional": "21.0.1",
+    "@commitlint/cli": "21.0.2",
+    "@commitlint/config-conventional": "21.0.2",
     "@eslint/js": "10.0.1",
     "@types/node": "25.9.1",
-    "@types/react": "19.2.15",
-    "@vitest/coverage-v8": "4.1.7",
-    "eslint": "10.4.0",
-    "eslint-plugin-prettier": "5.5.5",
+    "@types/react": "19.2.16",
+    "@vitest/coverage-v8": "4.1.8",
+    "eslint": "10.4.1",
+    "eslint-plugin-prettier": "5.5.6",
     "eslint-plugin-simple-import-sort": "13.0.0",
     "globals": "17.6.0",
     "husky": "9.1.7",
     "ink-testing-library": "4.0.0",
-    "lint-staged": "17.0.5",
+    "lint-staged": "17.0.7",
     "prettier": "3.8.3",
     "publint": "0.3.21",
-    "tsx": "4.22.3",
+    "tsx": "4.22.4",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.59.4",
-    "vite": "8.0.14",
-    "vitest": "4.1.7"
+    "typescript-eslint": "8.60.1",
+    "vite": "8.0.16",
+    "vitest": "4.1.8"
   },
   "files": [
     "dist/"