code-ollama 0.0.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Menglin "Mark" Xu <mark@remarkablemark.org>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# code-ollama
+
+[![NPM](https://nodei.co/npm/code-ollama.svg)](https://www.npmjs.com/package/code-ollama)
+
+[![NPM version](https://img.shields.io/npm/v/code-ollama.svg)](https://www.npmjs.com/package/code-ollama)
+[![build](https://github.com/ai-action/code-ollama/actions/workflows/build.yml/badge.svg)](https://github.com/ai-action/code-ollama/actions/workflows/build.yml)
+[![codecov](https://codecov.io/gh/ai-action/code-ollama/graph/badge.svg?token=gRGUasRn2k)](https://codecov.io/gh/ai-action/code-ollama)
+
+🦙 [Ollama](https://ollama.com/) coding agent that runs in your terminal.
+
+## Quick Start
+
+```sh
+npx code-ollama
+```
+
+## Install
+
+Install the [CLI](https://www.npmjs.com/package/code-ollama) globally:
+
+```sh
+npm install --global code-ollama
+```
+
+## Usage
+
+### TUI
+
+Open the TUI:
+
+```sh
+code-ollama
+```
+
+Or use the alias:
+
+```sh
+collama
+```
+
+### CLI
+
+Show the version:
+
+```sh
+code-ollama --version
+```
+
+Show the help:
+
+```sh
+code-ollama --help
+```
+
+Run a one-off prompt:
+
+```sh
+# code-ollama run <model> <prompt>
+code-ollama run gemma4 "review diff"
+```
+
+## License
+
+[MIT](https://github.com/ai-action/code-ollama/blob/master/LICENSE)

package/dist/assets/tui-DSR1MJGd.js

@@ -0,0 +1,438 @@
+import { a as streamChat, c as createSystemMessage, i as listModels, l as ROLE, n as TOOLS_REQUIRING_APPROVAL, o as loadConfig, r as executeTool, s as saveConfig, t as TOOLS, u as VERSION } 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/constants/commands.ts
+var COMMANDS = [{
+	name: "/model",
+	description: "switch the model"
+}];
+//#endregion
+//#region src/constants/ui.ts
+var HEADER_PREFIX = "🦙";
+//#endregion
+//#region src/components/Autocomplete.tsx
+function getMatches(input) {
+	if (!input.startsWith("/")) return [];
+	return COMMANDS.filter((command) => command.name.startsWith(input));
+}
+function Autocomplete({ isDisabled = false, onSubmit }) {
+	const [value, setValue] = useState("");
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const [inputKey, setInputKey] = useState(0);
+	const matches = getMatches(value);
+	const isCommandMode = value.startsWith("/");
+	useInput((_char, key) => {
+		// v8 ignore next
+		if (!isCommandMode) return;
+		if (key.upArrow) {
+			setSelectedIndex((i) => Math.max(0, i - 1));
+			return;
+		}
+		if (key.downArrow) {
+			setSelectedIndex((i) => Math.min(matches.length - 1, i + 1));
+			return;
+		}
+		if (key.tab && matches.length > 0) {
+			setValue((matches[selectedIndex] ?? matches[0]).name);
+			setSelectedIndex(0);
+			setInputKey((key) => key + 1);
+			return;
+		}
+	}, { isActive: !isDisabled && isCommandMode });
+	const handleSubmit = useCallback((input) => {
+		const trimmed = (isCommandMode && matches.length > 0 && matches[selectedIndex] ? matches[selectedIndex].name : input).trim();
+		if (trimmed) {
+			onSubmit(trimmed);
+			setValue("");
+			setSelectedIndex(0);
+			setInputKey((key) => key + 1);
+		}
+	}, [
+		isCommandMode,
+		matches,
+		onSubmit,
+		selectedIndex
+	]);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: "> " }), /* @__PURE__ */ jsx(TextInput, {
+			isDisabled,
+			defaultValue: value,
+			onChange: setValue,
+			onSubmit: handleSubmit
+		}, inputKey)] }), isCommandMode && matches.length > 0 && /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			marginLeft: 2,
+			children: matches.map((command, index) => {
+				const isHighlighted = index === selectedIndex;
+				return /* @__PURE__ */ jsxs(Box, {
+					gap: 3,
+					children: [/* @__PURE__ */ jsx(Text, {
+						color: isHighlighted ? "cyan" : void 0,
+						bold: isHighlighted,
+						children: command.name
+					}), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: command.description
+					})]
+				}, command.name);
+			})
+		})]
+	});
+}
+//#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 [submitKey, setSubmitKey] = useState(0);
+	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;
+		setSubmitKey((key) => key + 1);
+		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(Autocomplete, {
+				isDisabled: isLoading,
+				onSubmit: (val) => {
+					handleSubmit(val);
+				}
+			}, submitKey)
+		]
+	});
+}
+//#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 };

