novacode 0.6.0 → 0.7.0

package/src/tui/app.tsx

@@ -1,454 +0,0 @@
-import chalk from "chalk"
-import { Box, render, Static, Text, useApp, useInput } from "ink"
-import { useCallback, useEffect, useRef, useState } from "react"
-import type { Agent } from "../agent/agent.ts"
-import { COMMANDS, dispatch } from "../commands/index.ts"
-import { getProvider, MODELS } from "../config/providers.ts"
-import { loadAuth } from "../config/store.ts"
-import { generateSessionTitle } from "../session/compact.ts"
-import type { SessionStore } from "../session/store.ts"
-import type { Msg, Prompts } from "../types.ts"
-import { checkForUpdate, getCurrentVersion } from "../update.ts"
-import { Cursor, LiveArea } from "./components/liveArea.tsx"
-import { hasMeaningfulContent, Message } from "./components/message.tsx"
-import { StatusBar } from "./components/statusBar.tsx"
-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> {
-	process.stdout.write("\x1B[?25l")
-	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} />, {
-			exitOnCtrlC: false,
-		})
-		await waitUntilExit()
-	} finally {
-		process.stdout.write("\x1B[?25h")
-		await store.prune()
-	}
-}
-
-function App({
-	agent,
-	store,
-	sessionId: initialSessionId,
-}: {
-	agent: Agent
-	store: SessionStore
-	sessionId: string
-}) {
-	const [currSessionId, setCurrSessionId] = useState(initialSessionId)
-	const [msgs, setMsgs] = useState<Msg[]>(agent.messages)
-
-	const handleSwitchSession = useCallback(
-		async (newSessionId: string) => {
-			const s = await store.get(newSessionId)
-			if (!s) return
-
-			const provider = getProvider(s.provider)
-			const model =
-				MODELS.find((m) => m.id === s.model && m.provider === s.provider) ||
-				MODELS.find((m) => m.id === s.model)
-			if (provider && model) {
-				const auth = await loadAuth()
-				const apiKey = auth.apiKeys[s.provider] || ""
-				agent.updateConfig({
-					api: provider.api,
-					model,
-					apiKey,
-					baseUrl: provider.baseUrl,
-				})
-			}
-
-			const newMsgs = await store.messages(newSessionId)
-			agent.setMessages(newMsgs)
-			setMsgs(newMsgs)
-			setCurrSessionId(newSessionId)
-		},
-		[store, agent],
-	)
-	const [stream, setStream] = useState("")
-	const [thinkStream, setThinkStream] = useState("")
-	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 [selCmdIdx, setSelCmdIdx] = useState(0)
-	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 { exit } = useApp()
-	const lastExitPress = useRef<{ key: "C"; ts: number } | null>(null)
-	const [exitConfirmKey, setExitConfirmKey] = useState<"C" | 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
-		? COMMANDS.filter(
-				(c) =>
-					c.name.startsWith(input.slice(1).toLowerCase()) ||
-					c.aliases?.some((a) => a.startsWith(input.slice(1).toLowerCase())),
-			)
-		: []
-
-	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(currSessionId, msg).catch((err) => {
-			console.error("Error appending message to session store:", err)
-		})
-	}
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: reset selection on input change
-	useEffect(() => {
-		setSelCmdIdx(0)
-	}, [input])
-
-	useInput((ch, key) => {
-		if (key.ctrl && (ch === "c" || ch === "d")) {
-			if (busy) {
-				if (ch === "c") {
-					if (abortCtrl.current) {
-						abortCtrl.current.abort()
-						abortCtrl.current = null
-					}
-				}
-				return
-			}
-
-			// Idle state - handle exit
-			if (ch === "d") {
-				exit()
-				return
-			}
-
-			// Ctrl+C double-press exit logic
-			const now = Date.now()
-			if (
-				lastExitPress.current &&
-				lastExitPress.current.key === "C" &&
-				now - lastExitPress.current.ts < 2000
-			) {
-				exit()
-			} else {
-				lastExitPress.current = { key: "C", ts: now }
-				setExitConfirmKey("C")
-				// Clear the temporary status after 2 seconds
-				setTimeout(() => {
-					if (lastExitPress.current?.key === "C" && Date.now() - lastExitPress.current.ts >= 2000) {
-						lastExitPress.current = null
-						setExitConfirmKey(null)
-					}
-				}, 2000)
-			}
-			return
-		}
-
-		if (mode.type !== "chat") return
-
-		if (key.escape) {
-			if (abortCtrl.current) {
-				abortCtrl.current.abort()
-				abortCtrl.current = null
-			} else if (input) {
-				setInput("")
-			}
-			return
-		}
-		if (key.upArrow) {
-			if (isTypingCmd && suggestions.length > 0) {
-				setSelCmdIdx((prev) => (prev > 0 ? prev - 1 : suggestions.length - 1))
-				return
-			}
-			if (history.current.length > 0) {
-				hIdx.current = Math.min(hIdx.current + 1, history.current.length - 1)
-				setInput(history.current[hIdx.current] ?? "")
-			}
-			return
-		}
-		if (key.downArrow) {
-			if (isTypingCmd && suggestions.length > 0) {
-				setSelCmdIdx((prev) => (prev < suggestions.length - 1 ? prev + 1 : 0))
-				return
-			}
-			hIdx.current = Math.max(hIdx.current - 1, -1)
-			setInput(hIdx.current >= 0 ? (history.current[hIdx.current] ?? "") : "")
-			return
-		}
-		if (key.tab) {
-			if (isTypingCmd && suggestions.length > 0) {
-				const match = suggestions[selCmdIdx]
-				if (match) {
-					setInput(`/${match.name} `)
-				}
-			}
-			return
-		}
-		if (!key.return) {
-			setInput((prev) => {
-				if (key.backspace || key.delete) return prev.slice(0, -1)
-				return prev + (ch || "")
-			})
-			return
-		}
-
-		if (busy) return
-
-		let line = input.trim()
-		if (!line) return
-
-		if (isTypingCmd && suggestions.length > 0) {
-			const match = suggestions[selCmdIdx]
-			if (match) {
-				line = `/${match.name}`
-			}
-		}
-
-		setInput("")
-		history.current.unshift(line)
-		hIdx.current = -1
-
-		if (line.startsWith("/")) {
-			dispatch(line, agent, store, currSessionId, prompts, exit, handleSwitchSession).then((r) => {
-				if (r) {
-					commitMsg({
-						role: "assistant",
-						content: [{ type: "text", text: r }],
-						model: "system",
-						provider: "system",
-						usage: { in: 0, out: 0 },
-						stop: "stop",
-						ts: Date.now(),
-					})
-				}
-			})
-			return
-		}
-
-		const userMsg: Msg = { role: "user", content: line, ts: Date.now() }
-		commitMsg(userMsg)
-
-		abortCtrl.current = new AbortController()
-		const eventStream = agent.prompt(line, abortCtrl.current.signal)
-
-		runEventLoop(eventStream)
-	})
-
-	async function runEventLoop(eventStream: ReturnType<Agent["prompt"]>) {
-		try {
-			for await (const ev of eventStream) {
-				switch (ev.type) {
-					case "start":
-						setBusy(true)
-						setStream("")
-						setThinkStream("")
-						setStatus("")
-						break
-					case "text_delta":
-						if (ev.text) setStream((prev) => prev + ev.text)
-						break
-					case "thinking_delta":
-						if (ev.text) setThinkStream((prev) => prev + ev.text)
-						break
-					case "assistant_msg":
-						commitMsg(ev.msg)
-						setStream("")
-						setThinkStream("")
-
-						break
-					case "tool_call":
-						setStatus(chalk.dim(`⏳ ${ev.call.name}…`))
-						break
-					case "tool_result":
-						commitMsg(ev.result)
-						setStatus(
-							ev.result.isError
-								? chalk.red(`✗ ${ev.result.tool}`)
-								: chalk.green(`✓ ${ev.result.tool}`),
-						)
-						break
-					case "turn_end":
-						setStatus("")
-						store
-							.get(currSessionId)
-							.then((s) => {
-								if (s && !s.title && agent.messages.length >= 2) {
-									generateSessionTitle(agent.messages, agent.model, agent.apiKey, agent.baseUrl)
-										.then((title) => {
-											if (title) {
-												store.setTitle(currSessionId, title).catch(() => {})
-											}
-										})
-										.catch(() => {})
-								}
-							})
-							.catch(() => {})
-						break
-					case "usage":
-						if (ev.usage) setUsage(ev.usage)
-				}
-			}
-		} catch (err) {
-			const errMsg: Msg = {
-				role: "assistant",
-				model: "system",
-				provider: "system",
-				content: [{ type: "text", text: chalk.red(`Error: ${(err as Error).message}`) }],
-				usage: { in: 0, out: 0 },
-				stop: "error",
-				ts: Date.now(),
-			}
-			commitMsg(errMsg)
-		} finally {
-			abortCtrl.current = null
-			setBusy(false)
-			setStream("")
-			setThinkStream("")
-			setStatus("")
-		}
-	}
-
-	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)
-
-	return (
-		<Box flexDirection="column" paddingX={1}>
-			<Static items={visibleMsgs}>
-				{(m, i) => <Message key={`${m.ts}-${i}`} msg={m} isFirst={i === 0} />}
-			</Static>
-
-			<LiveArea stream={stream} thinkStream={thinkStream} busy={busy} status={status} />
-
-			<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">
-							{">"}
-						</Text>
-					</Box>
-					<Box flexGrow={1} flexShrink={1}>
-						<Text>
-							{input}
-							<Cursor />
-						</Text>
-					</Box>
-				</Box>
-
-				<StatusBar
-					model={agent.model}
-					usage={usage}
-					busy={busy}
-					suggestions={suggestions}
-					selCmdIdx={selCmdIdx}
-					exitConfirmKey={exitConfirmKey}
-				/>
-			</Box>
-		</Box>
-	)
-}

