code-ollama 0.23.2 → 0.24.1

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

@@ -1411,7 +1411,7 @@ function ChatInput({ history: sessionHistory, isDisabled = false, onInterrupt, o
 }
 //#endregion
 //#region src/components/Chat/constants.ts
-var ACTION_NOT_PERFORMED = "The requested action was NOT performed";
+var ACTION_NOT_PERFORMED = "The requested action did not complete successfully";
 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) {
@@ -1445,6 +1445,18 @@ function hasExecutablePlan(content) {
 	const nextSectionIndex = lines.findIndex((line, index) => index > executionStepsIndex && /^#{1,6}\s+\S/.test(line.trim()));
 	return lines.slice(executionStepsIndex + 1, nextSectionIndex === -1 ? void 0 : nextSectionIndex).some((line) => /^(?:[-*]|\d+[.)])\s+\S/.test(line.trim()));
 }
+function isPlanModeFinal(content) {
+	const firstHeading = content.split("\n").find((line) => line.trim())?.trim().toLowerCase();
+	return isPlanNeedsInput(content) || firstHeading === "## proposed plan";
+}
+function isPlanNeedsInput(content) {
+	return content.split("\n").find((line) => line.trim())?.trim().toLowerCase() === "## plan needs input";
+}
+function isDirectPlanAnswer(content) {
+	const normalized = content.trim();
+	if (!normalized || isPlanModeFinal(normalized)) return false;
+	return !/^(?:research(?: is)? complete|done)\.?$/i.test(normalized);
+}
 //#endregion
 //#region src/components/Chat/reducer.ts
 function createInitialChatState(messages = []) {
@@ -1667,7 +1679,9 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 						toolResultMessages.push(buildToolResultMessage(toolCall.function.name, {
 							content: "",
 							// v8 ignore next
-							error: error instanceof Error ? error.message : String(error)
+							error: error instanceof Error ? error.message : String(error),
+							// v8 ignore next
+							...error instanceof Error && error.stack ? { stack: error.stack } : {}
 						}));
 					}
 					nextMessages = [...updatedMessages, ...toolResultMessages];
@@ -1746,7 +1760,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		mode,
 		theme
 	]);
