novacode 0.2.0

package/src/tools/git.ts

@@ -0,0 +1,82 @@
+/**
+ * Git tools for executing safe repository operations programmatically.
+ */
+import type { Tool, ToolResult } from "../types.ts"
+import { textPart } from "../util.ts"
+
+export function gitTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "git",
+			description:
+				"Execute safe, non-interactive git commands (status, diff, log, add, commit) in the repository.",
+			parameters: {
+				type: "object",
+				properties: {
+					action: {
+						type: "string",
+						enum: ["status", "diff", "log", "add", "commit"],
+						description: "The git action to execute",
+					},
+					args: {
+						type: "array",
+						description: "Optional additional arguments or file paths for the git action",
+						items: { type: "string" },
+					},
+				},
+				required: ["action"],
+			},
+		},
+		async execute(args, signal): Promise<ToolResult> {
+			const action = args.action as string
+			const extraArgs = (args.args as string[]) || []
+
+			const allowed = new Set(["status", "diff", "log", "add", "commit"])
+			if (!allowed.has(action)) {
+				return {
+					content: [textPart(`Error: Git action '${action}' is not supported.`)],
+					isError: true,
+				}
+			}
+
+			try {
+				const cmd = ["git", action, ...extraArgs]
+				const proc = Bun.spawn(cmd, {
+					cwd,
+					stdout: "pipe",
+					stderr: "pipe",
+					env: { ...process.env, PAGER: "cat" },
+				})
+
+				const onAbort = () => proc.kill()
+				signal?.addEventListener("abort", onAbort, { once: true })
+
+				const exitCode = await proc.exited
+				signal?.removeEventListener("abort", onAbort)
+
+				const stdout = await new Response(proc.stdout).text()
+				const stderr = await new Response(proc.stderr).text()
+
+				// Prevent context window blowout by truncating very large outputs
+				const MAX = 50_000
+				let out = ""
+				if (stdout) out += stdout.slice(0, MAX)
+				if (stderr) {
+					if (out) out += "\n"
+					out += stderr.slice(0, MAX - out.length)
+				}
+				if (out.length >= MAX) out += "\n…truncated"
+
+				return {
+					content: [textPart(out || "(no output)")],
+					isError: exitCode !== 0,
+				}
+			} catch (e) {
+				return {
+					content: [textPart(`Error running git: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}

package/src/tools/index.ts

@@ -0,0 +1,33 @@
+import type { Tool } from "../types.ts"
+import { editTool, readTool, writeTool } from "./fs.ts"
+import { gitTool } from "./git.ts"
+import { globTool, grepTool, lsTool, treeTool } from "./search.ts"
+import { bashTool } from "./shell.ts"
+import { webFetchTool, webSearchTool } from "./web.ts"
+
+export function getAllTools(cwd: string): Tool[] {
+	return [
+		readTool(cwd),
+		writeTool(cwd),
+		editTool(cwd),
+		bashTool(cwd),
+		globTool(cwd),
+		grepTool(cwd),
+		lsTool(cwd),
+		treeTool(cwd),
+		gitTool(cwd),
+		webSearchTool(),
+		webFetchTool(),
+	]
+}
+
+export function getDefaultTools(cwd: string): Tool[] {
+	return [
+		readTool(cwd),
+		writeTool(cwd),
+		editTool(cwd),
+		bashTool(cwd),
+		webSearchTool(),
+		webFetchTool(),
+	]
+}

package/src/tools/search.ts

@@ -0,0 +1,252 @@
+/**
+ * Search tools for finding files and content.
+ * Uses 'rg' (ripgrep) if available, falling back to a pure JS implementation.
+ */
+import { readdir } from "node:fs/promises"
+import { relative, resolve } from "node:path"
+import { glob } from "glob"
+import type { Tool, ToolResult } from "../types.ts"
+
+import { textPart } from "../util.ts"
+
+/**
+ * Tool for finding files by glob pattern.
+ */
+export function globTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "glob",
+			description: "Find files by glob pattern (e.g. **/*.ts, src/**/*.test.ts).",
+			parameters: {
+				type: "object",
+				properties: {
+					pattern: { type: "string", description: "Glob pattern (e.g. **/*.ts)" },
+					path: { type: "string", description: "Directory to search in (default .)" },
+					nocase: { type: "boolean", description: "Case-insensitive search (default false)" },
+				},
+				required: ["pattern"],
+			},
+		},
+		async execute(args): Promise<ToolResult> {
+			try {
+				const rawPath = (args.path as string) || "."
+				const dir = resolve(cwd, rawPath)
+				if (dir !== cwd && !dir.startsWith(`${cwd}/`)) {
+					throw new Error(`Path outside project: ${rawPath}`)
+				}
+
+				const pattern = args.pattern as string
+				const nocase = !!args.nocase
+				const files = await glob(pattern, { cwd: dir, nocase })
+				const sliced = files.slice(0, 500)
+				const relSearchPath = relative(cwd, dir)
+				const prefix = relSearchPath ? `${relSearchPath}/` : ""
+				const relFiles = sliced.map((f) => prefix + f)
+				const out = relFiles.length > 0 ? relFiles.join("\n") : "No files found"
+				return { content: [textPart(out)], isError: false }
+			} catch (e) {
+				return {
+					content: [textPart(`Error: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+/**
+ * Tool for searching file contents using regex.
+ */
+export function grepTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "grep",
+			description:
+				"Search file contents with a regex pattern. Returns matching lines with file paths and line numbers.",
+			parameters: {
+				type: "object",
+				properties: {
+					pattern: { type: "string", description: "Regex pattern to search for" },
+					path: { type: "string", description: "Directory or file to search in (default .)" },
+					glob: { type: "string", description: "File filter glob (e.g. *.ts)" },
+				},
+				required: ["pattern"],
+			},
+		},
+		async execute(args, signal): Promise<ToolResult> {
+			try {
+				const rawPath = (args.path as string) || "."
+				const dir = resolve(cwd, rawPath)
+				if (dir !== cwd && !dir.startsWith(`${cwd}/`)) {
+					throw new Error(`Path outside project: ${rawPath}`)
+				}
+
+				const pattern = args.pattern as string
+				const globFilter = args.glob as string | undefined
+				const relSearchPath = relative(cwd, dir) || "."
+
+				// rg is 10-100x faster than our JS fallback, but isn't always installed
+				try {
+					const cmd = ["rg", "--line-number", "--max-count", "200"]
+					if (globFilter) cmd.push(`--glob=${globFilter}`)
+					cmd.push("--", pattern, relSearchPath)
+
+					const proc = Bun.spawn(cmd, {
+						cwd,
+						stdout: "pipe",
+						stderr: "pipe",
+					})
+					signal?.addEventListener("abort", () => proc.kill(), { once: true })
+					const exitCode = await proc.exited
+					signal?.removeEventListener("abort", () => proc.kill())
+
+					if (exitCode === 0) {
+						const out = await new Response(proc.stdout).text()
+						const lines = out.split("\n").slice(0, 200).join("\n")
+						return { content: [textPart(lines || "No matches")], isError: false }
+					}
+				} catch {
+					// rg not available, fall through
+				}
+
+				// Pure JS fallback when rg is not available
+				const files = await glob(globFilter || "**/*", { cwd: dir })
+				const prefix = relSearchPath === "." ? "" : `${relSearchPath}/`
+				const re = new RegExp(pattern, "i")
+				const matches: string[] = []
+				for (const file of files.slice(0, 500)) {
+					if (signal?.aborted) break
+					try {
+						const content = await Bun.file(resolve(dir, file)).text()
+						const lines = content.split("\n")
+						for (let i = 0; i < lines.length && matches.length < 200; i++) {
+							const line = lines[i]
+							if (line && re.test(line)) matches.push(`${prefix}${file}:${i + 1}:${line}`)
+						}
+					} catch {
+						// Skip binary/unreadable files silently
+					}
+				}
+				return {
+					content: [textPart(matches.join("\n") || "No matches")],
+					isError: false,
+				}
+			} catch (e) {
+				return {
+					content: [textPart(`Error: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+/**
+ * Tool for listing directory entries.
+ */
+export function lsTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "ls",
+			description: "List directory contents.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: { type: "string", description: "Directory to list (default .)" },
+				},
+				required: [],
+			},
+		},
+		async execute(args): Promise<ToolResult> {
+			try {
+				const dir = resolve(cwd, (args.path as string) || ".")
+				const entries = await readdir(dir, { withFileTypes: true })
+				const lines = entries.map((e) => {
+					const suffix = e.isDirectory() ? "/" : e.isSymbolicLink() ? "@" : ""
+					return `${e.name}${suffix}`
+				})
+				return { content: [textPart(lines.join("\n") || "(empty)")], isError: false }
+			} catch (e) {
+				return {
+					content: [textPart(`Error: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+/**
+ * Tool for visualizing a truncated directory tree.
+ */
+export function treeTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "tree",
+			description:
+				"Print a visual directory tree structure, ignoring common ignored folders like node_modules and .git.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: { type: "string", description: "Directory to start tree from (default .)" },
+					depth: { type: "number", description: "Maximum depth to traverse (default 3)" },
+				},
+				required: [],
+			},
+		},
+		async execute(args): Promise<ToolResult> {
+			try {
+				const startDir = resolve(cwd, (args.path as string) || ".")
+				const maxDepth = Number(args.depth ?? 3) || 3
+
+				const ignoreList = new Set([
+					".git",
+					"node_modules",
+					"dist",
+					"build",
+					".svelte-kit",
+					".next",
+					"out",
+					".scannerwork",
+					"coverage",
+				])
+
+				async function walk(dir: string, currentDepth: number, prefix: string): Promise<string> {
+					if (currentDepth > maxDepth) return ""
+					let result = ""
+
+					const entries = await readdir(dir, { withFileTypes: true })
+					const sorted = entries
+						.filter((e) => !ignoreList.has(e.name))
+						.sort((a, b) => {
+							if (a.isDirectory() && !b.isDirectory()) return -1
+							if (!a.isDirectory() && b.isDirectory()) return 1
+							return a.name.localeCompare(b.name)
+						})
+
+					for (let i = 0; i < sorted.length; i++) {
+						const entry = sorted[i]!
+						const isLast = i === sorted.length - 1
+						const connector = isLast ? "└── " : "├── "
+						const childPrefix = prefix + (isLast ? "    " : "│   ")
+
+						result += `${prefix}${connector}${entry.name}${entry.isDirectory() ? "/" : ""}\n`
+
+						if (entry.isDirectory()) {
+							result += await walk(resolve(dir, entry.name), currentDepth + 1, childPrefix)
+						}
+					}
+					return result
+				}
+
+				const treeText = await walk(startDir, 1, "")
+				return { content: [textPart(treeText || "(empty)")], isError: false }
+			} catch (e) {
+				return {
+					content: [textPart(`Error: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}

package/src/tools/shell.ts

@@ -0,0 +1,89 @@
+/**
+ * Tool for executing shell commands within the project root.
+ * Supports timeouts and output truncation to protect the context window.
+ */
+import type { Tool, ToolResult } from "../types.ts"
+
+import { textPart } from "../util.ts"
+
+export function bashTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "bash",
+			description:
+				"Execute a shell command. Returns stdout and stderr. Timeout after N seconds (default 120).",
+			parameters: {
+				type: "object",
+				properties: {
+					command: { type: "string", description: "Shell command to run" },
+					timeout: { type: "number", description: "Timeout in seconds (default 120)" },
+				},
+				required: ["command"],
+			},
+		},
+		async execute(args, signal): Promise<ToolResult> {
+			const command = args.command as string
+			const timeoutMs = (Number(args.timeout) || 120) * 1000
+
+			try {
+				const proc = Bun.spawn(["sh", "-c", command], {
+					cwd,
+					stdout: "pipe",
+					stderr: "pipe",
+				})
+
+				// Start reading pipes immediately so they don't block the process
+				const stdoutPromise = new Response(proc.stdout).text()
+				const stderrPromise = new Response(proc.stderr).text()
+
+				// Track whether we killed it vs normal exit, so the output reflects the cause
+				let killed = false
+				const timer = setTimeout(() => {
+					killed = true
+					proc.kill(9) // SIGKILL to be more aggressive against orphans
+				}, timeoutMs)
+
+				const onAbort = () => {
+					killed = true
+					proc.kill(9)
+				}
+				signal?.addEventListener("abort", onAbort, { once: true })
+
+				const exitCode = await proc.exited
+				clearTimeout(timer)
+				signal?.removeEventListener("abort", onAbort)
+
+				// After exitCode, pipes should close. We give them a tiny grace period
+				// to avoid hanging on orphans.
+				const stdout = await Promise.race([
+					stdoutPromise,
+					new Promise<string>((r) => setTimeout(() => r(""), 500)),
+				])
+				const stderr = await Promise.race([
+					stderrPromise,
+					new Promise<string>((r) => setTimeout(() => r(""), 500)),
+				])
+
+				// Prevent context-window blowout from noisy commands
+				const MAX = 50_000
+				let out = ""
+				if (stdout) out += stdout.slice(0, MAX)
+				if (stderr) {
+					if (out) out += "\n"
+					out += stderr.slice(0, MAX - out.length)
+				}
+				if (out.length >= MAX) out += `\n…truncated`
+
+				if (killed) out += `\n[timeout after ${timeoutMs / 1000}s]`
+				out += `\n[exit ${exitCode}]`
+
+				return { content: [textPart(out)], isError: exitCode !== 0 || killed }
+			} catch (e) {
+				return {
+					content: [textPart(`Error: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}

package/src/tools/web.ts

@@ -0,0 +1,239 @@
+/**
+ * Web tools for searching and fetching internet content.
+ * Uses DuckDuckGo HTML for search (no API key needed) and Bun's built-in
+ * fetch for reading URLs.
+ */
+import type { Tool, ToolResult } from "../types.ts"
+import { textPart } from "../util.ts"
+
+const MAX_CONTENT = 50_000
+
+// Minimal HTML → plaintext: strips tags, decodes entities, collapses whitespace
+function htmlToText(html: string): string {
+	let text = html
+		// Remove HTML comments
+		.replace(/<!--[\s\S]*?-->/g, "")
+		// Remove script and style blocks entirely
+		.replace(/<script[\s\S]*?<\/script>/gi, "")
+		.replace(/<style[\s\S]*?<\/style>/gi, "")
+		// Keep link hrefs visible (supports single, double, or no quotes)
+		.replace(/<a[^>]*href=["']?([^"'>\s]*)["']?[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)")
+		// Block-level tags → newlines
+		.replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote|pre|hr)[^>]*>/gi, "\n")
+		// Remove remaining tags
+		.replace(/<[^>]+>/g, "")
+		// Decode common HTML entities (both named and numeric, single/double quotes)
+		.replace(/&amp;/g, "&")
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&quot;/g, '"')
+		.replace(/&#34;/g, '"')
+		.replace(/&#x22;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/&#x27;/g, "'")
+		.replace(/&apos;/g, "'")
+		.replace(/&ldquo;/g, '"')
+		.replace(/&rdquo;/g, '"')
+		.replace(/&lsquo;/g, "'")
+		.replace(/&rsquo;/g, "'")
+		.replace(/&nbsp;/g, " ")
+		// Collapse whitespace but keep paragraph breaks
+		.replace(/[ \t]+/g, " ")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim()
+
+	if (text.length > MAX_CONTENT) {
+		text = `${text.slice(0, MAX_CONTENT)}\n…truncated`
+	}
+	return text
+}
+
+export function webSearchTool(): Tool {
+	return {
+		def: {
+			name: "web_search",
+			description:
+				"Search the web using DuckDuckGo. Returns up to 10 results with titles, URLs, and snippets. Use this when you need information from the internet.",
+			parameters: {
+				type: "object",
+				properties: {
+					query: { type: "string", description: "Search query" },
+				},
+				required: ["query"],
+			},
+		},
+		async execute(args, signal): Promise<ToolResult> {
+			const query = args.query as string
+			if (!query.trim()) {
+				return { content: [textPart("Error: empty search query")], isError: true }
+			}
+
+			try {
+				const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`
+				const resp = await fetch(url, {
+					signal: signal ?? undefined,
+					headers: {
+						"User-Agent":
+							"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+					},
+				})
+
+				if (!resp.ok) {
+					return {
+						content: [textPart(`Search failed: HTTP ${resp.status}`)],
+						isError: true,
+					}
+				}
+
+				const html = await resp.text()
+
+				// Split HTML into blocks by result__body to isolate each search result safely
+				const blocks: string[] = []
+				const containerRegex = /<div[^>]*class="[^"]*result__body[^"]*"[^>]*>/gi
+				const indices: number[] = []
+				for (const match of html.matchAll(containerRegex)) {
+					if (match.index !== undefined) {
+						indices.push(match.index)
+					}
+				}
+
+				if (indices.length > 0) {
+					for (let i = 0; i < indices.length; i++) {
+						const start = indices[i]!
+						const end = indices[i + 1] ?? html.length
+						blocks.push(html.slice(start, end))
+					}
+				}
+
+				const results: string[] = []
+				const titleRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i
+				const snippetRegex = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i
+
+				for (const block of blocks) {
+					if (results.length >= 10) break
+
+					const titleMatch = titleRegex.exec(block)
+					if (!titleMatch) continue
+
+					const rawUrl = titleMatch[1]!
+					const title = htmlToText(titleMatch[2]!)
+
+					const snippetMatch = snippetRegex.exec(block)
+					const snippet = snippetMatch ? htmlToText(snippetMatch[1]!) : ""
+
+					// DuckDuckGo wraps URLs through a redirect; extract the actual URL
+					let cleanUrl = rawUrl
+					try {
+						// Prepend protocol/host if DuckDuckGo returns a relative path or protocol-relative URL
+						const urlToParse = rawUrl.startsWith("//")
+							? `https:${rawUrl}`
+							: rawUrl.startsWith("/")
+								? `https://duckduckgo.com${rawUrl}`
+								: rawUrl
+						const param = new URL(urlToParse).searchParams.get("uddg")
+						if (param) cleanUrl = param
+					} catch {
+						// Not a redirect URL, use as-is
+					}
+
+					results.push(`## ${title}\n${cleanUrl}\n${snippet}`)
+				}
+
+				if (results.length === 0) {
+					return { content: [textPart("No results found.")], isError: false }
+				}
+
+				return {
+					content: [textPart(results.join("\n\n"))],
+					isError: false,
+				}
+			} catch (e) {
+				const msg = (e as Error).message
+				if (msg.includes("abort")) {
+					return { content: [textPart("Search aborted.")], isError: true }
+				}
+				return {
+					content: [textPart(`Search error: ${msg}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+export function webFetchTool(): Tool {
+	return {
+		def: {
+			name: "web_fetch",
+			description:
+				"Fetch and read the content of a web page. Returns the page text with HTML tags stripped. Useful for reading documentation, articles, or API references.",
+			parameters: {
+				type: "object",
+				properties: {
+					url: { type: "string", description: "URL to fetch" },
+				},
+				required: ["url"],
+			},
+		},
+		async execute(args, signal): Promise<ToolResult> {
+			const url = args.url as string
+			if (!url.trim()) {
+				return { content: [textPart("Error: empty URL")], isError: true }
+			}
+
+			try {
+				new URL(url)
+			} catch {
+				return { content: [textPart(`Error: invalid URL: ${url}`)], isError: true }
+			}
+
+			try {
+				const resp = await fetch(url, {
+					signal: signal ?? undefined,
+					headers: {
+						"User-Agent":
+							"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+						Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+					},
+					redirect: "follow",
+				})
+
+				if (!resp.ok) {
+					return {
+						content: [textPart(`Fetch failed: HTTP ${resp.status} ${resp.statusText}`)],
+						isError: true,
+					}
+				}
+
+				const contentType = (resp.headers.get("content-type") ?? "").toLowerCase()
+				const body = await resp.text()
+
+				// Sniff HTML: check content-type or if body has HTML markup signature
+				const isHtml =
+					contentType.includes("text/html") ||
+					contentType.includes("application/xhtml+xml") ||
+					body.trim().toLowerCase().startsWith("<!doctype html") ||
+					body.trim().toLowerCase().startsWith("<html")
+
+				if (isHtml) {
+					const text = htmlToText(body)
+					return { content: [textPart(text)], isError: false }
+				}
+
+				// For plain text, JSON, etc. return as-is (truncated if needed)
+				const truncated =
+					body.length > MAX_CONTENT ? `${body.slice(0, MAX_CONTENT)}\n…truncated` : body
+				return { content: [textPart(truncated)], isError: false }
+			} catch (e) {
+				const msg = (e as Error).message
+				if (msg.includes("abort")) {
+					return { content: [textPart("Fetch aborted.")], isError: true }
+				}
+				return {
+					content: [textPart(`Fetch error: ${msg}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}