novacode 0.5.5 → 0.7.0

package/src/provider/stream.ts

@@ -1,138 +0,0 @@
-import type { AgentEvent, ApiFormat, AssistantResult, StreamFn, StreamOpts } from "../types.ts"
-import { streamGemini } from "./gemini.ts"
-import { streamOpenAI } from "./openai.ts"
-
-export type { AssistantResult, StreamEvent, StreamFn, StreamOpts } from "../types.ts"
-
-/*
- * 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) {
-				yield item
-			}
-		}
-	}
-
-	get result(): R | undefined {
-		return this.#result
-	}
-
-	get isDone(): boolean {
-		return this.#done
-	}
-}
-
-// Internal map of registered provider implementations
-const registry = new Map<ApiFormat, StreamFn>([
-	["openai", streamOpenAI],
-	["gemini", streamGemini],
-])
-
-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/session/compact.ts

@@ -1,126 +0,0 @@
-import { getProvider } from "../config/providers.ts"
-import { stream } from "../provider/stream.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

@@ -1,229 +0,0 @@
-import { unlinkSync } from "node:fs"
-import { join } from "node:path"
-import BetterSqlite3 from "better-sqlite3"
-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: BetterSqlite3.Database
-
-	constructor(dbPath: string) {
-		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 {
-		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()
-	}
-
-	#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

@@ -1,189 +0,0 @@
-/**
- * Filesystem tools for reading, writing, and editing files.
- * Includes safety checks to prevent path traversal.
- */
-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"
-
-// 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)
-				// Return images as base64 so the LLM can process them visually
-				const ext = extname(filePath).toLowerCase()
-				if (IMAGES.has(ext)) {
-					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 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
-				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 writeFile(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)
-				let content: string
-				try {
-					content = await readFile(filePath, "utf-8")
-				} catch {
-					return { content: [textPart(`File not found: ${args.path}`)], isError: true }
-				}
-				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 writeFile(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,
-				}
-			}
-		},
-	}
-}