-	const processStreamReadOnly = useCallback(async (currentMessages) => {
+	const processStreamReadOnly = useCallback(async (currentMessages, toolIntentCorrections = 0) => {
 		const modelName = model;
 		// v8 ignore next
 		if (!modelName) throw new Error("Model is required");
@@ -1843,7 +1857,9 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 						/* v8 ignore start */
 						const toolResultMessage = buildToolResultMessage(toolCall.function.name, {
 							content: "",
-							error: error instanceof Error ? error.message : String(error)
+							error: error instanceof Error ? error.message : String(error),
+							// v8 ignore next
+							...error instanceof Error && error.stack ? { stack: error.stack } : {}
 						});
 						const newMessages = [...updatedMessages, toolResultMessage];
 						dispatch({
@@ -1866,6 +1882,13 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 			}
 			await prewarmCodeBlocks(assistantMessage.content, theme);
 			const researchMessages = commitAssistantMessage();
+			if (isPlanNeedsInput(assistantMessage.content)) {
+				dispatch({
+					type: ChatActionType.SetLoading,
+					isLoading: false
+				});
+				return;
+			}
 			if (hasExecutablePlan(assistantMessage.content)) {
 				dispatch({
 					type: ChatActionType.RequestPlanReview,
@@ -1876,6 +1899,32 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				});
 				return;
 			}
+			if (hasUncalledToolIntent(assistantMessage.content) && toolIntentCorrections < MAX_TOOL_INTENT_CORRECTIONS) {
+				const correctedMessages = [...researchMessages, {
+					role: SYSTEM,
+					content: TOOL_INTENT_CORRECTION
+				}];
+				dispatch({
+					type: ChatActionType.CommitMessages,
+					messages: correctedMessages
+				});
+				await processStreamReadOnly(correctedMessages, toolIntentCorrections + 1);
+				return;
+			}
+			if (isPlanModeFinal(assistantMessage.content)) {
+				dispatch({
+					type: ChatActionType.SetLoading,
+					isLoading: false
+				});
+				return;
+			}
+			if (currentMessages.some((message) => !!message.toolResult) && isDirectPlanAnswer(assistantMessage.content)) {
+				dispatch({
+					type: ChatActionType.SetLoading,
+					isLoading: false
+				});
+				return;
+			}
 			const planInstruction = {
 				role: SYSTEM,
 				content: PLAN_GENERATION_INSTRUCTION
@@ -2003,6 +2052,13 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		});
 		switch (decision) {
 			case APPROVE: {
+				dispatch({
+					type: ChatActionType.SetStreamingMessage,
+					message: {
+						role: ASSISTANT,
+						content: ""
+					}
+				});
 				const result = await executeToolCall(toolCall);
 				const toolResultMessage = buildToolResultMessage(toolCall.function.name, result, toolCall.function.arguments);
 				const newMessages = [...approvedMessages, toolResultMessage];

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import cac from "cac";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
@@ -50,7 +50,7 @@ var LIST$1 = [
 //#endregion
 //#region package.json
 var name = "code-ollama";
-var version = "0.23.2";
+var version = "0.24.1";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -107,13 +107,16 @@ var BACK = {
 //#endregion
 //#region src/constants/tool.ts
 var tool_exports = /* @__PURE__ */ __exportAll({
+	CREATE_DIRECTORY: () => CREATE_DIRECTORY,
+	DELETE_PATH: () => DELETE_PATH,
 	EDIT_FILE: () => EDIT_FILE,
+	FIND_FILES: () => FIND_FILES,
 	GREP_SEARCH: () => GREP_SEARCH,
 	LIST_DIR: () => LIST_DIR,
 	READ_FILE: () => READ_FILE,
 	READ_TOOL_NAMES: () => READ_TOOL_NAMES,
+	RENAME_PATH: () => RENAME_PATH,
 	RUN_SHELL: () => RUN_SHELL,
-	VIEW_RANGE: () => VIEW_RANGE,
 	WEB_FETCH: () => WEB_FETCH,
 	WEB_SEARCH: () => WEB_SEARCH,
 	WRITE_FILE: () => WRITE_FILE,
@@ -122,23 +125,29 @@ var tool_exports = /* @__PURE__ */ __exportAll({
 var READ_FILE = "read_file";
 var WRITE_FILE = "write_file";
 var EDIT_FILE = "edit_file";
+var CREATE_DIRECTORY = "create_directory";
+var RENAME_PATH = "rename_path";
+var DELETE_PATH = "delete_path";
 var RUN_SHELL = "run_shell";
 var LIST_DIR = "list_dir";
+var FIND_FILES = "find_files";
 var GREP_SEARCH = "grep_search";
-var VIEW_RANGE = "view_range";
 var WEB_SEARCH = "web_search";
 var WEB_FETCH = "web_fetch";
 var READ_TOOL_NAMES = [
 	READ_FILE,
 	LIST_DIR,
+	FIND_FILES,
 	GREP_SEARCH,
-	VIEW_RANGE,
 	WEB_SEARCH,
 	WEB_FETCH
 ];
 var WRITE_TOOL_NAMES = [
 	WRITE_FILE,
 	EDIT_FILE,
+	CREATE_DIRECTORY,
+	RENAME_PATH,
+	DELETE_PATH,
 	RUN_SHELL
 ];
 //#endregion
@@ -157,10 +166,14 @@ Follow these rules:
 
 When tools return results, incorporate them into your response naturally`;
 var TOOL_INSTRUCTIONS = `Available tools:
-- read_file: Read file contents at a path
+- read_file: Read file contents at a path; supports startLine, endLine, and maxLines options
 - write_file: Write content to a file (requires approval)
 - edit_file: Replace one exact text match in a file (requires approval)
+- create_directory: Create a directory and missing parent directories (requires approval)
+- rename_path: Rename or move a file or directory without overwriting existing destinations (requires approval)
+- delete_path: Delete a file or directory; non-empty directories require recursive=true (requires approval)
 - list_dir: List files in a directory
+- find_files: Recursively find files by optional substring or wildcard path pattern; supports includeHidden and ignoredDirs options
 - grep_search: Search code with regex
 - web_search: Search the web for current or external information
 - run_shell: Execute shell commands (requires approval)
@@ -217,10 +230,18 @@ Use the exact headings shown below
 ${PLAN_RESPONSE_TEMPLATE}`;
 var PLAN_INSTRUCTION = `Plan mode is active
 
+Explore first:
+- If the user provides an exact file path, inspect it with read_file before planning changes
+- If the user asks "where", names an identifier/symbol, or asks where behavior is implemented, search the codebase with grep_search before answering
+- If the user asks about project structure without a target identifier or path, use list_dir or find_files to locate likely files
+- Prefer targeted grep_search for exact names over broad directory listing when the user provides an identifier
+- After each read-only tool result, decide whether another read-only tool would materially improve the answer
+- Do not produce Plan Needs Input while also saying you will use another read-only tool; call that tool instead
+
 Only use read-only tools: ${PLAN_READ_TOOLS}
 Do not call ${PLAN_WRITE_TOOLS} during Plan mode
 Use read-only tools to resolve discoverable facts before asking questions
-If the user asks to search, inspect, find, read, or locate something, use read-only tools immediately
+If the user asks to search, inspect, find, read, locate, change, adjust, update, edit, configure, or identify something, use read-only tools immediately
 Only ask questions for user preferences or product decisions that cannot be discovered from available tools
 When enough context is available, stop calling tools and produce either Plan Needs Input or Proposed Plan using the required template
 
@@ -815,10 +836,24 @@ function defineTool(name, description, params, required) {
 * Tool definitions for Ollama API
 */
 var TOOLS = [
-	defineTool(READ_FILE, "Read the contents of a file at the specified path", { path: {
-		type: "string",
-		description: "The path to the file to read"
-	} }, ["path"]),
+	defineTool(READ_FILE, "Read the contents of a file at the specified path, optionally limited by line range", {
+		path: {
+			type: "string",
+			description: "The path to the file to read"
+		},
+		startLine: {
+			type: "number",
+			description: "Optional starting line number to read from (1-indexed)"
+		},
+		endLine: {
+			type: "number",
+			description: "Optional ending line number to read through (inclusive)"
+		},
+		maxLines: {
+			type: "number",
+			description: "Optional maximum number of lines to read; cannot be combined with endLine"
+		}
+	}, ["path"]),
 	defineTool(WRITE_FILE, "Write content to a file at the specified path", {
 		path: {
 			type: "string",
@@ -847,6 +882,30 @@ var TOOLS = [
 		"oldText",
 		"newText"
 	]),
+	defineTool(CREATE_DIRECTORY, "Create a directory and any missing parent directories at the specified path", { path: {
+		type: "string",
+		description: "The directory path to create"
+	} }, ["path"]),
+	defineTool(RENAME_PATH, "Rename or move an existing file or directory to a new path", {
+		from: {
+			type: "string",
+			description: "The existing file or directory path to rename or move"
+		},
+		to: {
+			type: "string",
+			description: "The destination path for the renamed or moved item"
+		}
+	}, ["from", "to"]),
+	defineTool(DELETE_PATH, "Delete a file or directory at the specified path", {
+		path: {
+			type: "string",
+			description: "The file or directory path to delete"
+		},
+		recursive: {
+			type: "boolean",
+			description: "Whether to delete non-empty directories recursively; use false for files and empty directories"
+		}
+	}, ["path", "recursive"]),
 	defineTool(RUN_SHELL, "Execute a shell command", { command: {
 		type: "string",
 		description: "The shell command to execute"
@@ -855,6 +914,28 @@ var TOOLS = [
 		type: "string",
 		description: "The path to the directory to list"
 	} }, ["path"]),
+	defineTool(FIND_FILES, "Recursively find files under a directory, optionally matching a simple substring or wildcard pattern", {
+		path: {
+			type: "string",
+			description: "The directory path to search in"
+		},
+		pattern: {
+			type: "string",
+			description: "Optional case-insensitive substring or wildcard pattern to match against file paths"
+		},
+		includeHidden: {
+			type: "boolean",
+			description: "Whether to include hidden files and directories; defaults to false"
+		},
+		ignoredDirs: {
+			type: "array",
+			description: "Optional directory names or simple wildcard patterns to skip instead of the default ignored directory list; .git is always skipped",
+			items: {
+				type: "string",
+				description: "Directory name or wildcard pattern to skip"
+			}
+		}
+	}, ["path"]),
 	defineTool(GREP_SEARCH, "Search files within a directory; multi-word queries also match common code identifier forms", {
 		pattern: {
 			type: "string",
@@ -865,24 +946,6 @@ var TOOLS = [
 			description: "The directory path to search in"
 		}
 	}, ["pattern", "path"]),
-	defineTool(VIEW_RANGE, "View a specific range of lines from a file", {
-		path: {
-			type: "string",
-			description: "The path to the file"
-		},
-		start: {
-			type: "number",
-			description: "The starting line number (1-indexed)"
-		},
-		end: {
-			type: "number",
-			description: "The ending line number (inclusive)"
-		}
-	}, [
-		"path",
-		"start",
-		"end"
-	]),
 	defineTool(WEB_SEARCH, "Search the web for external or current information", { query: {
 		type: "string",
 		description: "The search query to look up"
@@ -901,6 +964,11 @@ var SHELL_EXEC_OPTIONS = {
 	timeout: 3e4,
 	maxBuffer: 1024 * 1024
 };
+function getErrorOutput(error) {
+	if (typeof error !== "object" || error === null) return "";
+	const output = error;
+	return [output.stdout, output.stderr].filter((value) => typeof value === "string" && !!value).join("\n");
+}
 /**
 * Execute shell command with shared options (throws on error)
 */
@@ -915,9 +983,12 @@ async function runShell(command) {
 		const { stdout, stderr } = await execShell(command);
 		return { content: stdout || stderr };
 	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
 		return {
-			content: "",
-			error: `Command failed: ${error instanceof Error ? error.message : String(error)}`
+			content: getErrorOutput(error),
+			error: `Command failed: ${message}`,
+			// v8 ignore next
+			...error instanceof Error && error.stack ? { stack: error.stack } : {}
 		};
 	}
 }
@@ -926,6 +997,17 @@ async function runShell(command) {
 var DIFF_CONTEXT_LINES = 3;
 var DIFF_MAX_LINES = 120;
 var DIFF_MAX_CHARS = 12e3;
+var DEFAULT_FIND_FILES_IGNORED_DIRS = [
+	"node_modules",
+	"__pycache__",
+	".*cache",
+	".tox",
+	".venv",
+	"venv",
+	"dist",
+	"build",
+	"coverage"
+];
 function splitLines(content) {
 	return content.split("\n");
 }
@@ -993,16 +1075,63 @@ function buildSearchPatterns(pattern) {
 function capitalize(value) {
 	return value.charAt(0).toUpperCase() + value.slice(1);
 }
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function fileMatchesPattern(filePath, pattern) {
+	const trimmedPattern = pattern?.trim();
+	if (!trimmedPattern) return true;
+	const normalizedPath = filePath.toLowerCase();
+	const normalizedFileName = normalizedPath.slice(Math.max(normalizedPath.lastIndexOf("/"), normalizedPath.lastIndexOf("\\")) + 1);
+	const normalizedPattern = trimmedPattern.toLowerCase();
+	if (!normalizedPattern.includes("*") && !normalizedPattern.includes("?")) return normalizedPath.includes(normalizedPattern);
+	const regexPattern = normalizedPattern.split("").map((char) => {
+		if (char === "*") return ".*";
+		if (char === "?") return ".";
+		return escapeRegExp(char);
+	}).join("");
+	const regex = new RegExp(`^${regexPattern}$`);
+	return regex.test(normalizedPath) || regex.test(normalizedFileName);
+}
+function valueMatchesWildcardPattern(value, pattern) {
+	const normalizedValue = value.toLowerCase();
+	const normalizedPattern = pattern.trim().toLowerCase();
+	if (!normalizedPattern.includes("*") && !normalizedPattern.includes("?")) return normalizedValue === normalizedPattern;
+	const regexPattern = normalizedPattern.split("").map((char) => {
+		if (char === "*") return ".*";
+		if (char === "?") return ".";
+		return escapeRegExp(char);
+	}).join("");
+	return new RegExp(`^${regexPattern}$`).test(normalizedValue);
+}
+function directoryMatchesIgnoredPattern(dirName, ignoredDirs) {
+	for (const ignoredDir of ignoredDirs) if (valueMatchesWildcardPattern(dirName, ignoredDir)) return true;
+	return false;
+}
+function formatNumberedLines(lines, startLine) {
+	return lines.map((line, index) => `${String(startLine + index)}: ${line}`).join("\n");
+}
 /**
 * Read file contents
 */
-function readFile(filePath) {
+function readFile(filePath, options = {}) {
 	try {
 		if (!existsSync(filePath)) return {
 			content: "",
 			error: `File not found: ${filePath}`
 		};
-		return { content: readFileSync(filePath, "utf8") };
+		const content = readFileSync(filePath, "utf8");
+		if (!(options.startLine !== void 0 || options.endLine !== void 0 || options.maxLines !== void 0)) return { content };
+		const lines = content.split("\n");
+		const startLine = options.startLine ?? 1;
+		const endLine = options.endLine ?? startLine + (options.maxLines ?? lines.length) - 1;
+		const startIndex = startLine - 1;
+		const endIndex = Math.min(lines.length, endLine);
+		if (startIndex >= lines.length) return {
+			content: "",
+			error: "Invalid line range"
+		};
+		return { content: formatNumberedLines(lines.slice(startIndex, endIndex), startLine) };
 	} catch (error) {
 		return {
 			content: "",
@@ -1067,26 +1196,73 @@ function editFile(filePath, oldText, newText) {
 	}
 }
 /**
-* View specific line range from file
+* Create a directory and any missing parent directories
 */
-function viewRange(filePath, start, end) {
+function createDirectory(dirPath) {
 	try {
-		if (!existsSync(filePath)) return {
+		if (existsSync(dirPath)) {
+			if (statSync(dirPath).isDirectory()) return { content: `Directory already exists: ${dirPath}` };
+			return {
+				content: "",
+				error: `Path already exists and is not a directory: ${dirPath}`
+			};
+		}
+		mkdirSync(dirPath, { recursive: true });
+		return { content: `Directory created successfully: ${dirPath}` };
+	} catch (error) {
+		return {
 			content: "",
-			error: `File not found: ${filePath}`
+			error: `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Rename or move an existing file or directory
+*/
+function renamePath(fromPath, toPath) {
+	try {
+		if (!existsSync(fromPath)) return {
+			content: "",
+			error: `Source path not found: ${fromPath}`
 		};
-		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 {
+		if (existsSync(toPath)) return {
 			content: "",
-			error: "Invalid line range"
+			error: `Destination path already exists: ${toPath}`
+		};
+		renameSync(fromPath, toPath);
+		return { content: `Path renamed successfully: ${fromPath} -> ${toPath}` };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to rename path: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
+* Delete a file or directory
+*/
+function deletePath(path, recursive) {
+	try {
+		if (!existsSync(path)) return {
+			content: "",
+			error: `Path not found: ${path}`
 		};
-		return { content: lines.slice(startIdx, endIdx).join("\n") };
+		if (statSync(path).isDirectory()) {
+			if (readdirSync(path).length > 0 && !recursive) return {
+				content: "",
+				error: `Directory is not empty; set recursive to true to delete: ${path}`
+			};
+			if (recursive) rmSync(path, {
+				recursive: true,
+				force: false
+			});
+			else rmdirSync(path);
+		} else rmSync(path, { force: false });
+		return { content: `Path deleted successfully: ${path}` };
 	} catch (error) {
 		return {
 			content: "",
-			error: `Failed to view range: ${error instanceof Error ? error.message : String(error)}`
+			error: `Failed to delete path: ${error instanceof Error ? error.message : String(error)}`
 		};
 	}
 }
@@ -1110,6 +1286,40 @@ function listDir(dirPath) {
 	}
 }
 /**
+* Recursively find files by path
+*/
+function findFiles(dirPath, options = {}) {
+	try {
+		if (!existsSync(dirPath)) return {
+			content: "",
+			error: `Directory not found: ${dirPath}`
+		};
+		if (!statSync(dirPath).isDirectory()) return {
+			content: "",
+			error: `Path is not a directory: ${dirPath}`
+		};
+		const results = [];
+		const includeHidden = options.includeHidden ?? false;
+		const ignoredDirs = new Set(options.ignoredDirs ?? DEFAULT_FIND_FILES_IGNORED_DIRS);
+		function searchDirectory(currentPath) {
+			const entries = readdirSync(currentPath, { withFileTypes: true });
+			for (const entry of entries) {
+				const fullPath = join(currentPath, entry.name);
+				if (entry.isDirectory()) {
+					if (entry.name !== ".git" && !directoryMatchesIgnoredPattern(entry.name, ignoredDirs) && (includeHidden || !entry.name.startsWith("."))) searchDirectory(fullPath);
+				} else if (entry.isFile() && (includeHidden || !entry.name.startsWith(".")) && fileMatchesPattern(fullPath, options.pattern)) results.push(fullPath);
+			}
+		}
+		searchDirectory(dirPath);
+		return { content: results.join("\n") };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to find files: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+/**
 * Search for pattern in files using ripgrep if available, fallback to Node.js
 */
 async function grepSearch(pattern, dirPath) {
@@ -1333,10 +1543,13 @@ var REQUIRED_STRING_ARGS = {
 		"oldText",
 		"newText"
 	],
+	[CREATE_DIRECTORY]: ["path"],
+	[RENAME_PATH]: ["from", "to"],
+	[DELETE_PATH]: ["path"],
 	[RUN_SHELL]: ["command"],
 	[LIST_DIR]: ["path"],
+	[FIND_FILES]: ["path"],
 	[GREP_SEARCH]: ["pattern", "path"],
-	[VIEW_RANGE]: ["path"],
 	[WEB_SEARCH]: ["query"],
 	[WEB_FETCH]: ["url"]
 };
@@ -1351,14 +1564,44 @@ function validateArgs(name, args) {
 		content: "",
 		error: `Missing required argument: ${key} (received keys: ${received})`
 	};
-	if (name === "view_range") {
-		if (!Number.isInteger(args.start) || !Number.isInteger(args.end)) return {
+	if (name === "read_file") {
+		for (const key of [
+			"startLine",
+			"endLine",
+			"maxLines"
+		]) if (args[key] !== void 0 && !Number.isInteger(args[key])) return {
+			content: "",
+			error: `Invalid optional numeric argument: ${key} (received keys: ${received})`
+		};
+		if (typeof args.startLine === "number" && args.startLine < 1 || typeof args.endLine === "number" && args.endLine < 1 || typeof args.maxLines === "number" && args.maxLines < 1) return {
+			content: "",
+			error: "Invalid read range: startLine, endLine, and maxLines must be >= 1"
+		};
+		if (args.endLine !== void 0 && args.maxLines !== void 0) return {
 			content: "",
-			error: `Missing required numeric arguments: start, end (received keys: ${received})`
+			error: "Invalid read range: endLine cannot be combined with maxLines"
 		};
-		if (args.start < 1 || args.end < args.start) return {
+		if (typeof args.startLine === "number" && typeof args.endLine === "number" && args.endLine < args.startLine) return {
 			content: "",
-			error: "Invalid line range: start must be >= 1 and end must be >= start"
+			error: "Invalid read range: endLine must be >= startLine"
+		};
+	}
+	if (name === "delete_path" && typeof args.recursive !== "boolean") return {
+		content: "",
+		error: `Missing required boolean argument: recursive (received keys: ${received})`
+	};
+	if (name === "find_files" && args.pattern !== void 0 && typeof args.pattern !== "string") return {
+		content: "",
+		error: `Invalid optional argument: pattern must be a string (received keys: ${received})`
+	};
+	if (name === "find_files" && args.includeHidden !== void 0 && typeof args.includeHidden !== "boolean") return {
+		content: "",
+		error: `Invalid optional argument: includeHidden must be a boolean (received keys: ${received})`
+	};
+	if (name === "find_files" && args.ignoredDirs !== void 0) {
+		if (!Array.isArray(args.ignoredDirs) || !args.ignoredDirs.every((value) => typeof value === "string")) return {
+			content: "",
+			error: `Invalid optional argument: ignoredDirs must be an array of strings (received keys: ${received})`
 		};
 	}
 	if (name === "web_fetch") try {
@@ -1390,14 +1633,16 @@ function normalizeToolCall(toolCall) {
 }
 function formatToolResultContent(toolName, result, args) {
 	const formattedArgs = args ? `(${formatToolArguments(args)})` : "";
-	const status = result.error ? "The requested action was NOT performed" : "";
+	const status = result.error ? "The requested action did not complete successfully" : "";
 	const content = result.content ? `\n${result.content}` : "";
 	const error = result.error ? `\nError: ${result.error}` : "";
+	const stack = result.error && result.stack ? `\nStack trace:\n${result.stack}` : "";
 	return [
 		`Tool ${toolName}${formattedArgs} result:`,
 		status,
 		content.trim(),
-		error.trim()
+		error.trim(),
+		stack.trim()
 	].filter(Boolean).join("\n");
 }
 function formatToolArguments(args) {
@@ -1415,7 +1660,9 @@ async function executeToolCall(toolCall, options) {
 		return {
 			content: "",
 			// v8 ignore next
-			error: error instanceof Error ? error.message : String(error)
+			error: error instanceof Error ? error.message : String(error),
+			// v8 ignore next
+			...error instanceof Error && error.stack ? { stack: error.stack } : {}
 		};
 	}
 }
@@ -1435,13 +1682,24 @@ async function executeTool(name, args, options) {
 	if (invalid) return invalid;
 	const stringArgs = args;
 	switch (name) {
-		case READ_FILE: return readFile(stringArgs.path);
+		case READ_FILE: return readFile(stringArgs.path, {
+			endLine: args.endLine,
+			maxLines: args.maxLines,
+			startLine: args.startLine
+		});
 		case WRITE_FILE: return writeFile(stringArgs.path, stringArgs.content);
 		case EDIT_FILE: return editFile(stringArgs.path, stringArgs.oldText, stringArgs.newText);
+		case CREATE_DIRECTORY: return createDirectory(stringArgs.path);
+		case RENAME_PATH: return renamePath(stringArgs.from, stringArgs.to);
+		case DELETE_PATH: return deletePath(stringArgs.path, args.recursive);
 		case RUN_SHELL: return runShell(stringArgs.command);
 		case LIST_DIR: return listDir(stringArgs.path);
+		case FIND_FILES: return findFiles(stringArgs.path, {
+			ignoredDirs: args.ignoredDirs,
+			includeHidden: args.includeHidden,
+			pattern: stringArgs.pattern
+		});
 		case GREP_SEARCH: return await grepSearch(stringArgs.pattern, stringArgs.path);
-		case VIEW_RANGE: return viewRange(stringArgs.path, args.start, args.end);
 		case WEB_SEARCH: return await webSearch(stringArgs.query);
 		case WEB_FETCH: return await webFetch(stringArgs.url);
 		// v8 ignore next 2
@@ -1582,7 +1840,7 @@ async function main(args = process.argv.slice(2)) {
 	else await launchTui();
 }
 async function launchTui(sessionId) {
-	const { renderApp } = await import("./assets/tui-DEmaVgHT.js");
+	const { renderApp } = await import("./assets/tui-CboegfoT.js");
 	reset();
 	renderApp(sessionId);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.23.2",
+  "version": "0.24.1",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",
@@ -20,7 +20,7 @@
     "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"
+    "test:watch": "vitest"
   },
   "repository": {
     "type": "git",