novacode 0.2.0

package/src/provider/registry.ts

@@ -0,0 +1,62 @@
+/**
+ * Registry for different model providers (OpenAI, Anthropic, etc.).
+ * Provides a unified streaming interface for the agent loop.
+ */
+import type { AgentEvent, ApiFormat, AssistantResult, StreamFn, StreamOpts } from "../types.ts"
+import { EventStream } from "./stream.ts"
+
+export type { AssistantResult, StreamEvent, StreamFn, StreamOpts } from "../types.ts"
+
+// Internal map of registered provider implementations
+const registry = new Map<ApiFormat, StreamFn>()
+
+export function register(api: ApiFormat, fn: StreamFn): void {
+	registry.set(api, fn)
+}
+
+// Bridges provider-specific StreamEvents into AgentEvents so the loop and TUI deal with one type.
+export function stream(opts: StreamOpts): EventStream<AgentEvent, AssistantResult> {
+	const fn = registry.get(opts.api)
+	if (!fn) throw new Error(`No provider registered for API format: ${opts.api}`)
+
+	// Bridge layer: converts provider-specific StreamEvents into the agent's
+	// AgentEvent shape, so the loop and TUI only deal with one event type.
+	const providerStream = fn(opts)
+	const agentStream = new EventStream<AgentEvent, AssistantResult>()
+
+	;(async () => {
+		for await (const event of providerStream) {
+			if (event.type === "text_delta") {
+				agentStream.push({ type: "text_delta", text: event.text ?? "" })
+			} else if (event.type === "thinking_delta") {
+				agentStream.push({ type: "thinking_delta", text: event.text ?? "" })
+			} else if (event.type === "tool_call" && event.call) {
+				agentStream.push({
+					type: "tool_call",
+					call: {
+						type: "tool_call",
+						id: event.call.id,
+						name: event.call.name,
+						args: event.call.args,
+					},
+				})
+			} else if (event.type === "usage" && event.usage) {
+				agentStream.push({ type: "usage", usage: event.usage })
+			}
+		}
+
+		const res = providerStream.result
+		if (res) {
+			agentStream.finish(res)
+		} else {
+			// Fallback for unexpected closure
+			agentStream.finish({ content: [], usage: { in: 0, out: 0 }, stop: "stop" })
+		}
+	})()
+
+	return agentStream
+}
+
+export function getRegisteredApis(): ApiFormat[] {
+	return [...registry.keys()]
+}

package/src/provider/stream.ts

