novacode 0.2.0

package/src/commands/compact.ts

@@ -0,0 +1,28 @@
+import chalk from "chalk"
+import type { Agent } from "../agent/agent.ts"
+import { compact as runCompact } from "../session/compact.ts"
+import type { SessionStore } from "../session/store.ts"
+
+export async function handleCompact(
+	agent: Agent,
+	store: SessionStore,
+	sessionId: string,
+): Promise<string> {
+	const res = await runCompact(
+		store,
+		sessionId,
+		agent.messages,
+		agent.model,
+		agent.apiKey,
+		agent.baseUrl,
+	)
+
+	if (res.compacted) {
+		// Update agent messages
+		const msgs = store.messages(sessionId)
+		agent.setMessages(msgs)
+		return chalk.green(`✓ Context compacted (${res.msgsRemoved} messages removed)`)
+	}
+
+	return chalk.yellow("Context is small enough, no compaction needed.")
+}

package/src/commands/index.ts

@@ -0,0 +1,62 @@
+import chalk from "chalk"
+import type { Agent } from "../agent/agent.ts"
+import type { SessionStore } from "../session/store.ts"
+import type { Cmd } from "../types.ts"
+import { handleCompact } from "./compact.ts"
+import { handleModels } from "./models.ts"
+import { handleProviders } from "./providers.ts"
+
+export const COMMANDS: Cmd[] = [
+	{ name: "models", desc: "Switch model", aliases: ["model"] },
+	{ name: "providers", desc: "Manage providers", aliases: ["prov", "config", "cfg"] },
+	{ name: "compact", desc: "Compact context" },
+	{ name: "help", desc: "Show help" },
+	{ name: "clear", desc: "Clear screen" },
+	{ name: "quit", desc: "Exit (Ctrl+D)", aliases: ["exit"] },
+]
+
+const HELP = `
+${chalk.bold("Commands:")}
+${COMMANDS.map((c) => `  /${c.name.padEnd(12)} ${c.desc}`).join("\n")}
+
+${chalk.dim("Keys:")}
+  Esc             Abort
+  ↑ / ↓           History
+`
+
+export async function dispatch(
+	input: string,
+	agent: Agent,
+	store?: SessionStore,
+	sessionId?: string,
+): Promise<string | null> {
+	const [cmd, ...rest] = input.slice(1).split(" ")
+	const args = rest.join(" ")
+
+	switch (cmd) {
+		case "models":
+		case "model":
+			return handleModels(args, agent)
+		case "providers":
+		case "prov":
+		case "config":
+		case "cfg":
+			return handleProviders(agent)
+		case "compact":
+			if (!store || !sessionId) return chalk.red("Session store not available")
+			return handleCompact(agent, store, sessionId)
+		case "help":
+			return HELP
+		case "clear":
+			console.clear()
+			return ""
+		case "quit":
+			process.exit(0)
+			return null
+		case "exit":
+			process.exit(0)
+			return null
+		default:
+			return chalk.yellow(`Unknown: /${cmd}. Type /help`)
+	}
+}

package/src/commands/models.ts

