novacode 0.6.0 → 0.7.0

package/src/tui/constants.ts

@@ -1,25 +0,0 @@
-/**
- * TUI-specific static constants and configuration styles.
- */
-
-export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-
-export const TOOL_STYLE: Record<string, string> = {
-	read: "blue",
-	write: "magenta",
-	edit: "yellow",
-	bash: "cyan",
-	glob: "green",
-	find: "green",
-	grep: "green",
-	tree: "green",
-}
-
-export const TERMINATION_PHRASES = [
-	"Terminated by user",
-	"Aborted by user",
-	"Execution stopped",
-	"Interrupted by user",
-	"Agent halted",
-	"Stopped by user",
-]

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,262 +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
-}
-
-export interface Compaction {
-	summary: string
-	seqBefore: number
-	filesRead: string[]
-	filesWrote: string[]
-	ts: number
-}
-
-export interface CompactResult {
-	compacted: boolean
-	summary?: string
-	msgsRemoved: 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[]
-}

package/src/update.ts

@@ -1,89 +0,0 @@
-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 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"
-	}
-}
-
-export async function getLatestVersion(): Promise<string | null> {
-	if (cachedLatest) return cachedLatest
-	try {
-		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()))
-		})
-		if (text) {
-			cachedLatest = text
-			return text
-		}
-	} 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.gt(latest, current),
-		current,
-		latest,
-	}
-}
-
-export async function runUpdate(silent = false): Promise<boolean> {
-	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
-		}
-	} catch (e) {
-		if (!silent) {
-			console.error(`Update failed: ${(e as Error).message}`)
-			process.exit(1)
-		}
-		return false
-	}
-}

package/src/util.ts

@@ -1,80 +0,0 @@
-import { isAbsolute, relative } from "node:path"
-import chalk from "chalk"
-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 {
-	let chars = 0
-	for (const msg of messages) {
-		if (typeof msg.content === "string") {
-			chars += msg.content.length
-		} else if (Array.isArray(msg.content)) {
-			for (const part of msg.content) {
-				if (part.type === "text") chars += part.text.length
-			}
-		}
-	}
-	return Math.ceil(chars / 4)
-}
-
-export function textPart(s: string): TextPart {
-	return { type: "text", text: s }
-}
-
-export function getRelativeIfInside(cwd: string, filePath: string): string {
-	if (filePath === cwd || filePath.startsWith(`${cwd}/`)) {
-		return relative(cwd, filePath) || "."
-	}
-	return filePath
-}
-
-export function makeRelative(val: string): string {
-	if (typeof val !== "string") return val
-
-	let pathVal = val
-	let prefix = ""
-	if (val.startsWith("file://")) {
-		pathVal = val.slice(7)
-		prefix = "file://"
-	}
-
-	if (isAbsolute(pathVal)) {
-		const cwd = process.cwd()
-		return prefix + getRelativeIfInside(cwd, pathVal)
-	}
-	return val
-}
-
-export function formatToolArgs(
-	args: Record<string, unknown> | undefined,
-	useChalk = false,
-): string {
-	if (!args) return ""
-	return Object.entries(args)
-		.map(([k, v]) => {
-			const val = typeof v === "string" ? makeRelative(v) : JSON.stringify(v)
-			const valStr = val.length > 40 ? `${val.slice(0, 40)}…` : val
-			const keyStr = useChalk ? chalk.dim(`${k}:`) : `${k}:`
-			return `${keyStr} ${valStr}`
-		})
-		.join(" ")
-}
-
-export function formatRelativeTime(ts: number): string {
-	const now = Date.now()
-	const diffMs = now - ts
-	const diffSec = Math.floor(diffMs / 1000)
-	const diffMin = Math.floor(diffSec / 60)
-	const diffHour = Math.floor(diffMin / 60)
-
-	if (diffSec < 60) {
-		return "just now"
-	}
-	if (diffMin < 60) {
-		return `${diffMin}m ago`
-	}
-	if (diffHour < 24) {
-		return `${diffHour}h ago`
-	}
-	return new Date(ts).toLocaleDateString()
-}