@@ -0,0 +1,77 @@
+/*
+ * Push-based async event stream.
+ *
+ * Producers call push()/finish(). Consumers iterate with for-await-of.
+ * Backpressure is implicit: push() resolves immediately; the iterator
+ * awaits the next value only when the consumer asks for it.
+ */
+export class EventStream<T, R> {
+	#events: T[] = []
+	#done = false
+	#result?: R
+	#resolve?: (value: T) => void
+	#doneResolve?: (value: R) => void
+	#abort = false
+
+	push(event: T): void {
+		if (this.#abort) return
+		// If a consumer is already waiting, deliver directly — skip the queue
+		if (this.#resolve) {
+			const resolve = this.#resolve
+			this.#resolve = undefined
+			resolve(event)
+		} else {
+			this.#events.push(event)
+		}
+	}
+
+	finish(result: R): void {
+		this.#done = true
+		this.#result = result
+		// Wake up a suspended iterator so it can see done=true and exit
+		if (this.#resolve) {
+			// undefined is a sentinel — the iterator loop checks done after waking
+			this.#resolve(undefined as T)
+		}
+		if (this.#doneResolve) {
+			this.#doneResolve(result)
+		}
+	}
+
+	abort(): void {
+		this.#abort = true
+		this.#done = true
+		if (this.#resolve) {
+			this.#resolve(undefined as T)
+		}
+		if (this.#doneResolve) {
+			this.#doneResolve(undefined as R)
+		}
+	}
+
+	async *[Symbol.asyncIterator](): AsyncGenerator<T> {
+		while (!this.#done || this.#events.length > 0) {
+			if (this.#events.length > 0) {
+				yield this.#events.shift() as T
+				continue
+			}
+			if (this.#done) break
+			const item = await new Promise<T | undefined>((resolve) => {
+				this.#resolve = resolve as (value: T) => void
+			})
+			if (item !== undefined && this.#events.length === 0) {
+				yield item
+			} else if (this.#events.length > 0) {
+				yield this.#events.shift() as T
+			}
+		}
+	}
+
+	get result(): R | undefined {
+		return this.#result
+	}
+
+	get isDone(): boolean {
+		return this.#done
+	}
+}

package/src/session/compact.ts

@@ -0,0 +1,126 @@
+import { getProvider } from "../config/providers.ts"
+import { stream } from "../provider/registry.ts"
+import type { Model, Msg } from "../types.ts"
+import { estimateTokens } from "../util.ts"
+import type { SessionStore } from "./store.ts"
+
+const COMPACT_THRESHOLD = 0.8
+const KEEP_RECENT = 10
+
+function extractText(msg: Msg): string {
+	if (typeof msg.content === "string") return msg.content
+	return msg.content
+		.filter((c) => c.type === "text")
+		.map((c) => (c.type === "text" ? c.text : ""))
+		.join("")
+}
+
+function extractToolFiles(msg: Msg, toolName: string): string[] {
+	if (msg.role !== "tool_result") return []
+	if (!("tool" in msg) || msg.tool !== toolName) return []
+	const text = extractText(msg)
+	// Extract file paths from tool result content
+	const lines = text.split("\n")
+	return lines.filter((l) => l.trim().length > 0)
+}
+
+export interface CompactResult {
+	compacted: boolean
+	summary?: string
+	msgsRemoved: number
+}
+
+export function needsCompact(messages: Msg[], contextWindow: number): boolean {
+	return estimateTokens(messages) > contextWindow * COMPACT_THRESHOLD
+}
+
+export async function compact(
+	store: SessionStore,
+	sessionId: string,
+	messages: Msg[],
+	model: Model,
+	apiKey: string,
+	baseUrl: string,
+): Promise<CompactResult> {
+	if (!needsCompact(messages, model.contextWindow)) {
+		return { compacted: false, msgsRemoved: 0 }
+	}
+
+	const old = messages.slice(0, -KEEP_RECENT)
+	if (old.length === 0) {
+		return { compacted: false, msgsRemoved: 0 }
+	}
+	const convo = old
+		.map((m) => {
+			if (m.role === "user") return `User: ${extractText(m)}`
+			if (m.role === "assistant") return `Assistant: ${extractText(m)}`
+			if (m.role === "tool_result" && "tool" in m)
+				return `Tool(${m.tool}): ${extractText(m).slice(0, 200)}`
+			return ""
+		})
+		.join("\n\n")
+
+	const summary = await generateSummary(convo, model, apiKey, baseUrl)
+	if (!summary) {
+		return { compacted: false, msgsRemoved: 0 }
+	}
+
+	const filesRead: string[] = []
+	const filesWrote: string[] = []
+	for (const m of old) {
+		filesRead.push(...extractToolFiles(m, "read"))
+		filesRead.push(...extractToolFiles(m, "glob"))
+		filesWrote.push(...extractToolFiles(m, "write"))
+		filesWrote.push(...extractToolFiles(m, "edit"))
+	}
+
+	const seqBefore = old.length
+	store.saveCompaction(
+		sessionId,
+		summary,
+		[...new Set(filesRead)],
+		[...new Set(filesWrote)],
+		seqBefore,
+	)
+	store.truncateBeforeSeq(sessionId, seqBefore + 1)
+
+	// Insert the summary as a user message so the model retains context
+	const summaryMsg: Msg = {
+		role: "user",
+		content: `[Prior context summary]\n${summary}`,
+		ts: Date.now(),
+	}
+	store.append(sessionId, summaryMsg)
+
+	return { compacted: true, summary, msgsRemoved: old.length }
+}
+
+async function generateSummary(
+	convo: string,
+	model: Model,
+	apiKey: string,
+	baseUrl: string,
+): Promise<string | null> {
+	const provider = getProvider(model.provider)
+	if (!provider) return null
+
+	const es = stream({
+		api: provider.api,
+		model,
+		apiKey,
+		baseUrl,
+		system:
+			"Summarize this coding session concisely. Cover: what was asked, files touched, what was done, key decisions. Keep it under 300 words.",
+		messages: [{ role: "user", content: convo, ts: Date.now() }],
+		tools: [],
+	})
+
+	let summary = ""
+	for await (const ev of es) {
+		if (ev.type === "text_delta" && ev.text) {
+			summary += ev.text
+		}
+	}
+
+	return summary.trim() || null
+}

package/src/session/store.ts

@@ -0,0 +1,206 @@
+import { Database } from "bun:sqlite"
+import { join } from "node:path"
+import type { Msg, Session } from "../types.ts"
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+	id TEXT PRIMARY KEY,
+	cwd TEXT NOT NULL,
+	model TEXT NOT NULL,
+	provider TEXT NOT NULL,
+	title TEXT,
+	created INTEGER NOT NULL,
+	updated INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+	seq INTEGER NOT NULL,
+	role TEXT NOT NULL,
+	content TEXT NOT NULL,
+	ts INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, seq);
+
+CREATE TABLE IF NOT EXISTS compactions (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+	summary TEXT NOT NULL,
+	files_read TEXT NOT NULL DEFAULT '[]',
+	files_wrote TEXT NOT NULL DEFAULT '[]',
+	seq_before INTEGER NOT NULL,
+	ts INTEGER NOT NULL
+);
+`
+
+function generateId(): string {
+	return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`
+}
+
+export class SessionStore {
+	#db: 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)
+	}
+
+	create(cwd: string, model: string, provider: string): Session {
+		const id = generateId()
+		const now = Date.now()
+		this.#db
+			.prepare(
+				"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,
+			})
+		return { id, cwd, model, provider, title: null, created: now, updated: now }
+	}
+
+	get(id: string): Session | null {
+		return (
+			(this.#db
+				.prepare(
+					"SELECT id, cwd, model, provider, title, created, updated FROM sessions WHERE id = $id",
+				)
+				.get({ $id: id }) as Session | null) ?? null
+		)
+	}
+
+	list(limit = 50): Session[] {
+		return this.#db
+			.prepare(
+				"SELECT id, cwd, model, provider, title, created, updated FROM sessions ORDER BY updated DESC LIMIT $limit",
+			)
+			.all({ $limit: limit }) as Session[]
+	}
+
+	delete(id: string): boolean {
+		const result = this.#db.prepare("DELETE FROM sessions WHERE id = $id").run({ $id: id })
+		return result.changes > 0
+	}
+
+	append(sessionId: string, msg: Msg): void {
+		const seq = this.#nextSeq(sessionId)
+		this.#db
+			.prepare(
+				"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,
+			})
+		this.#db
+			.prepare("UPDATE sessions SET updated = $now WHERE id = $id")
+			.run({ $now: Date.now(), $id: sessionId })
+	}
+
+	appendMany(sessionId: string, msgs: Msg[]): void {
+		const tx = this.#db.transaction(() => {
+			for (const msg of msgs) {
+				this.append(sessionId, msg)
+			}
+		})
+		tx()
+	}
+
+	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 }[]
+		return rows.map((r) => JSON.parse(r.content) as Msg)
+	}
+
+	messagesAfter(sessionId: string, afterSeq: number): Msg[] {
+		const rows = this.#db
+			.prepare(
+				"SELECT content FROM messages WHERE session_id = $sid AND seq > $seq ORDER BY seq ASC",
+			)
+			.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 })
+	}
+
+	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 }
+		return row.count
+	}
+
+	saveCompaction(
+		sessionId: string,
+		summary: string,
+		filesRead: string[],
+		filesWrote: string[],
+		seqBefore: number,
+	): void {
+		this.#db
+			.prepare(
+				"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(),
+			})
+	}
+
+	getLatestCompaction(sessionId: string): { summary: string; seqBefore: number } | null {
+		return (
+			(this.#db
+				.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
+		)
+	}
+
+	truncateBeforeSeq(sessionId: string, seq: number): void {
+		this.#db
+			.prepare("DELETE FROM messages WHERE session_id = $sid AND seq < $seq")
+			.run({ $sid: sessionId, $seq: seq })
+	}
+
+	close(): void {
+		this.#db.close(false)
+	}
+
+	#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 }
+		return (row.maxSeq ?? 0) + 1
+	}
+}
+
+let _store: SessionStore | null = null
+
+export function getSessionStore(dir?: string): SessionStore {
+	if (_store) return _store
+	const dbPath = join(dir ?? join(process.env.HOME ?? "~", ".novacode"), "sessions.db")
+	_store = new SessionStore(dbPath)
+	return _store
+}

