novacode 0.5.5 → 0.7.0

package/src/main.ts

@@ -1,175 +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 { 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" },
-		},
-		strict: true,
-		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 <cmd>  Session management (list, delete)
-  nova --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
-	}
-
-	// Handle update subcommand
-	if (args[0] === "update") {
-		await runUpdate()
-		return
-	}
-
-	// Reject positional args — use interactive mode with / commands
-	if (args.length > 0) {
-		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()
-
-	// 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 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)
-
-	// 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,
-	})
-
-	// 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,261 +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 () => {
-		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 })
-										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) 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
-}

package/src/provider/openai.ts

@@ -1,215 +0,0 @@
-import type {
-	AssistantResult,
-	Msg,
-	StopReason,
-	StreamEvent,
-	StreamFn,
-	StreamOpts,
-	ToolDef,
-	Usage,
-} from "../types.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 textContent = ""
-			let stop = "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)
-					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 })
-							textContent += 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"] = []
-			if (textContent) {
-				content.push({ type: "text", text: textContent })
-			}
-			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
-}