novacode 0.2.0

package/src/main.ts

@@ -0,0 +1,169 @@
+/**
+ * Entry point for the novacode CLI.
+ * Handles configuration, CLI flags, and switches between interactive/print modes.
+ */
+import { parseArgs } from "node:util"
+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 { runPrintMode } from "./tui/print.ts"
+
+// Ensure providers are registered
+import "./provider/openai.ts"
+import "./provider/gemini.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" },
+		},
+		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 pkg = await Bun.file("package.json").json()
+		console.log(`novacode ${pkg.version}`)
+		process.exit(0)
+	}
+
+	if (flags.help) {
+		console.log(`novacode — open-source coding agent
+
+Usage:
+  novacode                Interactive mode
+  novacode "prompt"       Print mode (non-interactive)
+  novacode session <cmd>  Session management (list, delete)
+  novacode --session <id> Resume a 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 session by ID`)
+		process.exit(0)
+	}
+
+	// Handle session subcommand
+	if (args[0] === "session") {
+		await handleSessionCommand(args.slice(1))
+		return
+	}
+
+	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()
+
+	// CLI overrides
+	const providerId = (flags.provider as string) || config.provider
+	const modelId = (flags.model as string) || 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 novacode 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)
+
+	// Session persistence
+	const store = getSessionStore()
+	const session = flags.session
+		? store.get(flags.session as string)
+		: store.create(cwd, model.id, providerId)
+
+	if (flags.session && !session) {
+		console.error(`Session not found: ${flags.session}`)
+		process.exit(1)
+	}
+
+	const sessionId = session!.id
+	const existingMessages = store.messages(sessionId)
+
+	const agent = new Agent({
+		api: provider.api,
+		model,
+		apiKey,
+		baseUrl: provider.baseUrl,
+		system,
+		tools,
+		messages: existingMessages,
+	})
+
+	// Print mode: prompt provided as arg
+	const prompt = args.join(" ")
+	if (prompt) {
+		const result = await runPrintMode(agent, prompt, controller.signal)
+		if (result) {
+			store.appendMany(sessionId, result)
+		}
+		return
+	}
+
+	// Interactive TUI mode (Phase 3)
+	process.off("SIGINT", onSignal)
+	process.off("SIGTERM", onSignal)
+	const { interactive } = await import("./tui/app.tsx")
+	await interactive(agent, store, sessionId)
+}
+
+main().catch((e) => {
+	console.error("Fatal:", e.message)
+	process.exit(1)
+})

package/src/onboarding/wizard.ts

@@ -0,0 +1,58 @@
+import * as clack from "@clack/prompts"
+import { getModelsForProvider, getProvider, PROVIDERS } from "../config/providers.ts"
+import { saveAuth, saveConfig } from "../config/store.ts"
+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")
+		process.exit(0)
+	}
+
+	const provider = getProvider(providerId as string)
+	if (!provider) {
+		clack.cancel("Unknown provider")
+		process.exit(1)
+	}
+
+	const apiKey = await clack.password({
+		message: `Enter ${provider.name} API key`,
+	})
+
+	if (clack.isCancel(apiKey)) {
+		clack.cancel("Cancelled")
+		process.exit(0)
+	}
+
+	const models = getModelsForProvider(providerId as string)
+	const modelId = await clack.select({
+		message: "Pick a default model",
+		options: models.map((m) => ({
+			value: m.id,
+			label: `${m.name} (${(m.contextWindow / 1000).toFixed(0)}k ctx)`,
+		})),
+	})
+
+	if (clack.isCancel(modelId)) {
+		clack.cancel("Cancelled")
+		process.exit(0)
+	}
+
+	const config: NovaConfig = {
+		provider: providerId as string,
+		model: modelId as string,
+	}
+
+	await saveConfig(config)
+	await saveAuth({ apiKeys: { [providerId as string]: apiKey as string } })
+
+	clack.note("Ready. Type your prompt or /help for commands")
+	return config
+}

package/src/provider/gemini.ts

@@ -0,0 +1,254 @@
+import type {
+	AssistantResult,
+	ContentPart,
+	Msg,
+	StopReason,
+	StreamEvent,
+	StreamFn,
+	StreamOpts,
+	ToolDef,
+	Usage,
+} from "../types.ts"
+import { register } from "./registry.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 () => {
+		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 usage: Usage = { in: 0, out: 0 }
+			let stop: StopReason = "stop"
+			const content: ContentPart[] = []
+
+			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 })
+										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 })
+									}
+								}
+
+								// 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) 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
+}
+
+register("gemini", streamGemini)

package/src/provider/openai.ts

