code-ollama 0.23.1 → 0.23.2

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

@@ -50,7 +50,7 @@ var LIST$1 = [
 //#endregion
 //#region package.json
 var name = "code-ollama";
-var version = "0.23.1";
+var version = "0.23.2";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -1582,7 +1582,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.23.2",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",