package/dist/cli.js

@@ -0,0 +1,448 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
+import cac from "cac";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { Ollama } from "ollama";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#endregion
+//#region src/constants/package.ts
+var VERSION = "0.1.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
+
+Follow these rules:
+1. Always use available tools rather than guessing file contents or code behavior
+2. Read files before editing them to understand context
+3. When writing files, provide complete, working code
+4. Explain your reasoning when making non-trivial changes
+5. Prefer minimal changes that achieve the goal
+6. Confirm with the user before destructive operations
+
+When tools return results, incorporate them into your response naturally`;
+var TOOL_INSTRUCTIONS = `Available tools:
+- read_file: Read file contents at a path
+- write_file: Write content to a file (requires approval)
+- edit_file: Make precise edits to a file
+- list_dir: List files in a directory
+- grep_search: Search code with regex
+- run_shell: Execute shell commands (requires approval)
+
+Always use tools when you need to:
+- Check file contents before referencing them
+- Make file changes
+- Explore project structure
+- Search the codebase`;
+//#endregion
+//#region src/constants/role.ts
+var ROLE = {
+	USER: "user",
+	ASSISTANT: "assistant",
+	SYSTEM: "system"
+};
+//#endregion
+//#region src/constants/tool.ts
+var NAME = {
+	READ_FILE: "read_file",
+	WRITE_FILE: "write_file",
+	RUN_SHELL: "run_shell",
+	LIST_DIR: "list_dir",
+	GREP_SEARCH: "grep_search",
+	VIEW_RANGE: "view_range"
+};
+//#endregion
+//#region src/utils/agents.ts
+var AGENTS_FILE = "AGENTS.md";
+function loadAgentsContent() {
+	const agentsPath = join(process.cwd(), AGENTS_FILE);
+	if (!existsSync(agentsPath)) return null;
+	try {
+		return readFileSync(agentsPath, "utf8");
+	} catch {
+		return null;
+	}
+}
+function buildSystemPrompt() {
+	const parts = [BASE_SYSTEM_PROMPT];
+	const agentsContent = loadAgentsContent();
+	if (agentsContent) parts.push("\n\nProject context from AGENTS.md:\n", agentsContent);
+	parts.push("\n\n", TOOL_INSTRUCTIONS);
+	return parts.join("");
+}
+function createSystemMessage() {
+	return {
+		role: ROLE.SYSTEM,
+		content: buildSystemPrompt()
+	};
+}
+//#endregion
+//#region src/utils/config.ts
+var CONFIG_DIR = join(homedir(), ".code-ollama");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var DEFAULTS = {
+	host: "http://localhost:11434",
+	model: "gemma4"
+};
+function readFile$1() {
+	if (!existsSync(CONFIG_PATH)) return {};
+	try {
+		return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+	} catch {
+		return {};
+	}
+}
+function loadConfig() {
+	const file = readFile$1();
+	return {
+		host: process.env.OLLAMA_HOST ?? file.host ?? DEFAULTS.host,
+		model: process.env.OLLAMA_MODEL ?? file.model ?? DEFAULTS.model
+	};
+}
+function saveConfig(patch) {
+	const updated = {
+		...readFile$1(),
+		...patch
+	};
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(CONFIG_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
+}
+//#endregion
+//#region src/utils/ollama.ts
+var { host, model: DEFAULT_MODEL } = loadConfig();
+var client = new Ollama({ host });
+async function* streamChat(messages, model = DEFAULT_MODEL, tools) {
+	const response = await client.chat({
+		model,
+		messages,
+		stream: true,
+		tools
+	});
+	for await (const chunk of response) {
+		if (chunk.message.content) yield {
+			type: "content",
+			content: chunk.message.content
+		};
+		if (chunk.message.tool_calls) yield {
+			type: "tool_calls",
+			tool_calls: chunk.message.tool_calls
+		};
+	}
+}
+async function listModels() {
+	const { models } = await client.list();
+	return models.map(({ name }) => name);
+}
+//#endregion
+//#region src/utils/screen.ts
+var CLEAR = "\x1Bc";
+function clear() {
+	process.stdout.write(CLEAR);
+}
+//#endregion
+//#region src/utils/tools.ts
+var execAsync = promisify(exec);
+/**
+* Helper to define tool parameters
+*/
+function defineTool(name, description, params, required) {
+	return {
+		type: "function",
+		function: {
+			name,
+			description,
+			parameters: {
+				type: "object",
+				properties: params,
+				required
+			}
+		}
+	};
+}
+/**
+* Tool definitions for Ollama API
+*/
+var TOOLS = [
+	defineTool(NAME.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(NAME.WRITE_FILE, "Write content to a file at the specified path", {
+		path: {
+			type: "string",
+			description: "The path to the file to write"
+		},
+		content: {
+			type: "string",
+			description: "The content to write to the file"
+		}
+	}, ["path", "content"]),
+	defineTool(NAME.RUN_SHELL, "Execute a shell command", { command: {
+		type: "string",
+		description: "The shell command to execute"
+	} }, ["command"]),
+	defineTool(NAME.LIST_DIR, "List the contents of a directory", { path: {
+		type: "string",
+		description: "The path to the directory to list"
+	} }, ["path"]),
+	defineTool(NAME.GREP_SEARCH, "Search for a pattern in files within a directory", {
+		pattern: {
+			type: "string",
+			description: "The regex pattern to search for"
+		},
+		path: {
+			type: "string",
+			description: "The directory path to search in"
+		}
+	}, ["pattern", "path"]),
+	defineTool(NAME.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"
+	])
+];
+var TOOLS_REQUIRING_APPROVAL = new Set([NAME.WRITE_FILE, NAME.RUN_SHELL]);
+/**
+* Execute a tool by name with arguments
+*/
+async function executeTool(name, args) {
+	switch (name) {
+		case NAME.READ_FILE: return readFile(args.path);
+		case NAME.WRITE_FILE: return writeFile(args.path, args.content);
+		case NAME.RUN_SHELL: return runShell(args.command);
+		case NAME.LIST_DIR: return listDir(args.path);
+		case NAME.GREP_SEARCH: return await grepSearch(args.pattern, args.path);
+		case NAME.VIEW_RANGE: return viewRange(args.path, args.start, args.end);
+		default: return {
+			content: "",
+			error: `Unknown tool: ${name}`
+		};
+	}
+}
+/**
+* Read file contents
+*/
+function readFile(filePath) {
+	try {
+		if (!existsSync(filePath)) return {
+			content: "",
+			error: `File not found: ${filePath}`
+		};
+		return { content: readFileSync(filePath, "utf8") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Write content to file
+*/
+function writeFile(filePath, content) {
+	try {
+		writeFileSync(filePath, content, "utf8");
+		return { content: `File written successfully: ${filePath}` };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+var SHELL_EXEC_OPTIONS = {
+	timeout: 3e4,
+	maxBuffer: 1024 * 1024
+};
+/**
+* Execute shell command with shared options (throws on error)
+*/
+function execShell(command) {
+	return execAsync(command, SHELL_EXEC_OPTIONS);
+}
+/**
+* Execute shell command
+*/
+async function runShell(command) {
+	try {
+		const { stdout, stderr } = await execShell(command);
+		return { content: stdout || stderr };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Command failed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* List directory contents
+*/
+function listDir(dirPath) {
+	try {
+		if (!existsSync(dirPath)) return {
+			content: "",
+			error: `Directory not found: ${dirPath}`
+		};
+		return { content: readdirSync(dirPath, { withFileTypes: true }).map((entry) => {
+			return `[${entry.isDirectory() ? "d" : "f"}] ${entry.name}`;
+		}).join("\n") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to list directory: ${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) {
+	try {
+		const { stdout } = await execShell(`rg --line-number --no-heading --smart-case "${pattern.replace(/"/g, "\\\"")}" "${dirPath}"`);
+		// v8 ignore next
+		return { content: stdout || "No matches found" };
+	} catch {}
+	try {
+		if (!existsSync(dirPath)) return {
+			content: "",
+			error: `Directory not found: ${dirPath}`
+		};
+		const regex = new RegExp(pattern, "g");
+		const results = [];
+		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.startsWith(".") && entry.name !== "node_modules") searchDirectory(fullPath);
+				} else if (entry.isFile()) try {
+					const lines = readFileSync(fullPath, "utf8").split("\n");
+					for (let i = 0; i < lines.length; i++) {
+						if (regex.test(lines[i])) results.push(`${fullPath}:${(i + 1).toString()}: ${lines[i].trim()}`);
+						regex.lastIndex = 0;
+					}
+				} catch {}
+			}
+		}
+		searchDirectory(dirPath);
+		if (results.length === 0) return { content: "No matches found" };
+		return { content: results.join("\n") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Search failed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* View specific line range from file
+*/
+function viewRange(filePath, start, end) {
+	try {
+		if (!existsSync(filePath)) return {
+			content: "",
+			error: `File not found: ${filePath}`
+		};
+		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 {
+			content: "",
+			error: "Invalid line range"
+		};
+		return { content: lines.slice(startIdx, endIdx).join("\n") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to view range: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+//#endregion
+//#region src/cli.ts
+var cli = cac("code-ollama");
+cli.version(VERSION);
+cli.help();
+cli.command("run <model> <prompt>", "Run a one-off prompt").action(async (model, prompt) => {
+	try {
+		await runPrompt(model, prompt);
+	} catch (error) {
+		// v8 ignore next
+		const message = error instanceof Error ? error.message : "Unknown error";
+		process.stderr.write(`Error: ${message}\n`);
+		process.exitCode = 1;
+	}
+});
+async function runPrompt(model, prompt) {
+	await processRunStream([createSystemMessage(), {
+		role: ROLE.USER,
+		content: prompt
+	}], model);
+	process.stdout.write("\n");
+}
+async function processRunStream(messages, model) {
+	const assistantMessage = {
+		role: ROLE.ASSISTANT,
+		content: ""
+	};
+	for await (const chunk of streamChat(messages, model, TOOLS)) {
+		if (chunk.type === "content") {
+			assistantMessage.content += chunk.content;
+			process.stdout.write(chunk.content);
+			continue;
+		}
+		for (const toolCall of chunk.tool_calls) {
+			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}` : ""}`
+			};
+			await processRunStream([
+				...messages,
+				assistantMessage,
+				toolResultMessage
+			], model);
+			return;
+		}
+	}
+}
+async function main(args = process.argv.slice(2)) {
+	if (!args.length) {
+		const { renderApp } = await import("./assets/tui-DSR1MJGd.js");
+		clear();
+		renderApp();
+		return;
+	}
+	cli.parse([
+		"node",
+		"code-ollama",
+		...args
+	]);
+}
+/* v8 ignore start */
+function isEntrypoint(argv1 = process.argv[1]) {
+	if (!argv1) return false;
+	try {
+		return realpathSync(argv1) === import.meta.filename;
+	} catch {
+		return false;
+	}
+}
+if (isEntrypoint()) main();
+/* v8 ignore stop */
+//#endregion
+export { streamChat as a, createSystemMessage as c, listModels as i, ROLE as l, main, TOOLS_REQUIRING_APPROVAL as n, loadConfig as o, executeTool as r, saveConfig as s, TOOLS as t, VERSION as u };

package/package.json

@@ -1,4 +1,81 @@
 {
   "name": "code-ollama",
-  "version": "0.0.0"
+  "version": "0.1.1",
+  "description": "Ollama coding agent that runs in your terminal",
+  "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
+  "type": "module",
+  "bin": {
+    "code-ollama": "./dist/cli.js",
+    "collama": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "vite build",
+    "start": "tsx --tsconfig tsconfig.test.json src/cli.ts",
+    "clean": "rm -rf coverage dist docs",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "lint:package": "publint",
+    "lint:tsc": "tsc --build",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build && npm run lint && npm run lint:tsc && npm run test:ci",
+    "test": "vitest run",
+    "test:ci": "CI=true npm test -- --color --coverage",
+    "test:watch": "vitest --coverage.enabled=false"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai-action/code-ollama.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ai-action/code-ollama/issues"
+  },
+  "keywords": [
+    "code-ollama",
+    "collama",
+    "code",
+    "ollama",
+    "tui",
+    "cli",
+    "ai"
+  ],
+  "dependencies": {
+    "@inkjs/ui": "2.0.0",
+    "cac": "7.0.0",
+    "ink": "7.0.1",
+    "ollama": "0.6.3",
+    "react": "19.2.5"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "20.5.3",
+    "@commitlint/config-conventional": "20.5.3",
+    "@eslint/compat": "2.0.5",
+    "@eslint/js": "10.0.1",
+    "@types/node": "25.6.0",
+    "@types/react": "19.2.14",
+    "@vitest/coverage-v8": "4.1.5",
+    "eslint": "10.3.0",
+    "eslint-plugin-prettier": "5.5.5",
+    "eslint-plugin-simple-import-sort": "13.0.0",
+    "globals": "17.6.0",
+    "husky": "9.1.7",
+    "ink-testing-library": "4.0.0",
+    "lint-staged": "16.4.0",
+    "prettier": "3.8.3",
+    "publint": "0.3.18",
+    "tsx": "4.21.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.59.2",
+    "vite": "8.0.10",
+    "vitest": "4.1.5"
+  },
+  "files": [
+    "dist/"
+  ],
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/remarkablemark"
+    }
+  ],
+  "license": "MIT"
 }