novacode 0.5.2 → 0.5.5

package/src/tui/components/message.tsx

@@ -0,0 +1,113 @@
+import { Box, Text } from "ink"
+import type { Msg } from "../../types.ts"
+import { formatToolArgs } from "../../util.ts"
+import { formatMarkdown } from "../markdown.ts"
+
+const TOOL_STYLE: Record<string, string> = {
+	read: "blue",
+	write: "magenta",
+	edit: "yellow",
+	bash: "cyan",
+	glob: "green",
+	find: "green",
+	grep: "green",
+	tree: "green",
+}
+
+export function hasMeaningfulContent(msg: Msg): boolean {
+	if (msg.role === "user") return true
+	if (msg.role === "tool_result") return true
+	if (msg.role === "assistant") {
+		if (msg.model === "system") return true
+		return msg.content.some((c) => {
+			if (c.type === "thinking") return c.text.trim().length > 0
+			if (c.type === "text") return c.text.trim().length > 0
+			return false
+		})
+	}
+	return false
+}
+
+export function Message({ msg, isFirst }: { msg: Msg; isFirst: boolean }) {
+	if (msg.role === "user") {
+		return (
+			<Box marginTop={isFirst ? 0 : 1} flexDirection="row">
+				<Box flexShrink={0} marginRight={1}>
+					<Text bold color="green">
+						{">"}
+					</Text>
+				</Box>
+				<Box flexGrow={1} flexShrink={1}>
+					<Text>
+						{typeof msg.content === "string"
+							? msg.content
+							: msg.content.map((c) => (c.type === "text" ? c.text : "")).join("")}
+					</Text>
+				</Box>
+			</Box>
+		)
+	}
+
+	if (msg.role === "assistant") {
+		if (msg.model === "system") {
+			return (
+				<Box flexDirection="column" marginTop={0}>
+					{msg.content.map((c, i) =>
+						// biome-ignore lint/suspicious/noArrayIndexKey: stable turn content
+						c.type === "text" ? <Text key={i}>{formatMarkdown(c.text)}</Text> : null,
+					)}
+				</Box>
+			)
+		}
+
+		const hasVisibleContent = msg.content.some((c) => c.type === "text" || c.type === "thinking")
+		if (!hasVisibleContent) return null
+
+		return (
+			<Box flexDirection="column" marginTop={0}>
+				{msg.content.map((c, i) => {
+					if (c.type === "thinking") {
+						return (
+							// biome-ignore lint/suspicious/noArrayIndexKey: stable turn content
+							<Text key={i} dimColor italic>
+								{c.text}
+							</Text>
+						)
+					}
+					if (c.type === "text") {
+						// biome-ignore lint/suspicious/noArrayIndexKey: stable turn content
+						return <Text key={i}>{formatMarkdown(c.text)}</Text>
+					}
+					return null
+				})}
+			</Box>
+		)
+	}
+
+	if (msg.role === "tool_result") {
+		const args = msg.args ? formatToolArgs(msg.args, true) : ""
+
+		const resText = msg.content
+			.map((c) => (c.type === "text" ? c.text : ""))
+			.join("")
+			.trim()
+
+		const isRead = msg.tool === "read"
+		const lineCount = isRead ? resText.split("\n").length : 0
+		const color = TOOL_STYLE[msg.tool] || "white"
+
+		return (
+			<Box flexDirection="row">
+				<Text color={msg.isError ? "red" : "green"}>{msg.isError ? "✗" : "✓"} </Text>
+				<Text color={color} bold>
+					{msg.tool}
+				</Text>
+				{args && <Text> {args}</Text>}
+				{isRead && !msg.isError && <Text dimColor> ({lineCount} lines)</Text>}
+				{msg.isError && resText && <Text color="red"> {resText.slice(0, 80)}</Text>}
+			</Box>
+		)
+	}
+
+	return null
+}

package/src/tui/components/statusBar.tsx

