novacode 0.5.5 → 0.6.0

package/src/session/store.ts

@@ -1,229 +1,209 @@
-import { unlinkSync } from "node:fs"
+import { appendFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"
 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
-);
-`
+import type { Compaction, Msg, Session } from "../types.ts"
 
 function generateId(): string {
 	return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`
 }
 
 export class SessionStore {
-	#db: BetterSqlite3.Database
+	#sessionsDir: string
 
-	constructor(dbPath: string) {
-		this.#db = SessionStore.#open(dbPath)
+	constructor(sessionsDir: string) {
+		this.#sessionsDir = sessionsDir
 	}
 
-	// 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
+	#sessionDir(id: string): string {
+		return join(this.#sessionsDir, id)
+	}
+
+	#metadataPath(id: string): string {
+		return join(this.#sessionDir(id), "metadata.json")
+	}
+
+	#messagesPath(id: string): string {
+		return join(this.#sessionDir(id), "messages.jsonl")
+	}
+
+	#compactionPath(id: string): string {
+		return join(this.#sessionDir(id), "compaction.json")
+	}
+
+	async create(cwd: string, model: string, provider: string): Promise<Session> {
+		const id = generateId()
+		const now = Date.now()
+		const session: Session = {
+			id,
+			cwd,
+			model,
+			provider,
+			title: null,
+			created: now,
+			updated: now,
 		}
+
+		await mkdir(this.#sessionDir(id), { recursive: true })
+		await writeFile(this.#metadataPath(id), JSON.stringify(session, null, 2))
+		return session
+	}
+
+	async get(id: string): Promise<Session | null> {
 		try {
-			return init(new BetterSqlite3(dbPath))
+			const data = await readFile(this.#metadataPath(id), "utf-8")
+			return JSON.parse(data) as Session
 		} 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))
+			return null
 		}
 	}
 
-	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)
+	async list(limit = 10): Promise<Session[]> {
+		try {
+			const entries = await readdir(this.#sessionsDir, { withFileTypes: true })
+			const dirNames = entries
+				.filter((e) => e.isDirectory())
+				.map((e) => e.name)
+				.sort((a, b) => b.localeCompare(a))
+
+			const candidates = dirNames.slice(0, Math.max(limit * 2, 50))
+			const sessions: Session[] = []
+			for (const name of candidates) {
+				const s = await this.get(name)
+				if (s) sessions.push(s)
 			}
-		})
-		tx()
+			sessions.sort((a, b) => b.updated - a.updated)
+			return sessions.slice(0, limit)
+		} catch {
+			return []
+		}
 	}
 
-	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)
+	async latest(): Promise<Session | null> {
+		const sessions = await this.list(1)
+		return sessions[0] ?? null
 	}
 
