@oh-my-pi/pi-coding-agent 14.1.0 → 14.1.2

package/src/vim/parser.ts

@@ -0,0 +1,151 @@
+import { VimInputError as VimError, type VimKeyToken } from "./types";
+
+const SPECIAL_KEYS = new Map<string, string>([
+	["esc", "Esc"],
+	["escape", "Esc"],
+	["cr", "CR"],
+	["enter", "CR"],
+	["return", "CR"],
+	["bs", "BS"],
+	["backspace", "BS"],
+	["tab", "Tab"],
+	["c-d", "C-d"],
+	["c-u", "C-u"],
+	["c-r", "C-r"],
+	["c-w", "C-w"],
+	["c-o", "C-o"],
+]);
+
+function normalizeSpecialKey(raw: string): string | undefined {
+	return SPECIAL_KEYS.get(raw.trim().toLowerCase());
+}
+
+function toDisplayToken(value: string): string {
+	switch (value) {
+		case " ":
+			return "<Space>";
+		default:
+			return value.length === 1 ? value : `<${value}>`;
+	}
+}
+
+export function parseKeySequences(sequences: string[]): VimKeyToken[] {
+	const tokens: VimKeyToken[] = [];
+
+	for (let sequenceIndex = 0; sequenceIndex < sequences.length; sequenceIndex += 1) {
+		const sequence = sequences[sequenceIndex] ?? "";
+		for (let offset = 0; offset < sequence.length; offset += 1) {
+			const char = sequence[offset] ?? "";
+			// Handle literal escape byte (\x1b / \u001b)
+			if (char === "\x1b") {
+				tokens.push({
+					value: "Esc",
+					display: "<Esc>",
+					sequenceIndex,
+					offset,
+				});
+				continue;
+			}
+			// Handle literal carriage return
+			if (char === "\r") {
+				tokens.push({
+					value: "CR",
+					display: "<CR>",
+					sequenceIndex,
+					offset,
+				});
+				continue;
+			}
+			// Handle escaped sequences: \r → CR, \e → Esc, \n → newline, \t → Tab
+			if (char === "\\" && offset + 1 < sequence.length) {
+				const next = sequence[offset + 1];
+				if (next === "r") {
+					tokens.push({ value: "CR", display: "\\r", sequenceIndex, offset });
+					offset += 1;
+					continue;
+				}
+				if (next === "e") {
+					tokens.push({ value: "Esc", display: "\\e", sequenceIndex, offset });
+					offset += 1;
+					continue;
+				}
+				if (next === "n") {
+					tokens.push({ value: "\n", display: "\\n", sequenceIndex, offset });
+					offset += 1;
+					continue;
+				}
+				if (next === "t") {
+					tokens.push({ value: "Tab", display: "\\t", sequenceIndex, offset });
+					offset += 1;
+					continue;
+				}
+			}
+			if (char !== "<") {
+				tokens.push({
+					value: char,
+					display: toDisplayToken(char),
+					sequenceIndex,
+					offset,
+				});
+				continue;
+			}
+
+			const close = sequence.indexOf(">", offset + 1);
+			if (close === -1) {
+				throw new VimError(`Unterminated special key in sequence ${sequenceIndex + 1}`, {
+					value: char,
+					display: char,
+					sequenceIndex,
+					offset,
+				});
+			}
+
+			const rawSpecial = sequence.slice(offset + 1, close);
+			const special = normalizeSpecialKey(rawSpecial);
+			if (!special) {
+				throw new VimError(`Unknown special key <${rawSpecial}> in sequence ${sequenceIndex + 1}`, {
+					value: rawSpecial,
+					display: `<${rawSpecial}>`,
+					sequenceIndex,
+					offset,
+				});
+			}
+
+			tokens.push({
+				value: special,
+				display: `<${rawSpecial}>`,
+				sequenceIndex,
+				offset,
+			});
+			offset = close;
+		}
+	}
+
+	return tokens;
+}
+
+export function tokensToReplay(tokens: readonly VimKeyToken[]): string[] {
+	return tokens.map(token => token.value);
+}
+
+export function replayTokens(values: readonly string[]): VimKeyToken[] {
+	return values.map((value, index) => ({
+		value,
+		display: toDisplayToken(value),
+		sequenceIndex: 0,
+		offset: index,
+	}));
+}
+
+export function formatVimError(error: unknown): string {
+	if (!(error instanceof VimError)) {
+		return error instanceof Error ? error.message : String(error);
+	}
+
+	const base = error.message;
+	if (!error.location) {
+		return base;
+	}
+
+	return `${base} (sequence ${error.location.sequenceIndex + 1}, token ${error.location.offset + 1})`;
+}