package/src/tui/components/liveArea.tsx

@@ -1,70 +0,0 @@
-import chalk from "chalk"
-import { Box, Text } from "ink"
-import { useEffect, useState } from "react"
-import { SPINNER_FRAMES } from "../constants.ts"
-import { formatMarkdown } from "../markdown.ts"
-
-export function Spinner() {
-	const [frame, setFrame] = useState(0)
-
-	useEffect(() => {
-		const timer = setInterval(() => {
-			setFrame((f) => (f + 1) % SPINNER_FRAMES.length)
-		}, 80)
-		return () => clearInterval(timer)
-	}, [])
-
-	return <Text color="yellow">{SPINNER_FRAMES[frame]}</Text>
-}
-
-export function Cursor() {
-	const [visible, setVisible] = useState(true)
-	useEffect(() => {
-		const timer = setInterval(() => setVisible((v) => !v), 530)
-		return () => clearInterval(timer)
-	}, [])
-	return <Text color="green">{visible ? "│" : " "}</Text>
-}
-
-export function LiveArea({
-	stream,
-	thinkStream,
-	busy,
-	status,
-}: {
-	stream: string
-	thinkStream: string
-	busy: boolean
-	status: string
-}) {
-	const isActive = !!(stream || thinkStream || busy)
-	if (!isActive) return null
-
-	return (
-		<Box flexDirection="column" marginTop={0}>
-			{thinkStream && (
-				<Text dimColor italic>
-					{thinkStream}
-				</Text>
-			)}
-			{stream && (
-				<Box flexDirection="row">
-					<Box flexGrow={1} flexShrink={1}>
-						<Text>
-							{formatMarkdown(stream)}
-							<Cursor />
-						</Text>
-					</Box>
-				</Box>
-			)}
-			{busy && !stream && (
-				<Box flexDirection="row">
-					<Box marginRight={1}>
-						<Spinner />
-					</Box>
-					<Text dimColor>{status ? status.replace("⏳ ", "") : chalk.yellow("working…")}</Text>
-				</Box>
-			)}
-		</Box>
-	)
-}

