novacode 0.6.0 → 0.7.0

package/src/config/store.ts

@@ -1,66 +0,0 @@
-import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises"
-import { join } from "node:path"
-import type { NovaAuth, NovaConfig } from "../types.ts"
-
-const NOVA_DIR = () => join(process.env.HOME ?? "~", ".novacode")
-const CONFIG_PATH = () => join(NOVA_DIR(), "config.json")
-const AUTH_PATH = () => join(NOVA_DIR(), "auth.json")
-
-const defaultConfig: NovaConfig = {
-	provider: "",
-	model: "",
-}
-
-const defaultAuth: NovaAuth = {
-	apiKeys: {},
-}
-
-export async function configExists(): Promise<boolean> {
-	try {
-		await stat(CONFIG_PATH())
-		return true
-	} catch {
-		return false
-	}
-}
-
-export async function loadConfig(): Promise<NovaConfig> {
-	try {
-		const raw = JSON.parse(await readFile(CONFIG_PATH(), "utf-8"))
-		return { ...defaultConfig, ...raw }
-	} catch {
-		return { ...defaultConfig }
-	}
-}
-
-export async function loadAuth(): Promise<NovaAuth> {
-	try {
-		const raw = JSON.parse(await readFile(AUTH_PATH(), "utf-8"))
-		return { ...defaultAuth, ...raw }
-	} catch {
-		return { ...defaultAuth }
-	}
-}
-
-async function ensureDir(): Promise<void> {
-	await mkdir(NOVA_DIR(), { recursive: true })
-}
-
-export async function saveConfig(config: NovaConfig): Promise<void> {
-	await ensureDir()
-	await writeFile(CONFIG_PATH(), JSON.stringify(config, null, 2))
-}
-
-export async function saveAuth(auth: NovaAuth): Promise<void> {
-	await ensureDir()
-	await writeFile(AUTH_PATH(), JSON.stringify(auth, null, 2))
-	try {
-		await chmod(AUTH_PATH(), 0o600)
-	} catch {
-		// chmod may fail on some platforms, non-fatal
-	}
-}
-
-export function getNovaDir(): string {
-	return NOVA_DIR()
-}

package/src/main.ts

