novacode 0.6.0 → 0.7.0

package/src/provider/openai.ts

@@ -1,239 +0,0 @@
-import type {
-	AssistantResult,
-	Msg,
-	StopReason,
-	StreamEvent,
-	StreamFn,
-	StreamOpts,
-	ToolDef,
-	Usage,
-} from "../types.ts"
-import { EventStream } from "./stream.ts"
-
-function msgToOpenAI(msg: Msg): Record<string, unknown> {
-	if (msg.role === "user") {
-		return {
-			role: "user",
-			content:
-				typeof msg.content === "string"
-					? msg.content
-					: msg.content.map((c) => {
-							if (c.type === "text") return { type: "text", text: c.text }
-							if (c.type === "image")
-								return { type: "image_url", image_url: { url: `data:${c.mime};base64,${c.data}` } }
-							return { type: "text", text: "" }
-						}),
-		}
-	}
-	if (msg.role === "assistant") {
-		const textParts: string[] = []
-		const toolCalls: unknown[] = []
-
-		for (const c of msg.content) {
-			if (c.type === "text") textParts.push(c.text)
-			// thinking parts are internal — never sent back to the API
-			if (c.type === "tool_call")
-				toolCalls.push({
-					type: "function",
-					id: c.id,
-					function: { name: c.name, arguments: JSON.stringify(c.args) },
-				})
-		}
-
-		const result: Record<string, unknown> = {
-			role: "assistant",
-			content: textParts.length > 0 ? textParts.join("") : null,
-		}
-		if (toolCalls.length > 0) result.tool_calls = toolCalls
-		return result
-	}
-	// tool_result
-	if (msg.role === "tool_result") {
-		return {
-			role: "tool",
-			tool_call_id: msg.callId,
-			content: msg.content.map((c) => (c.type === "text" ? c.text : JSON.stringify(c))).join("\n"),
-		}
-	}
-	return { role: "user", content: "" }
-}
-
-function toolsToOpenAI(tools: ToolDef[]): unknown[] {
-	return tools.map((t) => ({
-		type: "function",
-		function: {
-			name: t.name,
-			description: t.description,
-			parameters: t.parameters,
-		},
-	}))
-}
-
-export const streamOpenAI: StreamFn = (
-	opts: StreamOpts,
-): EventStream<StreamEvent, AssistantResult> => {
-	const es = new EventStream<StreamEvent, AssistantResult>()
-
-	;(async () => {
-		let textContent = ""
-		const currentToolCalls = new Map<number, { id: string; name: string; args: string }>()
-		let usage: Usage = { in: 0, out: 0 }
-
-		try {
-			const body = {
-				model: opts.model.id,
-				messages: [{ role: "system", content: opts.system }, ...opts.messages.map(msgToOpenAI)],
-				tools: opts.tools.length > 0 ? toolsToOpenAI(opts.tools) : undefined,
-				stream: true,
-			}
-
-			const response = await fetch(`${opts.baseUrl}/chat/completions`, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${opts.apiKey}`,
-				},
-				body: JSON.stringify(body),
-				signal: opts.signal,
-			})
-
-			if (!response.ok) {
-				const text = await response.text()
-				const errorMsg = `API error ${response.status}: ${text}`
-				es.push({ type: "text_delta", text: errorMsg })
-				es.finish({
-					content: [{ type: "text", text: errorMsg }],
-					usage: { in: 0, out: 0 },
-					stop: "error",
-				})
-				return
-			}
-
-			const reader = response.body?.getReader()
-			if (!reader) {
-				es.finish({ content: [], usage: { in: 0, out: 0 }, stop: "error" })
-				return
-			}
-
-			const decoder = new TextDecoder()
-			let buffer = ""
-			let stop = "stop"
-
-			while (true) {
-				const { done, value } = await reader.read()
-				if (done) break
-
-				buffer += decoder.decode(value, { stream: true })
-				const lines = buffer.split("\n")
-				buffer = lines.pop() ?? ""
-
-				for (const line of lines) {
-					const trimmed = line.trim()
-					if (!trimmed?.startsWith("data: ")) continue
-					const data = trimmed.slice(6)
-					if (data === "[DONE]") continue
-
-					try {
-						const chunk = JSON.parse(data)
-						const delta = chunk.choices?.[0]?.delta
-						if (!delta) continue
-
-						if (delta.content) {
-							es.push({ type: "text_delta", text: delta.content })
-							textContent += delta.content
-						}
-
-						if (delta.tool_calls) {
-							for (const tc of delta.tool_calls) {
-								const idx = tc.index ?? 0
-								if (!currentToolCalls.has(idx)) {
-									currentToolCalls.set(idx, {
-										id: tc.id ?? "",
-										name: tc.function?.name ?? "",
-										args: "",
-									})
-								}
-								const existing = currentToolCalls.get(idx)!
-								if (tc.id) existing.id = tc.id
-								if (tc.function?.name) existing.name = tc.function.name
-								if (tc.function?.arguments) existing.args += tc.function.arguments
-							}
-						}
-
-						if (chunk.usage) {
-							usage = {
-								in: chunk.usage.prompt_tokens ?? 0,
-								out: chunk.usage.completion_tokens ?? 0,
-							}
-							es.push({ type: "usage", usage })
-						}
-
-						const finishReason = chunk.choices?.[0]?.finish_reason
-						if (finishReason) stop = finishReason
-					} catch {
-						// Skip malformed JSON chunks
-					}
-				}
-			}
-
-			const content: AssistantResult["content"] = []
-			if (textContent) {
-				content.push({ type: "text", text: textContent })
-			}
-			for (const [, tc] of currentToolCalls) {
-				content.push({
-					type: "tool_call",
-					id: tc.id,
-					name: tc.name,
-					args: JSON.parse(tc.args || "{}"),
-				})
-				es.push({
-					type: "tool_call",
-					call: {
-						type: "tool_call",
-						id: tc.id,
-						name: tc.name,
-						args: JSON.parse(tc.args || "{}"),
-					},
-				})
-				stop = "tool_use"
-			}
-
-			es.finish({ content, usage, stop: stop as StopReason })
-		} catch (e) {
-			if (opts.signal?.aborted) {
-				const content: AssistantResult["content"] = []
-				if (textContent) {
-					content.push({ type: "text", text: textContent })
-				}
-				for (const [, tc] of currentToolCalls) {
-					try {
-						content.push({
-							type: "tool_call",
-							id: tc.id,
-							name: tc.name,
-							args: JSON.parse(tc.args || "{}"),
-						})
-					} catch {
-						// skip malformed
-					}
-				}
-				es.finish({
-					content,
-					usage,
-					stop: "aborted",
-				})
-				return
-			}
-			const errorMsg = `Unexpected error: ${e instanceof Error ? e.message : String(e)}`
-			es.push({ type: "text_delta", text: errorMsg })
-			es.finish({
-				content: [{ type: "text", text: errorMsg }],
-				usage: { in: 0, out: 0 },
-				stop: "error",
-			})
-		}
-	})()
-
-	return es
-}

package/src/provider/stream.ts

@@ -1,138 +0,0 @@
-import type { AgentEvent, ApiFormat, AssistantResult, StreamFn, StreamOpts } from "../types.ts"
-import { streamGemini } from "./gemini.ts"
-import { streamOpenAI } from "./openai.ts"
-
-export type { AssistantResult, StreamEvent, StreamFn, StreamOpts } from "../types.ts"
-
-/*
- * Push-based async event stream.
- *
- * Producers call push()/finish(). Consumers iterate with for-await-of.
- * Backpressure is implicit: push() resolves immediately; the iterator
- * awaits the next value only when the consumer asks for it.
- */
-export class EventStream<T, R> {
-	#events: T[] = []
-	#done = false
-	#result?: R
-	#resolve?: (value: T) => void
-	#doneResolve?: (value: R) => void
-	#abort = false
-
-	push(event: T): void {
-		if (this.#abort) return
-		// If a consumer is already waiting, deliver directly — skip the queue
-		if (this.#resolve) {
-			const resolve = this.#resolve
-			this.#resolve = undefined
-			resolve(event)
-		} else {
-			this.#events.push(event)
-		}
-	}
-
-	finish(result: R): void {
-		this.#done = true
-		this.#result = result
-		// Wake up a suspended iterator so it can see done=true and exit
-		if (this.#resolve) {
-			// undefined is a sentinel — the iterator loop checks done after waking
-			this.#resolve(undefined as T)
-		}
-		if (this.#doneResolve) {
-			this.#doneResolve(result)
-		}
-	}
-
-	abort(): void {
-		this.#abort = true
-		this.#done = true
-		if (this.#resolve) {
-			this.#resolve(undefined as T)
-		}
-		if (this.#doneResolve) {
-			this.#doneResolve(undefined as R)
-		}
-	}
-
-	async *[Symbol.asyncIterator](): AsyncGenerator<T> {
-		while (!this.#done || this.#events.length > 0) {
-			if (this.#events.length > 0) {
-				yield this.#events.shift() as T
-				continue
-			}
-			if (this.#done) break
-			const item = await new Promise<T | undefined>((resolve) => {
-				this.#resolve = resolve as (value: T) => void
-			})
-			if (item !== undefined) {
-				yield item
-			}
-		}
-	}
-
-	get result(): R | undefined {
-		return this.#result
-	}
-
-	get isDone(): boolean {
-		return this.#done
-	}
-}
-
-// Internal map of registered provider implementations
-const registry = new Map<ApiFormat, StreamFn>([
-	["openai", streamOpenAI],
-	["gemini", streamGemini],
-])
-
-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()]
-}

package/src/session/compact.ts

@@ -1,159 +0,0 @@
-import { getProvider } from "../config/providers.ts"
-import { stream } from "../provider/stream.ts"
-import type { CompactResult, Model, Msg } from "../types.ts"
-import { estimateTokens } from "../util.ts"
-import type { SessionStore } from "./store.ts"
-
-const COMPACT_THRESHOLD = 0.8
-const KEEP_RECENT = 10
-
-function extractText(msg: Msg): string {
-	if (typeof msg.content === "string") return msg.content
-	return msg.content
-		.filter((c) => c.type === "text")
-		.map((c) => (c.type === "text" ? c.text : ""))
-		.join("")
-}
-
-function extractToolFiles(msg: Msg, toolName: string): string[] {
-	if (msg.role !== "tool_result") return []
-	if (!("tool" in msg) || msg.tool !== toolName) return []
-	const text = extractText(msg)
-	// Extract file paths from tool result content
-	const lines = text.split("\n")
-	return lines.filter((l) => l.trim().length > 0)
-}
-
-export function needsCompact(messages: Msg[], contextWindow: number): boolean {
-	return estimateTokens(messages) > contextWindow * COMPACT_THRESHOLD
-}
-
-export async function compact(
-	store: SessionStore,
-	sessionId: string,
-	messages: Msg[],
-	model: Model,
-	apiKey: string,
-	baseUrl: string,
-): Promise<CompactResult> {
-	if (!needsCompact(messages, model.contextWindow)) {
-		return { compacted: false, msgsRemoved: 0 }
-	}
-
-	const old = messages.slice(0, -KEEP_RECENT)
-	if (old.length === 0) {
-		return { compacted: false, msgsRemoved: 0 }
-	}
-	const convo = old
-		.map((m) => {
-			if (m.role === "user") return `User: ${extractText(m)}`
-			if (m.role === "assistant") return `Assistant: ${extractText(m)}`
-			if (m.role === "tool_result" && "tool" in m)
-				return `Tool(${m.tool}): ${extractText(m).slice(0, 200)}`
-			return ""
-		})
-		.join("\n\n")
-
-	const summary = await generateSummary(convo, model, apiKey, baseUrl)
-	if (!summary) {
-		return { compacted: false, msgsRemoved: 0 }
-	}
-
-	const filesRead: string[] = []
-	const filesWrote: string[] = []
-	for (const m of old) {
-		filesRead.push(...extractToolFiles(m, "read"))
-		filesRead.push(...extractToolFiles(m, "glob"))
-		filesWrote.push(...extractToolFiles(m, "write"))
-		filesWrote.push(...extractToolFiles(m, "edit"))
-	}
-
-	const seqBefore = old.length
-	await store.saveCompaction(
-		sessionId,
-		summary,
-		[...new Set(filesRead)],
-		[...new Set(filesWrote)],
-		seqBefore,
-	)
-	await store.truncateBeforeSeq(sessionId, seqBefore + 1)
-
-	// Insert the summary as a user message so the model retains context
-	const summaryMsg: Msg = {
-		role: "user",
-		content: `[Prior context summary]\n${summary}`,
-		ts: Date.now(),
-	}
-	await store.append(sessionId, summaryMsg)
-
-	return { compacted: true, summary, msgsRemoved: old.length }
-}
-
-async function generateSummary(
-	convo: string,
-	model: Model,
-	apiKey: string,
-	baseUrl: string,
-): Promise<string | null> {
-	const provider = getProvider(model.provider)
-	if (!provider) return null
-
-	const es = stream({
-		api: provider.api,
-		model,
-		apiKey,
-		baseUrl,
-		system:
-			"Summarize this coding session concisely. Cover: what was asked, files touched, what was done, key decisions. Keep it under 300 words.",
-		messages: [{ role: "user", content: convo, ts: Date.now() }],
-		tools: [],
-	})
-
-	let summary = ""
-	for await (const ev of es) {
-		if (ev.type === "text_delta" && ev.text) {
-			summary += ev.text
-		}
-	}
-
-	return summary.trim() || null
-}
-
-export async function generateSessionTitle(
-	messages: Msg[],
-	model: Model,
-	apiKey: string,
-	baseUrl: string,
-): Promise<string | null> {
-	const provider = getProvider(model.provider)
-	if (!provider) return null
-
-	const convo = messages
-		.slice(0, 4)
-		.map((m) => {
-			if (m.role === "user") return `User: ${extractText(m)}`
-			if (m.role === "assistant") return `Assistant: ${extractText(m)}`
-			return ""
-		})
-		.join("\n")
-
-	const es = stream({
-		api: provider.api,
-		model,
-		apiKey,
-		baseUrl,
-		system:
-			"Generate a very short, descriptive, and concise title for this coding conversation. Do not use quotes or prefixes like 'Title:'. Max 6 words.",
-		messages: [{ role: "user", content: convo, ts: Date.now() }],
-		tools: [],
-	})
-
-	let title = ""
-	for await (const ev of es) {
-		if (ev.type === "text_delta" && ev.text) {
-			title += ev.text
-		}
-	}
-
-	return title.trim().replace(/^["']|["']$/g, "") || null
-}