novacode 0.6.0 → 0.8.0

package/src/session/store.ts

@@ -1,209 +0,0 @@
-import { appendFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"
-import { join } from "node:path"
-import type { Compaction, Msg, Session } from "../types.ts"
-
-function generateId(): string {
-	return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`
-}
-
-export class SessionStore {
-	#sessionsDir: string
-
-	constructor(sessionsDir: string) {
-		this.#sessionsDir = sessionsDir
-	}
-
-	#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 {
-			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)
-			}
-			sessions.sort((a, b) => b.updated - a.updated)
-			return sessions.slice(0, limit)
-		} catch {
-			return []
-		}
-	}
-
-	async latest(): Promise<Session | null> {
-		const sessions = await this.list(1)
-		return sessions[0] ?? null
-	}
-
-	async delete(id: string): Promise<boolean> {
-		try {
-			await rm(this.#sessionDir(id), { recursive: true, force: true })
-			return true
-		} catch {
-			return false
-		}
-	}
-
-	async deleteAll(): Promise<void> {
-		try {
-			await rm(this.#sessionsDir, { recursive: true, force: true })
-			await mkdir(this.#sessionsDir, { recursive: true })
-		} catch {
-			// ignore
-		}
-	}
-
-	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)
-	}
-
-	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,
-	): 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 {
-		// no-op
-	}
-}
-
-let _store: SessionStore | null = null
-
-export async function getSessionStore(dir?: string): Promise<SessionStore> {
-	if (_store) return _store
-	const sessionsPath = join(dir ?? join(process.env.HOME ?? "~", ".novacode"), "sessions")
-	await mkdir(sessionsPath, { recursive: true })
-	_store = new SessionStore(sessionsPath)
-	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,
-				}
-			}
-		},
-	}
-}

package/src/tools/git.ts

@@ -1,99 +0,0 @@
-/**
- * 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"
-
-export function gitTool(cwd: string): Tool {
-	return {
-		def: {
-			name: "git",
-			description:
-				"Execute safe, non-interactive git commands (status, diff, log, add, commit) in the repository.",
-			parameters: {
-				type: "object",
-				properties: {
-					action: {
-						type: "string",
-						enum: ["status", "diff", "log", "add", "commit"],
-						description: "The git action to execute",
-					},
-					args: {
-						type: "array",
-						description: "Optional additional arguments or file paths for the git action",
-						items: { type: "string" },
-					},
-				},
-				required: ["action"],
-			},
-		},
-		async execute(args, signal): Promise<ToolResult> {
-			const action = args.action as string
-			const extraArgs = (args.args as string[]) || []
-
-			const allowed = new Set(["status", "diff", "log", "add", "commit"])
-			if (!allowed.has(action)) {
-				return {
-					content: [textPart(`Error: Git action '${action}' is not supported.`)],
-					isError: true,
-				}
-			}
-
-			try {
-				const cmd = ["git", action, ...extraArgs]
-				const proc = spawn(cmd[0]!, cmd.slice(1), {
-					cwd,
-					stdio: ["ignore", "pipe", "pipe"],
-					env: { ...process.env, PAGER: "cat" },
-				})
-
-				let stdout = ""
-				let stderr = ""
-				proc.stdout.on("data", (chunk: Buffer) => {
-					stdout += chunk.toString()
-				})
-				proc.stderr.on("data", (chunk: Buffer) => {
-					stderr += chunk.toString()
-				})
-
-				const onAbort = () => {
-					proc.kill("SIGKILL")
-					proc.stdout.destroy()
-					proc.stderr.destroy()
-				}
-				signal?.addEventListener("abort", onAbort, { once: true })
-
-				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
-				let out = ""
-				if (stdout) out += stdout.slice(0, MAX)
-				if (stderr) {
-					if (out) out += "\n"
-					out += stderr.slice(0, MAX - out.length)
-				}
-				if (out.length >= MAX) out += "\n…truncated"
-
-				return {
-					content: [textPart(out || "(no output)")],
-					isError: exitCode !== 0,
-				}
-			} catch (e) {
-				return {
-					content: [textPart(`Error running git: ${(e as Error).message}`)],
-					isError: true,
-				}
-			}
-		},
-	}
-}

package/src/tools/index.ts

@@ -1,33 +0,0 @@
-import type { Tool } from "../types.ts"
-import { editTool, readTool, writeTool } from "./fs.ts"
-import { gitTool } from "./git.ts"
-import { globTool, grepTool, lsTool, treeTool } from "./search.ts"
-import { bashTool } from "./shell.ts"
-import { webFetchTool, webSearchTool } from "./web.ts"
-
-export function getAllTools(cwd: string): Tool[] {
-	return [
-		readTool(cwd),
-		writeTool(cwd),
-		editTool(cwd),
-		bashTool(cwd),
-		globTool(cwd),
-		grepTool(cwd),
-		lsTool(cwd),
-		treeTool(cwd),
-		gitTool(cwd),
-		webSearchTool(),
-		webFetchTool(),
-	]
-}
-
-export function getDefaultTools(cwd: string): Tool[] {
-	return [
-		readTool(cwd),
-		writeTool(cwd),
-		editTool(cwd),
-		bashTool(cwd),
-		webSearchTool(),
-		webFetchTool(),
-	]
-}