package/src/vim/render.ts

@@ -0,0 +1,252 @@
+import { extractSegments } from "@oh-my-pi/pi-tui";
+import { truncateToWidth } from "../tools/render-utils";
+import type {
+	VimErrorLocation,
+	VimFocusLine,
+	VimMode,
+	VimPendingInput,
+	VimSelection,
+	VimToolDetails,
+	VimViewport,
+	VimViewportLine,
+} from "./types";
+
+export const VIM_OPEN_VIEWPORT_LINES = 80;
+export const VIM_DEFAULT_VIEWPORT_LINES = 10;
+export const VIM_TAB_DISPLAY = "→";
+const VIM_INLINE_CURSOR = "▏";
+
+const VIM_VIEWPORT_WIDTH = 140;
+const VIM_FOCUS_WIDTH = 100;
+
+interface ViewportRenderInput {
+	file: string;
+	mode: VimMode;
+	cursor: { line: number; col: number };
+	totalLines: number;
+	modified: boolean;
+	lines: string[];
+	viewport: VimViewport;
+	selection?: VimSelection;
+	statusMessage?: string;
+	lastCommand?: string;
+	pendingInput?: VimPendingInput;
+	errorLocation?: VimErrorLocation;
+	closed?: boolean;
+}
+
+function renderHeader(details: Pick<VimToolDetails, "file" | "modified" | "mode" | "cursor" | "totalLines">): string {
+	const modified = details.modified ? "[+]" : "[ ]";
+	return `${details.file} ${modified} ${details.mode} L${details.cursor.line}:${details.cursor.col} (${details.totalLines} lines)`;
+}
+
+function selectionContainsLine(selection: VimSelection | undefined, lineNumber: number): boolean {
+	if (!selection) {
+		return false;
+	}
+	return lineNumber >= selection.start.line && lineNumber <= selection.end.line;
+}
+
+function visibleWidthForChar(char: string): number {
+	return char === "\t" ? VIM_TAB_DISPLAY.length : Math.max(1, Bun.stringWidth(char));
+}
+
+function renderVisibleText(input: string): string {
+	let output = "";
+	for (const char of input) {
+		output += char === "\t" ? VIM_TAB_DISPLAY : char;
+	}
+	return output;
+}
+
+function renderedColumnForRawColumn(input: string, rawCol: number): number {
+	let column = 0;
+	let index = 0;
+	for (const char of input) {
+		if (index >= rawCol) {
+			break;
+		}
+		column += visibleWidthForChar(char);
+		index += 1;
+	}
+	return column;
+}
+
+function cropVisibleText(text: string, startCol: number, width: number): { text: string; startCol: number } {
+	if (text.length <= width) {
+		return { text, startCol: 0 };
+	}
+
+	const maxStart = Math.max(0, text.length - width);
+	const clampedStart = Math.max(0, Math.min(startCol, maxStart));
+	let window = text.slice(clampedStart, clampedStart + width);
+	if (clampedStart > 0 && window.length > 0) {
+		window = `…${window.slice(1)}`;
+	}
+	if (clampedStart + width < text.length && window.length > 0) {
+		window = `${window.slice(0, -1)}…`;
+	}
+	return { text: window, startCol: clampedStart };
+}
+
+function buildFocusLine(lineNumber: number, rawText: string, rawCursorCol: number): VimFocusLine {
+	const visibleText = renderVisibleText(rawText);
+	const caretCol = renderedColumnForRawColumn(rawText, rawCursorCol);
+	const desiredStart = Math.max(0, caretCol - Math.floor(VIM_FOCUS_WIDTH / 2));
+	const cropped = cropVisibleText(visibleText, desiredStart, VIM_FOCUS_WIDTH);
+	return {
+		line: lineNumber,
+		text: cropped.text,
+		windowStartCol: cropped.startCol + 1,
+		windowEndCol: cropped.startCol + cropped.text.length,
+		caretCol: Math.max(0, caretCol - cropped.startCol),
+	};
+}
+
+function buildViewportLines(
+	input: Pick<ViewportRenderInput, "lines" | "viewport" | "cursor" | "selection">,
+): VimViewportLine[] {
+	const lines: VimViewportLine[] = [];
+	for (let lineNumber = input.viewport.start; lineNumber <= input.viewport.end; lineNumber += 1) {
+		const rawText = input.lines[lineNumber - 1] ?? "";
+		const visibleText = renderVisibleText(rawText);
+		const isCursor = lineNumber === input.cursor.line;
+		if (isCursor) {
+			const cursorCol = renderedColumnForRawColumn(rawText, input.cursor.col - 1);
+			const desiredStart = Math.max(0, cursorCol - Math.floor(VIM_VIEWPORT_WIDTH / 2));
+			const cropped = cropVisibleText(visibleText, desiredStart, VIM_VIEWPORT_WIDTH);
+			lines.push({
+				line: lineNumber,
+				text: cropped.text,
+				isCursor: true,
+				isSelected: selectionContainsLine(input.selection, lineNumber),
+				cursorCol: Math.max(0, cursorCol - cropped.startCol),
+			});
+			continue;
+		}
+		lines.push({
+			line: lineNumber,
+			text: truncateToWidth(visibleText, VIM_VIEWPORT_WIDTH),
+			isCursor: false,
+			isSelected: selectionContainsLine(input.selection, lineNumber),
+		});
+	}
+	return lines;
+}
+
+export function computeViewport(
+	cursorLine: number,
+	totalLines: number,
+	size: number,
+	preferredStart?: number,
+): VimViewport {
+	const lineCount = Math.max(totalLines, 1);
+	const clampedSize = Math.max(1, Math.min(size, lineCount));
+	const maxStart = Math.max(1, lineCount - clampedSize + 1);
+	const centered = Math.max(1, Math.min(cursorLine - Math.floor(clampedSize / 2), maxStart));
+	let start = preferredStart ? Math.max(1, Math.min(preferredStart, maxStart)) : centered;
+	const end = Math.min(lineCount, start + clampedSize - 1);
+	if (cursorLine < start) {
+		start = cursorLine;
+	}
+	if (cursorLine > end) {
+		start = Math.max(1, cursorLine - clampedSize + 1);
+	}
+	return {
+		start,
+		end: Math.min(lineCount, start + clampedSize - 1),
+	};
+}
+
+function formatPendingInput(pending: VimPendingInput | undefined): string | undefined {
+	if (!pending) {
+		return undefined;
+	}
+	if (pending.kind === "insert") {
+		return "Pending: INSERT mode";
+	}
+	const prefix = pending.kind === "command" ? ":" : pending.kind === "search-forward" ? "/" : "?";
+	return `Pending: ${prefix}${truncateToWidth(renderVisibleText(pending.text), 80)}`;
+}
+
+function renderPlainViewportCursor(line: VimViewportLine): string {
+	if (!line.isCursor || line.cursorCol === undefined) {
+		return line.text;
+	}
+	const totalWidth = Bun.stringWidth(line.text);
+	const cursorCol = Math.max(0, Math.min(line.cursorCol, totalWidth));
+	const segments = extractSegments(line.text, cursorCol, cursorCol, Math.max(0, totalWidth - cursorCol), true);
+	return `${segments.before}${VIM_INLINE_CURSOR}${segments.after}`;
+}
+
+export function renderVimDetails(details: VimToolDetails): string {
+	const lines: string[] = [renderHeader(details)];
+
+	// Explicit cursor position indicator (models miss it in header)
+	lines.push(`[CURSOR] Line ${details.cursor.line}, Column ${details.cursor.col} (of ${details.totalLines} lines)`);
+
+	if (details.lastCommand) {
+		lines.push(`Command: ${truncateToWidth(details.lastCommand, 80)}`);
+	}
+	if (details.statusMessage) {
+		lines.push(`Status: ${details.statusMessage}`);
+	}
+	if (details.errorLocation) {
+		lines.push(
+			`Error location: sequence ${details.errorLocation.sequenceIndex + 1}, token ${details.errorLocation.offset + 1}`,
+		);
+	}
+
+	const pending = formatPendingInput(details.pendingInput);
+	if (pending) {
+		lines.push(pending);
+	}
+
+	if (details.closed) {
+		return lines.join("\n");
+	}
+
+	if (details.focus) {
+		const focusPrefix = `>${String(details.focus.line).padStart(String(details.viewport.end).length, " ")}│`;
+		const caretPrefix = `${" ".repeat(focusPrefix.length)} `;
+		const caretPadding = " ".repeat(Math.max(0, details.focus.caretCol));
+		lines.push("Focus:");
+		lines.push(`${focusPrefix}${details.focus.text}`);
+		lines.push(`${caretPrefix}${caretPadding}^`);
+	}
+
+	if (details.viewportLines && details.viewportLines.length > 0) {
+		const padWidth = String(details.viewport.end).length;
+		lines.push("Viewport:");
+		for (const line of details.viewportLines) {
+			const prefix = line.isCursor ? ">" : line.isSelected ? "*" : " ";
+			lines.push(`${prefix}${String(line.line).padStart(padWidth, " ")}│${renderPlainViewportCursor(line)}`);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+export function buildDetails(input: ViewportRenderInput): VimToolDetails {
+	const details: VimToolDetails = {
+		file: input.file,
+		mode: input.mode,
+		cursor: input.cursor,
+		totalLines: input.totalLines,
+		modified: input.modified,
+		viewport: input.viewport,
+		selection: input.selection,
+		lastCommand: input.lastCommand,
+		statusMessage: input.statusMessage,
+		pendingInput: input.pendingInput,
+		errorLocation: input.errorLocation,
+		closed: input.closed,
+	};
+
+	if (!input.closed) {
+		details.focus = buildFocusLine(input.cursor.line, input.lines[input.cursor.line - 1] ?? "", input.cursor.col - 1);
+		details.viewportLines = buildViewportLines(input);
+	}
+
+	return details;
+}

package/src/vim/types.ts

@@ -0,0 +1,197 @@
+import type { FileDiagnosticsResult } from "../lsp";
+import type { OutputMeta } from "../tools/output-meta";
+
+export type VimMode = "NORMAL" | "INSERT" | "VISUAL" | "VISUAL-LINE" | "COMMAND";
+
+export type VimInputMode =
+	| "normal"
+	| "insert"
+	| "visual"
+	| "visual-line"
+	| "command"
+	| "search-forward"
+	| "search-backward";
+
+export interface Position {
+	line: number;
+	col: number;
+}
+
+export interface VimViewport {
+	start: number;
+	end: number;
+}
+
+export interface VimSelection {
+	kind: "char" | "line";
+	start: Position;
+	end: Position;
+}
+
+export interface VimFocusLine {
+	line: number;
+	text: string;
+	windowStartCol: number;
+	windowEndCol: number;
+	caretCol: number;
+}
+
+export interface VimViewportLine {
+	line: number;
+	text: string;
+	isCursor: boolean;
+	isSelected: boolean;
+	cursorCol?: number;
+}
+
+export interface VimPendingInput {
+	kind: "insert" | "command" | "search-forward" | "search-backward";
+	text: string;
+}
+
+export interface VimErrorLocation {
+	sequenceIndex: number;
+	offset: number;
+}
+
+export interface VimToolDetails {
+	file: string;
+	mode: VimMode;
+	cursor: { line: number; col: number };
+	totalLines: number;
+	modified: boolean;
+	viewport: VimViewport;
+	focus?: VimFocusLine;
+	viewportLines?: VimViewportLine[];
+	selection?: VimSelection;
+	pendingInput?: VimPendingInput;
+	errorLocation?: VimErrorLocation;
+	closed?: boolean;
+	meta?: OutputMeta;
+	lastCommand?: string;
+	statusMessage?: string;
+	diagnostics?: FileDiagnosticsResult;
+}
+
+export interface VimFingerprint {
+	exists: boolean;
+	size: number;
+	mtimeMs: number;
+	hash: string;
+}
+
+export interface VimLoadedFile {
+	absolutePath: string;
+	displayPath: string;
+	lines: string[];
+	trailingNewline: boolean;
+	fingerprint: VimFingerprint | null;
+}
+
+export interface VimKeyToken {
+	value: string;
+	display: string;
+	sequenceIndex: number;
+	offset: number;
+}
+
+export interface VimRegister {
+	kind: "char" | "line";
+	text: string;
+}
+
+export interface VimSearchState {
+	pattern: string;
+	direction: 1 | -1;
+}
+
+export interface VimBufferSnapshot {
+	displayPath: string;
+	filePath: string;
+	lines: string[];
+	cursor: Position;
+	modified: boolean;
+	trailingNewline: boolean;
+	baseFingerprint: VimFingerprint | null;
+	editabilityChecked: boolean;
+}
+
+export interface VimUndoEntry {
+	before: VimBufferSnapshot;
+	after: VimBufferSnapshot;
+}
+
+export interface VimLineRange {
+	start: number;
+	end: number;
+}
+
+export type VimExCommand =
+	| { kind: "write"; force: boolean }
+	| { kind: "update"; force: boolean }
+	| { kind: "quit"; force: boolean }
+	| { kind: "write-quit"; force: boolean }
+	| { kind: "edit"; force: boolean; path?: string }
+	| { kind: "goto-line"; line: number }
+	| { kind: "substitute"; range?: VimLineRange | "all"; pattern: string; replacement: string; flags: string }
+	| { kind: "delete"; range?: VimLineRange | "all" }
+	| { kind: "yank"; range?: VimLineRange | "all" }
+	| { kind: "put"; range?: VimLineRange | "all"; before: boolean }
+	| { kind: "copy"; range?: VimLineRange | "all"; destination: number }
+	| { kind: "move"; range?: VimLineRange | "all"; destination: number }
+	| { kind: "sort"; range?: VimLineRange | "all"; flags: string }
+	| { kind: "join"; range?: VimLineRange | "all"; trimWhitespace: boolean }
+	| { kind: "global"; range?: VimLineRange | "all"; pattern: string; command: string; invert: boolean }
+	| { kind: "append"; range?: VimLineRange; text: string }
+	| { kind: "insert-before"; range?: VimLineRange; text: string };
+
+export class VimInputError extends Error {
+	location?: { sequenceIndex: number; offset: number };
+
+	constructor(message: string, token?: VimKeyToken) {
+		super(message);
+		this.name = "VimInputError";
+		if (token) {
+			this.location = {
+				sequenceIndex: token.sequenceIndex,
+				offset: token.offset,
+			};
+		}
+	}
+}
+
+export function clonePosition(position: Position): Position {
+	return { line: position.line, col: position.col };
+}
+
+export function comparePositions(left: Position, right: Position): number {
+	if (left.line !== right.line) {
+		return left.line - right.line;
+	}
+	return left.col - right.col;
+}
+
+export function minPosition(left: Position, right: Position): Position {
+	return comparePositions(left, right) <= 0 ? clonePosition(left) : clonePosition(right);
+}
+
+export function maxPosition(left: Position, right: Position): Position {
+	return comparePositions(left, right) >= 0 ? clonePosition(left) : clonePosition(right);
+}
+
+export function toPublicMode(mode: VimInputMode): VimMode {
+	switch (mode) {
+		case "insert":
+			return "INSERT";
+		case "visual":
+			return "VISUAL";
+		case "visual-line":
+			return "VISUAL-LINE";
+		case "command":
+		case "search-forward":
+		case "search-backward":
+			return "COMMAND";
+		default:
+			return "NORMAL";
+	}
+}