package/src/tools/fs.ts

@@ -0,0 +1,195 @@
+/**
+ * Filesystem tools for reading, writing, and editing files.
+ * Includes safety checks to prevent path traversal.
+ */
+import { mkdir } from "node:fs/promises"
+import { dirname, extname, resolve } from "node:path"
+import type { Tool, ToolResult } from "../types.ts"
+import { getRelativeIfInside, textPart } from "../util.ts"
+
+// Extensions we return as base64 images instead of text
+const IMAGES = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp"])
+
+function safePath(cwd: string, p: string): string {
+	const abs = resolve(cwd, p)
+	if (abs !== cwd && !abs.startsWith(`${cwd}/`)) {
+		throw new Error(`Path outside project: ${p}`)
+	}
+	return abs
+}
+
+export function readTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "read",
+			description:
+				"Read file contents. Supports text and images (jpg, png, gif, webp). Text output is truncated to 2000 lines.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: { type: "string", description: "Path to file (relative or absolute)" },
+					offset: { type: "number", description: "Start line (1-based, default 1)" },
+					limit: { type: "number", description: "Max lines to read (default 2000)" },
+				},
+				required: ["path"],
+			},
+		},
+		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 mime = ext === ".jpg" ? "image/jpeg" : `image/${ext.slice(1)}`
+					return { content: [{ type: "image", data: b64, mime }], isError: false }
+				}
+
+				const content = await file.text()
+				const lines = content.split("\n")
+				const offset = Math.max(0, (Number(args.offset ?? 1) || 1) - 1)
+				const limit = Number(args.limit ?? 2000) || 2000
+				const slice = lines.slice(offset, offset + limit)
+				const truncated = offset + limit < lines.length
+
+				const out = slice.join("\n")
+				const suffix = truncated ? `\n…${lines.length - offset - limit} more lines` : ""
+
+				return { content: [textPart(out + suffix)], isError: false }
+			} catch (e) {
+				return {
+					content: [textPart(`Error reading file: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+export function writeTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "write",
+			description: "Write content to a file. Creates the file and parent directories if needed.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: { type: "string", description: "Path to file" },
+					content: { type: "string", description: "Content to write" },
+				},
+				required: ["path", "content"],
+			},
+		},
+		async execute(args): Promise<ToolResult> {
+			try {
+				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)
+				const relPath = getRelativeIfInside(cwd, filePath)
+				return {
+					content: [textPart(`Wrote ${content.length} bytes → ${relPath}`)],
+					isError: false,
+				}
+			} catch (e) {
+				return {
+					content: [textPart(`Error writing file: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}
+
+// Requires oldText to be unique to avoid ambiguous replacements.
+export function editTool(cwd: string): Tool {
+	return {
+		def: {
+			name: "edit",
+			description:
+				"Edit a file using exact text replacement. Each edit's oldText must be unique in the file.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: { type: "string", description: "Path to file" },
+					edits: {
+						type: "array",
+						description:
+							"Array of {oldText, newText} replacements. oldText must be unique. Non-overlapping.",
+						items: {
+							type: "object",
+							properties: {
+								oldText: { type: "string", description: "Exact text to find (must be unique)" },
+								newText: { type: "string", description: "Replacement text" },
+							},
+							required: ["oldText", "newText"],
+						},
+					},
+				},
+				required: ["path", "edits"],
+			},
+		},
+		async execute(args): Promise<ToolResult> {
+			try {
+				const filePath = safePath(cwd, args.path as string)
+				const file = Bun.file(filePath)
+				if (!(await file.exists())) {
+					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
+				for (const edit of edits) {
+					const count = content.split(edit.oldText).length - 1
+					if (count === 0) {
+						return {
+							content: [textPart(`oldText not found: "${edit.oldText.slice(0, 80)}…"`)],
+							isError: true,
+						}
+					}
+					// Ambiguous match would replace the wrong occurrence
+					if (count > 1) {
+						return {
+							content: [
+								textPart(
+									`oldText found ${count} times — add surrounding context to make it unique: "${edit.oldText.slice(0, 60)}…"`,
+								),
+							],
+							isError: true,
+						}
+					}
+				}
+
+				// Apply edits sequentially
+				for (const edit of edits) {
+					content = content.replace(edit.oldText, edit.newText)
+				}
+
+				await Bun.write(filePath, content)
+				const relPath = getRelativeIfInside(cwd, filePath)
+				return {
+					content: [
+						textPart(
+							`Edited ${relPath} (${edits.length} replacement${edits.length > 1 ? "s" : ""})`,
+						),
+					],
+					isError: false,
+				}
+			} catch (e) {
+				return {
+					content: [textPart(`Error editing file: ${(e as Error).message}`)],
+					isError: true,
+				}
+			}
+		},
+	}
+}