code-ollama 0.23.1 → 0.24.0

package/dist/assets/{tui-iewVFcZW.js → tui-DEmaVgHT.js}

@@ -3,8 +3,8 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { exec } from "node:child_process";
-import { Box, Static, Text, render, useApp, useInput, useStdout } from "ink";
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Static, Text, render, useApp, useInput, usePaste, useStdout } from "ink";
+import { memo, useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { ProgressBar, Select, Spinner } from "@inkjs/ui";
 import { Marked } from "marked";
@@ -747,36 +747,46 @@ function ToolApproval({ toolCall, onDecision, theme = getTheme() }) {
 //#region src/components/TextInput/TextInput.tsx
 function buildLineSegments(displayValue, cursorPosition, width) {
 	const safeWidth = Math.max(1, width);
-	const cursorChar = displayValue[cursorPosition] || " ";
-	const renderValue = displayValue.slice(0, cursorPosition) + cursorChar + displayValue.slice(cursorPosition + 1);
-	const totalLength = Math.max(1, renderValue.length);
 	const lines = [];
-	for (let start = 0; start < totalLength; start += safeWidth) {
-		const end = start + safeWidth;
-		const text = renderValue.slice(start, end);
-		const hasCursor = cursorPosition >= start && cursorPosition < end;
-		if (!hasCursor) {
+	const logicalLines = displayValue.split("\n");
+	let lineStart = 0;
+	for (const [lineIndex, logicalLine] of logicalLines.entries()) {
+		const lineEnd = lineStart + logicalLine.length;
+		const hasCursorOnLine = cursorPosition >= lineStart && cursorPosition <= lineEnd;
+		const cursorOffset = cursorPosition - lineStart;
+		const renderValue = hasCursorOnLine && cursorOffset === logicalLine.length ? `${logicalLine} ` : logicalLine;
+		const totalLength = Math.max(1, renderValue.length);
+		for (let start = 0; start < totalLength; start += safeWidth) {
+			const end = start + safeWidth;
+			const text = renderValue.slice(start, end);
+			const hasCursor = hasCursorOnLine && cursorOffset >= start && cursorOffset < end;
+			if (!hasCursor) {
+				lines.push({
+					text,
+					hasCursor,
+					beforeCursor: "",
+					cursorChar: " ",
+					afterCursor: ""
+				});
+				continue;
+			}
+			const offset = cursorOffset - start;
 			lines.push({
 				text,
 				hasCursor,
-				beforeCursor: "",
-				cursorChar: " ",
-				afterCursor: ""
+				beforeCursor: text.slice(0, offset),
+				cursorChar: text[offset],
+				afterCursor: text.slice(offset + 1)
 			});
-			continue;
 		}
-		const offset = cursorPosition - start;
-		lines.push({
-			text,
-			hasCursor,
-			beforeCursor: text.slice(0, offset),
-			cursorChar: text[offset] || " ",
-			afterCursor: text.slice(offset + 1)
-		});
+		lineStart = lineEnd + (lineIndex < logicalLines.length - 1 ? 1 : 0);
 	}
 	return lines;
 }
-function TextInput({ value, isDisabled = false, placeholder, cursorPosition: externalCursorPosition, wrapIndent = 0, onChange, onSubmit }) {
+function normalizePastedText(input) {
+	return input.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function TextInput({ value, isDisabled = false, placeholder, cursorPosition: externalCursorPosition, allowMultilinePaste = false, wrapIndent = 0, onChange, onSubmit }) {
 	const { stdout } = useStdout();
 	const [cursorPosition, setCursorPosition] = useState(value.length);
 	const prevValueRef = useRef(value);
@@ -798,9 +808,24 @@ function TextInput({ value, isDisabled = false, placeholder, cursorPosition: ext
 		cursorPosition,
 		externalCursorPosition
 	]);
+	const insertText = useCallback((text) => {
+		onChange(value.slice(0, cursorPosition) + text + value.slice(cursorPosition));
+		setCursorPosition(cursorPosition + text.length);
+	}, [
+		cursorPosition,
+		onChange,
+		value
+	]);
+	usePaste((text) => {
+		insertText(normalizePastedText(text));
+	}, { isActive: allowMultilinePaste && !isDisabled });
 	useInput((input, key) => {
 		// v8 ignore next
 		if (isDisabled) return;
+		if (allowMultilinePaste && input.length > 1 && /[\r\n]/.test(input)) {
+			insertText(normalizePastedText(input));
+			return;
+		}
 		if (key.return) {
 			onSubmit(value);
 			setCursorPosition(0);
@@ -845,10 +870,7 @@ function TextInput({ value, isDisabled = false, placeholder, cursorPosition: ext
 		}
 		if (key.ctrl) return;
 		// v8 ignore start
-		if (input) {
-			onChange(value.slice(0, cursorPosition) + input + value.slice(cursorPosition));
-			setCursorPosition(cursorPosition + input.length);
-		}
+		if (input) insertText(input);
 		// v8 ignore stop
 	}, { isActive: !isDisabled });
 	const displayValue = value || (placeholder ?? "");
@@ -948,25 +970,6 @@ function extractImageAttachments(input) {
 	};
 }
 //#endregion
-//#region src/components/Chat/CommandMenu.tsx
-function getMatchingCommands(input) {
-	const normalizedInput = input.trim().toLowerCase();
-	if (!normalizedInput.startsWith("/")) return [];
-	return LIST.filter(({ name }) => name.toLowerCase().startsWith(normalizedInput)).map(({ name, description }) => ({
-		label: `${name} - ${description}`,
-		value: name
-	}));
-}
-function CommandMenu({ input, onSubmit }) {
-	const commandOptions = useMemo(() => getMatchingCommands(input), [input]);
-	if (!commandOptions.length) return null;
-	return /* @__PURE__ */ jsx(SelectPrompt, {
-		highlightText: input,
-		onChange: onSubmit,
-		options: commandOptions
-	});
-}
-//#endregion
 //#region src/components/Suggestions/Suggestions.tsx
 var DEFAULT_MAX_VISIBLE_OPTIONS = 5;
 function Suggestions({ options, isDisabled = false, maxVisibleOptions = DEFAULT_MAX_VISIBLE_OPTIONS, resetKey, onHighlight, onSelect }) {
@@ -999,7 +1002,7 @@ function Suggestions({ options, isDisabled = false, maxVisibleOptions = DEFAULT_
 			setFocusedIndex((currentIndex) => Math.max(currentIndex - 1, 0));
 			return;
 		}
-		if (key.tab || key.return || input === "	" || input === "\r") onSelect(options[focusedIndex]);
+		if (key.tab || key.return) onSelect(options[focusedIndex]);
 	});
 	if (!options.length) return null;
 	const visibleStart = Math.min(Math.max(0, focusedIndex - maxVisibleOptions + 1), Math.max(0, options.length - maxVisibleOptions));
@@ -1017,6 +1020,26 @@ function Suggestions({ options, isDisabled = false, maxVisibleOptions = DEFAULT_
 	});
 }
 //#endregion
+//#region src/components/Chat/CommandMenu.tsx
+function getMatchingCommands(input) {
+	const normalizedInput = input.trim().toLowerCase();
+	if (!normalizedInput.startsWith("/")) return [];
+	return LIST.filter(({ name }) => name.toLowerCase().startsWith(normalizedInput)).map(({ name, description }) => ({
+		label: `${name} - ${description}`,
+		value: name
+	}));
+}
+function CommandMenu({ input, onSubmit }) {
+	const commandOptions = useMemo(() => getMatchingCommands(input), [input]);
+	if (!commandOptions.length) return null;
+	return /* @__PURE__ */ jsx(Suggestions, {
+		onSelect: (option) => {
+			onSubmit(option.value);
+		},
+		options: commandOptions
+	});
+}
+//#endregion
 //#region src/components/Chat/FileSuggestions.tsx
 var MENTION_PATTERN = /(^|.)@(\S+)/;
 var RIPGREP_MAX_BUFFER = 10 * 1024 * 1024;
@@ -1263,7 +1286,8 @@ function ChatInput({ history: sessionHistory, isDisabled = false, onInterrupt, o
 		onSubmit,
 		resetInput
 	]);
-	const showCommandMenu = input.startsWith("/");
+	const isMultilineInput = input.includes("\n");
+	const showCommandMenu = input.startsWith("/") && !isMultilineInput;
 	const showFileSuggestions = !showCommandMenu && hasFileSuggestionQuery(input);
 	const handleHistoryNavigation = useCallback((direction) => {
 		if (!history.length || showFileSuggestions || hasAttachments) return;
@@ -1305,7 +1329,7 @@ function ChatInput({ history: sessionHistory, isDisabled = false, onInterrupt, o
 		showFileSuggestions
 	]);
 	const handleSubmitText = useCallback((value) => {
-		if (value.startsWith("/")) return;
+		if (value.startsWith("/") && !value.includes("\n")) return;
 		if (hasFileSuggestionQuery(value)) {
 			if (fileSuggestionRef.current) handleSelectFileSuggestion(fileSuggestionRef.current);
 			return;
@@ -1365,6 +1389,7 @@ function ChatInput({ history: sessionHistory, isDisabled = false, onInterrupt, o
 					value: input,
 					isDisabled,
 					cursorPosition,
+					allowMultilinePaste: true,
 					wrapIndent,
 					onChange: handleInputChange,
 					onSubmit: handleSubmitText,
@@ -1389,6 +1414,21 @@ function ChatInput({ history: sessionHistory, isDisabled = false, onInterrupt, o
 var ACTION_NOT_PERFORMED = "The requested action was NOT performed";
 var PLAN_CHECKLIST_REMINDER = "Then display the plan using either the Plan Needs Input or Proposed Plan Markdown template";
 var PLAN_EXECUTION_REMINDER = `Do not claim success and do not call ${Array.from(WRITE_TOOLS).join(", ")} until the user approves execution`;
+var ChatActionType = /* @__PURE__ */ function(ChatActionType) {
+	ChatActionType["AppendMessage"] = "append-message";
+	ChatActionType["ClearPendingPlan"] = "clear-pending-plan";
+	ChatActionType["ClearPendingToolCall"] = "clear-pending-tool-call";
+	ChatActionType["CommitMessages"] = "commit-messages";
+	ChatActionType["Interrupt"] = "interrupt";
+	ChatActionType["RequestPlanReview"] = "request-plan-review";
+	ChatActionType["RequestToolApproval"] = "request-tool-approval";
+	ChatActionType["ResetSession"] = "reset-session";
+	ChatActionType["SetLoading"] = "set-loading";
+	ChatActionType["SetStreamingMessage"] = "set-streaming-message";
+	ChatActionType["StartTurn"] = "start-turn";
+	ChatActionType["ToolRejected"] = "tool-rejected";
+	return ChatActionType;
+}({});
 var InterruptReason = /* @__PURE__ */ function(InterruptReason) {
 	InterruptReason["Interrupted"] = "interrupted";
 	InterruptReason["Rejected"] = "rejected";
@@ -1406,27 +1446,91 @@ function hasExecutablePlan(content) {
 	return lines.slice(executionStepsIndex + 1, nextSectionIndex === -1 ? void 0 : nextSectionIndex).some((line) => /^(?:[-*]|\d+[.)])\s+\S/.test(line.trim()));
 }
 //#endregion
+//#region src/components/Chat/reducer.ts
+function createInitialChatState(messages = []) {
+	return {
+		messages,
+		streamingMessage: null,
+		isLoading: false,
+		pendingToolCall: null,
+		pendingPlan: null,
+		interruptReason: null
+	};
+}
+function chatReducer(state, action) {
+	switch (action.type) {
+		case ChatActionType.AppendMessage: return {
+			...state,
+			messages: [...state.messages, action.message]
+		};
+		case ChatActionType.ClearPendingPlan: return {
+			...state,
+			pendingPlan: null
+		};
+		case ChatActionType.ClearPendingToolCall: return {
+			...state,
+			pendingToolCall: null
+		};
+		case ChatActionType.CommitMessages: return {
+			...state,
+			messages: action.messages
+		};
+		case ChatActionType.Interrupt: return {
+			...state,
+			messages: [...state.messages, action.message],
+			streamingMessage: null,
+			isLoading: false,
+			interruptReason: InterruptReason.Interrupted
+		};
+		case ChatActionType.RequestPlanReview: return {
+			...state,
+			pendingPlan: action.pendingPlan,
+			isLoading: false
+		};
+		case ChatActionType.RequestToolApproval: return {
+			...state,
+			pendingToolCall: action.pendingToolCall,
+			isLoading: false
+		};
+		case ChatActionType.ResetSession: return createInitialChatState(action.messages);
+		case ChatActionType.SetLoading: return {
+			...state,
+			isLoading: action.isLoading
+		};
+		case ChatActionType.SetStreamingMessage: return {
+			...state,
+			streamingMessage: action.message
+		};
+		case ChatActionType.StartTurn: return {
+			...state,
+			messages: [...state.messages, action.message],
+			isLoading: true,
+			interruptReason: null
+		};
+		case ChatActionType.ToolRejected: return {
+			...state,
+			messages: action.messages,
+			isLoading: false,
+			interruptReason: InterruptReason.Rejected
+		};
+	}
+}
+//#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]);
-	const [messages, setMessages] = useState(sessionMessages);
-	const [streamingMessage, setStreamingMessage] = useState(null);
-	const [isLoading, setIsLoading] = useState(false);
-	const [pendingToolCall, setPendingToolCall] = useState(null);
-	const [pendingPlan, setPendingPlan] = useState(null);
-	const [interruptReason, setInterruptReason] = useState(null);
+	const [state, dispatch] = useReducer(chatReducer, sessionMessages, createInitialChatState);
+	const { messages, streamingMessage, isLoading, pendingToolCall, pendingPlan, interruptReason } = state;
 	const abortControllerRef = useRef(null);
 	const persistedSnapshotRef = useRef("");
 	useEffect(() => {
-		setMessages(sessionMessages);
-		setStreamingMessage(null);
-		setIsLoading(false);
-		setPendingToolCall(null);
-		setPendingPlan(null);
-		setInterruptReason(null);
+		dispatch({
+			type: ChatActionType.ResetSession,
+			messages: sessionMessages
+		});
 		persistedSnapshotRef.current = JSON.stringify(sessionMessages);
 	}, [sessionId]);
 	useEffect(() => {
@@ -1467,13 +1571,13 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 	const handleInterrupt = useCallback(() => {
 		abortControllerRef.current?.abort();
 		abortControllerRef.current = null;
-		setIsLoading(false);
-		setStreamingMessage(null);
-		setInterruptReason(InterruptReason.Interrupted);
-		setMessages((prev) => [...prev, {
-			role: USER,
-			content: TURN_ABORTED_MESSAGE
-		}]);
+		dispatch({
+			type: ChatActionType.Interrupt,
+			message: {
+				role: USER,
+				content: TURN_ABORTED_MESSAGE
+			}
+		});
 	}, []);
 	const processStream = useCallback(async (currentMessages, executionMode = mode) => {
 		const modelName = model;
@@ -1498,27 +1602,45 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					if (assistantCommitted) {
 						if (committedMessages.at(-1)?.role === "assistant") {
 							committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
-							setMessages(committedMessages);
+							dispatch({
+								type: ChatActionType.CommitMessages,
+								messages: committedMessages
+							});
 						}
 						return committedMessages;
 					}
 					// v8 ignore stop
 					assistantCommitted = true;
-					setStreamingMessage(null);
+					dispatch({
+						type: ChatActionType.SetStreamingMessage,
+						message: null
+					});
 					if (!assistantMessage.content) {
-						setMessages(committedMessages);
+						dispatch({
+							type: ChatActionType.CommitMessages,
+							messages: committedMessages
+						});
 						return committedMessages;
 					}
 					committedMessages = [...committedMessages, { ...assistantMessage }];
-					setMessages(committedMessages);
+					dispatch({
+						type: ChatActionType.CommitMessages,
+						messages: committedMessages
+					});
 					return committedMessages;
 				};
-				setStreamingMessage(assistantMessage);
+				dispatch({
+					type: ChatActionType.SetStreamingMessage,
+					message: 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 });
+						dispatch({
+							type: ChatActionType.SetStreamingMessage,
+							message: { ...assistantMessage }
+						});
 						continue;
 					}
 					if (chunk.tool_calls.length === 0) continue;
@@ -1527,12 +1649,14 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					for (const toolCall of chunk.tool_calls) try {
 						const normalized = normalizeToolCall(toolCall);
 						if (executionMode === "safe" && normalized.requiresApproval) {
-							setPendingToolCall({
-								toolCall,
-								messages: [...updatedMessages, ...toolResultMessages],
-								executionMode
+							dispatch({
+								type: ChatActionType.RequestToolApproval,
+								pendingToolCall: {
+									toolCall,
+									messages: [...updatedMessages, ...toolResultMessages],
+									executionMode
+								}
 							});
-							setIsLoading(false);
 							return;
 						}
 						// v8 ignore next
@@ -1547,7 +1671,10 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 						}));
 					}
 					nextMessages = [...updatedMessages, ...toolResultMessages];
-					setMessages(nextMessages);
+					dispatch({
+						type: ChatActionType.CommitMessages,
+						messages: nextMessages
+					});
 					break;
 				}
 				if (!nextMessages) {
@@ -1559,7 +1686,10 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 							role: SYSTEM,
 							content: TOOL_INTENT_CORRECTION
 						}];
-						setMessages(activeMessages);
+						dispatch({
+							type: ChatActionType.CommitMessages,
+							messages: activeMessages
+						});
 						continue;
 					}
 					return;
@@ -1568,14 +1698,18 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				toolIntentCorrections = 0;
 				/* v8 ignore start */
 				if (toolTurns >= MAX_TOOL_TURNS) {
-					setMessages([...nextMessages, {
+					const stoppedMessages = [...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")
-					}]);
+					}];
+					dispatch({
+						type: ChatActionType.CommitMessages,
+						messages: stoppedMessages
+					});
 					return;
 				}
 				/* v8 ignore stop */
@@ -1589,13 +1723,22 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					content: `Error: ${error instanceof Error ? error.message : String(error)}`
 				};
 				await prewarmCodeBlocks(errorMessage.content, theme);
-				setStreamingMessage(null);
-				setMessages([...activeMessages, errorMessage]);
+				dispatch({
+					type: ChatActionType.SetStreamingMessage,
+					message: null
+				});
+				dispatch({
+					type: ChatActionType.CommitMessages,
+					messages: [...activeMessages, errorMessage]
+				});
 			}
 		} finally {
 			// v8 ignore next
 			if (abortControllerRef.current === controller) abortControllerRef.current = null;
-			setIsLoading(false);
+			dispatch({
+				type: ChatActionType.SetLoading,
+				isLoading: false
+			});
 		}
 	}, [
 		buildToolResultMessage,
@@ -1625,22 +1768,37 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 			if (assistantCommitted) {
 				if (committedMessages.at(-1)?.role === "assistant") {
 					committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
-					setMessages(committedMessages);
+					dispatch({
+						type: ChatActionType.CommitMessages,
+						messages: committedMessages
+					});
 				}
 				return committedMessages;
 			}
 			/* v8 ignore stop */
 			assistantCommitted = true;
-			setStreamingMessage(null);
+			dispatch({
+				type: ChatActionType.SetStreamingMessage,
+				message: null
+			});
 			if (!assistantMessage.content) {
-				setMessages(committedMessages);
+				dispatch({
+					type: ChatActionType.CommitMessages,
+					messages: committedMessages
+				});
 				return committedMessages;
 			}
 			committedMessages = [...committedMessages, { ...assistantMessage }];
-			setMessages(committedMessages);
+			dispatch({
+				type: ChatActionType.CommitMessages,
+				messages: committedMessages
+			});
 			return committedMessages;
 		};
-		setStreamingMessage(emptyAssistantMessage);
+		dispatch({
+			type: ChatActionType.SetStreamingMessage,
+			message: emptyAssistantMessage
+		});
 		try {
 			const readOnlyTools = TOOLS.filter((tool) => READ_TOOLS.has(tool.function.name));
 			const planResearchMessages = [...currentMessages, {
@@ -1652,18 +1810,30 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				if (controller.signal.aborted) return;
 				if (chunk.type === "content") {
 					assistantMessage.content = sanitizeAssistantContent(assistantMessage.content + chunk.content);
-					setStreamingMessage({ ...assistantMessage });
+					dispatch({
+						type: ChatActionType.SetStreamingMessage,
+						message: { ...assistantMessage }
+					});
 				} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
 					const toolName = toolCall.function.name;
 					if (!READ_TOOLS.has(toolName)) {
 						const correctionMessage = buildPlanModeCorrectionMessage(toolName);
-						setStreamingMessage(null);
+						dispatch({
+							type: ChatActionType.SetStreamingMessage,
+							message: null
+						});
 						const newMessages = [...committedMessages, correctionMessage];
-						setMessages(newMessages);
+						dispatch({
+							type: ChatActionType.CommitMessages,
+							messages: newMessages
+						});
 						await processStreamReadOnly(newMessages);
 						return;
 					}
-					setStreamingMessage(emptyAssistantMessage);
+					dispatch({
+						type: ChatActionType.SetStreamingMessage,
+						message: emptyAssistantMessage
+					});
 					assistantMessage.content = "";
 					const updatedMessages = committedMessages;
 					let normalized;
@@ -1676,14 +1846,20 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 							error: error instanceof Error ? error.message : String(error)
 						});
 						const newMessages = [...updatedMessages, toolResultMessage];
-						setMessages(newMessages);
+						dispatch({
+							type: ChatActionType.CommitMessages,
+							messages: newMessages
+						});
 						await processStreamReadOnly(newMessages);
 						return;
 					}
 					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);
+					dispatch({
+						type: ChatActionType.CommitMessages,
+						messages: newMessages
+					});
 					await processStreamReadOnly(newMessages);
 					return;
 				}
@@ -1691,11 +1867,13 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 			await prewarmCodeBlocks(assistantMessage.content, theme);
 			const researchMessages = commitAssistantMessage();
 			if (hasExecutablePlan(assistantMessage.content)) {
-				setPendingPlan({
-					planContent: assistantMessage.content,
-					messages: researchMessages
+				dispatch({
+					type: ChatActionType.RequestPlanReview,
+					pendingPlan: {
+						planContent: assistantMessage.content,
+						messages: researchMessages
+					}
 				});
-				setIsLoading(false);
 				return;
 			}
 			const planInstruction = {
@@ -1707,32 +1885,60 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				role: ASSISTANT,
 				content: ""
 			};
-			setStreamingMessage(emptyAssistantMessage);
+			dispatch({
+				type: ChatActionType.SetStreamingMessage,
+				message: emptyAssistantMessage
+			});
 			try {
 				for await (const chunk of streamChat(withSystemMessage(planMessages), modelName, [], controller.signal)) {
 					// v8 ignore next 3
 					if (controller.signal.aborted) return;
 					if (chunk.type === "content") {
 						planAssistantMessage.content = sanitizeAssistantContent(planAssistantMessage.content + chunk.content);
-						setStreamingMessage({ ...planAssistantMessage });
+						dispatch({
+							type: ChatActionType.SetStreamingMessage,
+							message: { ...planAssistantMessage }
+						});
 					}
 				}
 			} catch (error) {
 				// v8 ignore next
 				planAssistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
-				setMessages([...planMessages, { ...planAssistantMessage }]);
-				setStreamingMessage(null);
-				setIsLoading(false);
+				const errorPlanMessages = [...planMessages, { ...planAssistantMessage }];
+				dispatch({
+					type: ChatActionType.CommitMessages,
+					messages: errorPlanMessages
+				});
+				dispatch({
+					type: ChatActionType.SetStreamingMessage,
+					message: null
+				});
+				dispatch({
+					type: ChatActionType.SetLoading,
+					isLoading: false
+				});
 				return;
 			}
 			const finalPlanMessages = [...planMessages, { ...planAssistantMessage }];
-			setMessages(finalPlanMessages);
-			setStreamingMessage(null);
-			if (hasExecutablePlan(planAssistantMessage.content)) setPendingPlan({
-				planContent: planAssistantMessage.content,
+			dispatch({
+				type: ChatActionType.CommitMessages,
 				messages: finalPlanMessages
 			});
-			setIsLoading(false);
+			dispatch({
+				type: ChatActionType.SetStreamingMessage,
+				message: null
+			});
+			if (hasExecutablePlan(planAssistantMessage.content)) dispatch({
+				type: ChatActionType.RequestPlanReview,
+				pendingPlan: {
+					planContent: planAssistantMessage.content,
+					messages: finalPlanMessages
+				}
+			});
+			dispatch({
+				type: ChatActionType.SetLoading,
+				isLoading: false
+			});
 		} catch (error) {
 			// v8 ignore next
 			if (!controller.signal.aborted) {
@@ -1742,7 +1948,10 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 			}
 		} finally {
 			if (abortControllerRef.current === controller) abortControllerRef.current = null;
-			setIsLoading(false);
+			dispatch({
+				type: ChatActionType.SetLoading,
+				isLoading: false
+			});
 		}
 	}, [
 		buildPlanModeCorrectionMessage,
@@ -1754,19 +1963,25 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		// v8 ignore next
 		if (!pendingPlan) return;
 		const { messages: planMessages } = pendingPlan;
-		setPendingPlan(null);
+		dispatch({ type: ChatActionType.ClearPendingPlan });
 		if (mode === "plan") {
 			onModeChange(PLAN);
 			const cancelMessage = {
 				role: SYSTEM,
 				content: "Continuing in Plan mode. No tools were executed."
 			};
-			setMessages((previousMessages) => [...previousMessages, cancelMessage]);
+			dispatch({
+				type: ChatActionType.AppendMessage,
+				message: cancelMessage
+			});
 			return;
 		}
 		const selectedMode = mode === "auto" ? AUTO : SAFE;
 		onModeChange(selectedMode);
-		setIsLoading(true);
+		dispatch({
+			type: ChatActionType.SetLoading,
+			isLoading: true
+		});
 		const executeInstruction = {
 			role: SYSTEM,
 			content: mode === "auto" ? "Execute the plan above. Use tools as needed without asking for further confirmation." : "Execute the plan above one step at a time. Wait for user approval before each tool call that modifies files or runs commands."
@@ -1781,14 +1996,20 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		// v8 ignore next
 		if (!pendingToolCall) return;
 		const { executionMode, messages: approvedMessages, toolCall } = pendingToolCall;
-		setPendingToolCall(null);
-		setIsLoading(true);
+		dispatch({ type: ChatActionType.ClearPendingToolCall });
+		dispatch({
+			type: ChatActionType.SetLoading,
+			isLoading: true
+		});
 		switch (decision) {
 			case APPROVE: {
 				const result = await executeToolCall(toolCall);
 				const toolResultMessage = buildToolResultMessage(toolCall.function.name, result, toolCall.function.arguments);
 				const newMessages = [...approvedMessages, toolResultMessage];
-				setMessages(newMessages);
+				dispatch({
+					type: ChatActionType.CommitMessages,
+					messages: newMessages
+				});
 				await processStream(newMessages, executionMode);
 				break;
 			}
@@ -1800,9 +2021,10 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 						error: "Tool call rejected by user"
 					}, toolCall.function.arguments)
 				};
-				setMessages([...approvedMessages, toolResultMessage]);
-				setIsLoading(false);
-				setInterruptReason(InterruptReason.Rejected);
+				dispatch({
+					type: ChatActionType.ToolRejected,
+					messages: [...approvedMessages, toolResultMessage]
+				});
 				break;
 			}
 		}
@@ -1812,21 +2034,22 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		processStream
 	]);
 	const handleSubmit = useCallback(async ({ content, images }) => {
-		setInterruptReason(null);
 		const userContent = content.trim();
 		if (!userContent && !images?.length) return;
 		if (userContent.startsWith("/")) {
 			onCommand(userContent);
 			return;
 		}
-		setIsLoading(true);
 		const userMessage = {
 			role: USER,
 			content: userContent,
 			...images?.length ? { images } : {}
 		};
 		const updatedMessages = [...messages, userMessage];
-		setMessages(updatedMessages);
+		dispatch({
+			type: ChatActionType.StartTurn,
+			message: userMessage
+		});
 		if (mode === "plan") await processStreamReadOnly(updatedMessages);
 		else await processStream(updatedMessages);
 	}, [

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import cac from "cac";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
@@ -50,7 +50,7 @@ var LIST$1 = [
 //#endregion
 //#region package.json
 var name = "code-ollama";
-var version = "0.23.1";
+var version = "0.24.0";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -107,13 +107,16 @@ var BACK = {
 //#endregion
 //#region src/constants/tool.ts
 var tool_exports = /* @__PURE__ */ __exportAll({
+	CREATE_DIRECTORY: () => CREATE_DIRECTORY,
+	DELETE_PATH: () => DELETE_PATH,
 	EDIT_FILE: () => EDIT_FILE,
+	FIND_FILES: () => FIND_FILES,
 	GREP_SEARCH: () => GREP_SEARCH,
 	LIST_DIR: () => LIST_DIR,
 	READ_FILE: () => READ_FILE,
 	READ_TOOL_NAMES: () => READ_TOOL_NAMES,
+	RENAME_PATH: () => RENAME_PATH,
 	RUN_SHELL: () => RUN_SHELL,
-	VIEW_RANGE: () => VIEW_RANGE,
 	WEB_FETCH: () => WEB_FETCH,
 	WEB_SEARCH: () => WEB_SEARCH,
 	WRITE_FILE: () => WRITE_FILE,
@@ -122,23 +125,29 @@ var tool_exports = /* @__PURE__ */ __exportAll({
 var READ_FILE = "read_file";
 var WRITE_FILE = "write_file";
 var EDIT_FILE = "edit_file";
+var CREATE_DIRECTORY = "create_directory";
+var RENAME_PATH = "rename_path";
+var DELETE_PATH = "delete_path";
 var RUN_SHELL = "run_shell";
 var LIST_DIR = "list_dir";
+var FIND_FILES = "find_files";
 var GREP_SEARCH = "grep_search";
-var VIEW_RANGE = "view_range";
 var WEB_SEARCH = "web_search";
 var WEB_FETCH = "web_fetch";
 var READ_TOOL_NAMES = [
 	READ_FILE,
 	LIST_DIR,
+	FIND_FILES,
 	GREP_SEARCH,
-	VIEW_RANGE,
 	WEB_SEARCH,
 	WEB_FETCH
 ];
 var WRITE_TOOL_NAMES = [
 	WRITE_FILE,
 	EDIT_FILE,
+	CREATE_DIRECTORY,
+	RENAME_PATH,
+	DELETE_PATH,
 	RUN_SHELL
 ];
 //#endregion
@@ -157,10 +166,14 @@ Follow these rules:
 
 When tools return results, incorporate them into your response naturally`;
 var TOOL_INSTRUCTIONS = `Available tools:
-- read_file: Read file contents at a path
+- read_file: Read file contents at a path; supports startLine, endLine, and maxLines options
 - write_file: Write content to a file (requires approval)
 - edit_file: Replace one exact text match in a file (requires approval)
+- create_directory: Create a directory and missing parent directories (requires approval)
+- rename_path: Rename or move a file or directory without overwriting existing destinations (requires approval)
+- delete_path: Delete a file or directory; non-empty directories require recursive=true (requires approval)
 - list_dir: List files in a directory
+- find_files: Recursively find files by optional substring or wildcard path pattern; supports includeHidden and ignoredDirs options
 - grep_search: Search code with regex
 - web_search: Search the web for current or external information
 - run_shell: Execute shell commands (requires approval)
@@ -815,10 +828,24 @@ function defineTool(name, description, params, required) {
 * Tool definitions for Ollama API
 */
 var TOOLS = [
-	defineTool(READ_FILE, "Read the contents of a file at the specified path", { path: {
-		type: "string",
-		description: "The path to the file to read"
-	} }, ["path"]),
+	defineTool(READ_FILE, "Read the contents of a file at the specified path, optionally limited by line range", {
+		path: {
+			type: "string",
+			description: "The path to the file to read"
+		},
+		startLine: {
+			type: "number",
+			description: "Optional starting line number to read from (1-indexed)"
+		},
+		endLine: {
+			type: "number",
+			description: "Optional ending line number to read through (inclusive)"
+		},
+		maxLines: {
+			type: "number",
+			description: "Optional maximum number of lines to read; cannot be combined with endLine"
+		}
+	}, ["path"]),
 	defineTool(WRITE_FILE, "Write content to a file at the specified path", {
 		path: {
 			type: "string",
@@ -847,6 +874,30 @@ var TOOLS = [
 		"oldText",
 		"newText"
 	]),
+	defineTool(CREATE_DIRECTORY, "Create a directory and any missing parent directories at the specified path", { path: {
+		type: "string",
+		description: "The directory path to create"
+	} }, ["path"]),
+	defineTool(RENAME_PATH, "Rename or move an existing file or directory to a new path", {
+		from: {
+			type: "string",
+			description: "The existing file or directory path to rename or move"
+		},
+		to: {
+			type: "string",
+			description: "The destination path for the renamed or moved item"
+		}
+	}, ["from", "to"]),
+	defineTool(DELETE_PATH, "Delete a file or directory at the specified path", {
+		path: {
+			type: "string",
+			description: "The file or directory path to delete"
+		},
+		recursive: {
+			type: "boolean",
+			description: "Whether to delete non-empty directories recursively; use false for files and empty directories"
+		}
+	}, ["path", "recursive"]),
 	defineTool(RUN_SHELL, "Execute a shell command", { command: {
 		type: "string",
 		description: "The shell command to execute"
@@ -855,6 +906,28 @@ var TOOLS = [
 		type: "string",
 		description: "The path to the directory to list"
 	} }, ["path"]),
+	defineTool(FIND_FILES, "Recursively find files under a directory, optionally matching a simple substring or wildcard pattern", {
+		path: {
+			type: "string",
+			description: "The directory path to search in"
+		},
+		pattern: {
+			type: "string",
+			description: "Optional case-insensitive substring or wildcard pattern to match against file paths"
+		},
+		includeHidden: {
+			type: "boolean",
+			description: "Whether to include hidden files and directories; defaults to false"
+		},
+		ignoredDirs: {
+			type: "array",
+			description: "Optional directory names or simple wildcard patterns to skip instead of the default ignored directory list; .git is always skipped",
+			items: {
+				type: "string",
+				description: "Directory name or wildcard pattern to skip"
+			}
+		}
+	}, ["path"]),
 	defineTool(GREP_SEARCH, "Search files within a directory; multi-word queries also match common code identifier forms", {
 		pattern: {
 			type: "string",
@@ -865,24 +938,6 @@ var TOOLS = [
 			description: "The directory path to search in"
 		}
 	}, ["pattern", "path"]),
-	defineTool(VIEW_RANGE, "View a specific range of lines from a file", {
-		path: {
-			type: "string",
-			description: "The path to the file"
-		},
-		start: {
-			type: "number",
-			description: "The starting line number (1-indexed)"
-		},
-		end: {
-			type: "number",
-			description: "The ending line number (inclusive)"
-		}
-	}, [
-		"path",
-		"start",
-		"end"
-	]),
 	defineTool(WEB_SEARCH, "Search the web for external or current information", { query: {
 		type: "string",
 		description: "The search query to look up"
@@ -926,6 +981,17 @@ async function runShell(command) {
 var DIFF_CONTEXT_LINES = 3;
 var DIFF_MAX_LINES = 120;
 var DIFF_MAX_CHARS = 12e3;
+var DEFAULT_FIND_FILES_IGNORED_DIRS = [
+	"node_modules",
+	"__pycache__",
+	".*cache",
+	".tox",
+	".venv",
+	"venv",
+	"dist",
+	"build",
+	"coverage"
+];
 function splitLines(content) {
 	return content.split("\n");
 }
@@ -993,16 +1059,63 @@ function buildSearchPatterns(pattern) {
 function capitalize(value) {
 	return value.charAt(0).toUpperCase() + value.slice(1);
 }
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function fileMatchesPattern(filePath, pattern) {
+	const trimmedPattern = pattern?.trim();
+	if (!trimmedPattern) return true;
+	const normalizedPath = filePath.toLowerCase();
+	const normalizedFileName = normalizedPath.slice(Math.max(normalizedPath.lastIndexOf("/"), normalizedPath.lastIndexOf("\\")) + 1);
+	const normalizedPattern = trimmedPattern.toLowerCase();
+	if (!normalizedPattern.includes("*") && !normalizedPattern.includes("?")) return normalizedPath.includes(normalizedPattern);
+	const regexPattern = normalizedPattern.split("").map((char) => {
+		if (char === "*") return ".*";
+		if (char === "?") return ".";
+		return escapeRegExp(char);
+	}).join("");
+	const regex = new RegExp(`^${regexPattern}$`);
+	return regex.test(normalizedPath) || regex.test(normalizedFileName);
+}
+function valueMatchesWildcardPattern(value, pattern) {
+	const normalizedValue = value.toLowerCase();
+	const normalizedPattern = pattern.trim().toLowerCase();
+	if (!normalizedPattern.includes("*") && !normalizedPattern.includes("?")) return normalizedValue === normalizedPattern;
+	const regexPattern = normalizedPattern.split("").map((char) => {
+		if (char === "*") return ".*";
+		if (char === "?") return ".";
+		return escapeRegExp(char);
+	}).join("");
+	return new RegExp(`^${regexPattern}$`).test(normalizedValue);
+}
+function directoryMatchesIgnoredPattern(dirName, ignoredDirs) {
+	for (const ignoredDir of ignoredDirs) if (valueMatchesWildcardPattern(dirName, ignoredDir)) return true;
+	return false;
+}
+function formatNumberedLines(lines, startLine) {
+	return lines.map((line, index) => `${String(startLine + index)}: ${line}`).join("\n");
+}
 /**
 * Read file contents
 */
-function readFile(filePath) {
+function readFile(filePath, options = {}) {
 	try {
 		if (!existsSync(filePath)) return {
 			content: "",
 			error: `File not found: ${filePath}`
 		};
-		return { content: readFileSync(filePath, "utf8") };
+		const content = readFileSync(filePath, "utf8");
+		if (!(options.startLine !== void 0 || options.endLine !== void 0 || options.maxLines !== void 0)) return { content };
+		const lines = content.split("\n");
+		const startLine = options.startLine ?? 1;
+		const endLine = options.endLine ?? startLine + (options.maxLines ?? lines.length) - 1;
+		const startIndex = startLine - 1;
+		const endIndex = Math.min(lines.length, endLine);
+		if (startIndex >= lines.length) return {
+			content: "",
+			error: "Invalid line range"
+		};
+		return { content: formatNumberedLines(lines.slice(startIndex, endIndex), startLine) };
 	} catch (error) {
 		return {
 			content: "",
@@ -1067,26 +1180,73 @@ function editFile(filePath, oldText, newText) {
 	}
 }
 /**
-* View specific line range from file
+* Create a directory and any missing parent directories
 */
-function viewRange(filePath, start, end) {
+function createDirectory(dirPath) {
 	try {
-		if (!existsSync(filePath)) return {
+		if (existsSync(dirPath)) {
+			if (statSync(dirPath).isDirectory()) return { content: `Directory already exists: ${dirPath}` };
+			return {
+				content: "",
+				error: `Path already exists and is not a directory: ${dirPath}`
+			};
+		}
+		mkdirSync(dirPath, { recursive: true });
+		return { content: `Directory created successfully: ${dirPath}` };
+	} catch (error) {
+		return {
 			content: "",
-			error: `File not found: ${filePath}`
+			error: `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`
 		};
-		const lines = readFileSync(filePath, "utf8").split("\n");
-		const startIdx = Math.max(0, start - 1);
-		const endIdx = Math.min(lines.length, end);
-		if (startIdx >= lines.length || startIdx > endIdx) return {
+	}
+}
+/**
+* Rename or move an existing file or directory
+*/
+function renamePath(fromPath, toPath) {
+	try {
+		if (!existsSync(fromPath)) return {
 			content: "",
-			error: "Invalid line range"
+			error: `Source path not found: ${fromPath}`
+		};
+		if (existsSync(toPath)) return {
+			content: "",
+			error: `Destination path already exists: ${toPath}`
 		};
-		return { content: lines.slice(startIdx, endIdx).join("\n") };
+		renameSync(fromPath, toPath);
+		return { content: `Path renamed successfully: ${fromPath} -> ${toPath}` };
 	} catch (error) {
 		return {
 			content: "",
-			error: `Failed to view range: ${error instanceof Error ? error.message : String(error)}`
+			error: `Failed to rename path: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Delete a file or directory
+*/
+function deletePath(path, recursive) {
+	try {
+		if (!existsSync(path)) return {
+			content: "",
+			error: `Path not found: ${path}`
+		};
+		if (statSync(path).isDirectory()) {
+			if (readdirSync(path).length > 0 && !recursive) return {
+				content: "",
+				error: `Directory is not empty; set recursive to true to delete: ${path}`
+			};
+			if (recursive) rmSync(path, {
+				recursive: true,
+				force: false
+			});
+			else rmdirSync(path);
+		} else rmSync(path, { force: false });
+		return { content: `Path deleted successfully: ${path}` };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to delete path: ${error instanceof Error ? error.message : String(error)}`
 		};
 	}
 }
@@ -1110,6 +1270,40 @@ function listDir(dirPath) {
 	}
 }
 /**
+* Recursively find files by path
+*/
+function findFiles(dirPath, options = {}) {
+	try {
+		if (!existsSync(dirPath)) return {
+			content: "",
+			error: `Directory not found: ${dirPath}`
+		};
+		if (!statSync(dirPath).isDirectory()) return {
+			content: "",
+			error: `Path is not a directory: ${dirPath}`
+		};
+		const results = [];
+		const includeHidden = options.includeHidden ?? false;
+		const ignoredDirs = new Set(options.ignoredDirs ?? DEFAULT_FIND_FILES_IGNORED_DIRS);
+		function searchDirectory(currentPath) {
+			const entries = readdirSync(currentPath, { withFileTypes: true });
+			for (const entry of entries) {
+				const fullPath = join(currentPath, entry.name);
+				if (entry.isDirectory()) {
+					if (entry.name !== ".git" && !directoryMatchesIgnoredPattern(entry.name, ignoredDirs) && (includeHidden || !entry.name.startsWith("."))) searchDirectory(fullPath);
+				} else if (entry.isFile() && (includeHidden || !entry.name.startsWith(".")) && fileMatchesPattern(fullPath, options.pattern)) results.push(fullPath);
+			}
+		}
+		searchDirectory(dirPath);
+		return { content: results.join("\n") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to find files: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
 * Search for pattern in files using ripgrep if available, fallback to Node.js
 */
 async function grepSearch(pattern, dirPath) {
@@ -1333,10 +1527,13 @@ var REQUIRED_STRING_ARGS = {
 		"oldText",
 		"newText"
 	],
+	[CREATE_DIRECTORY]: ["path"],
+	[RENAME_PATH]: ["from", "to"],
+	[DELETE_PATH]: ["path"],
 	[RUN_SHELL]: ["command"],
 	[LIST_DIR]: ["path"],
+	[FIND_FILES]: ["path"],
 	[GREP_SEARCH]: ["pattern", "path"],
-	[VIEW_RANGE]: ["path"],
 	[WEB_SEARCH]: ["query"],
 	[WEB_FETCH]: ["url"]
 };
@@ -1351,14 +1548,44 @@ function validateArgs(name, args) {
 		content: "",
 		error: `Missing required argument: ${key} (received keys: ${received})`
 	};
-	if (name === "view_range") {
-		if (!Number.isInteger(args.start) || !Number.isInteger(args.end)) return {
+	if (name === "read_file") {
+		for (const key of [
+			"startLine",
+			"endLine",
+			"maxLines"
+		]) if (args[key] !== void 0 && !Number.isInteger(args[key])) return {
+			content: "",
+			error: `Invalid optional numeric argument: ${key} (received keys: ${received})`
+		};
+		if (typeof args.startLine === "number" && args.startLine < 1 || typeof args.endLine === "number" && args.endLine < 1 || typeof args.maxLines === "number" && args.maxLines < 1) return {
+			content: "",
+			error: "Invalid read range: startLine, endLine, and maxLines must be >= 1"
+		};
+		if (args.endLine !== void 0 && args.maxLines !== void 0) return {
 			content: "",
-			error: `Missing required numeric arguments: start, end (received keys: ${received})`
+			error: "Invalid read range: endLine cannot be combined with maxLines"
 		};
-		if (args.start < 1 || args.end < args.start) return {
+		if (typeof args.startLine === "number" && typeof args.endLine === "number" && args.endLine < args.startLine) return {
+			content: "",
+			error: "Invalid read range: endLine must be >= startLine"
+		};
+	}
+	if (name === "delete_path" && typeof args.recursive !== "boolean") return {
+		content: "",
+		error: `Missing required boolean argument: recursive (received keys: ${received})`
+	};
+	if (name === "find_files" && args.pattern !== void 0 && typeof args.pattern !== "string") return {
+		content: "",
+		error: `Invalid optional argument: pattern must be a string (received keys: ${received})`
+	};
+	if (name === "find_files" && args.includeHidden !== void 0 && typeof args.includeHidden !== "boolean") return {
+		content: "",
+		error: `Invalid optional argument: includeHidden must be a boolean (received keys: ${received})`
+	};
+	if (name === "find_files" && args.ignoredDirs !== void 0) {
+		if (!Array.isArray(args.ignoredDirs) || !args.ignoredDirs.every((value) => typeof value === "string")) return {
 			content: "",
-			error: "Invalid line range: start must be >= 1 and end must be >= start"
+			error: `Invalid optional argument: ignoredDirs must be an array of strings (received keys: ${received})`
 		};
 	}
 	if (name === "web_fetch") try {
@@ -1435,13 +1662,24 @@ async function executeTool(name, args, options) {
 	if (invalid) return invalid;
 	const stringArgs = args;
 	switch (name) {
-		case READ_FILE: return readFile(stringArgs.path);
+		case READ_FILE: return readFile(stringArgs.path, {
+			endLine: args.endLine,
+			maxLines: args.maxLines,
+			startLine: args.startLine
+		});
 		case WRITE_FILE: return writeFile(stringArgs.path, stringArgs.content);
 		case EDIT_FILE: return editFile(stringArgs.path, stringArgs.oldText, stringArgs.newText);
+		case CREATE_DIRECTORY: return createDirectory(stringArgs.path);
+		case RENAME_PATH: return renamePath(stringArgs.from, stringArgs.to);
+		case DELETE_PATH: return deletePath(stringArgs.path, args.recursive);
 		case RUN_SHELL: return runShell(stringArgs.command);
 		case LIST_DIR: return listDir(stringArgs.path);
+		case FIND_FILES: return findFiles(stringArgs.path, {
+			ignoredDirs: args.ignoredDirs,
+			includeHidden: args.includeHidden,
+			pattern: stringArgs.pattern
+		});
 		case GREP_SEARCH: return await grepSearch(stringArgs.pattern, stringArgs.path);
-		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
@@ -1582,7 +1820,7 @@ async function main(args = process.argv.slice(2)) {
 	else await launchTui();
 }
 async function launchTui(sessionId) {
-	const { renderApp } = await import("./assets/tui-iewVFcZW.js");
+	const { renderApp } = await import("./assets/tui-DEmaVgHT.js");
 	reset();
 	renderApp(sessionId);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",