@@ -1,205 +0,0 @@
-#!/usr/bin/env node
-import { parseArgs } from "node:util"
-/**
- * Entry point for the nova CLI.
- * Handles configuration, CLI flags, and runs interactive TUI mode.
- */
-import chalk from "chalk"
-import { Agent } from "./agent/agent.ts"
-import { buildSystemPrompt } from "./agent/prompt.ts"
-import { handleSessionCommand } from "./commands/session.ts"
-import { getProvider, MODELS } from "./config/providers.ts"
-import { configExists, loadAuth, loadConfig } from "./config/store.ts"
-import { runOnboarding } from "./onboarding/wizard.ts"
-import { getSessionStore } from "./session/store.ts"
-import { getAllTools } from "./tools/index.ts"
-import type { Session } from "./types.ts"
-import { getCurrentVersion, runUpdate } from "./update.ts"
-
-function parseCli() {
-	const { values, positionals } = parseArgs({
-		options: {
-			help: { type: "boolean", short: "h" },
-			version: { type: "boolean", short: "v" },
-			provider: { type: "string" },
-			model: { type: "string" },
-			"api-key": { type: "string" },
-			session: { type: "string", short: "s" },
-			resume: { type: "boolean" },
-			n: { type: "string" },
-			limit: { type: "string" },
-			all: { type: "boolean" },
-		},
-		strict: false,
-		allowPositionals: true,
-	})
-
-	return { flags: values, args: positionals }
-}
-
-function findModel(modelId: string, providerId?: string) {
-	return MODELS.find((m) => {
-		if (providerId) return m.provider === providerId && m.id === modelId
-		return m.id === modelId
-	})
-}
-
-async function main() {
-	const { flags, args } = parseCli()
-
-	if (flags.version) {
-		const version = await getCurrentVersion()
-		console.log(`nova ${version}`)
-		process.exit(0)
-	}
-
-	if (flags.help) {
-		console.log(`nova — open-source coding agent
-
-Usage:
-  nova                    Interactive mode
-  nova update             Update to latest version
-  nova --session ls       List sessions (last 10 by default)
-  nova --session ls -n N  List last N sessions
-  nova --session rm <id>  Delete a specific session
-  nova --session rm --all Delete all sessions
-  nova --session <id>     Resume a session by ID
-  nova --resume           Resume the most recent session
-
-Options:
-  -h, --help              Show help
-  -v, --version           Show version
-  --provider <id>         Provider to use
-  --model <id>            Model to use
-  --api-key <key>         API key override
-  -s, --session <id>      Resume/manage session`)
-		process.exit(0)
-	}
-
-	// Handle update subcommand
-	if (args[0] === "update") {
-		await runUpdate()
-		return
-	}
-
-	// Reject positional args — use interactive mode with / commands
-	if (args.length > 0 && !flags.session) {
-		console.error(chalk.yellow(`Unknown command: ${args.join(" ")}`))
-		console.error("Run `nova --help` for usage.")
-		process.exit(1)
-	}
-
-	const controller = new AbortController()
-
-	const onSignal = () => {
-		controller.abort()
-		process.stderr.write("\nAborted.\n")
-		process.exit(130)
-	}
-	process.on("SIGINT", onSignal)
-	process.on("SIGTERM", onSignal)
-
-	// First-run onboarding
-	const config = await ((await configExists()) ? loadConfig() : runOnboarding())
-	const auth = await loadAuth()
-
-	const store = await getSessionStore()
-	await store.prune()
-
-	// Handle --session commands (ls, rm)
-	if (flags.session) {
-		const sessionFlag = flags.session as string
-		if (sessionFlag === "ls" || sessionFlag === "list") {
-			const limit = parseInt((flags.n as string) || (flags.limit as string) || "10", 10)
-			await handleSessionCommand(store, ["ls"], { limit })
-			return
-		}
-		if (sessionFlag === "rm" || sessionFlag === "delete") {
-			const id = args[0]
-			const all = !!flags.all
-			await handleSessionCommand(store, ["rm", id ?? ""], { all })
-			return
-		}
-	}
-
-	let session: Session | null = null
-	if (flags.resume) {
-		session = await store.latest()
-		if (!session) {
-			console.error("No recent session found to resume.")
-			process.exit(1)
-		}
-	} else if (flags.session) {
-		session = await store.get(flags.session as string)
-		if (!session) {
-			console.error(`Session not found: ${flags.session}`)
-			process.exit(1)
-		}
-	}
-
-	// CLI overrides or session default or config default
-	const providerId = (flags.provider as string) || session?.provider || config.provider
-	const modelId = (flags.model as string) || session?.model || config.model
-	const apiKey = (flags["api-key"] as string) || auth.apiKeys[providerId]
-
-	const provider = getProvider(providerId)
-	if (!provider) {
-		console.error(`Unknown provider: ${providerId}`)
-		console.error(`Available: ${getProvider("glm") ? "glm, " : ""}gemini, deepseek, openai`)
-		process.exit(1)
-	}
-
-	if (!apiKey) {
-		console.error(
-			`No API key for ${provider.name}. Set ${provider.envKey} or run nova for onboarding.`,
-		)
-		process.exit(1)
-	}
-
-	const model = findModel(modelId, providerId)
-	if (!model) {
-		console.error(`Unknown model: ${modelId}`)
-		console.error("Available models:")
-		for (const m of MODELS.filter((m) => m.provider === providerId)) {
-			console.error(`  ${m.id} — ${m.name}`)
-		}
-		process.exit(1)
-	}
-
-	const cwd = process.cwd()
-	const tools = getAllTools(cwd)
-	const system = buildSystemPrompt(cwd, tools)
-
-	if (!session) {
-		session = await store.create(cwd, model.id, providerId)
-	}
-
-	const sessionId = session.id
-	const existingMessages = await store.messages(sessionId)
-
-	const agent = new Agent({
-		api: provider.api,
-		model,
-		apiKey,
-		baseUrl: provider.baseUrl,
-		system,
-		tools,
-		messages: existingMessages,
-	})
-
-	// Interactive TUI mode
-	process.off("SIGINT", onSignal)
-	process.off("SIGTERM", onSignal)
-	const { interactive } = await import("./tui/app.tsx")
-	await interactive(agent, store, sessionId)
-}
-
-process.on("unhandledRejection", (reason) => {
-	console.error("Unhandled rejection:", reason)
-	process.exit(1)
-})
-
-main().catch((e) => {
-	console.error("Fatal:", e)
-	process.exit(1)
-})

package/src/onboarding/wizard.ts