package/src/tui/components/message.tsx

@@ -1,117 +0,0 @@
-import { Box, Text } from "ink"
-import type { Msg } from "../../types.ts"
-import { formatToolArgs } from "../../util.ts"
-import { TERMINATION_PHRASES, TOOL_STYLE } from "../constants.ts"
-import { formatMarkdown } from "../markdown.ts"
-
-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
-		if (msg.stop === "aborted") 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 isAborted = msg.stop === "aborted"
-		const hasVisibleContent =
-			isAborted || msg.content.some((c) => c.type === "text" || c.type === "thinking")
-		if (!hasVisibleContent) return null
-
-		const termPhrase = isAborted
-			? (TERMINATION_PHRASES[msg.ts % TERMINATION_PHRASES.length] ?? "Terminated by user")
-			: ""
-
-		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
-				})}
-				{isAborted && (
-					<Box marginTop={0}>
-						<Text color="red" italic>
-							▲ {termPhrase}
-						</Text>
-					</Box>
-				)}
-			</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

@@ -1,64 +0,0 @@
-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,
-	exitConfirmKey,
-}: {
-	model: Model
-	usage: { in: number; out: number }
-	busy: boolean
-	suggestions: Array<{ name: string; desc: string }>
-	selCmdIdx: number
-	exitConfirmKey: "C" | null
-}) {
-	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>
-				) : exitConfirmKey === "C" ? (
-					<Text color="yellow">Press Ctrl+C again to exit</Text>
-				) : busy ? (
-					<Text dimColor>Press Esc to abort or terminate</Text>
-				) : (
-					<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>
-	)
-}