@@ -0,0 +1,58 @@
+import { Box, Text } from "ink"
+import type { Model } from "../../types.ts"
+
+function fmtK(n: number): string {
+	const k = n / 1000
+	return k >= 100 ? `${Math.round(k)}K` : `${k.toFixed(1)}K`
+}
+
+function formatTokenUsage(used: number, contextWindow: number): string {
+	if (used === 0) return `0/${fmtK(contextWindow)}`
+	const pct = Math.round((used / contextWindow) * 100)
+	return `${fmtK(used)}/${fmtK(contextWindow)} (${pct}%)`
+}
+
+export function StatusBar({
+	model,
+	usage,
+	busy,
+	suggestions,
+	selCmdIdx,
+}: {
+	model: Model
+	usage: { in: number; out: number }
+	busy: boolean
+	suggestions: Array<{ name: string; desc: string }>
+	selCmdIdx: number
+}) {
+	return (
+		<Box justifyContent="space-between">
+			<Box>
+				{suggestions.length > 0 ? (
+					<Box flexDirection="column" marginLeft={2}>
+						{suggestions.map((s, i) => (
+							<Box key={s.name}>
+								<Text
+									color={i === selCmdIdx ? "black" : "yellow"}
+									backgroundColor={i === selCmdIdx ? "yellow" : undefined}
+								>
+									/{s.name.padEnd(10)}
+								</Text>
+								<Text dimColor> {s.desc}</Text>
+							</Box>
+						))}
+					</Box>
+				) : (
+					<Text dimColor>Enter to send · /help for commands</Text>
+				)}
+			</Box>
+
+			<Box>
+				<Text dimColor>{formatTokenUsage(usage.in, model.contextWindow)}</Text>
+				<Text dimColor> │ </Text>
+				<Text dimColor>{model.id}</Text>
+				{busy && <Text dimColor> │ Esc to stop</Text>}
+			</Box>
+		</Box>
+	)
+}

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,5 +1,10 @@
-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
@@ -7,7 +12,8 @@ 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()
+		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 {
@@ -18,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
@@ -41,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

package/src/util.ts

@@ -1,6 +1,6 @@
 import { isAbsolute, relative } from "node:path"
 import chalk from "chalk"
-import type { ContentPart, Msg, TextPart } from "./types.ts"
+import type { Msg, TextPart } from "./types.ts"
 
 // ~4 chars per token for English/code. Close enough for capacity warnings.
 export function estimateTokens(messages: Msg[]): number {
@@ -21,33 +21,6 @@ export function textPart(s: string): TextPart {
 	return { type: "text", text: s }
 }
 
-export function consolidate(parts: ContentPart[]): ContentPart[] {
-	if (parts.length === 0) return parts
-	const out: ContentPart[] = []
-	for (const p of parts) {
-		const last = out[out.length - 1]
-		if (last?.type === "text" && p.type === "text") {
-			last.text += p.text
-		} else if (last?.type === "thinking" && p.type === "thinking") {
-			last.text += p.text
-		} else {
-			out.push({ ...p })
-		}
-	}
-
-	const hasTool = out.some((p) => p.type === "tool_call")
-	if (hasTool) {
-		return out.filter((p) => {
-			if (p.type === "text") {
-				return p.text.trim().length > 0
-			}
-			return true
-		})
-	}
-
-	return out
-}
-
 export function getRelativeIfInside(cwd: string, filePath: string): string {
 	if (filePath === cwd || filePath.startsWith(`${cwd}/`)) {
 		return relative(cwd, filePath) || "."

package/src/provider/registry.ts

@@ -1,62 +0,0 @@
-/**
- * Registry for different model providers (OpenAI, Anthropic, etc.).
- * Provides a unified streaming interface for the agent loop.
- */
-import type { AgentEvent, ApiFormat, AssistantResult, StreamFn, StreamOpts } from "../types.ts"
-import { EventStream } from "./stream.ts"
-
-export type { AssistantResult, StreamEvent, StreamFn, StreamOpts } from "../types.ts"
-
-// Internal map of registered provider implementations
-const registry = new Map<ApiFormat, StreamFn>()
-
-export function register(api: ApiFormat, fn: StreamFn): void {
-	registry.set(api, fn)
-}
-
-// Bridges provider-specific StreamEvents into AgentEvents so the loop and TUI deal with one type.
-export function stream(opts: StreamOpts): EventStream<AgentEvent, AssistantResult> {
-	const fn = registry.get(opts.api)
-	if (!fn) throw new Error(`No provider registered for API format: ${opts.api}`)
-
-	// Bridge layer: converts provider-specific StreamEvents into the agent's
-	// AgentEvent shape, so the loop and TUI only deal with one event type.
-	const providerStream = fn(opts)
-	const agentStream = new EventStream<AgentEvent, AssistantResult>()
-
-	;(async () => {
-		for await (const event of providerStream) {
-			if (event.type === "text_delta") {
-				agentStream.push({ type: "text_delta", text: event.text ?? "" })
-			} else if (event.type === "thinking_delta") {
-				agentStream.push({ type: "thinking_delta", text: event.text ?? "" })
-			} else if (event.type === "tool_call" && event.call) {
-				agentStream.push({
-					type: "tool_call",
-					call: {
-						type: "tool_call",
-						id: event.call.id,
-						name: event.call.name,
-						args: event.call.args,
-					},
-				})
-			} else if (event.type === "usage" && event.usage) {
-				agentStream.push({ type: "usage", usage: event.usage })
-			}
-		}
-
-		const res = providerStream.result
-		if (res) {
-			agentStream.finish(res)
-		} else {
-			// Fallback for unexpected closure
-			agentStream.finish({ content: [], usage: { in: 0, out: 0 }, stop: "stop" })
-		}
-	})()
-
-	return agentStream
-}
-
-export function getRegisteredApis(): ApiFormat[] {
-	return [...registry.keys()]
-}