novacode 0.5.3 → 0.6.0

package/src/session/store.ts

@@ -1,206 +1,209 @@
+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 = new BetterSqlite3(dbPath)
-		this.#db.pragma("journal_mode = WAL")
-		this.#db.pragma("foreign_keys = ON")
-		this.#db.exec(SCHEMA)
+	constructor(sessionsDir: string) {
+		this.#sessionsDir = sessionsDir
 	}
 
-	create(cwd: string, model: string, provider: string): Session {
+	#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()
-		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)
+		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 {
+			const data = await readFile(this.#metadataPath(id), "utf-8")
+			return JSON.parse(data) as Session
+		} catch {
+			return null
+		}
+	}
+
+	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))
+	}
+
+	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
+		}
+	}
+
+	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 {
-		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
+		// 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"