novacode 0.5.5 → 0.7.0

package/src/tools/web.ts

@@ -1,239 +0,0 @@
-/**
- * Web tools for searching and fetching internet content.
- * Uses DuckDuckGo HTML for search (no API key needed) and Bun's built-in
- * fetch for reading URLs.
- */
-import type { Tool, ToolResult } from "../types.ts"
-import { textPart } from "../util.ts"
-
-const MAX_CONTENT = 50_000
-
-// Minimal HTML → plaintext: strips tags, decodes entities, collapses whitespace
-function htmlToText(html: string): string {
-	let text = html
-		// Remove HTML comments
-		.replace(/<!--[\s\S]*?-->/g, "")
-		// Remove script and style blocks entirely
-		.replace(/<script[\s\S]*?<\/script>/gi, "")
-		.replace(/<style[\s\S]*?<\/style>/gi, "")
-		// Keep link hrefs visible (supports single, double, or no quotes)
-		.replace(/<a[^>]*href=["']?([^"'>\s]*)["']?[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)")
-		// Block-level tags → newlines
-		.replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote|pre|hr)[^>]*>/gi, "\n")
-		// Remove remaining tags
-		.replace(/<[^>]+>/g, "")
-		// Decode common HTML entities (both named and numeric, single/double quotes)
-		.replace(/&amp;/g, "&")
-		.replace(/&lt;/g, "<")
-		.replace(/&gt;/g, ">")
-		.replace(/&quot;/g, '"')
-		.replace(/&#34;/g, '"')
-		.replace(/&#x22;/g, '"')
-		.replace(/&#39;/g, "'")
-		.replace(/&#x27;/g, "'")
-		.replace(/&apos;/g, "'")
-		.replace(/&ldquo;/g, '"')
-		.replace(/&rdquo;/g, '"')
-		.replace(/&lsquo;/g, "'")
-		.replace(/&rsquo;/g, "'")
-		.replace(/&nbsp;/g, " ")
-		// Collapse whitespace but keep paragraph breaks
-		.replace(/[ \t]+/g, " ")
-		.replace(/\n{3,}/g, "\n\n")
-		.trim()
-
-	if (text.length > MAX_CONTENT) {
-		text = `${text.slice(0, MAX_CONTENT)}\n…truncated`
-	}
-	return text
-}
-
-export function webSearchTool(): Tool {
-	return {
-		def: {
-			name: "web_search",
-			description:
-				"Search the web using DuckDuckGo. Returns up to 10 results with titles, URLs, and snippets. Use this when you need information from the internet.",
-			parameters: {
-				type: "object",
-				properties: {
-					query: { type: "string", description: "Search query" },
-				},
-				required: ["query"],
-			},
-		},
-		async execute(args, signal): Promise<ToolResult> {
-			const query = args.query as string
-			if (!query.trim()) {
-				return { content: [textPart("Error: empty search query")], isError: true }
-			}
-
-			try {
-				const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`
-				const resp = await fetch(url, {
-					signal: signal ?? undefined,
-					headers: {
-						"User-Agent":
-							"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-					},
-				})
-
-				if (!resp.ok) {
-					return {
-						content: [textPart(`Search failed: HTTP ${resp.status}`)],
-						isError: true,
-					}
-				}
-
-				const html = await resp.text()
-
-				// Split HTML into blocks by result__body to isolate each search result safely
-				const blocks: string[] = []
-				const containerRegex = /<div[^>]*class="[^"]*result__body[^"]*"[^>]*>/gi
-				const indices: number[] = []
-				for (const match of html.matchAll(containerRegex)) {
-					if (match.index !== undefined) {
-						indices.push(match.index)
-					}
-				}
-
-				if (indices.length > 0) {
-					for (let i = 0; i < indices.length; i++) {
-						const start = indices[i]!
-						const end = indices[i + 1] ?? html.length
-						blocks.push(html.slice(start, end))
-					}
-				}
-
-				const results: string[] = []
-				const titleRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i
-				const snippetRegex = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i
-
-				for (const block of blocks) {
-					if (results.length >= 10) break
-
-					const titleMatch = titleRegex.exec(block)
-					if (!titleMatch) continue
-
-					const rawUrl = titleMatch[1]!
-					const title = htmlToText(titleMatch[2]!)
-
-					const snippetMatch = snippetRegex.exec(block)
-					const snippet = snippetMatch ? htmlToText(snippetMatch[1]!) : ""
-
-					// DuckDuckGo wraps URLs through a redirect; extract the actual URL
-					let cleanUrl = rawUrl
-					try {
-						// Prepend protocol/host if DuckDuckGo returns a relative path or protocol-relative URL
-						const urlToParse = rawUrl.startsWith("//")
-							? `https:${rawUrl}`
-							: rawUrl.startsWith("/")
-								? `https://duckduckgo.com${rawUrl}`
-								: rawUrl
-						const param = new URL(urlToParse).searchParams.get("uddg")
-						if (param) cleanUrl = param
-					} catch {
-						// Not a redirect URL, use as-is
-					}
-
-					results.push(`## ${title}\n${cleanUrl}\n${snippet}`)
-				}
-
-				if (results.length === 0) {
-					return { content: [textPart("No results found.")], isError: false }
-				}
-
-				return {
-					content: [textPart(results.join("\n\n"))],
-					isError: false,
-				}
-			} catch (e) {
-				const msg = (e as Error).message
-				if (msg.includes("abort")) {
-					return { content: [textPart("Search aborted.")], isError: true }
-				}
-				return {
-					content: [textPart(`Search error: ${msg}`)],
-					isError: true,
-				}
-			}
-		},
-	}
-}
-
-export function webFetchTool(): Tool {
-	return {
-		def: {
-			name: "web_fetch",
-			description:
-				"Fetch and read the content of a web page. Returns the page text with HTML tags stripped. Useful for reading documentation, articles, or API references.",
-			parameters: {
-				type: "object",
-				properties: {
-					url: { type: "string", description: "URL to fetch" },
-				},
-				required: ["url"],
-			},
-		},
-		async execute(args, signal): Promise<ToolResult> {
-			const url = args.url as string
-			if (!url.trim()) {
-				return { content: [textPart("Error: empty URL")], isError: true }
-			}
-
-			try {
-				new URL(url)
-			} catch {
-				return { content: [textPart(`Error: invalid URL: ${url}`)], isError: true }
-			}
-
-			try {
-				const resp = await fetch(url, {
-					signal: signal ?? undefined,
-					headers: {
-						"User-Agent":
-							"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-						Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-					},
-					redirect: "follow",
-				})
-
-				if (!resp.ok) {
-					return {
-						content: [textPart(`Fetch failed: HTTP ${resp.status} ${resp.statusText}`)],
-						isError: true,
-					}
-				}
-
-				const contentType = (resp.headers.get("content-type") ?? "").toLowerCase()
-				const body = await resp.text()
-
-				// Sniff HTML: check content-type or if body has HTML markup signature
-				const isHtml =
-					contentType.includes("text/html") ||
-					contentType.includes("application/xhtml+xml") ||
-					body.trim().toLowerCase().startsWith("<!doctype html") ||
-					body.trim().toLowerCase().startsWith("<html")
-
-				if (isHtml) {
-					const text = htmlToText(body)
-					return { content: [textPart(text)], isError: false }
-				}
-
-				// For plain text, JSON, etc. return as-is (truncated if needed)
-				const truncated =
-					body.length > MAX_CONTENT ? `${body.slice(0, MAX_CONTENT)}\n…truncated` : body
-				return { content: [textPart(truncated)], isError: false }
-			} catch (e) {
-				const msg = (e as Error).message
-				if (msg.includes("abort")) {
-					return { content: [textPart("Fetch aborted.")], isError: true }
-				}
-				return {
-					content: [textPart(`Fetch error: ${msg}`)],
-					isError: true,
-				}
-			}
-		},
-	}
-}

package/src/tui/app.tsx

@@ -1,364 +0,0 @@
-import chalk from "chalk"
-import { Box, render, Static, Text, 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 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} />)
-		await waitUntilExit()
-	} finally {
-		process.stdout.write("\x1B[?25h")
-	}
-}
-
-function App({
-	agent,
-	store,
-	sessionId,
-}: {
-	agent: Agent
-	store: SessionStore
-	sessionId: string
-}) {
-	const [msgs, setMsgs] = useState<Msg[]>(agent.messages)
-	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)
-
-	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(sessionId, msg)
-	}
-
-	// biome-ignore lint/correctness/useExhaustiveDependencies: reset selection on input change
-	useEffect(() => {
-		setSelCmdIdx(0)
-	}, [input])
-
-	useInput((ch, key) => {
-		if (mode.type !== "chat") return
-
-		if (key.escape) {
-			if (abortCtrl.current) {
-				abortCtrl.current.abort()
-				abortCtrl.current = null
-			}
-			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, sessionId, prompts).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("")
-						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}
-				hasMessages={visibleMsgs.length > 0}
-			/>
-
-			<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}
-				/>
-			</Box>
-		</Box>
-	)
-}

package/src/tui/components/liveArea.tsx

@@ -1,73 +0,0 @@
-import chalk from "chalk"
-import { Box, Text } from "ink"
-import { useEffect, useState } from "react"
-import { formatMarkdown } from "../markdown.ts"
-
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-
-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,
-	hasMessages,
-}: {
-	stream: string
-	thinkStream: string
-	busy: boolean
-	status: string
-	hasMessages: boolean
-}) {
-	const isActive = !!(stream || thinkStream || busy)
-	if (!isActive) return null
-
-	return (
-		<Box flexDirection="column" marginTop={hasMessages ? 1 : 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>
-	)
-}