novacode 0.5.1 → 0.5.3

package/src/tui/app.tsx

@@ -1,27 +1,43 @@
 import chalk from "chalk"
 import { Box, render, Static, Text, useInput } from "ink"
-import { useEffect, useRef, useState } from "react"
+import { useCallback, useEffect, useRef, useState } from "react"
 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 type { Msg, Prompts } from "../types.ts"
+import { checkForUpdate, getCurrentVersion } from "../update.ts"
+import { formatToolArgs } from "../util.ts"
 import { formatMarkdown } from "./markdown.ts"
+import { ConfirmPrompt, PasswordPrompt, SelectPrompt } from "./prompts.tsx"
+
+type PromptMode =
+	| { type: "chat" }
+	| {
+			type: "select"
+			message: string
+			options: Array<{ value: string; label: string; hint?: string }>
+			header?: string
+	  }
+	| {
+			type: "password"
+			message: string
+			validate?: (v: string) => string | undefined
+	  }
+	| { type: "confirm"; message: string }
+
 export async function interactive(
 	agent: Agent,
 	store: SessionStore,
 	sessionId: string,
 ): Promise<void> {
-	// Hide system cursor during session
 	process.stdout.write("\x1B[?25l")
-	process.stdout.write(chalk.bold.cyan("⚡ novacode\n"))
+	const version = await getCurrentVersion()
+	process.stdout.write(`${chalk.cyan.bold("⚡ novacode")} ${chalk.gray(`v${version}`)}\n`)
 
 	try {
 		const { waitUntilExit } = render(<App agent={agent} store={store} sessionId={sessionId} />)
 		await waitUntilExit()
 	} finally {
-		// Restore system cursor on exit
 		process.stdout.write("\x1B[?25h")
 	}
 }
