novacode 0.5.5 → 0.7.0

package/src/tools/git.ts

@@ -1,99 +0,0 @@
-/**
- * Git tools for executing safe repository operations programmatically.
- */
-import { spawn } from "node:child_process"
-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 = spawn(cmd[0]!, cmd.slice(1), {
-					cwd,
-					stdio: ["ignore", "pipe", "pipe"],
-					env: { ...process.env, PAGER: "cat" },
-				})
-
-				let stdout = ""
-				let stderr = ""
-				proc.stdout.on("data", (chunk: Buffer) => {
-					stdout += chunk.toString()
-				})
-				proc.stderr.on("data", (chunk: Buffer) => {
-					stderr += chunk.toString()
-				})
-
-				const onAbort = () => {
-					proc.kill("SIGKILL")
-					proc.stdout.destroy()
-					proc.stderr.destroy()
-				}
-				signal?.addEventListener("abort", onAbort, { once: true })
-
-				let exitCode: number
-				try {
-					exitCode = await new Promise<number>((resolve, reject) => {
-						proc.on("error", reject)
-						proc.on("close", (code) => resolve(code ?? -1))
-					})
-				} finally {
-					signal?.removeEventListener("abort", onAbort)
-				}
-
-				// 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

@@ -1,33 +0,0 @@
-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

@@ -1,274 +0,0 @@
-/**
- * Search tools for finding files and content.
- * Uses 'rg' (ripgrep) if available, falling back to a pure JS implementation.
- */
-
-import { spawn } from "node:child_process"
-import { readdir, readFile } 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 = spawn(cmd[0]!, cmd.slice(1), {
-						cwd,
-						stdio: ["ignore", "pipe", "pipe"],
-					})
-
-					const onAbort = () => {
-						proc.kill()
-						proc.stdout.destroy()
-						proc.stderr.destroy()
-					}
-					signal?.addEventListener("abort", onAbort, { once: true })
-
-					let stdout = ""
-					proc.stdout.on("data", (chunk: Buffer) => {
-						stdout += chunk.toString()
-					})
-
-					let exitCode: number
-					try {
-						exitCode = await new Promise<number>((resolve, reject) => {
-							proc.on("error", reject)
-							proc.on("close", (code) => resolve(code ?? -1))
-						})
-					} finally {
-						signal?.removeEventListener("abort", onAbort)
-					}
-
-					if (exitCode === 0) {
-						const lines = stdout.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,
-					ignore: ["**/node_modules/**", "**/.git/**"],
-				})
-				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 readFile(resolve(dir, file), "utf-8")
-						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

@@ -1,90 +0,0 @@
-/**
- * Tool for executing shell commands within the project root.
- * Supports timeouts and output truncation to protect the context window.
- */
-import { spawn } from "node:child_process"
-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 = spawn("sh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] })
-
-				let stdout = ""
-				let stderr = ""
-				proc.stdout.on("data", (chunk: Buffer) => {
-					stdout += chunk.toString()
-				})
-				proc.stderr.on("data", (chunk: Buffer) => {
-					stderr += chunk.toString()
-				})
-
-				let killed = false
-				const timer = setTimeout(() => {
-					killed = true
-					proc.kill("SIGKILL")
-					proc.stdout.destroy()
-					proc.stderr.destroy()
-				}, timeoutMs)
-
-				const onAbort = () => {
-					killed = true
-					proc.kill("SIGKILL")
-					proc.stdout.destroy()
-					proc.stderr.destroy()
-				}
-				signal?.addEventListener("abort", onAbort, { once: true })
-
-				let exitCode: number
-				try {
-					exitCode = await new Promise<number>((resolve, reject) => {
-						proc.on("error", reject)
-						proc.on("close", (code) => resolve(code ?? -1))
-					})
-				} finally {
-					clearTimeout(timer)
-					signal?.removeEventListener("abort", onAbort)
-				}
-
-				// 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,
-				}
-			}
-		},
-	}
-}