@@ -1,54 +0,0 @@
-import chalk from "chalk"
-import { getModelsForProvider, getProvider, PROVIDERS } from "../config/providers.ts"
-import { saveAuth, saveConfig } from "../config/store.ts"
-import { standalonePassword, standaloneSelect } from "../tui/prompts.tsx"
-import type { NovaConfig } from "../types.ts"
-
-export async function runOnboarding(): Promise<NovaConfig> {
-	console.log(chalk.bold.cyan("\n⚡ Nova — your coding companion\n"))
-
-	const providerId = await standaloneSelect(
-		"Pick a provider",
-		PROVIDERS.map((p) => ({ value: p.id, label: p.name })),
-	)
-	if (!providerId) {
-		console.log(chalk.dim("Cancelled"))
-		process.exit(0)
-	}
-
-	const provider = getProvider(providerId)
-	if (!provider) {
-		console.log(chalk.red("Unknown provider"))
-		process.exit(1)
-	}
-
-	const apiKey = await standalonePassword(`Enter ${provider.name} API key`)
-	if (!apiKey) {
-		console.log(chalk.dim("Cancelled"))
-		process.exit(0)
-	}
-
-	const models = getModelsForProvider(providerId)
-	const modelId = await standaloneSelect(
-		"Pick a default model",
-		models.map((m) => ({
-			value: m.id,
-			label: `${m.name} (${(m.contextWindow / 1000).toFixed(0)}k ctx)`,
-		})),
-	)
-	if (!modelId) {
-		console.log(chalk.dim("Cancelled"))
-		process.exit(0)
-	}
-
-	const config: NovaConfig = {
-		provider: providerId,
-		model: modelId,
-	}
-
-	await saveConfig(config)
-	await saveAuth({ apiKeys: { [providerId]: apiKey } })
-
-	console.log(chalk.green("\n✓ Ready. Type your prompt or /help for commands\n"))
-	return config
-}

package/src/provider/gemini.ts