@@ -0,0 +1,86 @@
+import * as clack from "@clack/prompts"
+import chalk from "chalk"
+import type { Agent } from "../agent/agent.ts"
+import { getProvider, MODELS } from "../config/providers.ts"
+import { loadAuth, loadConfig, saveConfig } from "../config/store.ts"
+
+export async function handleModels(args: string, agent: Agent): Promise<string> {
+	const config = await loadConfig()
+	const auth = await loadAuth()
+
+	if (args) return await switchDirect(args.trim(), agent)
+
+	const options: clack.Option<string>[] = []
+	for (const m of MODELS) {
+		const cur = m.id === config.model && m.provider === config.provider
+		const pDef = getProvider(m.provider)
+		if (!pDef) continue
+
+		// Ensure we have an API key for the provider
+		const hasKey = !!auth.apiKeys[m.provider]
+		if (!hasKey) continue
+
+		options.push({
+			value: `${m.provider}:${m.id}`,
+			label: `${cur ? chalk.green("●") : "○"} ${m.id.padEnd(20)} ${fmt(m.contextWindow).padEnd(8)}`,
+			hint: pDef.name,
+		})
+	}
+
+	if (!options.length)
+		return chalk.yellow("No models available. Use /providers to add a provider API key.")
+
+	const pick = await clack.select({ message: "Model", options })
+	if (clack.isCancel(pick)) return ""
+
+	const [pk, mid] = (pick as string).split(":")
+	const selectedModel = MODELS.find((m) => m.provider === pk && m.id === mid)
+	const selectedProvider = getProvider(pk!)
+
+	if (!selectedModel || !selectedProvider) return chalk.red("Error: Model or provider not found")
+
+	config.provider = pk!
+	config.model = mid!
+	await saveConfig(config)
+
+	// Update agent
+	agent.updateConfig({
+		api: selectedProvider.api,
+		model: selectedModel,
+		apiKey: auth.apiKeys[pk!] ?? "",
+		baseUrl: selectedProvider.baseUrl,
+	})
+	return chalk.green(`✓ Switched to ${mid}`)
+}
+
+async function switchDirect(id: string, agent: Agent): Promise<string> {
+	const config = await loadConfig()
+	const auth = await loadAuth()
+
+	const m = MODELS.find((m) => m.id === id)
+	if (!m) return chalk.yellow(`"${id}" not found. Use /models`)
+
+	const pk = m.provider
+	if (!auth.apiKeys[pk]) {
+		return chalk.yellow(`No API key configured for ${pk}. Use /providers`)
+	}
+
+	const selectedProvider = getProvider(pk)
+	if (!selectedProvider) return chalk.red("Error: Provider not found")
+
+	config.provider = pk
+	config.model = id
+	await saveConfig(config)
+
+	// Update agent
+	agent.updateConfig({
+		api: selectedProvider.api,
+		model: m,
+		apiKey: auth.apiKeys[pk],
+		baseUrl: selectedProvider.baseUrl,
+	})
+
+	return chalk.green(`✓ Switched to ${id}`)
+}
+
+const fmt = (n: number) => (n >= 1_000_000 ? `${n / 1_000_000}M` : `${n / 1000}K`)

package/src/commands/providers.ts

