novacode 0.6.0 → 0.8.0

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,
-				}
-			}
-		},
-	}
-}

package/src/tools/web.ts

@@ -1,239 +0,0 @@
-/**
- * Web tools for searching and fetching internet content.
- * Uses DuckDuckGo HTML for search (no API key needed) and Node'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,
-				}
-			}
-		},
-	}
-}