code-ollama 0.2.1 → 0.3.1

package/README.md

@@ -1,4 +1,7 @@
-# code-ollama
+> [!NOTE]
+> TUI is under active development. APIs may change.
+
+# Code Ollama
 
 [![NPM](https://nodei.co/npm/code-ollama.svg)](https://www.npmjs.com/package/code-ollama)
 

package/dist/assets/tui-CVsodXv3.js

@@ -0,0 +1,616 @@
+import { _ as REJECT, a as listModels, c as saveConfig, d as ROLE, f as PLAN_GENERATION_INSTRUCTION, g as APPROVE, h as NAME, i as executeTool, l as createSystemMessage, m as LABEL, n as READ_ONLY_TOOLS, o as streamChat, p as VERSION, r as TOOLS, s as loadConfig, t as DANGEROUS_TOOLS, u as HEADER_PREFIX, v as NAMES } from "../cli.js";
+import { homedir } from "node:os";
+import { Box, Text, render, useInput } from "ink";
+import { useCallback, useEffect, useState } from "react";
+import { Select, Spinner, TextInput } from "@inkjs/ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/Messages.tsx
+function getMessageColor(role) {
+	switch (role) {
+		case ROLE.USER: return "black";
+		case ROLE.ASSISTANT: return "blue";
+		case ROLE.SYSTEM: return "gray";
+		default: return;
+	}
+}
+function Messages({ messages, isLoading }) {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [messages.map((message, index) => /* @__PURE__ */ jsx(Box, {
+			marginBottom: 1,
+			children: /* @__PURE__ */ jsxs(Text, {
+				color: getMessageColor(message.role),
+				dimColor: message.role === ROLE.SYSTEM,
+				children: [message.role === ROLE.USER ? "> " : "", message.content]
+			})
+		}, index)), isLoading && messages[messages.length - 1]?.content === "" && /* @__PURE__ */ jsx(Box, {
+			marginTop: -1,
+			marginBottom: 1,
+			children: /* @__PURE__ */ jsx(Spinner, { label: "Thinking..." })
+		})]
+	});
+}
+//#endregion
+//#region src/components/SelectPrompt.tsx
+function SelectPrompt({ children, onEscape, ...selectProps }) {
+	useInput((_, key) => {
+		if (key.escape) onEscape?.();
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [children, /* @__PURE__ */ jsx(Select, { ...selectProps })]
+	});
+}
+//#endregion
+//#region src/components/PlanApproval.tsx
+var options$1 = [
+	{
+		label: "Auto - Execute tools automatically",
+		value: NAME.AUTO
+	},
+	{
+		label: "Safe - Approve each tool",
+		value: NAME.SAFE
+	},
+	{
+		label: "Cancel - Continue planning",
+		value: NAME.PLAN
+	}
+];
+function PlanApproval({ planContent, onModeChange }) {
+	return /* @__PURE__ */ jsx(SelectPrompt, {
+		options: options$1,
+		onChange: useCallback((value) => {
+			onModeChange(value);
+		}, [onModeChange]),
+		onEscape: useCallback(() => {
+			onModeChange(NAME.PLAN);
+		}, [onModeChange]),
+		children: /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			marginTop: 1,
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					color: "magenta",
+					children: "Plan Generated - Choose execution mode:"
+				}),
+				/* @__PURE__ */ jsx(Box, {
+					marginY: 1,
+					children: /* @__PURE__ */ jsx(Text, { children: planContent })
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "Select execution mode (↑↓ + Enter to confirm, Esc to cancel)"
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region src/components/ToolApproval.tsx
+var options = [{
+	label: "Approve tool call",
+	value: APPROVE
+}, {
+	label: "Reject tool call",
+	value: REJECT
+}];
+function ToolApproval({ toolCall, onDecision }) {
+	const handleChange = useCallback((value) => {
+		onDecision(value);
+	}, [onDecision]);
+	const handleEscape = useCallback(() => {
+		onDecision(REJECT);
+	}, [onDecision]);
+	const args = JSON.stringify(toolCall.function.arguments, null, 2);
+	return /* @__PURE__ */ jsxs(SelectPrompt, {
+		options,
+		onChange: handleChange,
+		onEscape: handleEscape,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "yellow",
+				children: "⚠️ Tool requires approval:"
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				marginX: 3,
+				marginBottom: 1,
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsxs(Text, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						italic: true,
+						children: "Tool:"
+					}),
+					" ",
+					toolCall.function.name
+				] }), /* @__PURE__ */ jsxs(Text, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						italic: true,
+						children: "Arguments:"
+					}),
+					" ",
+					args
+				] })]
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "Select approval action (↑↓ + Enter to confirm, Esc to reject)"
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Chat/constants.ts
+var ACTION_NOT_PERFORMED = "The requested action was NOT performed";
+var PLAN_CHECKLIST_REMINDER = "Then display the execution plan as an unchecked Markdown checklist only";
+var PLAN_EXECUTION_REMINDER = "Do not claim success and do not call write_file or run_shell until the user approves execution";
+//#endregion
+//#region src/components/Chat/Input.tsx
+function Input({ isDisabled = false, onSubmit }) {
+	const [resetKey, setResetKey] = useState(0);
+	const handleSubmit = useCallback((input) => {
+		const trimmed = input.trim();
+		if (!trimmed) return;
+		onSubmit(trimmed);
+		setResetKey((key) => key + 1);
+	}, [onSubmit]);
+	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: "> " }), /* @__PURE__ */ jsx(TextInput, {
+		isDisabled,
+		suggestions: NAMES,
+		onSubmit: handleSubmit
+	}, resetKey)] });
+}
+//#endregion
+//#region src/components/Chat/plan.ts
+function hasExecutablePlan(content) {
+	return content.split("\n").some((line) => {
+		const trimmedLine = line.trim();
+		return /^- \[ \] (write_file|edit_file|run_shell)\(/.test(trimmedLine);
+	});
+}
+//#endregion
+//#region src/components/Chat/Chat.tsx
+function Chat({ model, onCommand, mode, onModeChange }) {
+	const [messages, setMessages] = useState([createSystemMessage()]);
+	const [isLoading, setIsLoading] = useState(false);
+	const [pendingToolCall, setPendingToolCall] = useState(null);
+	const [pendingPlan, setPendingPlan] = useState(null);
+	const buildToolResultMessage = useCallback((toolName, result) => {
+		if (result.error?.startsWith("Tool not allowed:")) return {
+			role: ROLE.SYSTEM,
+			content: [
+				`Tool ${toolName} was blocked by execution policy`,
+				ACTION_NOT_PERFORMED,
+				`Blocked because ${result.error}`,
+				"Do not claim success. Either continue with allowed read-only tools or explain that approval/execution mode must change"
+			].join("\n")
+		};
+		return {
+			role: ROLE.SYSTEM,
+			content: `Tool ${toolName} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+		};
+	}, []);
+	const buildPlanModeCorrectionMessage = useCallback((toolName) => ({
+		role: ROLE.SYSTEM,
+		content: [
+			`Plan mode policy: ${toolName} cannot be executed during planning`,
+			ACTION_NOT_PERFORMED,
+			"Continue by using only read-only tools for research if needed",
+			PLAN_CHECKLIST_REMINDER,
+			PLAN_EXECUTION_REMINDER
+		].join("\n")
+	}), []);
+	const processStream = useCallback(async (currentMessages, executionMode = mode) => {
+		const assistantMessage = {
+			role: ROLE.ASSISTANT,
+			content: ""
+		};
+		setMessages((previousMessages) => [...previousMessages, assistantMessage]);
+		try {
+			for await (const chunk of streamChat(currentMessages, model, TOOLS)) if (chunk.type === "content") {
+				assistantMessage.content += chunk.content;
+				setMessages((previousMessages) => {
+					const newMessages = [...previousMessages];
+					newMessages[newMessages.length - 1] = { ...assistantMessage };
+					return newMessages;
+				});
+			} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
+				const requiresApproval = DANGEROUS_TOOLS.has(toolCall.function.name);
+				// v8 ignore start
+				const allowedTools = executionMode === NAME.PLAN ? READ_ONLY_TOOLS : void 0;
+				// v8 ignore stop
+				if (executionMode === NAME.SAFE && requiresApproval) {
+					setPendingToolCall(toolCall);
+					setIsLoading(false);
+					return;
+				}
+				const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools });
+				const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
+				const newMessages = [
+					...currentMessages,
+					assistantMessage,
+					toolResultMessage
+				];
+				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
+				await processStream(newMessages, executionMode);
+				return;
+			}
+		} catch (error) {
+			assistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
+			setMessages((previousMessages) => {
+				const newMessages = [...previousMessages];
+				newMessages[newMessages.length - 1] = { ...assistantMessage };
+				return newMessages;
+			});
+		} finally {
+			setIsLoading(false);
+		}
+	}, [
+		buildToolResultMessage,
+		model,
+		mode
+	]);
+	const processStreamReadOnly = useCallback(async (currentMessages) => {
+		const assistantMessage = {
+			role: ROLE.ASSISTANT,
+			content: ""
+		};
+		setMessages((previousMessages) => [...previousMessages, assistantMessage]);
+		try {
+			const readOnlyTools = TOOLS.filter((tool) => READ_ONLY_TOOLS.has(tool.function.name));
+			for await (const chunk of streamChat(currentMessages, model, readOnlyTools)) if (chunk.type === "content") {
+				assistantMessage.content += chunk.content;
+				setMessages((previousMessages) => {
+					const newMessages = [...previousMessages];
+					newMessages[newMessages.length - 1] = { ...assistantMessage };
+					return newMessages;
+				});
+			} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
+				if (!READ_ONLY_TOOLS.has(toolCall.function.name)) {
+					const correctionMessage = buildPlanModeCorrectionMessage(toolCall.function.name);
+					const newMessages = [
+						...currentMessages,
+						assistantMessage,
+						correctionMessage
+					];
+					setMessages((previousMessages) => [...previousMessages, correctionMessage]);
+					await processStreamReadOnly(newMessages);
+					return;
+				}
+				const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools: READ_ONLY_TOOLS });
+				const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
+				const newMessages = [
+					...currentMessages,
+					assistantMessage,
+					toolResultMessage
+				];
+				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
+				await processStreamReadOnly(newMessages);
+				return;
+			}
+			const planInstruction = {
+				role: ROLE.SYSTEM,
+				content: PLAN_GENERATION_INSTRUCTION
+			};
+			const planMessages = [
+				...currentMessages,
+				assistantMessage,
+				planInstruction
+			];
+			const planAssistantMessage = {
+				role: ROLE.ASSISTANT,
+				content: ""
+			};
+			setMessages((previousMessages) => [...previousMessages, planAssistantMessage]);
+			for await (const chunk of streamChat(planMessages, model, [])) if (chunk.type === "content") {
+				planAssistantMessage.content += chunk.content;
+				setMessages((previousMessages) => {
+					const newMessages = [...previousMessages];
+					newMessages[newMessages.length - 1] = { ...planAssistantMessage };
+					return newMessages;
+				});
+			}
+			if (hasExecutablePlan(planAssistantMessage.content)) setPendingPlan({
+				planContent: planAssistantMessage.content,
+				messages: [...planMessages, planAssistantMessage]
+			});
+			setIsLoading(false);
+		} catch (error) {
+			assistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
+			setMessages((previousMessages) => {
+				const newMessages = [...previousMessages];
+				newMessages[newMessages.length - 1] = { ...assistantMessage };
+				return newMessages;
+			});
+		} finally {
+			setIsLoading(false);
+		}
+	}, [
+		buildPlanModeCorrectionMessage,
+		buildToolResultMessage,
+		model
+	]);
+	const handlePlanApproval = useCallback(async (choice) => {
+		// v8 ignore next
+		if (!pendingPlan) return;
+		const { messages: planMessages } = pendingPlan;
+		setPendingPlan(null);
+		if (choice === NAME.PLAN) {
+			onModeChange(NAME.PLAN);
+			const cancelMessage = {
+				role: ROLE.SYSTEM,
+				content: "Continuing in Plan mode. No tools were executed."
+			};
+			setMessages((previousMessages) => [...previousMessages, cancelMessage]);
+			return;
+		}
+		const selectedMode = choice === NAME.AUTO ? NAME.AUTO : NAME.SAFE;
+		onModeChange(selectedMode);
+		setIsLoading(true);
+		const executeInstruction = {
+			role: ROLE.SYSTEM,
+			content: choice === NAME.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."
+		};
+		await processStream([...planMessages, executeInstruction], selectedMode);
+	}, [
+		onModeChange,
+		pendingPlan,
+		processStream
+	]);
+	const handleToolApproval = useCallback(async (decision) => {
+		// v8 ignore next
+		if (!pendingToolCall) return;
+		const toolCall = pendingToolCall;
+		setPendingToolCall(null);
+		setIsLoading(true);
+		switch (decision) {
+			case APPROVE: {
+				const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
+				const toolResultMessage = {
+					role: ROLE.SYSTEM,
+					content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+				};
+				const newMessages = [...messages, toolResultMessage];
+				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
+				await processStream(newMessages);
+				break;
+			}
+			case REJECT: {
+				const rejectionMessage = {
+					role: ROLE.SYSTEM,
+					content: `User declined to execute tool ${toolCall.function.name}`
+				};
+				const newMessages = [...messages, rejectionMessage];
+				setMessages((previousMessages) => [...previousMessages, rejectionMessage]);
+				await processStream(newMessages);
+				break;
+			}
+		}
+	}, [
+		pendingToolCall,
+		messages,
+		processStream
+	]);
+	const handleSubmit = useCallback(async (value) => {
+		const userContent = value.trim();
+		if (!userContent) return;
+		if (userContent.startsWith("/")) {
+			onCommand(userContent);
+			return;
+		}
+		setIsLoading(true);
+		const userMessage = {
+			role: ROLE.USER,
+			content: userContent
+		};
+		setMessages((previousMessages) => [...previousMessages, userMessage]);
+		const updatedMessages = [...messages, userMessage];
+		if (mode === NAME.PLAN) await processStreamReadOnly(updatedMessages);
+		else await processStream(updatedMessages);
+	}, [
+		messages,
+		onCommand,
+		processStream,
+		processStreamReadOnly,
+		mode
+	]);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Messages, {
+				messages: messages.slice(1),
+				isLoading
+			}),
+			pendingPlan && /* @__PURE__ */ jsx(PlanApproval, {
+				planContent: pendingPlan.planContent,
+				onModeChange: (selectedMode) => void handlePlanApproval(selectedMode)
+			}),
+			!pendingPlan && pendingToolCall && /* @__PURE__ */ jsx(ToolApproval, {
+				toolCall: pendingToolCall,
+				onDecision: handleToolApproval
+			}),
+			!pendingPlan && !pendingToolCall && /* @__PURE__ */ jsx(Input, {
+				isDisabled: isLoading,
+				onSubmit: handleSubmit
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Footer.tsx
+function getModeColor(mode) {
+	switch (mode) {
+		case NAME.PLAN: return "blue";
+		case NAME.AUTO: return "red";
+		case NAME.SAFE:
+		default: return "green";
+	}
+}
+function Footer({ mode, onToggleMode }) {
+	useInput((_, key) => {
+		if (key.tab && key.shift) onToggleMode();
+	});
+	const modeLabel = LABEL[mode];
+	return /* @__PURE__ */ jsx(Box, {
+		justifyContent: "space-between",
+		marginTop: 1,
+		children: /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				"Mode: ",
+				/* @__PURE__ */ jsx(Text, {
+					color: getModeColor(mode),
+					children: modeLabel
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: " (Shift+Tab to toggle)"
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region src/components/Header.tsx
+function abbreviatePath(dir) {
+	const home = homedir();
+	return dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+}
+function Header({ model }) {
+	const directory = abbreviatePath(process.cwd());
+	return /* @__PURE__ */ jsxs(Box, {
+		borderStyle: "round",
+		flexDirection: "column",
+		paddingX: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsxs(Text, {
+				bold: true,
+				children: [HEADER_PREFIX, "Code Ollama"]
+			}), /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					" (v",
+					VERSION,
+					")"
+				]
+			})] }),
+			/* @__PURE__ */ jsx(Text, { children: " " }),
+			/* @__PURE__ */ jsxs(Box, { children: [
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "model:".padEnd(11)
+				}),
+				/* @__PURE__ */ jsxs(Text, { children: [model, "   "] }),
+				/* @__PURE__ */ jsx(Text, {
+					color: "cyan",
+					children: "/model"
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: " to switch"
+				})
+			] }),
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "directory:".padEnd(11)
+			}), /* @__PURE__ */ jsx(Text, { children: directory })] })
+		]
+	});
+}
+//#endregion
+//#region src/components/ModelPicker.tsx
+function ModelPicker({ currentModel, onSelect, onClose }) {
+	const [options, setOptions] = useState([]);
+	const [error, setError] = useState(null);
+	useInput((_, key) => {
+		if (options.length && key.return) setTimeout(onClose);
+	});
+	useEffect(() => {
+		async function load() {
+			try {
+				const models = await listModels();
+				if (models.includes(currentModel)) {
+					models.splice(models.indexOf(currentModel), 1);
+					models.unshift(currentModel);
+				}
+				setOptions(models.map((model) => ({
+					label: model,
+					value: model
+				})));
+			} catch (error) {
+				setError(error instanceof Error ? error.message : String(error));
+			}
+		}
+		load();
+	}, [currentModel]);
+	if (error) return /* @__PURE__ */ jsxs(Text, {
+		color: "red",
+		children: ["Error loading models: ", error]
+	});
+	if (!options.length) return /* @__PURE__ */ jsx(Spinner, { label: "Loading models..." });
+	return /* @__PURE__ */ jsx(SelectPrompt, {
+		options,
+		defaultValue: currentModel,
+		onChange: onSelect,
+		onEscape: onClose,
+		children: /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "Select a model (↑↓ + Enter to confirm, Esc to cancel)"
+		})
+	});
+}
+//#endregion
+//#region src/components/App.tsx
+function App() {
+	const [model, setModel] = useState(() => loadConfig().model);
+	const [picking, setPicking] = useState(false);
+	const [mode, setMode] = useState(NAME.SAFE);
+	const handleCommand = useCallback((command) => {
+		if (command === "/model") setPicking(true);
+	}, []);
+	const handleSelect = useCallback((selected) => {
+		setModel(selected);
+		saveConfig({ model: selected });
+		setPicking(false);
+	}, []);
+	const handleClose = useCallback(() => {
+		setPicking(false);
+	}, []);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Header, { model }),
+			picking ? /* @__PURE__ */ jsx(ModelPicker, {
+				currentModel: model,
+				onSelect: handleSelect,
+				onClose: handleClose
+			}) : /* @__PURE__ */ jsx(Chat, {
+				model,
+				onCommand: handleCommand,
+				mode,
+				onModeChange: setMode
+			}),
+			/* @__PURE__ */ jsx(Footer, {
+				mode,
+				onToggleMode: () => {
+					setMode((mode) => {
+						switch (mode) {
+							case NAME.SAFE: return NAME.AUTO;
+							case NAME.AUTO: return NAME.PLAN;
+							case NAME.PLAN:
+							default: return NAME.SAFE;
+						}
+					});
+				}
+			})
+		]
+	});
+}
+//#endregion
+//#region src/tui.tsx
+function renderApp() {
+	render(/* @__PURE__ */ jsx(App, {}));
+}
+//#endregion
+export { renderApp };

package/dist/cli.js

@@ -11,8 +11,24 @@ var NAMES = [{
 	description: "switch the model"
 }].map(({ name }) => name);
 //#endregion
+//#region src/constants/decision.ts
+var APPROVE = "approve";
+var REJECT = "reject";
+//#endregion
+//#region src/constants/mode.ts
+var NAME$1 = {
+	SAFE: "safe",
+	AUTO: "auto",
+	PLAN: "plan"
+};
+var LABEL = {
+	safe: "Safe",
+	auto: "Auto",
+	plan: "Plan"
+};
+//#endregion
 //#region src/constants/package.ts
-var VERSION = "0.2.1";
+var VERSION = "0.3.1";
 //#endregion
 //#region src/constants/prompt.ts
 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, and searching code
@@ -39,6 +55,19 @@ Always use tools when you need to:
 - Make file changes
 - Explore project structure
 - Search the codebase`;
+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
+Do not execute any tools
+Do not claim any action was performed
+Display the plan as an unchecked Markdown checklist using only these forms:
+
+- [ ] write_file("path/to/file", "content") - Brief description
+- [ ] edit_file("path/to/file", "oldText", "newText") - Brief description
+- [ ] run_shell("command") - Brief description
+
+Only include write_file, edit_file, and run_shell tools in the checklist
+If no execution is needed, answer normally`;
 //#endregion
 //#region src/constants/role.ts
 var ROLE = {
@@ -241,7 +270,13 @@ var TOOLS = [
 		"end"
 	])
 ];
-var TOOLS_REQUIRING_APPROVAL = new Set([
+var READ_ONLY_TOOLS = new Set([
+	NAME.READ_FILE,
+	NAME.LIST_DIR,
+	NAME.GREP_SEARCH,
+	NAME.VIEW_RANGE
+]);
+var DANGEROUS_TOOLS = new Set([
 	NAME.WRITE_FILE,
 	NAME.EDIT_FILE,
 	NAME.RUN_SHELL
@@ -249,7 +284,11 @@ var TOOLS_REQUIRING_APPROVAL = new Set([
 /**
 * Execute a tool by name with arguments
 */
-async function executeTool(name, args) {
+async function executeTool(name, args, options) {
+	if (options?.allowedTools && !options.allowedTools.has(name)) return {
+		content: "",
+		error: `Tool not allowed: ${name}`
+	};
 	switch (name) {
 		case NAME.READ_FILE: return readFile(args.path);
 		case NAME.WRITE_FILE: return writeFile(args.path, args.content);
@@ -480,7 +519,7 @@ async function processRunStream(messages, model) {
 }
 async function main(args = process.argv.slice(2)) {
 	if (!args.length) {
-		const { renderApp } = await import("./assets/tui-eBtT-5hi.js");
+		const { renderApp } = await import("./assets/tui-CVsodXv3.js");
 		clear();
 		renderApp();
 		return;
@@ -503,4 +542,4 @@ function isEntrypoint(argv1 = process.argv[1]) {
 if (isEntrypoint()) main();
 /* v8 ignore stop */
 //#endregion
-export { streamChat as a, createSystemMessage as c, VERSION as d, NAMES as f, listModels as i, HEADER_PREFIX as l, main, TOOLS_REQUIRING_APPROVAL as n, loadConfig as o, executeTool as r, saveConfig as s, TOOLS as t, ROLE as u };
+export { REJECT as _, listModels as a, saveConfig as c, ROLE as d, PLAN_GENERATION_INSTRUCTION as f, APPROVE as g, NAME$1 as h, executeTool as i, createSystemMessage as l, LABEL as m, main, READ_ONLY_TOOLS as n, streamChat as o, VERSION as p, TOOLS as r, loadConfig as s, DANGEROUS_TOOLS as t, HEADER_PREFIX as u, NAMES as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",
@@ -43,7 +43,7 @@
     "cac": "7.0.0",
     "ink": "7.0.2",
     "ollama": "0.6.3",
-    "react": "19.2.5"
+    "react": "19.2.6"
   },
   "devDependencies": {
     "@commitlint/cli": "20.5.3",
@@ -59,7 +59,7 @@
     "globals": "17.6.0",
     "husky": "9.1.7",
     "ink-testing-library": "4.0.0",
-    "lint-staged": "16.4.0",
+    "lint-staged": "17.0.2",
     "prettier": "3.8.3",
     "publint": "0.3.19",
     "tsx": "4.21.0",

package/dist/assets/tui-eBtT-5hi.js

@@ -1,370 +0,0 @@
-import { a as streamChat, c as createSystemMessage, d as VERSION, f as NAMES, i as listModels, l as HEADER_PREFIX, n as TOOLS_REQUIRING_APPROVAL, o as loadConfig, r as executeTool, s as saveConfig, t as TOOLS, u as ROLE } from "../cli.js";
-import { homedir } from "node:os";
-import { Box, Text, render, useInput } from "ink";
-import { useCallback, useEffect, useState } from "react";
-import { Select, Spinner, TextInput } from "@inkjs/ui";
-import { jsx, jsxs } from "react/jsx-runtime";
-//#region src/components/ChatInput.tsx
-function ChatInput({ isDisabled = false, onSubmit }) {
-	const [resetKey, setResetKey] = useState(0);
-	const handleSubmit = useCallback((input) => {
-		const trimmed = input.trim();
-		if (!trimmed) return;
-		onSubmit(trimmed);
-		setResetKey((key) => key + 1);
-	}, [onSubmit]);
-	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: "> " }), /* @__PURE__ */ jsx(TextInput, {
-		isDisabled,
-		suggestions: NAMES,
-		onSubmit: handleSubmit
-	}, resetKey)] });
-}
-//#endregion
-//#region src/components/Messages.tsx
-function getMessageColor(role) {
-	switch (role) {
-		case ROLE.USER: return "black";
-		case ROLE.ASSISTANT: return "blue";
-		case ROLE.SYSTEM: return "gray";
-		default: return;
-	}
-}
-function Messages({ messages, isLoading }) {
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "column",
-		children: [messages.map((message, index) => /* @__PURE__ */ jsx(Box, {
-			marginBottom: 1,
-			children: /* @__PURE__ */ jsxs(Text, {
-				color: getMessageColor(message.role),
-				dimColor: message.role === ROLE.SYSTEM,
-				children: [message.role === ROLE.USER ? "> " : "", message.content]
-			})
-		}, index)), isLoading && messages[messages.length - 1]?.content === "" && /* @__PURE__ */ jsx(Box, {
-			marginTop: -1,
-			marginBottom: 1,
-			children: /* @__PURE__ */ jsx(Spinner, { label: "Thinking..." })
-		})]
-	});
-}
-//#endregion
-//#region src/components/ToolApproval.tsx
-function ToolApproval({ toolCall, onApprove, onReject }) {
-	const [selected, setSelected] = useState("yes");
-	useInput((_, key) => {
-		if (key.return) if (selected === "yes") onApprove();
-		else onReject();
-		else if (key.leftArrow || key.rightArrow) setSelected((prev) => prev === "yes" ? "no" : "yes");
-		// v8 ignore stop
-	});
-	const args = JSON.stringify(toolCall.function.arguments, null, 2);
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "column",
-		marginY: 1,
-		children: [
-			/* @__PURE__ */ jsx(Text, {
-				color: "yellow",
-				bold: true,
-				children: "⚠️ Tool requires approval:"
-			}),
-			/* @__PURE__ */ jsxs(Box, {
-				marginX: 2,
-				flexDirection: "column",
-				children: [/* @__PURE__ */ jsxs(Text, { children: [
-					/* @__PURE__ */ jsx(Text, {
-						bold: true,
-						children: "Tool:"
-					}),
-					" ",
-					toolCall.function.name
-				] }), /* @__PURE__ */ jsxs(Text, { children: [
-					/* @__PURE__ */ jsx(Text, {
-						bold: true,
-						children: "Arguments:"
-					}),
-					" ",
-					args
-				] })]
-			}),
-			/* @__PURE__ */ jsxs(Box, {
-				marginTop: 1,
-				gap: 2,
-				children: [/* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsxs(Text, {
-					color: selected === "yes" ? "green" : void 0,
-					children: [selected === "yes" ? "▶ " : "  ", "✓ Yes (Enter)"]
-				}) }), /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsxs(Text, {
-					color: selected === "no" ? "red" : void 0,
-					children: [selected === "no" ? "▶ " : "  ", "✗ No (Esc)"]
-				}) })]
-			})
-		]
-	});
-}
-//#endregion
-//#region src/components/Chat.tsx
-function Chat({ model, onCommand, autoExecute }) {
-	const [messages, setMessages] = useState([createSystemMessage()]);
-	const [isLoading, setIsLoading] = useState(false);
-	const [pendingToolCall, setPendingToolCall] = useState(null);
-	const processStream = useCallback(async (currentMessages) => {
-		const assistantMessage = {
-			role: ROLE.ASSISTANT,
-			content: ""
-		};
-		setMessages((previousMessages) => [...previousMessages, assistantMessage]);
-		try {
-			for await (const chunk of streamChat(currentMessages, model, TOOLS)) if (chunk.type === "content") {
-				assistantMessage.content += chunk.content;
-				setMessages((previousMessages) => {
-					const newMessages = [...previousMessages];
-					newMessages[newMessages.length - 1] = { ...assistantMessage };
-					return newMessages;
-				});
-			} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
-				const requiresApproval = TOOLS_REQUIRING_APPROVAL.has(toolCall.function.name);
-				if (!autoExecute && requiresApproval) {
-					setPendingToolCall(toolCall);
-					setIsLoading(false);
-					return;
-				}
-				const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
-				const toolResultMessage = {
-					role: ROLE.SYSTEM,
-					content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
-				};
-				const newMessages = [
-					...currentMessages,
-					assistantMessage,
-					toolResultMessage
-				];
-				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
-				await processStream(newMessages);
-				return;
-			}
-		} catch (error) {
-			assistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
-			setMessages((previousMessages) => {
-				const newMessages = [...previousMessages];
-				newMessages[newMessages.length - 1] = { ...assistantMessage };
-				return newMessages;
-			});
-		} finally {
-			setIsLoading(false);
-		}
-	}, [model, autoExecute]);
-	const handleToolApproval = useCallback(async (approved) => {
-		// v8 ignore next
-		if (!pendingToolCall) return;
-		const toolCall = pendingToolCall;
-		setPendingToolCall(null);
-		setIsLoading(true);
-		if (approved) {
-			const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
-			const toolResultMessage = {
-				role: ROLE.SYSTEM,
-				content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
-			};
-			const newMessages = [...messages, toolResultMessage];
-			setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
-			await processStream(newMessages);
-		} else {
-			const rejectionMessage = {
-				role: ROLE.SYSTEM,
-				content: `User declined to execute tool ${toolCall.function.name}`
-			};
-			const newMessages = [...messages, rejectionMessage];
-			setMessages((previousMessages) => [...previousMessages, rejectionMessage]);
-			await processStream(newMessages);
-		}
-	}, [
-		pendingToolCall,
-		messages,
-		processStream
-	]);
-	const handleSubmit = useCallback(async (value) => {
-		const userContent = value.trim();
-		if (!userContent) return;
-		if (userContent.startsWith("/")) {
-			onCommand(userContent);
-			return;
-		}
-		setIsLoading(true);
-		const userMessage = {
-			role: ROLE.USER,
-			content: userContent
-		};
-		setMessages((previousMessages) => [...previousMessages, userMessage]);
-		await processStream([...messages, userMessage]);
-	}, [
-		messages,
-		onCommand,
-		processStream
-	]);
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "column",
-		children: [
-			/* @__PURE__ */ jsx(Messages, {
-				messages: messages.slice(1),
-				isLoading
-			}),
-			pendingToolCall && /* @__PURE__ */ jsx(ToolApproval, {
-				toolCall: pendingToolCall,
-				onApprove: () => void handleToolApproval(true),
-				onReject: () => void handleToolApproval(false)
-			}),
-			!pendingToolCall && /* @__PURE__ */ jsx(ChatInput, {
-				isDisabled: isLoading,
-				onSubmit: handleSubmit
-			})
-		]
-	});
-}
-//#endregion
-//#region src/components/Footer.tsx
-function Footer({ autoExecute, onToggleMode }) {
-	useInput((_, key) => {
-		if (key.tab && key.shift) onToggleMode();
-	});
-	return /* @__PURE__ */ jsx(Box, {
-		justifyContent: "space-between",
-		marginTop: 1,
-		children: /* @__PURE__ */ jsxs(Text, {
-			dimColor: true,
-			children: [
-				"Mode: ",
-				autoExecute ? "Auto" : "Safe",
-				" (Shift+Tab to toggle)"
-			]
-		})
-	});
-}
-//#endregion
-//#region src/components/Header.tsx
-function abbreviatePath(dir) {
-	const home = homedir();
-	return dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
-}
-function Header({ model }) {
-	const directory = abbreviatePath(process.cwd());
-	return /* @__PURE__ */ jsxs(Box, {
-		borderStyle: "round",
-		flexDirection: "column",
-		paddingX: 1,
-		children: [
-			/* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsxs(Text, {
-				bold: true,
-				children: [HEADER_PREFIX, "Code Ollama"]
-			}), /* @__PURE__ */ jsxs(Text, {
-				dimColor: true,
-				children: [
-					" (v",
-					VERSION,
-					")"
-				]
-			})] }),
-			/* @__PURE__ */ jsx(Text, { children: " " }),
-			/* @__PURE__ */ jsxs(Box, { children: [
-				/* @__PURE__ */ jsx(Text, {
-					dimColor: true,
-					children: "model:".padEnd(11)
-				}),
-				/* @__PURE__ */ jsxs(Text, { children: [model, "   "] }),
-				/* @__PURE__ */ jsx(Text, {
-					color: "cyan",
-					children: "/model"
-				}),
-				/* @__PURE__ */ jsx(Text, {
-					dimColor: true,
-					children: " to switch"
-				})
-			] }),
-			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
-				dimColor: true,
-				children: "directory:".padEnd(11)
-			}), /* @__PURE__ */ jsx(Text, { children: directory })] })
-		]
-	});
-}
-//#endregion
-//#region src/components/ModelPicker.tsx
-function ModelPicker({ currentModel, onSelect, onCancel }) {
-	const [options, setOptions] = useState([]);
-	const [error, setError] = useState(null);
-	useEffect(() => {
-		async function load() {
-			try {
-				setOptions((await listModels()).map((name) => ({
-					label: name,
-					value: name
-				})));
-			} catch (err) {
-				setError(err instanceof Error ? err.message : String(err));
-			}
-		}
-		load();
-	}, []);
-	useInput((_, key) => {
-		if (key.escape) onCancel();
-	});
-	if (error) return /* @__PURE__ */ jsxs(Text, {
-		color: "red",
-		children: ["Error loading models: ", error]
-	});
-	if (!options.length) return /* @__PURE__ */ jsx(Spinner, { label: "Loading models..." });
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "column",
-		children: [/* @__PURE__ */ jsx(Text, {
-			dimColor: true,
-			children: "Select a model (↑↓ + Enter to confirm, Esc to cancel)"
-		}), /* @__PURE__ */ jsx(Select, {
-			options,
-			defaultValue: currentModel,
-			onChange: onSelect
-		})]
-	});
-}
-//#endregion
-//#region src/components/App.tsx
-function App() {
-	const [model, setModel] = useState(() => loadConfig().model);
-	const [picking, setPicking] = useState(false);
-	const [autoExecute, setAutoExecute] = useState(false);
-	const handleCommand = useCallback((command) => {
-		if (command === "/model") setPicking(true);
-	}, []);
-	const handleSelect = useCallback((selected) => {
-		setModel(selected);
-		saveConfig({ model: selected });
-		setPicking(false);
-	}, []);
-	const handleCancel = useCallback(() => {
-		setPicking(false);
-	}, []);
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "column",
-		children: [
-			/* @__PURE__ */ jsx(Header, { model }),
-			picking ? /* @__PURE__ */ jsx(ModelPicker, {
-				currentModel: model,
-				onSelect: handleSelect,
-				onCancel: handleCancel
-			}) : /* @__PURE__ */ jsx(Chat, {
-				model,
-				onCommand: handleCommand,
-				autoExecute
-			}),
-			/* @__PURE__ */ jsx(Footer, {
-				autoExecute,
-				onToggleMode: () => {
-					setAutoExecute((isAutoExecute) => !isAutoExecute);
-				}
-			})
-		]
-	});
-}
-//#endregion
-//#region src/tui.tsx
-function renderApp() {
-	render(/* @__PURE__ */ jsx(App, {}));
-}
-//#endregion
-export { renderApp };