code-ollama 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,70 +1,499 @@
 #!/usr/bin/env node
-import { d as e, i as t, l as n, o as r, r as i, t as a, u as o } from "./utils-DBXrYZEs.js";
-import { realpathSync as s } from "node:fs";
-import c from "cac";
+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.2.0";
+//#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: Replace one exact text match in a file (requires approval)
+- 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",
+	EDIT_FILE: "edit_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.EDIT_FILE, "Replace one exact text match in an existing file at the specified path", {
+		path: {
+			type: "string",
+			description: "The path to the file to edit"
+		},
+		oldText: {
+			type: "string",
+			description: "The exact existing text to replace"
+		},
+		newText: {
+			type: "string",
+			description: "The replacement text to write in place of oldText"
+		}
+	}, [
+		"path",
+		"oldText",
+		"newText"
+	]),
+	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.EDIT_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.EDIT_FILE: return editFile(args.path, args.oldText, args.newText);
+		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)}`
+		};
+	}
+}
+/**
+* Replace one exact text match in an existing file
+*/
+function editFile(filePath, oldText, newText) {
+	try {
+		if (!existsSync(filePath)) return {
+			content: "",
+			error: `File not found: ${filePath}`
+		};
+		const content = readFileSync(filePath, "utf8");
+		if (!content.includes(oldText)) return {
+			content: "",
+			error: `Exact text not found in file: ${filePath}`
+		};
+		if (content.split(oldText).length - 1 > 1) return {
+			content: "",
+			error: `Exact text matched multiple locations in file: ${filePath}`
+		};
+		writeFileSync(filePath, content.replace(oldText, newText), "utf8");
+		return { content: `File edited successfully: ${filePath}` };
+	} catch (error) {
+		return {
+			content: "",
+			error: `Failed to edit 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 l = c("code-ollama");
-l.version(e), l.help(), l.command("run <model> <prompt>", "Run a one-off prompt").action(async (e, t) => {
+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 u(e, t);
-	} catch (e) {
+		await runPrompt(model, prompt);
+	} catch (error) {
 		// v8 ignore next
-		let t = e instanceof Error ? e.message : "Unknown error";
-		process.stderr.write(`Error: ${t}\n`), process.exitCode = 1;
+		const message = error instanceof Error ? error.message : "Unknown error";
+		process.stderr.write(`Error: ${message}\n`);
+		process.exitCode = 1;
 	}
 });
-async function u(e, t) {
-	await d([n(), {
-		role: o.USER,
-		content: t
-	}], e), process.stdout.write("\n");
-}
-async function d(e, t) {
-	let n = {
-		role: o.ASSISTANT,
+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 (let s of r(e, t, a)) {
-		if (s.type === "content") {
-			n.content += s.content, process.stdout.write(s.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 (let r of s.tool_calls) {
-			let a = await i(r.function.name, r.function.arguments), s = {
-				role: o.SYSTEM,
-				content: `Tool ${r.function.name} result:\n${a.content}${a.error ? `\nError: ${a.error}` : ""}`
+		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 d([
-				...e,
-				n,
-				s
-			], t);
+			await processRunStream([
+				...messages,
+				assistantMessage,
+				toolResultMessage
+			], model);
 			return;
 		}
 	}
 }
-async function f(e = process.argv.slice(2)) {
-	if (!e.length) {
-		let { renderApp: e } = await import("./tui-Bu6wAbeu.js");
-		t(), e();
+async function main(args = process.argv.slice(2)) {
+	if (!args.length) {
+		const { renderApp } = await import("./assets/tui-DSR1MJGd.js");
+		clear();
+		renderApp();
 		return;
 	}
-	l.parse([
+	cli.parse([
 		"node",
 		"code-ollama",
-		...e
+		...args
 	]);
 }
 /* v8 ignore start */
-function p(e = process.argv[1]) {
-	if (!e) return !1;
+function isEntrypoint(argv1 = process.argv[1]) {
+	if (!argv1) return false;
 	try {
-		return s(e) === import.meta.filename;
+		return realpathSync(argv1) === import.meta.filename;
 	} catch {
-		return !1;
+		return false;
 	}
 }
-p() && f();
+if (isEntrypoint()) main();
 /* v8 ignore stop */
 //#endregion
-export { f as main };
+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,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",
@@ -64,7 +64,7 @@
     "publint": "0.3.18",
     "tsx": "4.21.0",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.59.1",
+    "typescript-eslint": "8.59.2",
     "vite": "8.0.10",
     "vitest": "4.1.5"
   },