code-ollama 0.21.0 → 0.22.0

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-CzkVRFXf.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 { $ as VERSION, A as loadConfig, B as ASSISTANT, C as checkHealth, D as pullModel, E as listModels, F as withSystemMessage, G as CATALOG, H as USER, I as HEADER_PREFIX, J as PLAN, K as AUTO, L as WARNING, M as removeClipboardImage, N as saveClipboardImage, O as sanitizeAssistantContent, P as resetSystemMessage, Q as NAME, R as LIST$1, S as TOOL_INTENT_CORRECTION, T as hasUncalledToolIntent, U as PLAN_GENERATION_INSTRUCTION, V as SYSTEM, W as BACK, X as APPROVE, Y as SAFE, Z as REJECT, _ as loadSession, a as normalizeToolCall, b as reset, c as WRITE_TOOLS, d as write, et as LIST, f as appendMessage, g as listSessions, h as deleteSessionIfEmpty, i as formatToolResultContent, j as saveConfig, k as streamChat, l as tick, m as deleteSession, n as executeTool, o as READ_TOOLS, p as createSession, q as LABEL, r as executeToolCall, s as TOOLS, t as checkForUpdate, u as color, v as updateSessionModel, w as deleteModel, x as setClearHandler, y as clear, z as getTheme } 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";
@@ -11,6 +11,16 @@ import { Marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 //#region src/components/CodeBlock/CodeBlock.tsx
 var highlightCache = /* @__PURE__ */ new Map();
+var DIFF_LANGUAGE = "diff";
+function getDiffLineColor(line, isSystem, theme) {
+	switch (true) {
+		case isSystem: return theme.colors.messageSystem;
+		case line.startsWith("+") && !line.startsWith("+++"): return "green";
+		case line.startsWith("-") && !line.startsWith("---"): return "red";
+		case line.startsWith("@@"): return theme.colors.accent;
+		case line.startsWith("---") || line.startsWith("+++"): return theme.colors.secondary;
+	}
+}
 var CODE_BLOCK_REGEX = /^(?<indent>[ \t]*)(`{3,})(\w+)?[ \t]*\n([\s\S]*?)^\k<indent>\2[ \t]*$/gm;
 function normalizeCodeBlockContent(content, indent = "") {
 	if (!indent) return content.trim();
@@ -48,6 +58,7 @@ async function highlightCode(code, language = "text", codeTheme = getTheme().cod
 	}
 }
 var CodeBlock = memo(function CodeBlock({ code, language, role, theme = getTheme() }) {
+	const isDiff = language === DIFF_LANGUAGE;
 	const cacheKey = `${theme.codeTheme}:${language ?? ""}:${code}`;
 	const [highlighted, setHighlighted] = useState(() => highlightCache.get(cacheKey) ?? code);
 	useEffect(() => {
@@ -76,7 +87,13 @@ var CodeBlock = memo(function CodeBlock({ code, language, role, theme = getTheme
 		borderColor: isSystem ? theme.colors.secondary : theme.colors.codeBorder,
 		paddingX: 1,
 		marginY: 1,
-		children: /* @__PURE__ */ jsx(Text, {
+		children: isDiff ? code.split("\n").map((line, index) => {
+			return /* @__PURE__ */ jsx(Text, {
+				color: getDiffLineColor(line, isSystem, theme),
+				dimColor: isSystem,
+				children: line || " "
+			}, index);
+		}) : /* @__PURE__ */ jsx(Text, {
 			color: isSystem ? theme.colors.messageSystem : void 0,
 			dimColor: isSystem,
 			children: highlighted
@@ -393,6 +410,24 @@ function renderStickyPaddingLines(count) {
 		index
 	));
 }
+function ToolResultMessage({ message, messageColor, theme }) {
+	const diffContent = message.toolResult?.diff?.visible;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginBottom: 1,
+		marginX: 2,
+		children: [/* @__PURE__ */ jsx(Text, {
+			color: messageColor,
+			dimColor: true,
+			children: message.content
+		}), diffContent && /* @__PURE__ */ jsx(CodeBlock, {
+			code: diffContent,
+			language: "diff",
+			role: "assistant",
+			theme
+		})]
+	});
+}
 function Message({ message, isStreaming = false, theme }) {
 	const messageColor = getMessageColor(message.role, theme);
 	const isSystem = message.role === SYSTEM;
@@ -403,16 +438,23 @@ function Message({ message, isStreaming = false, theme }) {
 		columns: stdout.columns,
 		maxHeight: 0
 	});
-	if (isSystem) return /* @__PURE__ */ jsx(Box, {
-		flexDirection: "column",
-		marginBottom: 1,
-		marginX: 2,
-		children: /* @__PURE__ */ jsx(Text, {
-			color: messageColor,
-			dimColor: true,
-			children: message.content
-		})
-	});
+	if (isSystem) {
+		if (message.toolResult?.diff) return /* @__PURE__ */ jsx(ToolResultMessage, {
+			message,
+			messageColor,
+			theme
+		});
+		return /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			marginBottom: 1,
+			marginX: 2,
+			children: /* @__PURE__ */ jsx(Text, {
+				color: messageColor,
+				dimColor: true,
+				children: message.content
+			})
+		});
+	}
 	if (isUser) {
 		// v8 ignore start
 		const attachmentPrefix = (message.images ?? []).map((path) => `[${path.split(/[\\/]/).at(-1) ?? path}]`).join(" ");
@@ -1362,6 +1404,8 @@ function hasExecutablePlan(content) {
 }
 //#endregion
 //#region src/components/Chat/Chat.tsx
+var MAX_TOOL_TURNS = 25;
+var MAX_TOOL_INTENT_CORRECTIONS = 2;
 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]);
@@ -1388,7 +1432,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		persistedSnapshotRef.current = snapshot;
 		onMessagesChange?.(messages);
 	}, [messages, onMessagesChange]);
-	const buildToolResultMessage = useCallback((toolName, result) => {
+	const buildToolResultMessage = useCallback((toolName, result, args) => {
 		if (result.error?.startsWith("Tool not allowed:")) return {
 			role: SYSTEM,
 			content: [
@@ -1400,7 +1444,11 @@ 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, args),
+			toolResult: {
+				name: toolName,
+				...result.diff ? { diff: result.diff } : {}
+			}
 		};
 	}, []);
 	const buildPlanModeCorrectionMessage = useCallback((toolName) => ({
@@ -1425,72 +1473,124 @@ 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;
+		let toolIntentCorrections = 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 = () => {
+					assistantMessage.content = sanitizeAssistantContent(assistantMessage.content);
 					// 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 = sanitizeAssistantContent(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, normalized.arguments));
+					} catch (error) {
+						toolResultMessages.push(buildToolResultMessage(toolCall.function.name, {
+							content: "",
+							// v8 ignore next
+							error: error instanceof Error ? error.message : String(error)
+						}));
+					}
+					nextMessages = [...updatedMessages, ...toolResultMessages];
+					setMessages(nextMessages);
+					break;
+				}
+				if (!nextMessages) {
+					await prewarmCodeBlocks(assistantMessage.content, theme);
+					const updatedMessages = commitAssistantMessage();
+					if (hasUncalledToolIntent(assistantMessage.content) && toolIntentCorrections < MAX_TOOL_INTENT_CORRECTIONS) {
+						toolIntentCorrections += 1;
+						activeMessages = [...updatedMessages, {
+							role: SYSTEM,
+							content: TOOL_INTENT_CORRECTION
+						}];
+						setMessages(activeMessages);
+						continue;
 					}
-					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);
 					return;
 				}
+				toolTurns += 1;
+				toolIntentCorrections = 0;
+				/* 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);
 		}
@@ -1513,6 +1613,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		let committedMessages = currentMessages;
 		let assistantCommitted = false;
 		const commitAssistantMessage = () => {
+			assistantMessage.content = sanitizeAssistantContent(assistantMessage.content);
 			if (assistantCommitted) {
 				// v8 ignore next
 				if (committedMessages.at(-1)?.role === "assistant") {
@@ -1538,19 +1639,33 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				// v8 ignore next 3
 				if (controller.signal.aborted) return;
 				if (chunk.type === "content") {
-					assistantMessage.content += chunk.content;
+					assistantMessage.content = sanitizeAssistantContent(assistantMessage.content + chunk.content);
 					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, normalized.arguments);
 					const newMessages = [...updatedMessages, toolResultMessage];
 					setMessages(newMessages);
 					await processStreamReadOnly(newMessages);
@@ -1574,7 +1689,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					// v8 ignore next 3
 					if (controller.signal.aborted) return;
 					if (chunk.type === "content") {
-						planAssistantMessage.content += chunk.content;
+						planAssistantMessage.content = sanitizeAssistantContent(planAssistantMessage.content + chunk.content);
 						setStreamingMessage({ ...planAssistantMessage });
 					}
 				}
@@ -1641,33 +1756,35 @@ 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 = buildToolResultMessage(toolCall.function.name, result, toolCall.function.arguments);
+				const newMessages = [...approvedMessages, toolResultMessage];
+				setMessages(newMessages);
+				await processStream(newMessages, executionMode);
+				break;
+			}
+			case REJECT: {
 				const toolResultMessage = {
 					role: SYSTEM,
-					content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+					content: formatToolResultContent(toolCall.function.name, {
+						content: "",
+						error: "Tool call rejected by user"
+					}, toolCall.function.arguments)
 				};
-				const newMessages = [...messages, toolResultMessage];
-				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
-				await processStream(newMessages);
-				break;
-			}
-			case REJECT:
-				setMessages((previousMessages) => [...previousMessages, {
-					role: USER,
-					content: TURN_ABORTED_MESSAGE
-				}]);
+				setMessages([...approvedMessages, toolResultMessage]);
 				setIsLoading(false);
 				setInterruptReason(InterruptReason.Rejected);
 				break;
+			}
 		}
 	}, [
+		buildToolResultMessage,
 		pendingToolCall,
-		messages,
 		processStream
 	]);
 	const handleSubmit = useCallback(async ({ content, images }) => {
@@ -1711,7 +1828,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.22.0";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -97,11 +109,11 @@ var BACK = {
 var BASE_SYSTEM_PROMPT = `You are a coding assistant that helps users write, edit, and understand code. You have access to tools for reading files, writing files, running shell commands, searching code, and searching the web
 
 Follow these rules:
-1. Always use available tools rather than guessing file contents or code behavior
-2. Read files before editing them to understand context
-3. When writing files, provide complete, working code
-4. Explain your reasoning when making non-trivial changes
-5. Prefer minimal changes that achieve the goal
+1. Use available tools rather than guessing file contents, paths, or code behavior
+2. When a tool is needed, call it immediately instead of saying you will call it
+3. Read files before editing them to understand context
+4. Make the smallest exact change that satisfies the request
+5. Explain after tool results are available, unless the user asks for discussion or a plan
 6. Confirm with the user before destructive operations
 
 When tools return results, incorporate them into your response naturally`;
@@ -119,7 +131,12 @@ Always use tools when you need to:
 - Make file changes
 - Explore project structure
 - Search the codebase
-- Look up current or external information`;
+- Look up current or external information
+
+Path rules:
+- Paths are relative to the project root unless absolute
+- Preserve parent directories from listings; if list_dir("src") returns [d] utils, use src/utils
+- If a path fails, inspect the parent directory or search before retrying`;
 var PLAN_GENERATION_INSTRUCTION = `Based on the research above, decide whether the user request needs code or shell execution
 
 If the request needs changes or commands, respond with a plan checklist only
@@ -280,6 +297,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";
@@ -467,6 +495,15 @@ function saveConfig(patch) {
 //#region src/utils/ollama.ts
 var { host } = loadConfig();
 var client = new Ollama({ host });
+var TRAILING_CONTROL_TOKEN_REGEX = /(?:\s*<\|?channel\|?>)+\s*$/;
+var TOOL_INTENT_REGEX = /\b(?:i\s+(?:will|am going to)|next,\s*i\s+will|now\s+i\s+will|first,\s*i\s+will)\b[\s\S]*\b(?:read|inspect|check|list|search|update|edit|write|modify|run)\b/i;
+var TOOL_INTENT_CORRECTION = "You said you would use a tool but did not call one. Continue by calling the appropriate tool now. Do not describe the tool call.";
+function sanitizeAssistantContent(content) {
+	return content.replace(TRAILING_CONTROL_TOKEN_REGEX, "");
+}
+function hasUncalledToolIntent(content) {
+	return TOOL_INTENT_REGEX.test(content);
+}
 async function checkHealth() {
 	try {
 		return (await fetch(host)).ok;
@@ -475,9 +512,15 @@ async function checkHealth() {
 	}
 }
 async function* streamChat(messages, model, tools, signal) {
+	const providerMessages = messages.map(({ role, content, images, tool_calls }) => ({
+		role,
+		content,
+		...images ? { images } : {},
+		...tool_calls ? { tool_calls } : {}
+	}));
 	const response = await client.chat({
 		model,
-		messages,
+		messages: providerMessages,
 		stream: true,
 		tools,
 		// v8 ignore next
@@ -759,10 +802,10 @@ var TOOLS = [
 		type: "string",
 		description: "The path to the directory to list"
 	} }, ["path"]),
-	defineTool(GREP_SEARCH, "Search for a pattern in files within a directory", {
+	defineTool(GREP_SEARCH, "Search files within a directory; multi-word queries also match common code identifier forms", {
 		pattern: {
 			type: "string",
-			description: "The regex pattern to search for"
+			description: "The regex, phrase, or code concept to search for"
 		},
 		path: {
 			type: "string",
@@ -838,6 +881,76 @@ async function runShell(command) {
 }
 //#endregion
 //#region src/utils/tools/filesystem.ts
+var DIFF_CONTEXT_LINES = 3;
+var DIFF_MAX_LINES = 120;
+var DIFF_MAX_CHARS = 12e3;
+function splitLines(content) {
+	return content.split("\n");
+}
+function createUnifiedDiff(filePath, beforeContent, afterContent) {
+	const beforeLines = splitLines(beforeContent);
+	const afterLines = splitLines(afterContent);
+	let commonPrefix = 0;
+	while (commonPrefix < beforeLines.length && commonPrefix < afterLines.length && beforeLines[commonPrefix] === afterLines[commonPrefix]) commonPrefix += 1;
+	let commonSuffix = 0;
+	while (commonSuffix < beforeLines.length - commonPrefix && commonSuffix < afterLines.length - commonPrefix && beforeLines[beforeLines.length - 1 - commonSuffix] === afterLines[afterLines.length - 1 - commonSuffix]) commonSuffix += 1;
+	const beforeChangeEnd = beforeLines.length - commonSuffix;
+	const afterChangeEnd = afterLines.length - commonSuffix;
+	const hunkStart = Math.max(0, commonPrefix - DIFF_CONTEXT_LINES);
+	const beforeHunkEnd = Math.min(beforeLines.length, beforeChangeEnd + DIFF_CONTEXT_LINES);
+	const afterHunkEnd = Math.min(afterLines.length, afterChangeEnd + DIFF_CONTEXT_LINES);
+	const beforeHunkLines = beforeLines.slice(hunkStart, beforeHunkEnd);
+	const afterHunkLines = afterLines.slice(hunkStart, afterHunkEnd);
+	const beforeChangedLines = beforeLines.slice(commonPrefix, beforeChangeEnd);
+	const afterChangedLines = afterLines.slice(commonPrefix, afterChangeEnd);
+	const contextBefore = beforeLines.slice(hunkStart, commonPrefix);
+	const contextAfter = beforeLines.slice(beforeChangeEnd, beforeHunkEnd);
+	return [
+		`--- ${filePath}`,
+		`+++ ${filePath}`,
+		`@@ -${String(hunkStart + 1)},${String(beforeHunkLines.length)} +${String(hunkStart + 1)},${String(afterHunkLines.length)} @@`,
+		...contextBefore.map((line) => ` ${line}`),
+		...beforeChangedLines.map((line) => `-${line}`),
+		...afterChangedLines.map((line) => `+${line}`),
+		...contextAfter.map((line) => ` ${line}`)
+	].join("\n");
+}
+function truncateDiff(diff) {
+	const lines = diff.split("\n");
+	let visibleLines = lines.slice(0, DIFF_MAX_LINES);
+	let truncated = lines.length > DIFF_MAX_LINES;
+	while (visibleLines.join("\n").length > DIFF_MAX_CHARS) {
+		visibleLines = visibleLines.slice(0, -1);
+		truncated = true;
+	}
+	if (truncated) visibleLines = [...visibleLines, `[diff truncated: showing ${String(visibleLines.length)} of ${String(lines.length)} lines]`];
+	return {
+		visible: visibleLines.join("\n"),
+		truncated,
+		totalLines: lines.length,
+		visibleLines: Math.min(visibleLines.length, lines.length)
+	};
+}
+function buildSearchPatterns(pattern) {
+	const words = pattern.trim().split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (words.length < 2) return [pattern];
+	const camelCase = words.map((word, index) => index === 0 ? word.toLowerCase() : capitalize(word.toLowerCase())).join("");
+	const pascalCase = words.map((word) => capitalize(word.toLowerCase())).join("");
+	const snakeCase = words.map((word) => word.toLowerCase()).join("_");
+	const upperSnakeCase = snakeCase.toUpperCase();
+	const flexibleWhitespace = words.join(String.raw`\s+`);
+	return Array.from(new Set([
+		pattern,
+		flexibleWhitespace,
+		snakeCase,
+		upperSnakeCase,
+		camelCase,
+		pascalCase
+	]));
+}
+function capitalize(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
 /**
 * Read file contents
 */
@@ -887,8 +1000,19 @@ function editFile(filePath, oldText, newText) {
 			content: "",
 			error: `Exact text matched multiple locations in file: ${filePath}`
 		};
-		writeFileSync(filePath, content.replace(oldText, newText), "utf8");
-		return { content: `File edited successfully: ${filePath}` };
+		const updatedContent = content.replace(oldText, newText);
+		const truncatedDiff = truncateDiff(createUnifiedDiff(filePath, content, updatedContent));
+		writeFileSync(filePath, updatedContent, "utf8");
+		return {
+			content: `File edited successfully: ${filePath}`,
+			diff: {
+				path: filePath,
+				visible: truncatedDiff.visible,
+				truncated: truncatedDiff.truncated,
+				totalLines: truncatedDiff.totalLines,
+				visibleLines: truncatedDiff.visibleLines
+			}
+		};
 	} catch (error) {
 		return {
 			content: "",
@@ -943,17 +1067,17 @@ function listDir(dirPath) {
 * Search for pattern in files using ripgrep if available, fallback to Node.js
 */
 async function grepSearch(pattern, dirPath) {
-	try {
-		const { stdout } = await execShell(`rg --line-number --no-heading --smart-case "${pattern.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" "${dirPath.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
-		// v8 ignore next
-		return { content: stdout || "No matches found" };
+	const patterns = buildSearchPatterns(pattern);
+	for (const searchPattern of patterns) try {
+		const { stdout } = await execShell(`rg --line-number --no-heading --smart-case "${searchPattern.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" "${dirPath.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
+		if (stdout) return { content: stdout };
 	} catch {}
 	try {
 		if (!existsSync(dirPath)) return {
 			content: "",
 			error: `Directory not found: ${dirPath}`
 		};
-		const regex = new RegExp(pattern, "g");
+		const regexes = patterns.map((searchPattern) => new RegExp(searchPattern));
 		const results = [];
 		function searchDirectory(currentPath) {
 			const entries = readdirSync(currentPath, { withFileTypes: true });
@@ -963,9 +1087,9 @@ async function grepSearch(pattern, dirPath) {
 					if (!entry.name.startsWith(".") && entry.name !== "node_modules") searchDirectory(fullPath);
 				} else if (entry.isFile()) try {
 					const lines = readFileSync(fullPath, "utf8").split("\n");
-					for (let i = 0; i < lines.length; i++) {
-						if (regex.test(lines[i])) results.push(`${fullPath}:${(i + 1).toString()}: ${lines[i].trim()}`);
-						regex.lastIndex = 0;
+					for (let i = 0; i < lines.length; i++) for (const regex of regexes) if (regex.test(lines[i])) {
+						results.push(`${fullPath}:${(i + 1).toString()}: ${lines[i].trim()}`);
+						break;
 					}
 				} catch {}
 			}
@@ -1170,18 +1294,93 @@ 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, args) {
+	const formattedArgs = args ? `(${formatToolArguments(args)})` : "";
+	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}${formattedArgs} result:`,
+		status,
+		content.trim(),
+		error.trim()
+	].filter(Boolean).join("\n");
+}
+function formatToolArguments(args) {
+	return JSON.stringify(args, (_, value) => {
+		if (typeof value !== "string") return value;
+		if (value.length <= 80 && !value.includes("\n")) return value;
+		return `<${String(value.length)} chars>`;
+	});
+}
+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 +1398,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 +1440,8 @@ async function checkForUpdate() {
 //#endregion
 //#region src/cli.ts
 var cli = cac("code-ollama");
+var MAX_TOOL_TURNS = 25;
+var MAX_TOOL_INTENT_CORRECTIONS = 2;
 cli.version(VERSION);
 cli.help();
 cli.command("run <model> <prompt>", "Run a one-off prompt").action(async (model, prompt) => {
@@ -1272,30 +1474,58 @@ 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;
+	let activeMessages = messages;
+	let toolTurns = 0;
+	let toolIntentCorrections = 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 = sanitizeAssistantContent(assistantMessage.content + chunk.content);
+				write(chunk.content);
+				continue;
+			}
+			assistantMessage.content = sanitizeAssistantContent(assistantMessage.content);
+			// 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, toolCall.function.arguments)
+				});
+			}
+			nextMessages = [...committedMessages, ...toolResultMessages];
+			break;
 		}
-		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);
+		if (!nextMessages) {
+			assistantMessage.content = sanitizeAssistantContent(assistantMessage.content);
+			if (hasUncalledToolIntent(assistantMessage.content) && toolIntentCorrections < MAX_TOOL_INTENT_CORRECTIONS) {
+				toolIntentCorrections += 1;
+				activeMessages = [
+					...activeMessages,
+					assistantMessage,
+					{
+						role: SYSTEM,
+						content: TOOL_INTENT_CORRECTION
+					}
+				];
+				continue;
+			}
 			return;
 		}
+		activeMessages = nextMessages;
+		toolTurns += 1;
+		toolIntentCorrections = 0;
 	}
+	// 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 +1536,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-CzkVRFXf.js");
 	reset();
 	renderApp(sessionId);
 }
@@ -1322,4 +1552,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 { VERSION as $, loadConfig as A, ASSISTANT as B, checkHealth as C, pullModel as D, listModels as E, withSystemMessage as F, CATALOG as G, USER as H, HEADER_PREFIX as I, PLAN as J, AUTO as K, WARNING as L, removeClipboardImage as M, saveClipboardImage as N, sanitizeAssistantContent as O, resetSystemMessage as P, NAME as Q, LIST as R, TOOL_INTENT_CORRECTION as S, hasUncalledToolIntent as T, PLAN_GENERATION_INSTRUCTION as U, SYSTEM as V, BACK as W, APPROVE as X, SAFE as Y, REJECT as Z, loadSession as _, normalizeToolCall as a, reset as b, WRITE_TOOLS as c, write as d, LIST$1 as et, appendMessage as f, listSessions as g, deleteSessionIfEmpty as h, formatToolResultContent as i, saveConfig as j, streamChat as k, tick as l, deleteSession as m, main, executeTool as n, READ_TOOLS as o, createSession as p, LABEL as q, executeToolCall as r, TOOLS as s, checkForUpdate as t, color as u, updateSessionModel as v, deleteModel as w, setClearHandler as x, clear as y, getTheme as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "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/"