@nghyane/arcane 0.1.0

package/src/tools/undo-edit.ts

@@ -0,0 +1,145 @@
+/**
+ * Undo edit tool — reverts the last edit/write to a file.
+ */
+import type { AgentTool, AgentToolResult } from "@nghyane/arcane-agent";
+import type { Component } from "@nghyane/arcane-tui";
+import { Text } from "@nghyane/arcane-tui";
+import { isEnoent, untilAborted } from "@nghyane/arcane-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { generateUnifiedDiffString } from "../patch/diff";
+import { normalizeToLF, stripBom } from "../patch/normalize";
+import undoEditDescription from "../prompts/tools/undo-edit.md" with { type: "text" };
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import type { ToolSession } from ".";
+import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
+import { resolveToCwd } from "./path-utils";
+import { getDiffStats, replaceTabs, shortenPath, ToolUIKit } from "./render-utils";
+import { ToolError } from "./tool-errors";
+import { popUndo } from "./undo-history";
+
+const undoEditSchema = Type.Object({
+	path: Type.String({ description: "Path to the file whose last edit should be undone (relative or absolute)" }),
+});
+
+export interface UndoEditToolDetails {
+	diff: string;
+}
+
+export class UndoEditTool implements AgentTool<typeof undoEditSchema, UndoEditToolDetails> {
+	readonly name = "undo_edit";
+	readonly label = "Undo";
+	readonly description: string;
+	readonly parameters = undoEditSchema;
+	readonly nonAbortable = true;
+	readonly concurrency = "exclusive";
+
+	constructor(private readonly session: ToolSession) {
+		this.description = renderPromptTemplate(undoEditDescription);
+	}
+
+	async execute(
+		_toolCallId: string,
+		{ path }: Static<typeof undoEditSchema>,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<UndoEditToolDetails>> {
+		return untilAborted(signal, async () => {
+			const absolutePath = resolveToCwd(path, this.session.cwd);
+
+			const previousContent = popUndo(absolutePath);
+			if (previousContent === undefined) {
+				throw new ToolError(`No undo history for ${path}. Only the most recent edit per file can be undone.`);
+			}
+
+			// Read current content for diff
+			let currentContent = "";
+			try {
+				currentContent = await Bun.file(absolutePath).text();
+			} catch (err) {
+				if (!isEnoent(err)) throw err;
+			}
+
+			await Bun.write(absolutePath, previousContent);
+			invalidateFsScanAfterWrite(absolutePath);
+
+			const normalizedOld = normalizeToLF(stripBom(currentContent).text);
+			const normalizedNew = normalizeToLF(stripBom(previousContent).text);
+			const diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew);
+
+			return {
+				content: [{ type: "text", text: `Reverted ${path} to its state before the last edit` }],
+				details: { diff: diffResult.diff },
+			};
+		});
+	}
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface UndoEditRenderArgs {
+	path?: string;
+}
+
+export const undoEditToolRenderer = {
+	mergeCallAndResult: true,
+
+	renderCall(args: UndoEditRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const filePath = shortenPath(args.path ?? "");
+		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		const text = renderStatusLine({ icon: "pending", title: "Undo", description: pathDisplay }, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: UndoEditToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: UndoEditRenderArgs,
+	): Component {
+		const ui = new ToolUIKit(uiTheme);
+		const filePath = shortenPath(args?.path ?? "");
+		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		const errorText = result.isError ? (result.content?.find(c => c.type === "text")?.text ?? "") : "";
+
+		let cached: RenderCache | undefined;
+
+		return {
+			render(width) {
+				const { expanded } = options;
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
+
+				const header = renderStatusLine(
+					{ icon: result.isError ? "error" : "success", title: "Undo", description: pathDisplay },
+					uiTheme,
+				);
+				let text = header;
+
+				if (result.isError) {
+					if (errorText) {
+						text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
+					}
+				} else if (result.details?.diff) {
+					const diffStats = getDiffStats(result.details.diff);
+					text += `\n${uiTheme.fg("dim", uiTheme.format.bracketLeft)}${ui.formatDiffStats(
+						diffStats.added,
+						diffStats.removed,
+						diffStats.hunks,
+					)}${uiTheme.fg("dim", uiTheme.format.bracketRight)}`;
+				}
+
+				const lines =
+					width > 0 ? text.split("\n").map(line => truncateToWidth(line, width, Ellipsis.Omit)) : text.split("\n");
+				cached = { key, lines };
+				return lines;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
+	},
+};

package/src/tools/undo-history.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-file undo history for the undo_edit tool.
+ *
+ * Stores the content of a file immediately before the last edit/write operation.
+ * Only the most recent state is kept per file path (not a full stack).
+ */
+
+const history = new Map<string, string>();
+
+/** Save the current file content before an edit/write overwrites it. */
+export function saveForUndo(absolutePath: string, content: string): void {
+	history.set(absolutePath, content);
+}
+
+/** Pop the saved content for a file, removing it from history. Returns undefined if none. */
+export function popUndo(absolutePath: string): string | undefined {
+	const content = history.get(absolutePath);
+	if (content !== undefined) {
+		history.delete(absolutePath);
+	}
+	return content;
+}

package/src/tools/write.ts

@@ -0,0 +1,274 @@
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ToolCallContext,
+} from "@nghyane/arcane-agent";
+import type { Component } from "@nghyane/arcane-tui";
+import { Text } from "@nghyane/arcane-tui";
+import { untilAborted } from "@nghyane/arcane-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
+import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
+import writeDescription from "../prompts/tools/write.md" with { type: "text" };
+import type { ToolSession } from "../sdk";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
+import { type OutputMeta, outputMeta } from "./output-meta";
+import { resolveToCwd } from "./path-utils";
+import {
+	formatDiagnostics,
+	formatExpandHint,
+	formatMoreItems,
+	formatStatusIcon,
+	replaceTabs,
+	shortenPath,
+	ToolUIKit,
+} from "./render-utils";
+
+const writeSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+	content: Type.String({ description: "Content to write to the file" }),
+});
+
+export type WriteToolInput = Static<typeof writeSchema>;
+
+/** Details returned by the write tool for TUI rendering */
+export interface WriteToolDetails {
+	diagnostics?: FileDiagnosticsResult;
+	meta?: OutputMeta;
+}
+
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some(call => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool Class
+// ═══════════════════════════════════════════════════════════════════════════
+
+type WriteParams = WriteToolInput;
+
+/**
+ * Write tool implementation.
+ *
+ * Creates or overwrites files with optional LSP formatting and diagnostics.
+ */
+export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
+	readonly name = "write";
+	readonly label = "Write";
+	readonly description: string;
+	readonly parameters = writeSchema;
+	readonly nonAbortable = true;
+	readonly concurrency = "exclusive";
+
+	readonly #writethrough: WritethroughCallback;
+
+	constructor(private readonly session: ToolSession) {
+		const enableLsp = session.enableLsp ?? true;
+		const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
+		const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnWrite");
+		this.#writethrough = enableLsp
+			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+			: writethroughNoop;
+		this.description = renderPromptTemplate(writeDescription);
+	}
+
+	async execute(
+		_toolCallId: string,
+		{ path, content }: WriteParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<WriteToolDetails>,
+		context?: AgentToolContext,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		return untilAborted(signal, async () => {
+			const absolutePath = resolveToCwd(path, this.session.cwd);
+			const batchRequest = getLspBatchRequest(context?.toolCall);
+
+			const diagnostics = await this.#writethrough(absolutePath, content, signal, undefined, batchRequest);
+			invalidateFsScanAfterWrite(absolutePath);
+
+			const resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+			if (!diagnostics) {
+				return {
+					content: [{ type: "text", text: resultText }],
+					details: {},
+				};
+			}
+
+			return {
+				content: [{ type: "text", text: resultText }],
+				details: {
+					diagnostics,
+					meta: outputMeta()
+						.diagnostics(diagnostics.summary, diagnostics.messages ?? [])
+						.get(),
+				},
+			};
+		});
+	}
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface WriteRenderArgs {
+	path?: string;
+	file_path?: string;
+	content?: string;
+}
+
+const WRITE_PREVIEW_LINES = 6;
+const WRITE_STREAMING_PREVIEW_LINES = 12;
+
+function countLines(text: string): number {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+
+function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
+	const icon = uiTheme.getLangIcon(language);
+	if (lineCount !== null) {
+		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
+	}
+	return uiTheme.fg("dim", `${icon}`);
+}
+
+function formatStreamingContent(content: string, uiTheme: Theme, ui: ToolUIKit): string {
+	if (!content) return "";
+	const lines = content.split("\n");
+	const displayLines = lines.slice(-WRITE_STREAMING_PREVIEW_LINES);
+	const hidden = lines.length - displayLines.length;
+
+	let text = "\n\n";
+	if (hidden > 0) {
+		text += uiTheme.fg("dim", `… (${hidden} earlier lines)\n`);
+	}
+	for (const line of displayLines) {
+		text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
+	}
+	text += uiTheme.fg("dim", `… (streaming)`);
+	return text;
+}
+
+function renderContentPreview(content: string, expanded: boolean, uiTheme: Theme, ui: ToolUIKit): string {
+	if (!content) return "";
+	const lines = content.split("\n");
+	const maxLines = expanded ? lines.length : Math.min(lines.length, WRITE_PREVIEW_LINES);
+	const displayLines = expanded ? lines : lines.slice(-maxLines);
+	const hidden = lines.length - displayLines.length;
+
+	let text = "\n\n";
+	for (const line of displayLines) {
+		text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
+	}
+	if (!expanded && hidden > 0) {
+		const hint = formatExpandHint(uiTheme, expanded, hidden > 0);
+		const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
+		text += uiTheme.fg("dim", moreLine);
+	}
+	return text;
+}
+
+export const writeToolRenderer = {
+	renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+		const ui = new ToolUIKit(uiTheme);
+		const rawPath = args.file_path || args.path || "";
+		const filePath = shortenPath(rawPath);
+		const lang = getLanguageFromPath(rawPath) ?? "text";
+		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		const spinner =
+			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
+
+		let text = `${ui.title("Write")} ${spinner ? `${spinner} ` : ""}${langIcon} ${pathDisplay}`;
+
+		if (!args.content) {
+			return new Text(text, 0, 0);
+		}
+
+		// Show streaming preview of content (tail)
+		text += formatStreamingContent(args.content, uiTheme, ui);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: WriteRenderArgs,
+	): Component {
+		const ui = new ToolUIKit(uiTheme);
+		const rawPath = args?.file_path || args?.path || "";
+		const filePath = shortenPath(rawPath);
+		const fileContent = args?.content || "";
+		const lang = getLanguageFromPath(rawPath);
+		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		const lineCount = countLines(fileContent);
+
+		// Build header with status icon
+		const header = renderStatusLine(
+			{
+				icon: "success",
+				title: "Write",
+				description: `${langIcon} ${pathDisplay}`,
+			},
+			uiTheme,
+		);
+		const metadataLine = formatMetadataLine(lineCount, lang ?? "text", uiTheme);
+		const diagnostics = result.details?.diagnostics;
+
+		let cached: RenderCache | undefined;
+
+		return {
+			render(width: number) {
+				const { expanded } = options;
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
+
+				let text = header;
+				text += `\n${metadataLine}`;
+				text += renderContentPreview(fileContent, expanded, uiTheme, ui);
+
+				if (diagnostics) {
+					const diagText = formatDiagnostics(diagnostics, expanded, uiTheme, fp =>
+						uiTheme.getLangIcon(getLanguageFromPath(fp)),
+					);
+					if (diagText.trim()) {
+						const diagLines = diagText.split("\n");
+						const firstNonEmpty = diagLines.findIndex(line => line.trim());
+						if (firstNonEmpty >= 0) {
+							text += `\n${diagLines.slice(firstNonEmpty).join("\n")}`;
+						}
+					}
+				}
+
+				const lines = text.split("\n").map(l => truncateToWidth(l, width, Ellipsis.Omit));
+				cached = { key, lines };
+				return lines;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
+	},
+	mergeCallAndResult: true,
+};

package/src/tui/code-cell.ts

@@ -0,0 +1,108 @@
+/**
+ * Render a code cell with optional output section.
+ */
+import { highlightCode, type Theme } from "../modes/theme/theme";
+import { formatDuration, formatExpandHint, formatMoreItems, replaceTabs } from "../tools/render-utils";
+import { renderOutputBlock } from "./output-block";
+import type { State } from "./types";
+import { getStateIcon } from "./utils";
+
+export interface CodeCellOptions {
+	code: string;
+	language?: string;
+	index?: number;
+	total?: number;
+	title?: string;
+	status?: "pending" | "running" | "complete" | "error";
+	spinnerFrame?: number;
+	duration?: number;
+	output?: string;
+	outputMaxLines?: number;
+	codeMaxLines?: number;
+	expanded?: boolean;
+	width: number;
+}
+
+function getState(status?: CodeCellOptions["status"]): State | undefined {
+	if (!status) return undefined;
+	if (status === "complete") return "success";
+	if (status === "error") return "error";
+	if (status === "running") return "running";
+	return "pending";
+}
+
+function formatHeader(options: CodeCellOptions, theme: Theme): { title: string; meta?: string } {
+	const { index, total, title, status, spinnerFrame, duration } = options;
+	const parts: string[] = [];
+	if (status) {
+		const icon = getStateIcon(
+			status === "complete"
+				? "success"
+				: status === "error"
+					? "error"
+					: status === "running"
+						? "running"
+						: "pending",
+			theme,
+			spinnerFrame,
+		);
+		if (status === "pending" || status === "running") {
+			parts.push(`${icon} ${theme.fg("muted", status)}`);
+		} else {
+			parts.push(icon);
+		}
+	}
+	if (index !== undefined && total !== undefined) {
+		parts.push(theme.fg("accent", `[${index + 1}/${total}]`));
+	}
+	if (title) {
+		parts.push(theme.fg("toolTitle", title));
+	}
+	const headerTitle = parts.length > 0 ? parts.join(" ") : theme.fg("toolTitle", "Code");
+
+	const metaParts: string[] = [];
+	if (duration !== undefined) {
+		metaParts.push(theme.fg("dim", `(${formatDuration(duration)})`));
+	}
+	if (metaParts.length === 0) return { title: headerTitle };
+	return { title: headerTitle, meta: metaParts.join(theme.fg("dim", theme.sep.dot)) };
+}
+
+export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[] {
+	const { code, language, output, expanded = false, outputMaxLines = 6, codeMaxLines = 12, width } = options;
+	const { title, meta } = formatHeader(options, theme);
+	const state = getState(options.status);
+
+	const rawCodeLines = highlightCode(replaceTabs(code ?? ""), language);
+	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
+	const codeLines = rawCodeLines.slice(0, maxCodeLines);
+	const hiddenCodeLines = rawCodeLines.length - codeLines.length;
+	if (hiddenCodeLines > 0) {
+		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
+		const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
+		codeLines.push(theme.fg("dim", moreLine));
+	}
+
+	const outputLines: string[] = [];
+	if (output?.trim()) {
+		const rawLines = output.split("\n");
+		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
+		const displayLines = rawLines
+			.slice(0, maxLines)
+			.map(line => (line.includes("\x1b[") ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))));
+		outputLines.push(...displayLines);
+		const remaining = rawLines.length - maxLines;
+		if (remaining > 0) {
+			const hint = formatExpandHint(theme, expanded, remaining > 0);
+			const moreLine = `${formatMoreItems(remaining, "line")}${hint ? ` ${hint}` : ""}`;
+			outputLines.push(theme.fg("dim", moreLine));
+		}
+	}
+
+	const sections: Array<{ label?: string; lines: string[] }> = [{ lines: codeLines }];
+	if (outputLines.length > 0) {
+		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
+	}
+
+	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
+}

package/src/tui/file-list.ts

@@ -0,0 +1,47 @@
+/**
+ * Render file listings with optional icons and metadata.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { getLanguageFromPath } from "../modes/theme/theme";
+import { renderTreeList } from "./tree-list";
+
+export interface FileEntry {
+	path: string;
+	isDirectory?: boolean;
+	meta?: string;
+}
+
+export interface FileListOptions {
+	files: FileEntry[];
+	expanded?: boolean;
+	maxCollapsed?: number;
+	showIcons?: boolean;
+}
+
+export function renderFileList(options: FileListOptions, theme: Theme): string[] {
+	const { files, expanded = false, maxCollapsed = 8, showIcons = true } = options;
+
+	return renderTreeList(
+		{
+			items: files,
+			expanded,
+			maxCollapsed,
+			itemType: "file",
+			renderItem: entry => {
+				const isDirectory = entry.isDirectory ?? entry.path.endsWith("/");
+				const displayPath = isDirectory && entry.path.endsWith("/") ? entry.path : entry.path;
+				const lang = isDirectory ? undefined : getLanguageFromPath(displayPath);
+				const icon = !showIcons
+					? ""
+					: isDirectory
+						? theme.fg("accent", theme.icon.folder)
+						: theme.fg("muted", theme.getLangIcon(lang));
+				const labelColor = isDirectory ? "accent" : "toolOutput";
+				const meta = entry.meta ? ` ${theme.fg("dim", entry.meta)}` : "";
+				const iconPrefix = icon ? `${icon} ` : "";
+				return `${iconPrefix}${theme.fg(labelColor, displayPath)}${meta}`;
+			},
+		},
+		theme,
+	);
+}

package/src/tui/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Public exports for shared TUI components.
+ */
+
+export * from "./code-cell";
+export * from "./file-list";
+export * from "./output-block";
+export * from "./status-line";
+export * from "./tree-list";
+export * from "./types";
+export * from "./utils";