novacode 0.5.2 → 0.5.3

package/src/commands/providers.ts

@@ -1,33 +1,33 @@
-import * as clack from "@clack/prompts"
 import chalk from "chalk"
 import type { Agent } from "../agent/agent.ts"
 import { getProvider, MODELS, PROVIDERS } from "../config/providers.ts"
 import { loadAuth, loadConfig, saveAuth, saveConfig } from "../config/store.ts"
+import type { Prompts } from "../types.ts"
+
+export async function handleProviders(agent: Agent, prompts?: Prompts): Promise<string> {
+	if (!prompts) return chalk.red("Prompts not available in this context")
 
-export async function handleProviders(agent: Agent): Promise<string> {
 	const config = await loadConfig()
 	const auth = await loadAuth()
-
 	const configured = PROVIDERS.filter((p) => !!auth.apiKeys[p.id])
 
-	console.log(chalk.bold("\n  ⚙  Configured Providers:\n"))
-	if (configured.length === 0) {
-		console.log(chalk.dim("    No providers configured. Use 'Add Provider' below.\n"))
-	} else {
-		for (const p of configured) {
-			const isDefault = p.id === config.provider
-			const active = isDefault ? chalk.green(" ●") : ""
-			const key = chalk.green("✅")
-			const currentModel = isDefault
-				? config.model
-				: (MODELS.find((m) => m.provider === p.id)?.id ?? "")
-			console.log(`    ${key} ${p.name.padEnd(24)} ${currentModel}${active}`)
-		}
-		console.log("") // Spacer
-	}
-
-	const act = await clack.select({
+	const headerLines =
+		configured.length === 0
+			? chalk.dim("No providers configured. Use 'Add Provider' below.")
+			: configured
+					.map((p) => {
+						const isDefault = p.id === config.provider
+						const active = isDefault ? chalk.green(" ●") : ""
+						const currentModel = isDefault
+							? config.model
+							: (MODELS.find((m) => m.provider === p.id)?.id ?? "")
+						return `  ✅ ${p.name.padEnd(24)} ${currentModel}${active}`
+					})
+					.join("\n")
+
+	const act = await prompts.select({
 		message: "Action",
+		header: headerLines,
 		options: [
 			{ value: "add", label: "Add Provider" },
 			{ value: "update", label: "Update API Key" },
@@ -36,16 +36,16 @@ export async function handleProviders(agent: Agent): Promise<string> {
 			{ value: "back", label: "Back" },
 		],
 	})
-	if (clack.isCancel(act) || act === "back") return ""
+	if (!act || act === "back") return ""
 
-	if (act === "add") return addProvider(agent)
-	if (act === "update") return updateKey(agent)
-	if (act === "remove") return removeKey(agent)
-	if (act === "default") return setDefault(agent)
+	if (act === "add") return addProvider(agent, prompts)
+	if (act === "update") return updateKey(agent, prompts)
+	if (act === "remove") return removeKey(agent, prompts)
+	if (act === "default") return setDefault(agent, prompts)
 	return ""
 }
 
-async function addProvider(agent: Agent): Promise<string> {
+async function addProvider(agent: Agent, prompts: Prompts): Promise<string> {
 	const auth = await loadAuth()
 	const config = await loadConfig()
 
@@ -54,25 +54,24 @@ async function addProvider(agent: Agent): Promise<string> {
 		return chalk.yellow("All providers already have API keys configured.")
 	}
 
-	const pick = await clack.select({
+	const pick = await prompts.select({
 		message: "Add Provider",
 		options: available.map((p) => ({ value: p.id, label: p.name })),
 	})
-	if (clack.isCancel(pick)) return ""
+	if (!pick) return ""
 
-	const pDef = getProvider(pick as string)
+	const pDef = getProvider(pick)
 	if (!pDef) return chalk.red("Error: Provider not found")
 
-	const key = await clack.password({
+	const key = await prompts.password({
 		message: `${pDef.name} API Key`,
 		validate: (v) => (!v || v.length < 8 ? "Enter a valid key" : undefined),
 	})
-	if (clack.isCancel(key)) return ""
+	if (!key) return ""
 
-	auth.apiKeys[pDef.id] = key as string
+	auth.apiKeys[pDef.id] = key
 	await saveAuth(auth)
 
-	// Set as active if no provider is currently set
 	if (!config.provider) {
 		config.provider = pDef.id
 		const mDef = MODELS.find((m) => m.provider === pDef.id)
@@ -83,7 +82,7 @@ async function addProvider(agent: Agent): Promise<string> {
 		agent.updateConfig({
 			api: pDef.api,
 			model: MODELS.find((m) => m.id === config.model)!,
-			apiKey: key as string,
+			apiKey: key,
 			baseUrl: pDef.baseUrl,
 		})
 	}
@@ -91,7 +90,7 @@ async function addProvider(agent: Agent): Promise<string> {
 	return chalk.green(`✓ ${pDef.name} configured`)
 }
 
-async function updateKey(agent: Agent): Promise<string> {
+async function updateKey(agent: Agent, prompts: Prompts): Promise<string> {
 	const auth = await loadAuth()
 
 	const configured = PROVIDERS.filter((p) => !!auth.apiKeys[p.id])
@@ -99,22 +98,21 @@ async function updateKey(agent: Agent): Promise<string> {
 		return chalk.yellow("No providers configured. Use 'Add Provider' first.")
 	}
 
-	const pick = await clack.select({
+	const pick = await prompts.select({
 		message: "Update API Key",
 		options: configured.map((p) => ({ value: p.id, label: p.name })),
 	})
-	if (clack.isCancel(pick)) return ""
+	if (!pick) return ""
 
-	const pDef = getProvider(pick as string)
+	const pDef = getProvider(pick)
 	if (!pDef) return chalk.red("Error: Provider not found")
 
-	const key = await clack.password({ message: `New key for ${pDef.name}` })
-	if (clack.isCancel(key)) return ""
+	const key = await prompts.password({ message: `New key for ${pDef.name}` })
+	if (!key) return ""
 
-	auth.apiKeys[pDef.id] = key as string
+	auth.apiKeys[pDef.id] = key
 	await saveAuth(auth)
 
-	// If this is the active provider, update the agent's key
 	const config = await loadConfig()
 	if (config.provider === pDef.id) {
 		const currentModel = MODELS.find((m) => m.id === config.model && m.provider === config.provider)
@@ -122,7 +120,7 @@ async function updateKey(agent: Agent): Promise<string> {
 			agent.updateConfig({
 				api: pDef.api,
 				model: currentModel,
-				apiKey: key as string,
+				apiKey: key,
 				baseUrl: pDef.baseUrl,
 			})
 		}
@@ -131,7 +129,7 @@ async function updateKey(agent: Agent): Promise<string> {
 	return chalk.green("✓ Key updated")
 }
 
-async function removeKey(agent: Agent): Promise<string> {
+async function removeKey(agent: Agent, prompts: Prompts): Promise<string> {
 	const auth = await loadAuth()
 	const config = await loadConfig()
 
@@ -140,26 +138,23 @@ async function removeKey(agent: Agent): Promise<string> {
 		return chalk.yellow("No configured providers to remove.")
 	}
 
-	const pick = await clack.select({
+	const pick = await prompts.select({
 		message: "Remove API Key",
 		options: configured.map((p) => ({ value: p.id, label: p.name })),
 	})
-	if (clack.isCancel(pick)) return ""
+	if (!pick) return ""
 
-	const pId = pick as string
-	const confirm = await clack.confirm({
-		message: `Are you sure you want to remove the API key for ${pId}?`,
+	const confirm = await prompts.confirm({
+		message: `Are you sure you want to remove the API key for ${pick}?`,
 	})
-	if (clack.isCancel(confirm) || !confirm) return ""
+	if (!confirm) return ""
 
-	delete auth.apiKeys[pId]
+	delete auth.apiKeys[pick]
 	await saveAuth(auth)
 
-	// If removing the active provider's key
-	if (config.provider === pId) {
+	if (config.provider === pick) {
 		config.provider = ""
 		config.model = ""
-		// Try to find another configured provider
 		const next = Object.keys(auth.apiKeys)[0]
 		if (next) {
 			const pDef = getProvider(next)
@@ -178,43 +173,39 @@ async function removeKey(agent: Agent): Promise<string> {
 		await saveConfig(config)
 	}
 
-	return chalk.green(`✓ Removed API key for ${pId}`)
+	return chalk.green(`✓ Removed API key for ${pick}`)
 }
 
-async function setDefault(agent: Agent): Promise<string> {
+async function setDefault(agent: Agent, prompts: Prompts): Promise<string> {
 	const config = await loadConfig()
 	const auth = await loadAuth()
 
-	const pick = await clack.select({
+	const pick = await prompts.select({
 		message: "Default Provider",
-		options: PROVIDERS.map((p) => {
-			const hasKey = !!auth.apiKeys[p.id]
-			return {
-				value: p.id,
-				label: `${hasKey ? "✅" : "❌"} ${p.name}`,
-			}
-		}),
+		options: PROVIDERS.map((p) => ({
+			value: p.id,
+			label: `${auth.apiKeys[p.id] ? "✅" : "❌"} ${p.name}`,
+		})),
 	})
-	if (clack.isCancel(pick)) return ""
+	if (!pick) return ""
 
-	const pId = pick as string
-	if (!auth.apiKeys[pId]) {
-		return chalk.yellow(`No API key for ${pId}. Please set one first.`)
+	if (!auth.apiKeys[pick]) {
+		return chalk.yellow(`No API key for ${pick}. Please set one first.`)
 	}
 
-	const pDef = getProvider(pId)
-	const mDef = MODELS.find((m) => m.provider === pId)
+	const pDef = getProvider(pick)
+	const mDef = MODELS.find((m) => m.provider === pick)
 
 	if (!pDef || !mDef) return chalk.red("Error: Provider or model not found")
 
-	config.provider = pId
+	config.provider = pick
 	config.model = mDef.id
 	await saveConfig(config)
 
 	agent.updateConfig({
 		api: pDef.api,
 		model: mDef,
-		apiKey: auth.apiKeys[pId],
+		apiKey: auth.apiKeys[pick],
 		baseUrl: pDef.baseUrl,
 	})
 

package/src/config/providers.ts

@@ -82,6 +82,14 @@ export const MODELS: Model[] = [
 		supportsThinking: false,
 	},
 	// Gemini
+	{
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
 	{
 		id: "gemini-3.1-pro-preview",
 		name: "Gemini 3.1 Pro Preview",
@@ -128,7 +136,7 @@ export const MODELS: Model[] = [
 		provider: "gemini",
 		contextWindow: 2_000_000,
 		maxTokens: 65_536,
-		supportsThinking: true,
+		supportsThinking: false,
 	},
 	{
 		id: "gemini-2.5-flash",
@@ -136,7 +144,7 @@ export const MODELS: Model[] = [
 		provider: "gemini",
 		contextWindow: 1_000_000,
 		maxTokens: 65_536,
-		supportsThinking: true,
+		supportsThinking: false,
 	},
 	{
 		id: "gemini-2.5-flash-lite",
@@ -144,7 +152,7 @@ export const MODELS: Model[] = [
 		provider: "gemini",
 		contextWindow: 1_000_000,
 		maxTokens: 65_536,
-		supportsThinking: true,
+		supportsThinking: false,
 	},
 	{
 		id: "gemini-2.5-computer-use-preview-10-2025",
@@ -152,7 +160,7 @@ export const MODELS: Model[] = [
 		provider: "gemini",
 		contextWindow: 1_000_000,
 		maxTokens: 65_536,
-		supportsThinking: true,
+		supportsThinking: false,
 	},
 	// DeepSeek
 	{

package/src/config/store.ts

@@ -1,3 +1,4 @@
+import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 import type { NovaAuth, NovaConfig } from "../types.ts"
 
@@ -16,7 +17,7 @@ const defaultAuth: NovaAuth = {
 
 export async function configExists(): Promise<boolean> {
 	try {
-		await Bun.file(CONFIG_PATH()).stat()
+		await stat(CONFIG_PATH())
 		return true
 	} catch {
 		return false
@@ -25,7 +26,7 @@ export async function configExists(): Promise<boolean> {
 
 export async function loadConfig(): Promise<NovaConfig> {
 	try {
-		const raw = await Bun.file(CONFIG_PATH()).json()
+		const raw = JSON.parse(await readFile(CONFIG_PATH(), "utf-8"))
 		return { ...defaultConfig, ...raw }
 	} catch {
 		return { ...defaultConfig }
@@ -34,7 +35,7 @@ export async function loadConfig(): Promise<NovaConfig> {
 
 export async function loadAuth(): Promise<NovaAuth> {
 	try {
-		const raw = await Bun.file(AUTH_PATH()).json()
+		const raw = JSON.parse(await readFile(AUTH_PATH(), "utf-8"))
 		return { ...defaultAuth, ...raw }
 	} catch {
 		return { ...defaultAuth }
@@ -42,20 +43,18 @@ export async function loadAuth(): Promise<NovaAuth> {
 }
 
 async function ensureDir(): Promise<void> {
-	const { mkdir } = await import("node:fs/promises")
 	await mkdir(NOVA_DIR(), { recursive: true })
 }
 
 export async function saveConfig(config: NovaConfig): Promise<void> {
 	await ensureDir()
-	await Bun.write(CONFIG_PATH(), JSON.stringify(config, null, 2))
+	await writeFile(CONFIG_PATH(), JSON.stringify(config, null, 2))
 }
 
 export async function saveAuth(auth: NovaAuth): Promise<void> {
 	await ensureDir()
-	await Bun.write(AUTH_PATH(), JSON.stringify(auth, null, 2))
+	await writeFile(AUTH_PATH(), JSON.stringify(auth, null, 2))
 	try {
-		const { chmod } = await import("node:fs/promises")
 		await chmod(AUTH_PATH(), 0o600)
 	} catch {
 		// chmod may fail on some platforms, non-fatal

package/src/main.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { parseArgs } from "node:util"
 /**
  * Entry point for the nova CLI.
@@ -15,10 +15,6 @@ import { getSessionStore } from "./session/store.ts"
 import { getAllTools } from "./tools/index.ts"
 import { getCurrentVersion, runUpdate } from "./update.ts"
 
-// Ensure providers are registered
-import "./provider/openai.ts"
-import "./provider/gemini.ts"
-
 function parseCli() {
 	const { values, positionals } = parseArgs({
 		options: {
@@ -168,7 +164,12 @@ Options:
 	await interactive(agent, store, sessionId)
 }
 
+process.on("unhandledRejection", (reason) => {
+	console.error("Unhandled rejection:", reason)
+	process.exit(1)
+})
+
 main().catch((e) => {
-	console.error("Fatal:", e.message)
+	console.error("Fatal:", e)
 	process.exit(1)
 })

package/src/onboarding/wizard.ts

@@ -1,58 +1,54 @@
-import * as clack from "@clack/prompts"
+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> {
-	clack.intro("⚡ Nova — your coding companion")
-
-	const providerId = await clack.select({
-		message: "Pick a provider",
-		options: PROVIDERS.map((p) => ({ value: p.id, label: p.name })),
-	})
-
-	if (clack.isCancel(providerId)) {
-		clack.cancel("Cancelled")
+	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 as string)
+	const provider = getProvider(providerId)
 	if (!provider) {
-		clack.cancel("Unknown provider")
+		console.log(chalk.red("Unknown provider"))
 		process.exit(1)
 	}
 
-	const apiKey = await clack.password({
-		message: `Enter ${provider.name} API key`,
-	})
-
-	if (clack.isCancel(apiKey)) {
-		clack.cancel("Cancelled")
+	const apiKey = await standalonePassword(`Enter ${provider.name} API key`)
+	if (!apiKey) {
+		console.log(chalk.dim("Cancelled"))
 		process.exit(0)
 	}
 
-	const models = getModelsForProvider(providerId as string)
-	const modelId = await clack.select({
-		message: "Pick a default model",
-		options: models.map((m) => ({
+	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 (clack.isCancel(modelId)) {
-		clack.cancel("Cancelled")
+	)
+	if (!modelId) {
+		console.log(chalk.dim("Cancelled"))
 		process.exit(0)
 	}
 
 	const config: NovaConfig = {
-		provider: providerId as string,
-		model: modelId as string,
+		provider: providerId,
+		model: modelId,
 	}
 
 	await saveConfig(config)
-	await saveAuth({ apiKeys: { [providerId as string]: apiKey as string } })
+	await saveAuth({ apiKeys: { [providerId]: apiKey } })
 
-	clack.note("Ready. Type your prompt or /help for commands")
+	console.log(chalk.green("\n✓ Ready. Type your prompt or /help for commands\n"))
 	return config
 }

package/src/provider/gemini.ts

@@ -9,7 +9,6 @@ import type {
 	ToolDef,
 	Usage,
 } from "../types.ts"
-import { register } from "./registry.ts"
 import { EventStream } from "./stream.ts"
 
 interface GeminiPart {
@@ -200,10 +199,20 @@ export const streamGemini: StreamFn = (
 									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 })
-										content.push({ type: "thinking", text: thoughtText, signature: sig })
+										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 })
-										content.push({ type: "text", text: part.text, signature: sig })
+										const last = content[content.length - 1]
+										if (last?.type === "text") {
+											last.text += part.text
+										} else {
+											content.push({ type: "text", text: part.text, signature: sig })
+										}
 									}
 								}
 
@@ -250,5 +259,3 @@ export const streamGemini: StreamFn = (
 
 	return es
 }
-
-register("gemini", streamGemini)

package/src/provider/openai.ts

@@ -1,6 +1,5 @@
 import type {
 	AssistantResult,
-	ContentPart,
 	Msg,
 	StopReason,
 	StreamEvent,
@@ -9,8 +8,6 @@ import type {
 	ToolDef,
 	Usage,
 } from "../types.ts"
-import { consolidate } from "../util.ts"
-import { register } from "./registry.ts"
 import { EventStream } from "./stream.ts"
 
 function msgToOpenAI(msg: Msg): Record<string, unknown> {
@@ -118,8 +115,8 @@ export const streamOpenAI: StreamFn = (
 			let buffer = ""
 			const currentToolCalls = new Map<number, { id: string; name: string; args: string }>()
 			let usage: Usage = { in: 0, out: 0 }
+			let textContent = ""
 			let stop = "stop"
-			const textParts: ContentPart[] = []
 
 			while (true) {
 				const { done, value } = await reader.read()
@@ -142,7 +139,7 @@ export const streamOpenAI: StreamFn = (
 
 						if (delta.content) {
 							es.push({ type: "text_delta", text: delta.content })
-							textParts.push({ type: "text", text: delta.content })
+							textContent += delta.content
 						}
 
 						if (delta.tool_calls) {
@@ -178,7 +175,10 @@ export const streamOpenAI: StreamFn = (
 				}
 			}
 
-			const content: AssistantResult["content"] = consolidate([...textParts])
+			const content: AssistantResult["content"] = []
+			if (textContent) {
+				content.push({ type: "text", text: textContent })
+			}
 			for (const [, tc] of currentToolCalls) {
 				content.push({
 					type: "tool_call",
@@ -213,6 +213,3 @@ export const streamOpenAI: StreamFn = (
 
 	return es
 }
-
-// Auto-register
-register("openai", streamOpenAI)

package/src/provider/stream.ts

@@ -1,3 +1,9 @@
+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.
  *
@@ -75,3 +81,60 @@ export class EventStream<T, R> {
 		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,5 +1,5 @@
 import { getProvider } from "../config/providers.ts"
-import { stream } from "../provider/registry.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"