novacode 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "novacode",
-	"version": "0.4.0",
+	"version": "0.5.1",
 	"description": "Open-source multi-provider coding agent. Bun-native.",
 	"type": "module",
 	"module": "src/main.ts",

package/src/commands/index.ts

@@ -2,6 +2,7 @@ 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 { checkForUpdate, runUpdate } from "../update.ts"
 import { handleCompact } from "./compact.ts"
 import { handleModels } from "./models.ts"
 import { handleProviders } from "./providers.ts"
@@ -10,6 +11,7 @@ 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: "update", desc: "Update novacode" },
 	{ name: "help", desc: "Show help" },
 	{ name: "clear", desc: "Clear screen" },
 	{ name: "quit", desc: "Exit (Ctrl+D)", aliases: ["exit"] },
@@ -19,6 +21,10 @@ const HELP = `
 ${chalk.bold("Commands:")}
 ${COMMANDS.map((c) => `  /${c.name.padEnd(12)} ${c.desc}`).join("\n")}
 
+${chalk.bold("CLI:")}
+  nova update      Update to latest version
+  nova session ls  List sessions
+
 ${chalk.dim("Keys:")}
   Esc             Abort
   ↑ / ↓           History
@@ -45,6 +51,8 @@ export async function dispatch(
 		case "compact":
 			if (!store || !sessionId) return chalk.red("Session store not available")
 			return handleCompact(agent, store, sessionId)
+		case "update":
+			return handleUpdate()
 		case "help":
 			return HELP
 		case "clear":
@@ -60,3 +68,18 @@ export async function dispatch(
 			return chalk.yellow(`Unknown: /${cmd}. Type /help`)
 	}
 }
+
+async function handleUpdate(): Promise<string> {
+	const info = await checkForUpdate()
+	if (!info) return chalk.yellow("Could not check for updates.")
+	if (!info.hasUpdate) return chalk.green(`✓ Already up to date (v${info.current})`)
+
+	console.log(chalk.yellow(`\n⚡ Updating novacode to v${info.latest}...`))
+	const success = await runUpdate(true)
+	if (success) {
+		return chalk.green(
+			`✓ Successfully updated to v${info.latest}! Please restart nova to apply changes.`,
+		)
+	}
+	return chalk.red("✗ Update failed. Please try running 'nova update' manually in your terminal.")
+}

package/src/main.ts

@@ -1,10 +1,11 @@
 #!/usr/bin/env bun
+import { join } from "node:path"
+import { parseArgs } from "node:util"
 /**
  * Entry point for the nova CLI.
  * Handles configuration, CLI flags, and switches between interactive/print modes.
  */
-import { join } from "node:path"
-import { parseArgs } from "node:util"
+import chalk from "chalk"
 import { Agent } from "./agent/agent.ts"
 import { buildSystemPrompt } from "./agent/prompt.ts"
 import { handleSessionCommand } from "./commands/session.ts"
@@ -13,7 +14,7 @@ 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"
+import { runUpdate } from "./update.ts"
 
 // Ensure providers are registered
 import "./provider/openai.ts"
@@ -29,7 +30,7 @@ function parseCli() {
 			"api-key": { type: "string" },
 			session: { type: "string", short: "s" },
 		},
-		strict: false,
+		strict: true,
 		allowPositionals: true,
 	})
 
@@ -57,7 +58,7 @@ async function main() {
 
 Usage:
   nova                Interactive mode
-  nova "prompt"       Print mode (non-interactive)
+  nova update         Update to latest version
   nova session <cmd>  Session management (list, delete)
   nova --session <id> Resume a session
 
@@ -77,6 +78,19 @@ Options:
 		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 = () => {
@@ -148,17 +162,7 @@ Options:
 		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)
+	// Interactive TUI mode
 	process.off("SIGINT", onSignal)
 	process.off("SIGTERM", onSignal)
 	const { interactive } = await import("./tui/app.tsx")

package/src/tui/app.tsx

@@ -5,6 +5,7 @@ import type { Agent } from "../agent/agent.ts"
 import { COMMANDS, dispatch } from "../commands/index.ts"
 import type { SessionStore } from "../session/store.ts"
 import type { Msg } from "../types.ts"
+import { checkForUpdate } from "../update.ts"
 import { formatToolArgs, makeRelative } from "../util.ts"
 import { formatMarkdown } from "./markdown.ts"
 export async function interactive(
@@ -71,6 +72,17 @@ function App({
 	const history = useRef<string[]>([])
 	const hIdx = useRef(-1)
 	const abortCtrl = useRef<AbortController | null>(null)
+	const [updateInfo, setUpdateInfo] = useState<{ current: string; latest: string } | null>(null)
+
+	useEffect(() => {
+		const check = async () => {
+			const info = await checkForUpdate()
+			if (info?.hasUpdate) {
+				setUpdateInfo({ current: info.current, latest: info.latest })
+			}
+		}
+		check()
+	}, [])
 
 	const isTypingCmd = input.startsWith("/") && !input.includes(" ")
 	const suggestions = isTypingCmd
@@ -349,6 +361,23 @@ function App({
 
 			{/* Input & Footer (Live) */}
 			<Box flexDirection="column" marginTop={visibleMsgs.length > 0 || isLiveActive ? 1 : 0}>
+				{updateInfo && (
+					<Box
+						borderStyle="round"
+						borderColor="yellow"
+						paddingX={1}
+						marginBottom={1}
+						flexDirection="column"
+					>
+						<Text color="yellow" bold>
+							⬆ Update Available (v{updateInfo.current} → v{updateInfo.latest})
+						</Text>
+						<Text dimColor>
+							Run <Text color="cyan">/update</Text> or <Text color="cyan">nova update</Text> to
+							upgrade.
+						</Text>
+					</Box>
+				)}
 				<Box flexDirection="row">
 					<Box flexShrink={0} marginRight={1}>
 						<Text bold color="green">

package/src/update.ts

@@ -0,0 +1,65 @@
+import { join } from "node:path"
+import { semver } from "bun"
+
+let cachedLatest: string | null = null
+
+export async function getCurrentVersion(): Promise<string> {
+	try {
+		const pkg = await Bun.file(join(import.meta.dir, "..", "package.json")).json()
+		return pkg.version ?? "0.0.0"
+	} catch {
+		return "0.0.0"
+	}
+}
+
+export async function getLatestVersion(): Promise<string | null> {
+	if (cachedLatest) return cachedLatest
+	try {
+		const proc = Bun.spawn(["bun", "info", "novacode", "version"], {
+			stdout: "pipe",
+			stderr: "ignore",
+		})
+		const text = await new Response(proc.stdout).text()
+		const latest = text.trim()
+		if (latest) {
+			cachedLatest = latest
+			return latest
+		}
+	} catch {}
+	return null
+}
+
+export async function checkForUpdate(): Promise<{
+	hasUpdate: boolean
+	current: string
+	latest: string
+} | null> {
+	const current = await getCurrentVersion()
+	const latest = await getLatestVersion()
+	if (!latest) return null
+	return {
+		hasUpdate: semver.order(latest, current) === 1,
+		current,
+		latest,
+	}
+}
+
+export async function runUpdate(silent = false): Promise<boolean> {
+	const proc = Bun.spawn(["bun", "update", "-g", "novacode", "--latest"], {
+		stdout: silent ? "ignore" : "inherit",
+		stderr: silent ? "ignore" : "inherit",
+	})
+	const exitCode = await proc.exited
+	if (exitCode === 0) {
+		if (!silent) {
+			console.log("✓ novacode updated to latest version successfully.")
+		}
+		return true
+	} else {
+		if (!silent) {
+			console.error(`Update failed (exit code ${exitCode})`)
+			process.exit(1)
+		}
+		return false
+	}
+}

package/src/tui/print.ts

@@ -1,75 +0,0 @@
-import chalk from "chalk"
-import type { Agent } from "../agent/agent.ts"
-import type { Msg } from "../types.ts"
-import { formatToolArgs } from "../util.ts"
-import { MarkdownRenderer } from "./markdown.ts"
-
-const TOOL_STYLE: Record<string, (s: string) => string> = {
-	read: (s) => chalk.blue.bold(s),
-	write: (s) => chalk.magenta.bold(s),
-	edit: (s) => chalk.yellow.bold(s),
-	bash: (s) => chalk.cyan.bold(s),
-	glob: (s) => chalk.green.bold(s),
-	find: (s) => chalk.green.bold(s),
-	grep: (s) => chalk.green.bold(s),
-}
-
-function stylizeTool(name: string): string {
-	const stylize = TOOL_STYLE[name] || ((s) => chalk.white.bold(s))
-	return stylize(name)
-}
-
-export async function runPrintMode(
-	agent: Agent,
-	prompt: string,
-	signal?: AbortSignal,
-): Promise<Msg[] | undefined> {
-	const stream = agent.prompt(prompt, signal)
-	let output = ""
-	let lastEventWasTool = false
-
-	const renderer = new MarkdownRenderer()
-	let lineBuffer = ""
-
-	for await (const event of stream) {
-		if (signal?.aborted) break
-		if (event.type === "text_delta") {
-			output += event.text
-			lineBuffer += event.text
-
-			if (lineBuffer.includes("\n")) {
-				const lines = lineBuffer.split("\n")
-				lineBuffer = lines.pop() ?? ""
-				for (const line of lines) {
-					process.stdout.write(`${renderer.renderLine(line)}\n`)
-				}
-			}
-			lastEventWasTool = false
-		}
-		if (event.type === "tool_call") {
-			const argsObj = event.call.args
-			const argsStr = argsObj ? ` ${formatToolArgs(argsObj, true)}` : ""
-			if (!lastEventWasTool) {
-				process.stderr.write("\n")
-			}
-			process.stderr.write(`⏳ ${stylizeTool(event.call.name)}${argsStr}… `)
-			lastEventWasTool = true
-		}
-		if (event.type === "tool_result") {
-			const status = event.result.isError ? chalk.red("✗") : chalk.green("✓")
-			const argsObj = event.result.args
-			const argsStr = argsObj ? ` ${formatToolArgs(argsObj, true)}` : ""
-			process.stderr.write(`\r${status} ${stylizeTool(event.result.tool)}${argsStr}\x1B[K\n`)
-		}
-	}
-
-	if (lineBuffer) {
-		process.stdout.write(renderer.renderLine(lineBuffer))
-	}
-
-	if (output && !output.endsWith("\n")) {
-		process.stdout.write("\n")
-	}
-
-	return stream.result
-}