-	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)
+	async delete(id: string): Promise<boolean> {
+		try {
+			await rm(this.#sessionDir(id), { recursive: true, force: true })
+			return true
+		} catch {
+			return false
+		}
 	}
 
-	setTitle(sessionId: string, title: string): void {
-		this.#db
-			.prepare("UPDATE sessions SET title = $title WHERE id = $id")
-			.run({ title: title, id: sessionId })
+	async deleteAll(): Promise<void> {
+		try {
+			await rm(this.#sessionsDir, { recursive: true, force: true })
+			await mkdir(this.#sessionsDir, { recursive: true })
+		} catch {
+			// ignore
+		}
 	}
 
-	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
+	async append(sessionId: string, msg: Msg): Promise<void> {
+		const session = await this.get(sessionId)
+		if (!session) return
+
+		session.updated = Date.now()
+		await writeFile(this.#metadataPath(sessionId), JSON.stringify(session, null, 2))
+
+		const line = `${JSON.stringify(msg)}\n`
+		await appendFile(this.#messagesPath(sessionId), line)
 	}
 
-	saveCompaction(
+	async messages(sessionId: string): Promise<Msg[]> {
+		try {
+			const data = await readFile(this.#messagesPath(sessionId), "utf-8")
+			const lines = data.split("\n").filter((l) => l.trim().length > 0)
+			return lines.map((l) => JSON.parse(l) as Msg)
+		} catch {
+			return []
+		}
+	}
+
+	async messageCount(sessionId: string): Promise<number> {
+		try {
+			const data = await readFile(this.#messagesPath(sessionId), "utf-8")
+			const lines = data.split("\n").filter((l) => l.trim().length > 0)
+			return lines.length
+		} catch {
+			return 0
+		}
+	}
+
+	async setTitle(sessionId: string, title: string): Promise<void> {
+		const session = await this.get(sessionId)
+		if (!session) return
+		session.title = title
+		session.updated = Date.now()
+		await writeFile(this.#metadataPath(sessionId), JSON.stringify(session, null, 2))
+	}
+
+	async 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 })
+	): Promise<void> {
+		const compaction: Compaction = {
+			summary,
+			seqBefore,
+			filesRead,
+			filesWrote,
+			ts: Date.now(),
+		}
+		await writeFile(this.#compactionPath(sessionId), JSON.stringify(compaction, null, 2))
 	}
 
-	close(): void {
-		this.#db.close()
+	async getLatestCompaction(sessionId: string): Promise<Compaction | null> {
+		try {
+			const data = await readFile(this.#compactionPath(sessionId), "utf-8")
+			return JSON.parse(data) as Compaction
+		} catch {
+			return null
+		}
 	}
 
-	#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
+	async truncateBeforeSeq(sessionId: string, seq: number): Promise<void> {
+		const msgs = await this.messages(sessionId)
+		const remaining = msgs.slice(seq)
+		const data =
+			remaining.map((m) => JSON.stringify(m)).join("\n") + (remaining.length > 0 ? "\n" : "")
+		await writeFile(this.#messagesPath(sessionId), data)
+	}
+
+	async prune(limit = 10): Promise<void> {
+		try {
+			const entries = await readdir(this.#sessionsDir, { withFileTypes: true })
+			const dirNames = entries
+				.filter((e) => e.isDirectory())
+				.map((e) => e.name)
+				.sort((a, b) => b.localeCompare(a))
+
+			const targets = limit > 0 ? dirNames.slice(0, limit) : dirNames
+			for (const name of targets) {
+				const count = await this.messageCount(name)
+				if (count === 0) {
+					await this.delete(name)
+				}
+			}
+		} catch {
+			// ignore
+		}
+	}
+
+	close(): void {
+		// no-op
 	}
 }
 
 let _store: SessionStore | null = null
 
-export function getSessionStore(dir?: string): SessionStore {
+export async function getSessionStore(dir?: string): Promise<SessionStore> {
 	if (_store) return _store
-	const dbPath = join(dir ?? join(process.env.HOME ?? "~", ".novacode"), "sessions.db")
-	_store = new SessionStore(dbPath)
+	const sessionsPath = join(dir ?? join(process.env.HOME ?? "~", ".novacode"), "sessions")
+	await mkdir(sessionsPath, { recursive: true })
+	_store = new SessionStore(sessionsPath)
 	return _store
 }

package/src/tools/web.ts

@@ -1,6 +1,6 @@
 /**
  * Web tools for searching and fetching internet content.
- * Uses DuckDuckGo HTML for search (no API key needed) and Bun's built-in
+ * 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"

package/src/tui/app.tsx

@@ -1,8 +1,11 @@
 import chalk from "chalk"
-import { Box, render, Static, Text, useInput } from "ink"
+import { Box, render, Static, Text, useApp, useInput } from "ink"
 import { useCallback, useEffect, useRef, useState } from "react"
 import type { Agent } from "../agent/agent.ts"
 import { COMMANDS, dispatch } from "../commands/index.ts"
+import { getProvider, MODELS } from "../config/providers.ts"
+import { loadAuth } from "../config/store.ts"
+import { generateSessionTitle } from "../session/compact.ts"
 import type { SessionStore } from "../session/store.ts"
 import type { Msg, Prompts } from "../types.ts"
 import { checkForUpdate, getCurrentVersion } from "../update.ts"
@@ -36,23 +39,55 @@ export async function interactive(
 	process.stdout.write(`${chalk.cyan.bold("⚡ novacode")} ${chalk.gray(`v${version}`)}\n`)
 
 	try {
-		const { waitUntilExit } = render(<App agent={agent} store={store} sessionId={sessionId} />)
+		const { waitUntilExit } = render(<App agent={agent} store={store} sessionId={sessionId} />, {
+			exitOnCtrlC: false,
+		})
 		await waitUntilExit()
 	} finally {
 		process.stdout.write("\x1B[?25h")
+		await store.prune()
 	}
 }
 
 function App({
 	agent,
 	store,
-	sessionId,
+	sessionId: initialSessionId,
 }: {
 	agent: Agent
 	store: SessionStore
 	sessionId: string
 }) {
+	const [currSessionId, setCurrSessionId] = useState(initialSessionId)
 	const [msgs, setMsgs] = useState<Msg[]>(agent.messages)
+
+	const handleSwitchSession = useCallback(
+		async (newSessionId: string) => {
+			const s = await store.get(newSessionId)
+			if (!s) return
+
+			const provider = getProvider(s.provider)
+			const model =
+				MODELS.find((m) => m.id === s.model && m.provider === s.provider) ||
+				MODELS.find((m) => m.id === s.model)
+			if (provider && model) {
+				const auth = await loadAuth()
+				const apiKey = auth.apiKeys[s.provider] || ""
+				agent.updateConfig({
+					api: provider.api,
+					model,
+					apiKey,
+					baseUrl: provider.baseUrl,
+				})
+			}
+
+			const newMsgs = await store.messages(newSessionId)
+			agent.setMessages(newMsgs)
+			setMsgs(newMsgs)
+			setCurrSessionId(newSessionId)
+		},
+		[store, agent],
+	)
 	const [stream, setStream] = useState("")
 	const [thinkStream, setThinkStream] = useState("")
 	const [busy, setBusy] = useState(false)
@@ -69,6 +104,9 @@ function App({
 		current: string
 		latest: string
 	} | null>(null)
+	const { exit } = useApp()
+	const lastExitPress = useRef<{ key: "C"; ts: number } | null>(null)
+	const [exitConfirmKey, setExitConfirmKey] = useState<"C" | null>(null)
 
 	useEffect(() => {
 		const check = async () => {
@@ -126,7 +164,9 @@ function App({
 	function commitMsg(msg: Msg) {
 		setMsgs((prev) => [...prev, msg])
 		agent.setMessages([...agent.messages, msg])
-		store.append(sessionId, msg)
+		store.append(currSessionId, msg).catch((err) => {
+			console.error("Error appending message to session store:", err)
+		})
 	}
 
 	// biome-ignore lint/correctness/useExhaustiveDependencies: reset selection on input change
@@ -135,12 +175,53 @@ function App({
 	}, [input])
 
 	useInput((ch, key) => {
+		if (key.ctrl && (ch === "c" || ch === "d")) {
+			if (busy) {
+				if (ch === "c") {
+					if (abortCtrl.current) {
+						abortCtrl.current.abort()
+						abortCtrl.current = null
+					}
+				}
+				return
+			}
+
+			// Idle state - handle exit
+			if (ch === "d") {
+				exit()
+				return
+			}
+
+			// Ctrl+C double-press exit logic
+			const now = Date.now()
+			if (
+				lastExitPress.current &&
+				lastExitPress.current.key === "C" &&
+				now - lastExitPress.current.ts < 2000
+			) {
+				exit()
+			} else {
+				lastExitPress.current = { key: "C", ts: now }
+				setExitConfirmKey("C")
+				// Clear the temporary status after 2 seconds
+				setTimeout(() => {
+					if (lastExitPress.current?.key === "C" && Date.now() - lastExitPress.current.ts >= 2000) {
+						lastExitPress.current = null
+						setExitConfirmKey(null)
+					}
+				}, 2000)
+			}
+			return
+		}
+
 		if (mode.type !== "chat") return
 
 		if (key.escape) {
 			if (abortCtrl.current) {
 				abortCtrl.current.abort()
 				abortCtrl.current = null
+			} else if (input) {
+				setInput("")
 			}
 			return
 		}
@@ -198,7 +279,7 @@ function App({
 		hIdx.current = -1
 
 		if (line.startsWith("/")) {
-			dispatch(line, agent, store, sessionId, prompts).then((r) => {
+			dispatch(line, agent, store, currSessionId, prompts, exit, handleSwitchSession).then((r) => {
 				if (r) {
 					commitMsg({
 						role: "assistant",
@@ -258,6 +339,20 @@ function App({
 						break
 					case "turn_end":
 						setStatus("")
+						store
+							.get(currSessionId)
+							.then((s) => {
+								if (s && !s.title && agent.messages.length >= 2) {
+									generateSessionTitle(agent.messages, agent.model, agent.apiKey, agent.baseUrl)
+										.then((title) => {
+											if (title) {
+												store.setTitle(currSessionId, title).catch(() => {})
+											}
+										})
+										.catch(() => {})
+								}
+							})
+							.catch(() => {})
 						break
 					case "usage":
 						if (ev.usage) setUsage(ev.usage)
@@ -311,13 +406,7 @@ function App({
 				{(m, i) => <Message key={`${m.ts}-${i}`} msg={m} isFirst={i === 0} />}
 			</Static>
 
-			<LiveArea
-				stream={stream}
-				thinkStream={thinkStream}
-				busy={busy}
-				status={status}
-				hasMessages={visibleMsgs.length > 0}
-			/>
+			<LiveArea stream={stream} thinkStream={thinkStream} busy={busy} status={status} />
 
 			<Box flexDirection="column" marginTop={visibleMsgs.length > 0 || isLiveActive ? 1 : 0}>
 				{updateInfo && (
@@ -357,6 +446,7 @@ function App({
 					busy={busy}
 					suggestions={suggestions}
 					selCmdIdx={selCmdIdx}
+					exitConfirmKey={exitConfirmKey}
 				/>
 			</Box>
 		</Box>

package/src/tui/components/liveArea.tsx

@@ -1,10 +1,9 @@
 import chalk from "chalk"
 import { Box, Text } from "ink"
 import { useEffect, useState } from "react"
+import { SPINNER_FRAMES } from "../constants.ts"
 import { formatMarkdown } from "../markdown.ts"
 
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-
 export function Spinner() {
 	const [frame, setFrame] = useState(0)
 
@@ -32,19 +31,17 @@ export function LiveArea({
 	thinkStream,
 	busy,
 	status,
-	hasMessages,
 }: {
 	stream: string
 	thinkStream: string
 	busy: boolean
 	status: string
-	hasMessages: boolean
 }) {
 	const isActive = !!(stream || thinkStream || busy)
 	if (!isActive) return null
 
 	return (
-		<Box flexDirection="column" marginTop={hasMessages ? 1 : 0}>
+		<Box flexDirection="column" marginTop={0}>
 			{thinkStream && (
 				<Text dimColor italic>
 					{thinkStream}

package/src/tui/components/message.tsx

@@ -1,24 +1,15 @@
 import { Box, Text } from "ink"
 import type { Msg } from "../../types.ts"
 import { formatToolArgs } from "../../util.ts"
+import { TERMINATION_PHRASES, TOOL_STYLE } from "../constants.ts"
 import { formatMarkdown } from "../markdown.ts"
 
-const TOOL_STYLE: Record<string, string> = {
-	read: "blue",
-	write: "magenta",
-	edit: "yellow",
-	bash: "cyan",
-	glob: "green",
-	find: "green",
-	grep: "green",
-	tree: "green",
-}
-
 export function hasMeaningfulContent(msg: Msg): boolean {
 	if (msg.role === "user") return true
 	if (msg.role === "tool_result") return true
 	if (msg.role === "assistant") {
 		if (msg.model === "system") return true
+		if (msg.stop === "aborted") return true
 		return msg.content.some((c) => {
 			if (c.type === "thinking") return c.text.trim().length > 0
 			if (c.type === "text") return c.text.trim().length > 0
@@ -60,9 +51,15 @@ export function Message({ msg, isFirst }: { msg: Msg; isFirst: boolean }) {
 			)
 		}
 
-		const hasVisibleContent = msg.content.some((c) => c.type === "text" || c.type === "thinking")
+		const isAborted = msg.stop === "aborted"
+		const hasVisibleContent =
+			isAborted || msg.content.some((c) => c.type === "text" || c.type === "thinking")
 		if (!hasVisibleContent) return null
 
+		const termPhrase = isAborted
+			? (TERMINATION_PHRASES[msg.ts % TERMINATION_PHRASES.length] ?? "Terminated by user")
+			: ""
+
 		return (
 			<Box flexDirection="column" marginTop={0}>
 				{msg.content.map((c, i) => {
@@ -80,6 +77,13 @@ export function Message({ msg, isFirst }: { msg: Msg; isFirst: boolean }) {
 					}
 					return null
 				})}
+				{isAborted && (
+					<Box marginTop={0}>
+						<Text color="red" italic>
+							▲ {termPhrase}
+						</Text>
+					</Box>
+				)}
 			</Box>
 		)
 	}