@@ -0,0 +1,218 @@
+import type {
+	AssistantResult,
+	ContentPart,
+	Msg,
+	StopReason,
+	StreamEvent,
+	StreamFn,
+	StreamOpts,
+	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> {
+	if (msg.role === "user") {
+		return {
+			role: "user",
+			content:
+				typeof msg.content === "string"
+					? msg.content
+					: msg.content.map((c) => {
+							if (c.type === "text") return { type: "text", text: c.text }
+							if (c.type === "image")
+								return { type: "image_url", image_url: { url: `data:${c.mime};base64,${c.data}` } }
+							return { type: "text", text: "" }
+						}),
+		}
+	}
+	if (msg.role === "assistant") {
+		const textParts: string[] = []
+		const toolCalls: unknown[] = []
+
+		for (const c of msg.content) {
+			if (c.type === "text") textParts.push(c.text)
+			// thinking parts are internal — never sent back to the API
+			if (c.type === "tool_call")
+				toolCalls.push({
+					type: "function",
+					id: c.id,
+					function: { name: c.name, arguments: JSON.stringify(c.args) },
+				})
+		}
+
+		const result: Record<string, unknown> = {
+			role: "assistant",
+			content: textParts.length > 0 ? textParts.join("") : null,
+		}
+		if (toolCalls.length > 0) result.tool_calls = toolCalls
+		return result
+	}
+	// tool_result
+	if (msg.role === "tool_result") {
+		return {
+			role: "tool",
+			tool_call_id: msg.callId,
+			content: msg.content.map((c) => (c.type === "text" ? c.text : JSON.stringify(c))).join("\n"),
+		}
+	}
+	return { role: "user", content: "" }
+}
+
+function toolsToOpenAI(tools: ToolDef[]): unknown[] {
+	return tools.map((t) => ({
+		type: "function",
+		function: {
+			name: t.name,
+			description: t.description,
+			parameters: t.parameters,
+		},
+	}))
+}
+
+export const streamOpenAI: StreamFn = (
+	opts: StreamOpts,
+): EventStream<StreamEvent, AssistantResult> => {
+	const es = new EventStream<StreamEvent, AssistantResult>()
+
+	;(async () => {
+		try {
+			const body = {
+				model: opts.model.id,
+				messages: [{ role: "system", content: opts.system }, ...opts.messages.map(msgToOpenAI)],
+				tools: opts.tools.length > 0 ? toolsToOpenAI(opts.tools) : undefined,
+				stream: true,
+			}
+
+			const response = await fetch(`${opts.baseUrl}/chat/completions`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${opts.apiKey}`,
+				},
+				body: JSON.stringify(body),
+				signal: opts.signal,
+			})
+
+			if (!response.ok) {
+				const text = await response.text()
+				const errorMsg = `API error ${response.status}: ${text}`
+				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 = ""
+			const currentToolCalls = new Map<number, { id: string; name: string; args: string }>()
+			let usage: Usage = { in: 0, out: 0 }
+			let stop = "stop"
+			const textParts: ContentPart[] = []
+
+			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)
+					if (data === "[DONE]") continue
+
+					try {
+						const chunk = JSON.parse(data)
+						const delta = chunk.choices?.[0]?.delta
+						if (!delta) continue
+
+						if (delta.content) {
+							es.push({ type: "text_delta", text: delta.content })
+							textParts.push({ type: "text", text: delta.content })
+						}
+
+						if (delta.tool_calls) {
+							for (const tc of delta.tool_calls) {
+								const idx = tc.index ?? 0
+								if (!currentToolCalls.has(idx)) {
+									currentToolCalls.set(idx, {
+										id: tc.id ?? "",
+										name: tc.function?.name ?? "",
+										args: "",
+									})
+								}
+								const existing = currentToolCalls.get(idx)!
+								if (tc.id) existing.id = tc.id
+								if (tc.function?.name) existing.name = tc.function.name
+								if (tc.function?.arguments) existing.args += tc.function.arguments
+							}
+						}
+
+						if (chunk.usage) {
+							usage = {
+								in: chunk.usage.prompt_tokens ?? 0,
+								out: chunk.usage.completion_tokens ?? 0,
+							}
+							es.push({ type: "usage", usage })
+						}
+
+						const finishReason = chunk.choices?.[0]?.finish_reason
+						if (finishReason) stop = finishReason
+					} catch {
+						// Skip malformed JSON chunks
+					}
+				}
+			}
+
+			const content: AssistantResult["content"] = consolidate([...textParts])
+			for (const [, tc] of currentToolCalls) {
+				content.push({
+					type: "tool_call",
+					id: tc.id,
+					name: tc.name,
+					args: JSON.parse(tc.args || "{}"),
+				})
+				es.push({
+					type: "tool_call",
+					call: {
+						type: "tool_call",
+						id: tc.id,
+						name: tc.name,
+						args: JSON.parse(tc.args || "{}"),
+					},
+				})
+				stop = "tool_use"
+			}
+
+			es.finish({ content, usage, stop: stop as StopReason })
+		} catch (e) {
+			if (opts.signal?.aborted) return
+			const errorMsg = `Unexpected 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
+}
+
+// Auto-register
+register("openai", streamOpenAI)