@@ -66,13 +82,20 @@ function App({
 	const [busy, setBusy] = useState(false)
 	const [input, setInput] = useState("")
 	const [status, setStatus] = useState("")
-	const [usage, setUsage] = useState<{ in: number; out: number }>({ in: 0, out: 0 })
+	const [usage, setUsage] = useState<{ in: number; out: number }>({
+		in: 0,
+		out: 0,
+	})
 	const [selCmdIdx, setSelCmdIdx] = useState(0)
-	const [cmdRunning, setCmdRunning] = useState(false)
+	const [mode, setMode] = useState<PromptMode>({ type: "chat" })
+	const resolveRef = useRef<((v: unknown) => void) | null>(null)
 	const history = useRef<string[]>([])
 	const hIdx = useRef(-1)
 	const abortCtrl = useRef<AbortController | null>(null)
-	const [updateInfo, setUpdateInfo] = useState<{ current: string; latest: string } | null>(null)
+	const [updateInfo, setUpdateInfo] = useState<{
+		current: string
+		latest: string
+	} | null>(null)
 
 	useEffect(() => {
 		const check = async () => {
@@ -93,19 +116,53 @@ function App({
 			)
 		: []
 
+	const prompts: Prompts = {
+		select: useCallback(
+			(config) =>
+				new Promise((resolve) => {
+					resolveRef.current = resolve as (v: unknown) => void
+					setMode({ type: "select", ...config })
+				}),
+			[],
+		),
+		password: useCallback(
+			(config) =>
+				new Promise((resolve) => {
+					resolveRef.current = resolve as (v: unknown) => void
+					setMode({ type: "password", ...config })
+				}),
+			[],
+		),
+		confirm: useCallback(
+			(config) =>
+				new Promise((resolve) => {
+					resolveRef.current = resolve as (v: unknown) => void
+					setMode({ type: "confirm", ...config })
+				}),
+			[],
+		),
+	}
+
+	function resolvePrompt(value: unknown) {
+		const fn = resolveRef.current
+		resolveRef.current = null
+		setMode({ type: "chat" })
+		fn?.(value)
+	}
+
+	function commitMsg(msg: Msg) {
+		setMsgs((prev) => [...prev, msg])
+		agent.setMessages([...agent.messages, msg])
+		store.append(sessionId, msg)
+	}
+
 	// biome-ignore lint/correctness/useExhaustiveDependencies: reset selection on input change
 	useEffect(() => {
 		setSelCmdIdx(0)
 	}, [input])
 
-	useEffect(() => {
-		if (!cmdRunning) {
-			process.stdout.write("\x1B[?25l")
-		}
-	}, [cmdRunning])
-
 	useInput((ch, key) => {
-		if (cmdRunning) return
+		if (mode.type !== "chat") return
 
 		if (key.escape) {
 			if (abortCtrl.current) {
@@ -146,7 +203,7 @@ function App({
 		if (!key.return) {
 			setInput((prev) => {
 				if (key.backspace || key.delete) return prev.slice(0, -1)
-				return prev + ch
+				return prev + (ch || "")
 			})
 			return
 		}
@@ -168,71 +225,35 @@ function App({
 		hIdx.current = -1
 
 		if (line.startsWith("/")) {
-			const cmdName = line.slice(1).split(" ")[0]?.toLowerCase() ?? ""
-			const isInteractive =
-				["providers", "prov", "config", "cfg", "models", "model"].includes(cmdName) &&
-				!line.includes(" ")
-
-			if (isInteractive) {
-				setCmdRunning(true)
-				// Small delay to let Ink clear
-				setTimeout(() => {
-					dispatch(line, agent, store, sessionId).then((r) => {
-						process.stdin.setRawMode?.(true)
-						setCmdRunning(false)
-						if (r) {
-							setMsgs((prev) => {
-								const updated: Msg[] = [
-									...prev,
-									{
-										role: "assistant",
-										content: [{ type: "text", text: r }],
-										model: "system",
-										provider: "system",
-										usage: { in: 0, out: 0 },
-										stop: "stop",
-										ts: Date.now(),
-									},
-								]
-								agent.setMessages(updated)
-								return updated
-							})
-						}
-					})
-				}, 50)
-				return
-			}
-
-			// Slash commands
-			dispatch(line, agent, store, sessionId).then((r) => {
+			dispatch(line, agent, store, sessionId, prompts).then((r) => {
 				if (r) {
-					setMsgs((prev) => {
-						const updated: Msg[] = [
-							...prev,
-							{
-								role: "assistant",
-								content: [{ type: "text", text: r }],
-								model: "system",
-								provider: "system",
-								usage: { in: 0, out: 0 },
-								stop: "stop",
-								ts: Date.now(),
-							},
-						]
-
-						agent.setMessages(updated)
-						return updated
+					commitMsg({
+						role: "assistant",
+						content: [{ type: "text", text: r }],
+						model: "system",
+						provider: "system",
+						usage: { in: 0, out: 0 },
+						stop: "stop",
+						ts: Date.now(),
 					})
 				}
 			})
 			return
 		}
 
+		// Record user message before starting the stream
+		const userMsg: Msg = { role: "user", content: line, ts: Date.now() }
+		commitMsg(userMsg)
+
 		abortCtrl.current = new AbortController()
-		const stream = agent.prompt(line, abortCtrl.current.signal)
+		const eventStream = agent.prompt(line, abortCtrl.current.signal)
 
-		;(async () => {
-			for await (const ev of stream) {
+		runEventLoop(eventStream)
+	})
+
+	async function runEventLoop(eventStream: ReturnType<Agent["prompt"]>) {
+		try {
+			for await (const ev of eventStream) {
 				switch (ev.type) {
 					case "start":
 						setBusy(true)
@@ -247,40 +268,22 @@ function App({
 						if (ev.text) setThinkStream((prev) => prev + ev.text)
 						break
 					case "assistant_msg":
-						setStream("")
-						setThinkStream("")
-						setMsgs((prev) => {
-							const updated = [...prev, ev.msg]
-							agent.setMessages(updated)
-							return updated
-						})
-						store.append(sessionId, ev.msg)
+						commitMsg(ev.msg)
+						setTimeout(() => {
+							setStream("")
+							setThinkStream("")
+						}, 0)
 						break
 					case "tool_call":
 						setStatus(chalk.dim(`⏳ ${ev.call.name}…`))
 						break
 					case "tool_result":
-						setMsgs((prev) => {
-							const updated = [...prev, ev.result]
-							agent.setMessages(updated)
-							return updated
-						})
-						store.append(sessionId, ev.result)
-						{
-							const args = ev.args
-								? `(${Object.values(ev.args)
-										.map((v) => {
-											const val = typeof v === "string" ? makeRelative(v) : JSON.stringify(v)
-											return val.length > 20 ? `${val.slice(0, 20)}…` : val
-										})
-										.join(", ")})`
-								: ""
-							setStatus(
-								ev.result.isError
-									? chalk.red(`✗ ${ev.result.tool}${args}`)
-									: chalk.green(`✓ ${ev.result.tool}${args}`),
-							)
-						}
+						commitMsg(ev.result)
+						setStatus(
+							ev.result.isError
+								? chalk.red(`✗ ${ev.result.tool}`)
+								: chalk.green(`✓ ${ev.result.tool}`),
+						)
 						break
 					case "turn_end":
 						setStatus("")
@@ -289,36 +292,44 @@ function App({
 						if (ev.usage) setUsage(ev.usage)
 				}
 			}
-			abortCtrl.current = null
-			setBusy(false)
-			setStatus("")
-			setStream("")
-			setThinkStream("")
-		})().catch((err) => {
+		} catch (err) {
 			const errMsg: Msg = {
 				role: "assistant",
 				model: "system",
 				provider: "system",
-				content: [{ type: "text", text: chalk.red(`Error: ${err.message}`) }],
+				content: [{ type: "text", text: chalk.red(`Error: ${(err as Error).message}`) }],
 				usage: { in: 0, out: 0 },
 				stop: "error",
 				ts: Date.now(),
 			}
-			setMsgs((prev) => [...prev, errMsg])
+			commitMsg(errMsg)
+		} finally {
+			abortCtrl.current = null
 			setBusy(false)
-		})
-
-		// Record user msg immediately
-		const userMsg: Msg = { role: "user", content: line, ts: Date.now() }
-		setMsgs((prev) => {
-			const updated = [...prev, userMsg]
-			agent.setMessages(updated)
-			return updated
-		})
-		store.append(sessionId, userMsg)
-	})
+			setStream("")
+			setThinkStream("")
+			setStatus("")
+		}
+	}
 
-	if (cmdRunning) return null
+	if (mode.type === "select") {
+		return (
+			<SelectPrompt
+				message={mode.message}
+				options={mode.options}
+				header={mode.header}
+				onSelect={resolvePrompt}
+			/>
+		)
+	}
+	if (mode.type === "password") {
+		return (
+			<PasswordPrompt message={mode.message} validate={mode.validate} onSubmit={resolvePrompt} />
+		)
+	}
+	if (mode.type === "confirm") {
+		return <ConfirmPrompt message={mode.message} onConfirm={resolvePrompt} />
+	}
 
 	const visibleMsgs = msgs.filter(hasMeaningfulContent)
 	const isLiveActive = !!(stream || thinkStream || busy)
@@ -445,6 +456,7 @@ const TOOL_STYLE: Record<string, string> = {
 	glob: "green",
 	find: "green",
 	grep: "green",
+	tree: "green",
 }
 
 function hasMeaningfulContent(msg: Msg): boolean {
@@ -493,7 +505,6 @@ function Message({ msg, isFirst }: { msg: Msg; isFirst: boolean }) {
 			)
 		}
 
-		// Don't render empty assistant messages (often just tool call containers)
 		const hasVisibleContent = msg.content.some((c) => c.type === "text" || c.type === "thinking")
 		if (!hasVisibleContent) return null
 

package/src/tui/prompts.tsx

@@ -0,0 +1,205 @@
+import { Box, render, Text, useInput } from "ink"
+import { useState } from "react"
+
+interface SelectOption {
+	value: string
+	label: string
+	hint?: string
+}
+
+export function SelectPrompt({
+	message,
+	options,
+	header,
+	onSelect,
+}: {
+	message: string
+	options: SelectOption[]
+	header?: string
+	onSelect: (value: string | null) => void
+}) {
+	const [idx, setIdx] = useState(0)
+
+	useInput((_, key) => {
+		if (key.escape) {
+			onSelect(null)
+			return
+		}
+		if (key.upArrow) {
+			setIdx((i) => (i - 1 + options.length) % options.length)
+			return
+		}
+		if (key.downArrow) {
+			setIdx((i) => (i + 1) % options.length)
+			return
+		}
+		if (key.return) {
+			onSelect(options[idx]?.value ?? null)
+		}
+	})
+
+	return (
+		<Box flexDirection="column" paddingX={1}>
+			{header && (
+				<Box marginBottom={1}>
+					<Text>{header}</Text>
+				</Box>
+			)}
+			<Box marginBottom={1}>
+				<Text bold>{message}</Text>
+			</Box>
+			{options.map((opt, i) => (
+				<Box key={opt.value}>
+					<Text color={i === idx ? "green" : undefined}>
+						{i === idx ? "❯ " : "  "}
+						{opt.label}
+					</Text>
+					{opt.hint && i === idx && <Text dimColor> {opt.hint}</Text>}
+				</Box>
+			))}
+			<Box marginTop={1}>
+				<Text dimColor>↑↓ navigate · Enter select · Esc cancel</Text>
+			</Box>
+		</Box>
+	)
+}
+
+export function PasswordPrompt({
+	message,
+	validate,
+	onSubmit,
+}: {
+	message: string
+	validate?: (v: string) => string | undefined
+	onSubmit: (value: string | null) => void
+}) {
+	const [value, setValue] = useState("")
+	const [error, setError] = useState("")
+
+	useInput((ch, key) => {
+		if (key.escape) {
+			onSubmit(null)
+			return
+		}
+		if (key.return) {
+			const err = validate?.(value)
+			if (err) {
+				setError(err)
+				return
+			}
+			onSubmit(value)
+			return
+		}
+		if (key.backspace || key.delete) {
+			setValue((v) => v.slice(0, -1))
+			setError("")
+			return
+		}
+		if (ch) {
+			setValue((v) => v + ch)
+			setError("")
+		}
+	})
+
+	return (
+		<Box flexDirection="column" paddingX={1}>
+			<Box marginBottom={1}>
+				<Text bold>{message}</Text>
+			</Box>
+			<Box>
+				<Text color="green">│ </Text>
+				<Text dimColor>{"*".repeat(value.length)}</Text>
+				<Text color="green">│</Text>
+			</Box>
+			{error && (
+				<Box>
+					<Text color="red">{error}</Text>
+				</Box>
+			)}
+			<Box marginTop={1}>
+				<Text dimColor>Enter submit · Esc cancel</Text>
+			</Box>
+		</Box>
+	)
+}
+
+export function ConfirmPrompt({
+	message,
+	onConfirm,
+}: {
+	message: string
+	onConfirm: (value: boolean | null) => void
+}) {
+	const [yes, setYes] = useState(true)
+
+	useInput((_, key) => {
+		if (key.escape) {
+			onConfirm(null)
+			return
+		}
+		if (key.leftArrow || key.rightArrow || key.tab) {
+			setYes((y) => !y)
+			return
+		}
+		if (key.return) {
+			onConfirm(yes)
+		}
+	})
+
+	return (
+		<Box flexDirection="column" paddingX={1}>
+			<Box marginBottom={1}>
+				<Text bold>{message}</Text>
+			</Box>
+			<Box>
+				<Text color={yes ? "green" : undefined}>{yes ? "❯ " : "  "}Yes</Text>
+			</Box>
+			<Box>
+				<Text color={!yes ? "red" : undefined}>{!yes ? "❯ " : "  "}No</Text>
+			</Box>
+			<Box marginTop={1}>
+				<Text dimColor>←→ toggle · Enter confirm · Esc cancel</Text>
+			</Box>
+		</Box>
+	)
+}
+
+// Standalone wrappers for use outside the main TUI (e.g. onboarding)
+
+export function standaloneSelect(
+	message: string,
+	options: SelectOption[],
+	header?: string,
+): Promise<string | null> {
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<SelectPrompt
+				message={message}
+				options={options}
+				header={header}
+				onSelect={(v) => {
+					unmount()
+					resolve(v)
+				}}
+			/>,
+		)
+	})
+}
+
+export function standalonePassword(
+	message: string,
+	validate?: (v: string) => string | undefined,
+): Promise<string | null> {
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<PasswordPrompt
+				message={message}
+				validate={validate}
+				onSubmit={(v) => {
+					unmount()
+					resolve(v)
+				}}
+			/>,
+		)
+	})
+}

package/src/types.ts

@@ -224,6 +224,21 @@ export interface AssistantResult {
 	stop: StopReason
 }
 
+/** Prompts — used by interactive commands within the TUI */
+
+export interface Prompts {
+	select(config: {
+		message: string
+		header?: string
+		options: Array<{ value: string; label: string; hint?: string }>
+	}): Promise<string | null>
+	password(config: {
+		message: string
+		validate?: (v: string) => string | undefined
+	}): Promise<string | null>
+	confirm(config: { message: string }): Promise<boolean | null>
+}
+
 /** Commands */
 
 export interface Cmd {

package/src/update.ts

@@ -1,12 +1,21 @@
-import { join } from "node:path"
-import { semver } from "bun"
+import { spawn } from "node:child_process"
+import { readFile } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import semver from "semver"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
 
 let cachedLatest: string | null = null
+let cachedCurrent: string | null = null
 
 export async function getCurrentVersion(): Promise<string> {
+	if (cachedCurrent) return cachedCurrent
 	try {
-		const pkg = await Bun.file(join(import.meta.dir, "..", "package.json")).json()
-		return pkg.version ?? "0.0.0"
+		const raw = await readFile(join(__dirname, "..", "package.json"), "utf-8")
+		const pkg = JSON.parse(raw)
+		cachedCurrent = (pkg.version as string) ?? "0.0.0"
+		return cachedCurrent
 	} catch {
 		return "0.0.0"
 	}
@@ -15,15 +24,20 @@ export async function getCurrentVersion(): Promise<string> {
 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 proc = spawn("npm", ["info", "novacode", "version"], {
+			stdio: ["ignore", "pipe", "ignore"],
+		})
+		const text = await new Promise<string>((resolve, reject) => {
+			let out = ""
+			proc.stdout.on("data", (chunk: Buffer) => {
+				out += chunk.toString()
+			})
+			proc.on("error", reject)
+			proc.on("close", () => resolve(out.trim()))
 		})
-		const text = await new Response(proc.stdout).text()
-		const latest = text.trim()
-		if (latest) {
-			cachedLatest = latest
-			return latest
+		if (text) {
+			cachedLatest = text
+			return text
 		}
 	} catch {}
 	return null
@@ -38,26 +52,36 @@ export async function checkForUpdate(): Promise<{
 	const latest = await getLatestVersion()
 	if (!latest) return null
 	return {
-		hasUpdate: semver.order(latest, current) === 1,
+		hasUpdate: semver.gt(latest, current),
 		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.")
+	try {
+		const proc = spawn("npm", ["update", "-g", "novacode"], {
+			stdio: silent ? "ignore" : "inherit",
+		})
+		const exitCode = await new Promise<number>((resolve, reject) => {
+			proc.on("error", reject)
+			proc.on("close", (code) => resolve(code ?? -1))
+		})
+		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
 		}
-		return true
-	} else {
+	} catch (e) {
 		if (!silent) {
-			console.error(`Update failed (exit code ${exitCode})`)
+			console.error(`Update failed: ${(e as Error).message}`)
 			process.exit(1)
 		}
 		return false