@@ -0,0 +1,222 @@
+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"
+
+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({
+		message: "Action",
+		options: [
+			{ value: "add", label: "Add Provider" },
+			{ value: "update", label: "Update API Key" },
+			{ value: "remove", label: "Remove API Key" },
+			{ value: "default", label: "Set Default Provider" },
+			{ value: "back", label: "Back" },
+		],
+	})
+	if (clack.isCancel(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)
+	return ""
+}
+
+async function addProvider(agent: Agent): Promise<string> {
+	const auth = await loadAuth()
+	const config = await loadConfig()
+
+	const available = PROVIDERS.filter((p) => !auth.apiKeys[p.id])
+	if (available.length === 0) {
+		return chalk.yellow("All providers already have API keys configured.")
+	}
+
+	const pick = await clack.select({
+		message: "Add Provider",
+		options: available.map((p) => ({ value: p.id, label: p.name })),
+	})
+	if (clack.isCancel(pick)) return ""
+
+	const pDef = getProvider(pick as string)
+	if (!pDef) return chalk.red("Error: Provider not found")
+
+	const key = await clack.password({
+		message: `${pDef.name} API Key`,
+		validate: (v) => (!v || v.length < 8 ? "Enter a valid key" : undefined),
+	})
+	if (clack.isCancel(key)) return ""
+
+	auth.apiKeys[pDef.id] = key as string
+	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)
+		if (mDef) {
+			config.model = mDef.id
+		}
+		await saveConfig(config)
+		agent.updateConfig({
+			api: pDef.api,
+			model: MODELS.find((m) => m.id === config.model)!,
+			apiKey: key as string,
+			baseUrl: pDef.baseUrl,
+		})
+	}
+
+	return chalk.green(`✓ ${pDef.name} configured`)
+}
+
+async function updateKey(agent: Agent): Promise<string> {
+	const auth = await loadAuth()
+
+	const configured = PROVIDERS.filter((p) => !!auth.apiKeys[p.id])
+	if (configured.length === 0) {
+		return chalk.yellow("No providers configured. Use 'Add Provider' first.")
+	}
+
+	const pick = await clack.select({
+		message: "Update API Key",
+		options: configured.map((p) => ({ value: p.id, label: p.name })),
+	})
+	if (clack.isCancel(pick)) return ""
+
+	const pDef = getProvider(pick as string)
+	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 ""
+
+	auth.apiKeys[pDef.id] = key as string
+	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)
+		if (currentModel) {
+			agent.updateConfig({
+				api: pDef.api,
+				model: currentModel,
+				apiKey: key as string,
+				baseUrl: pDef.baseUrl,
+			})
+		}
+	}
+
+	return chalk.green("✓ Key updated")
+}
+
+async function removeKey(agent: Agent): Promise<string> {
+	const auth = await loadAuth()
+	const config = await loadConfig()
+
+	const configured = PROVIDERS.filter((p) => !!auth.apiKeys[p.id])
+	if (configured.length === 0) {
+		return chalk.yellow("No configured providers to remove.")
+	}
+
+	const pick = await clack.select({
+		message: "Remove API Key",
+		options: configured.map((p) => ({ value: p.id, label: p.name })),
+	})
+	if (clack.isCancel(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}?`,
+	})
+	if (clack.isCancel(confirm) || !confirm) return ""
+
+	delete auth.apiKeys[pId]
+	await saveAuth(auth)
+
+	// If removing the active provider's key
+	if (config.provider === pId) {
+		config.provider = ""
+		config.model = ""
+		// Try to find another configured provider
+		const next = Object.keys(auth.apiKeys)[0]
+		if (next) {
+			const pDef = getProvider(next)
+			const mDef = MODELS.find((m) => m.provider === next)
+			if (pDef && mDef) {
+				config.provider = next
+				config.model = mDef.id
+				agent.updateConfig({
+					api: pDef.api,
+					model: mDef,
+					apiKey: auth.apiKeys[next]!,
+					baseUrl: pDef.baseUrl,
+				})
+			}
+		}
+		await saveConfig(config)
+	}
+
+	return chalk.green(`✓ Removed API key for ${pId}`)
+}
+
+async function setDefault(agent: Agent): Promise<string> {
+	const config = await loadConfig()
+	const auth = await loadAuth()
+
+	const pick = await clack.select({
+		message: "Default Provider",
+		options: PROVIDERS.map((p) => {
+			const hasKey = !!auth.apiKeys[p.id]
+			return {
+				value: p.id,
+				label: `${hasKey ? "✅" : "❌"} ${p.name}`,
+			}
+		}),
+	})
+	if (clack.isCancel(pick)) return ""
+
+	const pId = pick as string
+	if (!auth.apiKeys[pId]) {
+		return chalk.yellow(`No API key for ${pId}. Please set one first.`)
+	}
+
+	const pDef = getProvider(pId)
+	const mDef = MODELS.find((m) => m.provider === pId)
+
+	if (!pDef || !mDef) return chalk.red("Error: Provider or model not found")
+
+	config.provider = pId
+	config.model = mDef.id
+	await saveConfig(config)
+
+	agent.updateConfig({
+		api: pDef.api,
+		model: mDef,
+		apiKey: auth.apiKeys[pId],
+		baseUrl: pDef.baseUrl,
+	})
+
+	return chalk.green(`✓ Default set to ${pDef.name} (${mDef.id})`)
+}

package/src/commands/session.ts

@@ -0,0 +1,40 @@
+import { getSessionStore } from "../session/store.ts"
+
+export async function handleSessionCommand(args: string[]): Promise<void> {
+	const store = getSessionStore()
+	const [subcommand, id] = args
+
+	if (subcommand === "list" || subcommand === "ls") {
+		const sessions = store.list()
+		if (sessions.length === 0) {
+			console.log("No sessions found.")
+			return
+		}
+
+		console.log("ID".padEnd(25), "MODEL".padEnd(20), "UPDATED")
+		console.log("-".repeat(70))
+		for (const s of sessions) {
+			const date = new Date(s.updated).toLocaleString()
+			console.log(s.id.padEnd(25), s.model.padEnd(20), date)
+		}
+		return
+	}
+
+	if (subcommand === "delete" || subcommand === "rm") {
+		if (!id) {
+			console.error("Usage: novacode session delete <id>")
+			process.exit(1)
+		}
+		const success = store.delete(id)
+		if (success) {
+			console.log(`Deleted session: ${id}`)
+		} else {
+			console.error(`Session not found: ${id}`)
+			process.exit(1)
+		}
+		return
+	}
+
+	console.error("Unknown session subcommand. Use 'list' or 'delete'.")
+	process.exit(1)
+}

package/src/config/providers.ts

@@ -0,0 +1,199 @@
+import type { Model, ProviderDef } from "../types.ts"
+
+export const PROVIDERS: ProviderDef[] = [
+	{
+		id: "glm",
+		name: "GLM (Z.AI)",
+		api: "openai",
+		baseUrl: "https://api.z.ai/api/coding/paas/v4",
+		envKey: "GLM_API_KEY",
+	},
+	{
+		id: "gemini",
+		name: "Gemini (Google)",
+		api: "gemini",
+		baseUrl: "https://generativelanguage.googleapis.com",
+		envKey: "GEMINI_API_KEY",
+	},
+	{
+		id: "deepseek",
+		name: "DeepSeek",
+		api: "openai",
+		baseUrl: "https://api.deepseek.com",
+		envKey: "DEEPSEEK_API_KEY",
+	},
+	{
+		id: "openai",
+		name: "OpenAI",
+		api: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		envKey: "OPENAI_API_KEY",
+	},
+]
+
+export const MODELS: Model[] = [
+	// GLM
+	{
+		id: "glm-5.1",
+		name: "GLM-5.1",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	{
+		id: "glm-5",
+		name: "GLM-5",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	{
+		id: "glm-5-turbo",
+		name: "GLM-5 Turbo",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	{
+		id: "glm-4.7",
+		name: "GLM-4.7",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	{
+		id: "glm-4.7-flash",
+		name: "GLM-4.7 Flash (Free)",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	{
+		id: "glm-4.5-flash",
+		name: "GLM-4.5 Flash (Free)",
+		provider: "glm",
+		contextWindow: 128_000,
+		maxTokens: 4096,
+		supportsThinking: false,
+	},
+	// Gemini
+	{
+		id: "gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro Preview",
+		provider: "gemini",
+		contextWindow: 2_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-3.1-pro-preview-customtools",
+		name: "Gemini 3.1 Pro (Custom Tools)",
+		provider: "gemini",
+		contextWindow: 2_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-3.1-flash-lite",
+		name: "Gemini 3.1 Flash-Lite",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-3.1-flash-lite-preview",
+		name: "Gemini 3.1 Flash-Lite Preview",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash Preview",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		provider: "gemini",
+		contextWindow: 2_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-2.5-flash-lite",
+		name: "Gemini 2.5 Flash-Lite",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	{
+		id: "gemini-2.5-computer-use-preview-10-2025",
+		name: "Gemini 2.5 Computer Use",
+		provider: "gemini",
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		supportsThinking: true,
+	},
+	// DeepSeek
+	{
+		id: "deepseek-chat",
+		name: "DeepSeek V3",
+		provider: "deepseek",
+		contextWindow: 64_000,
+		maxTokens: 8_192,
+		supportsThinking: false,
+	},
+	{
+		id: "deepseek-reasoner",
+		name: "DeepSeek R1",
+		provider: "deepseek",
+		contextWindow: 64_000,
+		maxTokens: 8_192,
+		supportsThinking: true,
+	},
+	// OpenAI
+	{
+		id: "gpt-4o",
+		name: "GPT-4o",
+		provider: "openai",
+		contextWindow: 128_000,
+		maxTokens: 16_384,
+		supportsThinking: false,
+	},
+	{
+		id: "o4-mini",
+		name: "o4-mini",
+		provider: "openai",
+		contextWindow: 200_000,
+		maxTokens: 100_000,
+		supportsThinking: true,
+	},
+]
+
+export function getProvider(id: string): ProviderDef | undefined {
+	return PROVIDERS.find((p) => p.id === id)
+}
+
+export function getModelsForProvider(providerId: string): Model[] {
+	return MODELS.filter((m) => m.provider === providerId)
+}

package/src/config/store.ts

@@ -0,0 +1,67 @@
+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 Bun.file(CONFIG_PATH()).stat()
+		return true
+	} catch {
+		return false
+	}
+}
+
+export async function loadConfig(): Promise<NovaConfig> {
+	try {
+		const raw = await Bun.file(CONFIG_PATH()).json()
+		return { ...defaultConfig, ...raw }
+	} catch {
+		return { ...defaultConfig }
+	}
+}
+
+export async function loadAuth(): Promise<NovaAuth> {
+	try {
+		const raw = await Bun.file(AUTH_PATH()).json()
+		return { ...defaultAuth, ...raw }
+	} catch {
+		return { ...defaultAuth }
+	}
+}
+
+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))
+}
+
+export async function saveAuth(auth: NovaAuth): Promise<void> {
+	await ensureDir()
+	await Bun.write(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
+	}
+}
+
+export function getNovaDir(): string {
+	return NOVA_DIR()
+}