novacode 0.5.2 → 0.5.5

package/src/session/store.ts

@@ -1,5 +1,6 @@
-import { Database } from "bun:sqlite"
+import { unlinkSync } from "node:fs"
 import { join } from "node:path"
+import BetterSqlite3 from "better-sqlite3"
 import type { Msg, Session } from "../types.ts"
 
 const SCHEMA = `
@@ -40,13 +41,35 @@ function generateId(): string {
 }
 
 export class SessionStore {
-	#db: Database
+	#db: BetterSqlite3.Database
 
 	constructor(dbPath: string) {
-		this.#db = new Database(dbPath, { create: true })
-		this.#db.run("PRAGMA journal_mode = WAL")
-		this.#db.run("PRAGMA foreign_keys = ON")
-		this.#db.exec(SCHEMA)
+		this.#db = SessionStore.#open(dbPath)
+	}
+
+	// Opens and fully initialises the DB. If anything throws (e.g. corrupt file),
+	// the bad file is deleted and a fresh DB is created and returned.
+	static #open(dbPath: string): BetterSqlite3.Database {
+		const init = (db: BetterSqlite3.Database) => {
+			db.pragma("journal_mode = WAL")
+			db.pragma("foreign_keys = ON")
+			db.exec(SCHEMA)
+			return db
+		}
+		try {
+			return init(new BetterSqlite3(dbPath))
+		} catch {
+			// Delete the main DB and WAL sidecar files — all three must go or
+			// SQLite will fail again trying to replay a corrupt WAL on reopen.
+			for (const f of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+				try {
+					unlinkSync(f)
+				} catch {
+					// file may already be absent — ignore
+				}
+			}
+			return init(new BetterSqlite3(dbPath))
+		}
 	}
 
 	create(cwd: string, model: string, provider: string): Session {
@@ -57,13 +80,13 @@ export class SessionStore {
 				"INSERT INTO sessions (id, cwd, model, provider, title, created, updated) VALUES ($id, $cwd, $model, $provider, $title, $created, $updated)",
 			)
 			.run({
-				$id: id,
-				$cwd: cwd,
-				$model: model,
-				$provider: provider,
-				$title: null,
-				$created: now,
-				$updated: now,
+				id: id,
+				cwd: cwd,
+				model: model,
+				provider: provider,
+				title: null,
+				created: now,
+				updated: now,
 			})
 		return { id, cwd, model, provider, title: null, created: now, updated: now }
 	}
@@ -74,7 +97,7 @@ export class SessionStore {
 				.prepare(
 					"SELECT id, cwd, model, provider, title, created, updated FROM sessions WHERE id = $id",
 				)
-				.get({ $id: id }) as Session | null) ?? null
+				.get({ id: id }) as Session | null) ?? null
 		)
 	}
 
@@ -83,11 +106,11 @@ export class SessionStore {
 			.prepare(
 				"SELECT id, cwd, model, provider, title, created, updated FROM sessions ORDER BY updated DESC LIMIT $limit",
 			)
-			.all({ $limit: limit }) as Session[]
+			.all({ limit: limit }) as Session[]
 	}
 
 	delete(id: string): boolean {
-		const result = this.#db.prepare("DELETE FROM sessions WHERE id = $id").run({ $id: id })
+		const result = this.#db.prepare("DELETE FROM sessions WHERE id = $id").run({ id: id })
 		return result.changes > 0
 	}
 
@@ -98,15 +121,15 @@ export class SessionStore {
 				"INSERT INTO messages (session_id, seq, role, content, ts) VALUES ($sid, $seq, $role, $content, $ts)",
 			)
 			.run({
-				$sid: sessionId,
-				$seq: seq,
-				$role: msg.role,
-				$content: JSON.stringify(msg),
-				$ts: msg.ts,
+				sid: sessionId,
+				seq: seq,
+				role: msg.role,
+				content: JSON.stringify(msg),
+				ts: msg.ts,
 			})
 		this.#db
 			.prepare("UPDATE sessions SET updated = $now WHERE id = $id")
-			.run({ $now: Date.now(), $id: sessionId })
+			.run({ now: Date.now(), id: sessionId })
 	}
 
 	appendMany(sessionId: string, msgs: Msg[]): void {
@@ -121,7 +144,7 @@ export class SessionStore {
 	messages(sessionId: string): Msg[] {
 		const rows = this.#db
 			.prepare("SELECT content FROM messages WHERE session_id = $sid ORDER BY seq ASC")
-			.all({ $sid: sessionId }) as { content: string }[]
+			.all({ sid: sessionId }) as { content: string }[]
 		return rows.map((r) => JSON.parse(r.content) as Msg)
 	}
 
@@ -130,20 +153,20 @@ export class SessionStore {
 			.prepare(
 				"SELECT content FROM messages WHERE session_id = $sid AND seq > $seq ORDER BY seq ASC",
 			)
-			.all({ $sid: sessionId, $seq: afterSeq }) as { content: string }[]
+			.all({ sid: sessionId, seq: afterSeq }) as { content: string }[]
 		return rows.map((r) => JSON.parse(r.content) as Msg)
 	}
 
 	setTitle(sessionId: string, title: string): void {
 		this.#db
 			.prepare("UPDATE sessions SET title = $title WHERE id = $id")
-			.run({ $title: title, $id: sessionId })
+			.run({ title: title, id: sessionId })
 	}
 
 	messageCount(sessionId: string): number {
 		const row = this.#db
 			.prepare("SELECT COUNT(*) as count FROM messages WHERE session_id = $sid")
-			.get({ $sid: sessionId }) as { count: number }
+			.get({ sid: sessionId }) as { count: number }
 		return row.count
 	}
 
@@ -159,12 +182,12 @@ export class SessionStore {
 				"INSERT INTO compactions (session_id, summary, files_read, files_wrote, seq_before, ts) VALUES ($sid, $summary, $read, $wrote, $seq, $ts)",
 			)
 			.run({
-				$sid: sessionId,
-				$summary: summary,
-				$read: JSON.stringify(filesRead),
-				$wrote: JSON.stringify(filesWrote),
-				$seq: seqBefore,
-				$ts: Date.now(),
+				sid: sessionId,
+				summary: summary,
+				read: JSON.stringify(filesRead),
+				wrote: JSON.stringify(filesWrote),
+				seq: seqBefore,
+				ts: Date.now(),
 			})
 	}
 
@@ -174,24 +197,24 @@ export class SessionStore {
 				.prepare(
 					"SELECT summary, seq_before FROM compactions WHERE session_id = $sid ORDER BY ts DESC LIMIT 1",
 				)
-				.get({ $sid: sessionId }) as { summary: string; seqBefore: number } | null) ?? null
+				.get({ sid: sessionId }) as { summary: string; seqBefore: number } | null) ?? null
 		)
 	}
 
 	truncateBeforeSeq(sessionId: string, seq: number): void {
 		this.#db
 			.prepare("DELETE FROM messages WHERE session_id = $sid AND seq < $seq")
-			.run({ $sid: sessionId, $seq: seq })
+			.run({ sid: sessionId, seq: seq })
 	}
 
 	close(): void {
-		this.#db.close(false)
+		this.#db.close()
 	}
 
 	#nextSeq(sessionId: string): number {
 		const row = this.#db
 			.prepare("SELECT MAX(seq) as maxSeq FROM messages WHERE session_id = $sid")
-			.get({ $sid: sessionId }) as { maxSeq: number | null }
+			.get({ sid: sessionId }) as { maxSeq: number | null }
 		return (row.maxSeq ?? 0) + 1
 	}
 }

package/src/tools/fs.ts

@@ -2,7 +2,7 @@
  * Filesystem tools for reading, writing, and editing files.
  * Includes safety checks to prevent path traversal.
  */
-import { mkdir } from "node:fs/promises"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
 import { dirname, extname, resolve } from "node:path"
 import type { Tool, ToolResult } from "../types.ts"
 import { getRelativeIfInside, textPart } from "../util.ts"
@@ -37,22 +37,16 @@ export function readTool(cwd: string): Tool {
 		async execute(args): Promise<ToolResult> {
 			try {
 				const filePath = safePath(cwd, args.path as string)
-				const relPath = getRelativeIfInside(cwd, filePath)
-				const file = Bun.file(filePath)
-				if (!(await file.exists())) {
-					return { content: [textPart(`File not found: ${relPath}`)], isError: true }
-				}
-
 				// Return images as base64 so the LLM can process them visually
 				const ext = extname(filePath).toLowerCase()
 				if (IMAGES.has(ext)) {
-					const buf = await file.arrayBuffer()
-					const b64 = Buffer.from(buf).toString("base64")
+					const buf = await readFile(filePath)
+					const b64 = buf.toString("base64")
 					const mime = ext === ".jpg" ? "image/jpeg" : `image/${ext.slice(1)}`
 					return { content: [{ type: "image", data: b64, mime }], isError: false }
 				}
 
-				const content = await file.text()
+				const content = await readFile(filePath, "utf-8")
 				const lines = content.split("\n")
 				const offset = Math.max(0, (Number(args.offset ?? 1) || 1) - 1)
 				const limit = Number(args.limit ?? 2000) || 2000
@@ -92,7 +86,7 @@ export function writeTool(cwd: string): Tool {
 				const filePath = safePath(cwd, args.path as string)
 				const content = args.content as string
 				await mkdir(dirname(filePath), { recursive: true })
-				await Bun.write(filePath, content)
+				await writeFile(filePath, content)
 				const relPath = getRelativeIfInside(cwd, filePath)
 				return {
 					content: [textPart(`Wrote ${content.length} bytes → ${relPath}`)],
@@ -139,12 +133,12 @@ export function editTool(cwd: string): Tool {
 		async execute(args): Promise<ToolResult> {
 			try {
 				const filePath = safePath(cwd, args.path as string)
-				const file = Bun.file(filePath)
-				if (!(await file.exists())) {
+				let content: string
+				try {
+					content = await readFile(filePath, "utf-8")
+				} catch {
 					return { content: [textPart(`File not found: ${args.path}`)], isError: true }
 				}
-
-				let content = await file.text()
 				const edits = args.edits as Array<{ oldText: string; newText: string }>
 
 				// Validate all edits before applying any — avoids partial writes on bad input
@@ -174,7 +168,7 @@ export function editTool(cwd: string): Tool {
 					content = content.replace(edit.oldText, edit.newText)
 				}
 
-				await Bun.write(filePath, content)
+				await writeFile(filePath, content)
 				const relPath = getRelativeIfInside(cwd, filePath)
 				return {
 					content: [

package/src/tools/git.ts

@@ -1,6 +1,7 @@
 /**
  * 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"
 
@@ -41,21 +42,37 @@ export function gitTool(cwd: string): Tool {
 
 			try {
 				const cmd = ["git", action, ...extraArgs]
-				const proc = Bun.spawn(cmd, {
+				const proc = spawn(cmd[0]!, cmd.slice(1), {
 					cwd,
-					stdout: "pipe",
-					stderr: "pipe",
+					stdio: ["ignore", "pipe", "pipe"],
 					env: { ...process.env, PAGER: "cat" },
 				})
 
-				const onAbort = () => proc.kill()
-				signal?.addEventListener("abort", onAbort, { once: true })
+				let stdout = ""
+				let stderr = ""
+				proc.stdout.on("data", (chunk: Buffer) => {
+					stdout += chunk.toString()
+				})
+				proc.stderr.on("data", (chunk: Buffer) => {
+					stderr += chunk.toString()
+				})
 
-				const exitCode = await proc.exited
-				signal?.removeEventListener("abort", onAbort)
+				const onAbort = () => {
+					proc.kill("SIGKILL")
+					proc.stdout.destroy()
+					proc.stderr.destroy()
+				}
+				signal?.addEventListener("abort", onAbort, { once: true })
 
-				const stdout = await new Response(proc.stdout).text()
-				const stderr = await new Response(proc.stderr).text()
+				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

package/src/tools/search.ts

@@ -2,7 +2,9 @@
  * 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 { 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"
@@ -91,18 +93,35 @@ export function grepTool(cwd: string): Tool {
 					if (globFilter) cmd.push(`--glob=${globFilter}`)
 					cmd.push("--", pattern, relSearchPath)
 
-					const proc = Bun.spawn(cmd, {
+					const proc = spawn(cmd[0]!, cmd.slice(1), {
 						cwd,
-						stdout: "pipe",
-						stderr: "pipe",
+						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()
 					})
-					signal?.addEventListener("abort", () => proc.kill(), { once: true })
-					const exitCode = await proc.exited
-					signal?.removeEventListener("abort", () => proc.kill())
+
+					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 out = await new Response(proc.stdout).text()
-						const lines = out.split("\n").slice(0, 200).join("\n")
+						const lines = stdout.split("\n").slice(0, 200).join("\n")
 						return { content: [textPart(lines || "No matches")], isError: false }
 					}
 				} catch {
@@ -110,14 +129,17 @@ export function grepTool(cwd: string): Tool {
 				}
 
 				// Pure JS fallback when rg is not available
-				const files = await glob(globFilter || "**/*", { cwd: dir })
+				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 Bun.file(resolve(dir, file)).text()
+						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]

package/src/tools/shell.ts

@@ -2,6 +2,7 @@
  * 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"
@@ -26,43 +27,43 @@ export function bashTool(cwd: string): Tool {
 			const timeoutMs = (Number(args.timeout) || 120) * 1000
 
 			try {
-				const proc = Bun.spawn(["sh", "-c", command], {
-					cwd,
-					stdout: "pipe",
-					stderr: "pipe",
-				})
+				const proc = spawn("sh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "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()
+				let stdout = ""
+				let stderr = ""
+				proc.stdout.on("data", (chunk: Buffer) => {
+					stdout += chunk.toString()
+				})
+				proc.stderr.on("data", (chunk: Buffer) => {
+					stderr += chunk.toString()
+				})
 
-				// 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
+					proc.kill("SIGKILL")
+					proc.stdout.destroy()
+					proc.stderr.destroy()
 				}, timeoutMs)
 
 				const onAbort = () => {
 					killed = true
-					proc.kill(9)
+					proc.kill("SIGKILL")
+					proc.stdout.destroy()
+					proc.stderr.destroy()
 				}
 				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)),
-				])
+				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