The Foundation

export interface SessionHeader {
	type: "session";
	id: string;
	timestamp: string;
	cwd: string;
	systemPrompt: string;
	model: string;
	thinkingLevel: string;
}

export const bashTool: AgentTool<typeof bashSchema> = {
	name: "bash",
	label: "bash",
	description:
		"Execute a bash command in the current working directory. Returns stdout and stderr. Commands run with a 30 second timeout.",
	parameters: bashSchema,
	execute: async (_toolCallId: string, { command }: { command: string }, signal?: AbortSignal) => {
		return new Promise((resolve, reject) => {
			const child = spawn("sh", ["-c", command], {
				detached: true,
				stdio: ["ignore", "pipe", "pipe"],
			});

			let stdout = "";
			let stderr = "";

export const editTool: AgentTool<typeof editSchema> = {
	name: "edit",
	label: "edit",
	description:
		"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
	parameters: editSchema,
	execute: async (
		_toolCallId: string,
		{ path, oldText, newText }: { path: string; oldText: string; newText: string },
	) => {
		const absolutePath = resolve(expandPath(path));

		if (!existsSync(absolutePath)) {
			throw new Error(`File not found: ${path}`);
		}

export class SessionSelectorComponent extends Container {
	private sessionList: SessionList;

	constructor(sessionManager: SessionManager, onSelect: (sessionPath: string) => void, onCancel: () => void) {
		super();

		// Load all sessions
		const sessions = sessionManager.loadAllSessions();

		// Add header
		this.addChild(new Spacer(1));
		this.addChild(new Text(chalk.bold("Resume Session"), 1, 0));
		this.addChild(new Spacer(1));
		this.addChild(new DynamicBorder());
		this.addChild(new Spacer(1));

export interface SessionHeader {
	type: "session";
	id: string;
	timestamp: string;
	cwd: string;
	systemPrompt: string;
	model: string;
	thinkingLevel: string;
}

export interface SessionHeader {
	type: "session";
	id: string;
	timestamp: string;
	cwd: string;
	systemPrompt: string;
	model: string;
	thinkingLevel: string;
}

export function agentLoop(
	prompt: UserMessage,

export interface CalculateResult extends AgentToolResult<undefined> {
	content: Array<{ type: "text"; text: string }>;
	details: undefined;
}

export interface AnthropicOptions extends StreamOptions {
	thinkingEnabled?: boolean;
	thinkingBudgetTokens?: number;
	toolChoice?: "auto" | "any" | "none" | { type: "tool"; name: string };
}

export function browserMessageTransformer(messages: AppMessage[]): Message[] {
	return messages
		.filter((m) => {
			// Keep LLM-compatible messages + navigation messages
			return m.role === "user" || m.role === "assistant" || m.role === "toolResult" || m.role === "navigation";
		})
		.map((m) => {
			// Transform navigation messages to user messages with <system> tags
			if (m.role === "navigation") {
				const nav = m as NavigationMessage;
				const tabInfo = nav.tabIndex !== undefined ? ` (tab ${nav.tabIndex})` : "";
				return {
					role: "user",
					content: `<system>Navigated to ${nav.title}${tabInfo}: ${nav.url}</system>`,
				} as Message;
			}

			// Strip attachments from user messages
			if (m.role === "user") {
				const { attachments, ...rest } = m as any;

export interface NavigationMessage {
	role: "navigation";
	url: string;
	title: string;
	favicon?: string;
	tabIndex?: number;
}

export interface SystemNotificationMessage {
	role: "system-notification";
	message: string;
	variant: "default" | "destructive";
	timestamp: string;
}

export class MessageList extends LitElement {
	@property({ type: Array }) messages: AppMessage[] = [];
	@property({ type: Array }) tools: AgentTool[] = [];
	@property({ type: Object }) pendingToolCalls?: Set<string>;
	@property({ type: Boolean }) isStreaming: boolean = false;
	@property({ attribute: false }) onCostClick?: () => void;

	protected override createRenderRoot(): HTMLElement | DocumentFragment {
		return this;
	}

	override connectedCallback(): void {
		super.connectedCallback();
		this.style.display = "block";
	}

export type UserMessageWithAttachments = UserMessageType & { attachments?: Attachment[] };

export type JavaScriptReplToolResult = {
	files?:
		| {
				fileName: string;
				contentBase64: any;
				mimeType: string;
		  }[]
		| undefined;
};

export interface TextEditorConfig {
	// Configuration options for text editor (none currently)
}

export class Loader extends Text {
	private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
	private currentFrame = 0;
	private intervalId: NodeJS.Timeout | null = null;
	private ui: TUI | null = null;

	constructor(
		ui: TUI,
		private message: string = "Loading...",
	) {
		super("");
		this.ui = ui;
		this.start();
	}

export function agentLoop(
	prompt: UserMessage,

export class TuiRenderer {
	private ui: TUI;
	private chatContainer: Container;
	private statusContainer: Container;
	private editor: CustomEditor;
	private editorContainer: Container; // Container to swap between editor and selector
	private footer: FooterComponent;
	private agent: Agent;
	private version: string;
	private isInitialized = false;
	private onInputCallback?: (text: string) => void;
	private loadingAnimation: Loader | null = null;
	private onInterruptCallback?: () => void;
	private lastSigintTime = 0;

export class IndexedDBStorageBackend implements StorageBackend {
	private dbPromise: Promise<IDBDatabase> | null = null;

	constructor(private config: IndexedDBConfig) {}

	private async getDB(): Promise<IDBDatabase> {
		if (!this.dbPromise) {
			this.dbPromise = new Promise((resolve, reject) => {
				const request = indexedDB.open(this.config.dbName, this.config.version);

				request.onerror = () => reject(request.error);
				request.onsuccess = () => resolve(request.result);

				request.onupgradeneeded = (_event) => {
					const db = request.result;

export class SessionsStore extends Store {
	getConfig(): StoreConfig {
		return {
			name: "sessions",
			keyPath: "id",
			indices: [{ name: "lastModified", keyPath: "lastModified" }],
		};
	}

	/**
	 * Additional config for sessions-metadata store.
	 * Must be included when creating the backend.
	 */
	static getMetadataConfig(): StoreConfig {
		return {

export class FooterComponent {
	private state: AgentState;

	constructor(state: AgentState) {
		this.state = state;
	}

	updateState(state: AgentState): void {
		this.state = state;
	}

	render(width: number): string[] {
		// Calculate cumulative usage from all assistant messages
		let totalInput = 0;
		let totalOutput = 0;

export class AssistantMessageComponent extends Container {
	private contentContainer: Container;

	constructor(message?: AssistantMessage) {
		super();

		// Container for text/thinking content
		this.contentContainer = new Container();
		this.addChild(this.contentContainer);

		if (message) {
			this.updateContent(message);
		}
	}

export const editTool: AgentTool<typeof editSchema> = {
	name: "edit",
	label: "edit",
	description:
		"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
	parameters: editSchema,
	execute: async (
		_toolCallId: string,
		{ path, oldText, newText }: { path: string; oldText: string; newText: string },
		signal?: AbortSignal,
	) => {
		// Check if already aborted
		if (signal?.aborted) {
			throw new Error("Operation aborted");
		}

export const readTool: AgentTool<typeof readSchema> = {
	name: "read",
	label: "read",
	description: "Read the contents of a file. Returns the full file content as text.",
	parameters: readSchema,
	execute: async (_toolCallId: string, { path }: { path: string }, signal?: AbortSignal) => {
		// Check if already aborted
		if (signal?.aborted) {
			throw new Error("Operation aborted");
		}

		const absolutePath = resolve(expandPath(path));

		if (!existsSync(absolutePath)) {
			throw new Error(`File not found: ${path}`);
		}

		const content = readFileSync(absolutePath, "utf-8");
		return { output: content, details: undefined };
	},

export interface SessionHeader {
	type: "session";
	id: string;
	timestamp: string;
	cwd: string;
	systemPrompt: string;
	model: string;
	thinkingLevel: string;
}

export class StreamingMessageComponent extends Container {
	private spacer: Spacer;
	private markdown: Markdown;
	private statsText: Text;

	constructor() {
		super();
		this.spacer = new Spacer(1);
		this.markdown = new Markdown("");
		this.statsText = new Text("", 1, 0);
		this.addChild(this.spacer);
		this.addChild(this.markdown);
		this.addChild(this.statsText);
	}

export class TuiRenderer {
	private ui: TUI;
	private chatContainer: Container;
	private statusContainer: Container;
	private editor: CustomEditor;
	private editorContainer: Container; // Container to swap between editor and selector
	private footer: FooterComponent;
	private agent: Agent;
	private version: string;
	private isInitialized = false;
	private onInputCallback?: (text: string) => void;
	private loadingAnimation: Loader | null = null;
	private onInterruptCallback?: () => void;
	private lastSigintTime = 0;

export class TuiRenderer {
	private ui: TUI;
	private chatContainer: Container;
	private statusContainer: Container;
	private editor: CustomEditor;
	private editorContainer: Container; // Container to swap between editor and selector
	private footer: FooterComponent;
	private agent: Agent;
	private version: string;
	private isInitialized = false;
	private onInputCallback?: (text: string) => void;
	private loadingAnimation: Loader | null = null;
	private onInterruptCallback?: () => void;
	private lastSigintTime = 0;

export class TuiRenderer {
	private ui: TUI;
	private chatContainer: Container;
	private statusContainer: Container;
	private editor: CustomEditor;
	private editorContainer: Container; // Container to swap between editor and selector
	private footer: FooterComponent;
	private agent: Agent;
	private version: string;
	private isInitialized = false;
	private onInputCallback?: (text: string) => void;
	private loadingAnimation: Loader | null = null;
	private onInterruptCallback?: () => void;
	private lastSigintTime = 0;