@@ -1,269 +0,0 @@
-import type {
-	AssistantResult,
-	ContentPart,
-	Msg,
-	StopReason,
-	StreamEvent,
-	StreamFn,
-	StreamOpts,
-	ToolDef,
-	Usage,
-} from "../types.ts"
-import { EventStream } from "./stream.ts"
-
-interface GeminiPart {
-	text?: string
-	thought?: boolean | string
-	inline_data?: { mime_type: string; data: string }
-	function_call?: { name: string; args: Record<string, unknown> }
-	function_response?: { name: string; response: Record<string, unknown> }
-	thought_signature?: string
-}
-
-interface GeminiContent {
-	role: "user" | "model"
-	parts: GeminiPart[]
-}
-
-/**
- * Maps our internal Msg format to the Gemini 'Content' format.
- * Groups consecutive tool_result messages into a single Gemini message.
- */
-function msgsToGemini(messages: Msg[]): GeminiContent[] {
-	const contents: GeminiContent[] = []
-
-	for (const msg of messages) {
-		if (msg.role === "user") {
-			const parts: GeminiPart[] =
-				typeof msg.content === "string"
-					? [{ text: msg.content }]
-					: msg.content.map((c) => {
-							if (c.type === "text") return { text: c.text }
-							if (c.type === "image") return { inline_data: { mime_type: c.mime, data: c.data } }
-							return { text: "" }
-						})
-			contents.push({ role: "user", parts })
-		} else if (msg.role === "assistant") {
-			const parts: GeminiPart[] = msg.content.map((c) => {
-				if (c.type === "text") return { text: c.text, thought_signature: c.signature }
-				if (c.type === "thinking")
-					return { thought: true, text: c.text, thought_signature: c.signature }
-				if (c.type === "tool_call")
-					return { function_call: { name: c.name, args: c.args }, thought_signature: c.signature }
-				return { text: "" }
-			})
-			contents.push({ role: "model", parts })
-		} else if (msg.role === "tool_result") {
-			const part: GeminiPart = {
-				function_response: {
-					name: msg.tool,
-					response: {
-						content: msg.content
-							.map((c) => (c.type === "text" ? c.text : JSON.stringify(c)))
-							.join("\n"),
-					},
-				},
-			}
-
-			const last = contents[contents.length - 1]
-			// Gemini requires alternating roles; multiple function_responses group into one 'user' message.
-			if (last && last.role === "user" && last.parts.some((p) => p.function_response)) {
-				last.parts.push(part)
-			} else {
-				contents.push({ role: "user", parts: [part] })
-			}
-		}
-	}
-
-	return contents
-}
-
-function toolsToGemini(tools: ToolDef[]): unknown[] {
-	if (tools.length === 0) return []
-	return [
-		{
-			function_declarations: tools.map((t) => ({
-				name: t.name,
-				description: t.description,
-				parameters: t.parameters,
-			})),
-		},
-	]
-}
-
-export const streamGemini: StreamFn = (
-	opts: StreamOpts,
-): EventStream<StreamEvent, AssistantResult> => {
-	const es = new EventStream<StreamEvent, AssistantResult>()
-
-	;(async () => {
-		let usage: Usage = { in: 0, out: 0 }
-		const content: ContentPart[] = []
-
-		try {
-			const baseUrl = opts.baseUrl || "https://generativelanguage.googleapis.com"
-			const url = `${baseUrl}/v1beta/models/${opts.model.id}:streamGenerateContent?alt=sse&key=${opts.apiKey}`
-
-			const body = {
-				contents: msgsToGemini(opts.messages),
-				system_instruction: opts.system ? { parts: [{ text: opts.system }] } : undefined,
-				tools: opts.tools.length > 0 ? toolsToGemini(opts.tools) : undefined,
-				generationConfig: {
-					thinkingConfig: opts.model.supportsThinking ? { thinkingLevel: "low" } : undefined,
-				},
-			}
-
-			const response = await fetch(url, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					"Api-Revision": "2026-05-20",
-				},
-				body: JSON.stringify(body),
-				signal: opts.signal,
-			})
-
-			if (!response.ok) {
-				const text = await response.text()
-				let msg = text
-				try {
-					const json = JSON.parse(text)
-					msg = json.error?.message || json.message || text
-				} catch {
-					/* use raw text */
-				}
-
-				const errorMsg = `Gemini Error (${response.status}): ${msg}`
-				es.push({ type: "text_delta", text: errorMsg })
-				es.finish({
-					content: [{ type: "text", text: errorMsg }],
-					usage: { in: 0, out: 0 },
-					stop: "error",
-				})
-				return
-			}
-
-			const reader = response.body?.getReader()
-			if (!reader) {
-				es.finish({ content: [], usage: { in: 0, out: 0 }, stop: "error" })
-				return
-			}
-
-			const decoder = new TextDecoder()
-			let buffer = ""
-			let stop: StopReason = "stop"
-
-			while (true) {
-				const { done, value } = await reader.read()
-				if (done) break
-
-				buffer += decoder.decode(value, { stream: true })
-				const lines = buffer.split("\n")
-				buffer = lines.pop() ?? ""
-
-				for (const line of lines) {
-					const trimmed = line.trim()
-					if (!trimmed?.startsWith("data: ")) continue
-					const data = trimmed.slice(6)
-
-					try {
-						const chunk = JSON.parse(data)
-						const candidate = chunk.candidates?.[0]
-
-						// Handle usage metadata
-						if (chunk.usageMetadata) {
-							usage = {
-								in: chunk.usageMetadata.promptTokenCount || usage.in,
-								out: chunk.usageMetadata.candidatesTokenCount || usage.out,
-							}
-							es.push({ type: "usage", usage })
-						}
-
-						if (!candidate) continue
-
-						// Map finish reason
-						if (candidate.finishReason) {
-							const reason = candidate.finishReason
-							if (reason === "STOP") stop = "stop"
-							else if (reason === "MAX_TOKENS") stop = "length"
-							else if (reason === "SAFETY" || reason === "RECITATION" || reason === "OTHER")
-								stop = "error"
-						}
-
-						const parts = candidate.content?.parts
-						if (parts) {
-							for (const part of parts) {
-								const sig = part.thought_signature || part.thoughtSignature
-
-								// Handle text and thinking deltas
-								if (part.text) {
-									if (part.thought === true || typeof part.thought === "string") {
-										const thoughtText = typeof part.thought === "string" ? part.thought : part.text
-										es.push({ type: "thinking_delta", text: thoughtText })
-										const last = content[content.length - 1]
-										if (last?.type === "thinking") {
-											last.text += thoughtText
-										} else {
-											content.push({ type: "thinking", text: thoughtText, signature: sig })
-										}
-									} else {
-										es.push({ type: "text_delta", text: part.text })
-										const last = content[content.length - 1]
-										if (last?.type === "text") {
-											last.text += part.text
-										} else {
-											content.push({ type: "text", text: part.text, signature: sig })
-										}
-									}
-								}
-
-								// Handle function calls (can be snake_case or camelCase in some API versions)
-								const fc = part.functionCall || part.function_call
-								if (fc) {
-									const name = fc.name
-									const args = (fc.args as Record<string, unknown>) || {}
-									const id = `call_${Math.random().toString(36).slice(2, 9)}`
-
-									const toolCall: ContentPart = {
-										type: "tool_call",
-										id,
-										name,
-										args,
-										signature: sig,
-									}
-									content.push(toolCall)
-									es.push({ type: "tool_call", call: toolCall })
-									stop = "tool_use"
-								}
-							}
-						}
-					} catch (_e) {
-						if (data.trim() !== "" && data.trim() !== "[DONE]") {
-							// skip noise
-						}
-					}
-				}
-			}
-
-			es.finish({ content, usage, stop })
-		} catch (e) {
-			if (opts.signal?.aborted) {
-				es.finish({
-					content,
-					usage,
-					stop: "aborted",
-				})
-				return
-			}
-			const errorMsg = `Gemini Network/Request Error: ${e instanceof Error ? e.message : String(e)}`
-			es.push({ type: "text_delta", text: errorMsg })
-			es.finish({
-				content: [{ type: "text", text: errorMsg }],
-				usage: { in: 0, out: 0 },
-				stop: "error",
-			})
-		}
-	})()
-
-	return es
-}