novacode 0.5.5 → 0.7.0

package/src/tui/components/message.tsx

@@ -1,113 +0,0 @@
-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

@@ -1,58 +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,
-}: {
-	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/markdown.ts

@@ -1,62 +0,0 @@
-import chalk from "chalk"
-
-export class MarkdownRenderer {
-	#inCodeBlock = false
-	#codeBlockLang = ""
-
-	renderLine(line: string): string {
-		if (line.startsWith("```")) {
-			if (this.#inCodeBlock) {
-				this.#inCodeBlock = false
-				return chalk.dim(`└${"─".repeat(50)}`)
-			}
-			this.#inCodeBlock = true
-			this.#codeBlockLang = line.slice(3).trim()
-			return chalk.dim(
-				"┌" +
-					"─".repeat(10) +
-					` [Code: ${this.#codeBlockLang || "text"}] ` +
-					"─".repeat(40 - (this.#codeBlockLang?.length || 4)),
-			)
-		}
-
-		if (this.#inCodeBlock) {
-			return chalk.cyan(`│  ${line}`)
-		}
-
-		if (line.startsWith("#")) {
-			const match = line.match(/^(#{1,6})\s+(.*)$/)
-			if (match?.[1] && match[2]) {
-				const level = match[1].length
-				const content = match[2]
-				if (level === 1) return chalk.bold.magenta.underline(content)
-				if (level === 2) return chalk.bold.blue(content)
-				return chalk.bold.cyan(content)
-			}
-		}
-
-		let formatted = line
-		if (formatted.startsWith("- ") || formatted.startsWith("* ")) {
-			formatted = `  ${chalk.yellow("•")} ${formatted.slice(2)}`
-		}
-
-		formatted = formatted.replace(/`([^`]+)`/g, (_, code) => chalk.yellow(code))
-		formatted = formatted.replace(/\*\*([^*]+)\*\*/g, (_, bold) => chalk.bold(bold))
-		formatted = formatted.replace(/__([^_]+)__/g, (_, bold) => chalk.bold(bold))
-		formatted = formatted.replace(/\*([^*]+)\*/g, (_, italic) => chalk.italic(italic))
-		formatted = formatted.replace(/_([^_]+)_/g, (_, italic) => chalk.italic(italic))
-		formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => {
-			return `${chalk.blue(text)} ${chalk.dim(`(${url})`)}`
-		})
-
-		return formatted
-	}
-}
-
-export function formatMarkdown(text: string): string {
-	const renderer = new MarkdownRenderer()
-	return text
-		.split("\n")
-		.map((line) => renderer.renderLine(line))
-		.join("\n")
-}

package/src/tui/prompts.tsx

@@ -1,205 +0,0 @@
-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

@@ -1,248 +0,0 @@
-/**
- * Shared type definitions for the entire project.
- * Includes messaging, tools, providers, and agent loop events.
- */
-/** Content Parts */
-
-export interface TextPart {
-	type: "text"
-	text: string
-	signature?: string
-}
-
-export interface ImagePart {
-	type: "image"
-	data: string // base64
-	mime: string
-}
-
-export interface ThinkPart {
-	type: "thinking"
-	text: string
-	signature?: string
-}
-
-export interface ToolCallPart {
-	type: "tool_call"
-	id: string
-	name: string
-	args: Record<string, unknown>
-	signature?: string
-}
-
-export type ContentPart = TextPart | ImagePart | ThinkPart | ToolCallPart
-
-/** Messages */
-
-export interface UserMsg {
-	role: "user"
-	content: string | ContentPart[]
-	ts: number
-}
-
-export interface AssistantMsg {
-	role: "assistant"
-	content: ContentPart[]
-	model: string
-	provider: string
-	usage: Usage
-	stop: StopReason
-	error?: string
-	ts: number
-}
-
-export interface ToolResultMsg {
-	role: "tool_result"
-	callId: string
-	tool: string
-	args?: Record<string, unknown>
-	content: ContentPart[]
-	isError: boolean
-	ts: number
-}
-
-export type Msg = UserMsg | AssistantMsg | ToolResultMsg
-export type StopReason = "stop" | "length" | "tool_use" | "error" | "aborted"
-
-/** Usage */
-
-export interface Usage {
-	in: number
-	out: number
-	cacheRead?: number
-	cacheWrite?: number
-}
-
-/** Provider */
-
-export type ApiFormat = "openai" | "gemini"
-
-export interface ProviderDef {
-	id: string
-	name: string
-	api: ApiFormat
-	baseUrl: string
-	envKey: string // env var name for API key
-}
-
-export interface Model {
-	id: string
-	name: string
-	provider: string
-	contextWindow: number
-	maxTokens: number
-	supportsThinking: boolean
-}
-
-/** Tools */
-
-export interface ToolDef {
-	name: string
-	description: string
-	parameters: ToolParamDef
-}
-
-export interface ToolParamDef {
-	type: "object"
-	properties: Record<string, ToolPropDef>
-	required?: string[]
-}
-
-export interface ToolPropDef {
-	type: string
-	description?: string
-	enum?: string[]
-	items?: ToolPropDef
-	properties?: Record<string, ToolPropDef>
-	required?: string[]
-}
-
-export interface ToolResult {
-	content: ContentPart[]
-	isError: boolean
-}
-
-export type ToolExecuteFn = (
-	args: Record<string, unknown>,
-	signal?: AbortSignal,
-) => Promise<ToolResult>
-
-export interface Tool {
-	def: ToolDef
-	execute: ToolExecuteFn
-}
-
-/** Agent Events */
-
-export type AgentEvent =
-	| { type: "start" }
-	| { type: "turn" }
-	| { type: "text_delta"; text: string }
-	| { type: "thinking_delta"; text: string }
-	| { type: "tool_call"; call: ToolCallPart }
-	| { type: "assistant_msg"; msg: AssistantMsg }
-	| { type: "tool_result"; callId: string; result: ToolResultMsg; args?: Record<string, unknown> }
-	| { type: "turn_end"; msg: AssistantMsg; results: ToolResultMsg[] }
-	| { type: "usage"; usage: Usage }
-
-/** Config */
-
-export interface NovaConfig {
-	provider: string
-	model: string
-}
-
-export interface NovaAuth {
-	apiKeys: Record<string, string> // provider -> key
-}
-
-/** Session */
-
-export interface Session {
-	id: string
-	cwd: string
-	model: string
-	provider: string
-	title: string | null
-	created: number
-	updated: number
-}
-
-/** Loop & Provider Types */
-
-export interface LoopCtx {
-	system: string
-	messages: Msg[]
-	tools: Tool[]
-}
-
-export interface LoopOpts {
-	api: ApiFormat
-	model: Model
-	apiKey: string
-	baseUrl: string
-	maxTurns?: number
-	// Intercept tool calls before they execute
-	beforeTool?: (
-		call: ToolCallPart,
-		args: Record<string, unknown>,
-		ctx: LoopCtx,
-	) => Promise<{ block?: boolean; reason?: string } | undefined>
-	// Run logic after a tool completes
-	afterTool?: (call: ToolCallPart, result: ToolResultMsg, ctx: LoopCtx) => Promise<void>
-}
-
-export interface StreamOpts {
-	api: ApiFormat
-	model: Model
-	apiKey: string
-	baseUrl: string
-	system: string
-	messages: Msg[]
-	tools: ToolDef[]
-	signal?: AbortSignal
-}
-
-export interface IEventStream<T, R> {
-	[Symbol.asyncIterator](): AsyncGenerator<T>
-	result: R | undefined
-	isDone: boolean
-}
-
-export type StreamFn = (opts: StreamOpts) => IEventStream<StreamEvent, AssistantResult>
-
-export interface StreamEvent {
-	type: "text_delta" | "thinking_delta" | "tool_call" | "usage"
-	text?: string
-	call?: ToolCallPart
-	usage?: Usage
-}
-
-export interface AssistantResult {
-	content: ContentPart[]
-	usage: Usage
-	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 {
-	name: string
-	desc: string
-	aliases?: string[]
-}