@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/vim/buffer.ts

@@ -0,0 +1,309 @@
+import { clonePosition, type Position, type VimBufferSnapshot, type VimFingerprint, type VimLoadedFile } from "./types";
+
+function splitText(text: string): string[] {
+	if (text.length === 0) {
+		return [""];
+	}
+	return text.split("\n");
+}
+
+export function snapshotEqual(left: VimBufferSnapshot, right: VimBufferSnapshot): boolean {
+	if (
+		left.displayPath !== right.displayPath ||
+		left.filePath !== right.filePath ||
+		left.modified !== right.modified ||
+		left.trailingNewline !== right.trailingNewline ||
+		left.cursor.line !== right.cursor.line ||
+		left.cursor.col !== right.cursor.col ||
+		left.editabilityChecked !== right.editabilityChecked
+	) {
+		return false;
+	}
+
+	if (left.baseFingerprint === null || right.baseFingerprint === null) {
+		if (left.baseFingerprint !== right.baseFingerprint) {
+			return false;
+		}
+	} else if (
+		left.baseFingerprint.exists !== right.baseFingerprint.exists ||
+		left.baseFingerprint.size !== right.baseFingerprint.size ||
+		left.baseFingerprint.mtimeMs !== right.baseFingerprint.mtimeMs ||
+		left.baseFingerprint.hash !== right.baseFingerprint.hash
+	) {
+		return false;
+	}
+
+	if (left.lines.length !== right.lines.length) {
+		return false;
+	}
+
+	for (let index = 0; index < left.lines.length; index += 1) {
+		if (left.lines[index] !== right.lines[index]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+export class VimBuffer {
+	displayPath: string;
+	filePath: string;
+	lines: string[];
+	cursor: Position;
+	modified: boolean;
+	trailingNewline: boolean;
+	baseFingerprint: VimFingerprint | null;
+	editabilityChecked: boolean;
+
+	constructor(input: VimLoadedFile) {
+		this.displayPath = input.displayPath;
+		this.filePath = input.absolutePath;
+		this.lines = input.lines.length > 0 ? [...input.lines] : [""];
+		this.cursor = { line: 0, col: 0 };
+		this.modified = false;
+		this.trailingNewline = input.trailingNewline;
+		this.baseFingerprint = input.fingerprint ? { ...input.fingerprint } : null;
+		this.editabilityChecked = false;
+	}
+
+	clone(): VimBuffer {
+		const clone = new VimBuffer({
+			absolutePath: this.filePath,
+			displayPath: this.displayPath,
+			lines: [...this.lines],
+			trailingNewline: this.trailingNewline,
+			fingerprint: this.baseFingerprint ? { ...this.baseFingerprint } : null,
+		});
+		clone.cursor = clonePosition(this.cursor);
+		clone.modified = this.modified;
+		clone.editabilityChecked = this.editabilityChecked;
+		return clone;
+	}
+
+	createSnapshot(): VimBufferSnapshot {
+		return {
+			displayPath: this.displayPath,
+			filePath: this.filePath,
+			lines: [...this.lines],
+			cursor: clonePosition(this.cursor),
+			modified: this.modified,
+			trailingNewline: this.trailingNewline,
+			baseFingerprint: this.baseFingerprint ? { ...this.baseFingerprint } : null,
+			editabilityChecked: this.editabilityChecked,
+		};
+	}
+
+	restore(snapshot: VimBufferSnapshot): void {
+		this.displayPath = snapshot.displayPath;
+		this.filePath = snapshot.filePath;
+		this.lines = snapshot.lines.length > 0 ? [...snapshot.lines] : [""];
+		this.cursor = clonePosition(snapshot.cursor);
+		this.modified = snapshot.modified;
+		this.trailingNewline = snapshot.trailingNewline;
+		this.baseFingerprint = snapshot.baseFingerprint ? { ...snapshot.baseFingerprint } : null;
+		this.editabilityChecked = snapshot.editabilityChecked;
+		this.clampCursor();
+	}
+
+	replaceLoadedFile(input: VimLoadedFile): void {
+		this.displayPath = input.displayPath;
+		this.filePath = input.absolutePath;
+		this.lines = input.lines.length > 0 ? [...input.lines] : [""];
+		this.cursor = { line: 0, col: 0 };
+		this.modified = false;
+		this.trailingNewline = input.trailingNewline;
+		this.baseFingerprint = input.fingerprint ? { ...input.fingerprint } : null;
+		this.editabilityChecked = false;
+	}
+
+	markSaved(input: VimLoadedFile): void {
+		this.lines = input.lines.length > 0 ? [...input.lines] : [""];
+		this.modified = false;
+		this.trailingNewline = input.trailingNewline;
+		this.baseFingerprint = input.fingerprint ? { ...input.fingerprint } : null;
+		this.clampCursor();
+	}
+
+	lineCount(): number {
+		return this.lines.length;
+	}
+
+	lastLineIndex(): number {
+		return Math.max(0, this.lines.length - 1);
+	}
+
+	getLine(line: number): string {
+		return this.lines[this.clampLine(line)] ?? "";
+	}
+
+	clampLine(line: number): number {
+		return Math.min(Math.max(line, 0), this.lastLineIndex());
+	}
+
+	clampCol(line: number, col: number): number {
+		return Math.min(Math.max(col, 0), this.getLine(line).length);
+	}
+
+	setCursor(position: Position): void {
+		this.cursor = {
+			line: this.clampLine(position.line),
+			col: this.clampCol(position.line, position.col),
+		};
+	}
+
+	clampCursor(): void {
+		this.setCursor(this.cursor);
+	}
+
+	firstNonBlank(line: number): number {
+		const content = this.getLine(line);
+		const index = content.search(/\S/);
+		return index === -1 ? 0 : index;
+	}
+
+	getText(): string {
+		return this.lines.join("\n");
+	}
+
+	setText(text: string, trailingNewline = this.trailingNewline): void {
+		const normalizedText = trailingNewline && text.endsWith("\n") ? text.slice(0, -1) : text;
+		this.lines = splitText(normalizedText);
+		this.trailingNewline = trailingNewline;
+		this.clampCursor();
+	}
+
+	currentOffset(): number {
+		return this.positionToOffset(this.cursor);
+	}
+
+	positionToOffset(position: Position): number {
+		const line = this.clampLine(position.line);
+		const col = this.clampCol(line, position.col);
+		let offset = 0;
+		for (let index = 0; index < line; index += 1) {
+			offset += this.lines[index]!.length + 1;
+		}
+		return offset + col;
+	}
+
+	offsetToPosition(offset: number): Position {
+		const text = this.getText();
+		const clamped = Math.min(Math.max(offset, 0), text.length);
+		let remaining = clamped;
+		for (let line = 0; line < this.lines.length; line += 1) {
+			const current = this.lines[line]!;
+			if (remaining <= current.length) {
+				return { line, col: remaining };
+			}
+			remaining -= current.length;
+			if (line < this.lines.length - 1) {
+				if (remaining === 0) {
+					return { line: line + 1, col: 0 };
+				}
+				remaining -= 1;
+			}
+		}
+		return { line: this.lastLineIndex(), col: this.getLine(this.lastLineIndex()).length };
+	}
+
+	setCursorFromOffset(offset: number): void {
+		this.cursor = this.offsetToPosition(offset);
+	}
+
+	replaceOffsets(start: number, end: number, replacement: string, cursorOffset = start + replacement.length): void {
+		const text = this.getText();
+		const normalizedStart = Math.min(Math.max(start, 0), text.length);
+		const normalizedEnd = Math.min(Math.max(end, normalizedStart), text.length);
+		const nextText = `${text.slice(0, normalizedStart)}${replacement}${text.slice(normalizedEnd)}`;
+		// getText() omits the trailing-newline marker, so any \n in the
+		// replacement is content (a line separator), not a file-trailing newline.
+		// Bypass setText() which would incorrectly strip it.
+		this.lines = splitText(nextText);
+		this.clampCursor();
+		this.setCursorFromOffset(cursorOffset);
+	}
+
+	deleteOffsets(start: number, end: number): string {
+		const text = this.getText();
+		const normalizedStart = Math.min(Math.max(start, 0), text.length);
+		const normalizedEnd = Math.min(Math.max(end, normalizedStart), text.length);
+		const removed = text.slice(normalizedStart, normalizedEnd);
+		this.replaceOffsets(normalizedStart, normalizedEnd, "", normalizedStart);
+		return removed;
+	}
+
+	deleteLines(startLine: number, endLine: number): string[] {
+		const start = this.clampLine(Math.min(startLine, endLine));
+		const end = this.clampLine(Math.max(startLine, endLine));
+		const removed = this.lines.slice(start, end + 1);
+		this.lines.splice(start, end - start + 1);
+		if (this.lines.length === 0) {
+			this.lines = [""];
+		}
+		this.setCursor({ line: Math.min(start, this.lastLineIndex()), col: 0 });
+		if (this.lines.length > 1 || removed.length > 1) {
+			this.trailingNewline = true;
+		}
+		return removed;
+	}
+
+	insertLines(index: number, newLines: string[]): void {
+		const at = Math.min(Math.max(index, 0), this.lines.length);
+		const normalized = newLines.length > 0 ? newLines : [""];
+		this.lines.splice(at, 0, ...normalized);
+		this.setCursor({ line: at, col: 0 });
+		this.trailingNewline = true;
+	}
+
+	replaceLine(line: number, content: string): void {
+		const target = this.clampLine(line);
+		this.lines[target] = content;
+		this.setCursor(this.cursor);
+	}
+
+	joinLines(startLine: number, count: number): void {
+		const start = this.clampLine(startLine);
+		const end = this.clampLine(start + Math.max(count, 1));
+		if (start >= end) {
+			return;
+		}
+		const joined = this.lines
+			.slice(start, end + 1)
+			.map(line => line.trim())
+			.join(" ");
+		this.lines.splice(start, end - start + 1, joined);
+		this.setCursor({ line: start, col: Math.max(0, joined.length - 1) });
+	}
+
+	indentLines(startLine: number, endLine: number, indentUnit: string, direction: 1 | -1): void {
+		const start = this.clampLine(Math.min(startLine, endLine));
+		const end = this.clampLine(Math.max(startLine, endLine));
+		for (let line = start; line <= end; line += 1) {
+			const content = this.lines[line] ?? "";
+			if (direction > 0) {
+				this.lines[line] = `${indentUnit}${content}`;
+				continue;
+			}
+			if (content.startsWith(indentUnit)) {
+				this.lines[line] = content.slice(indentUnit.length);
+				continue;
+			}
+			const spaces = content.match(/^ +/)?.[0].length ?? 0;
+			this.lines[line] = content.slice(Math.min(spaces, indentUnit.length));
+		}
+		this.setCursor(this.cursor);
+	}
+
+	getCharacterAtOffset(offset: number): string {
+		const text = this.getText();
+		if (offset < 0 || offset >= text.length) {
+			return "";
+		}
+		return text[offset] ?? "";
+	}
+
+	getCharacter(position: Position): string {
+		return this.getCharacterAtOffset(this.positionToOffset(position));
+	}
+}

package/src/vim/commands.ts

@@ -0,0 +1,382 @@
+import type { VimExCommand, VimLineRange } from "./types";
+import { VimInputError } from "./types";
+
+export interface VimExParseContext {
+	currentLine: number;
+	lastLine: number;
+}
+
+interface ParsedLineAddress {
+	line: number;
+	nextIndex: number;
+}
+
+function clampLine(line: number, context: VimExParseContext): number {
+	return Math.min(Math.max(line, 1), Math.max(1, context.lastLine));
+}
+
+function readDigits(raw: string, start: number): { digits: string; nextIndex: number } {
+	let index = start;
+	let digits = "";
+	while (index < raw.length) {
+		const char = raw[index] ?? "";
+		if (!/^\d$/.test(char)) {
+			break;
+		}
+		digits += char;
+		index += 1;
+	}
+	return { digits, nextIndex: index };
+}
+
+function parseLineAddress(
+	raw: string,
+	start: number,
+	context: VimExParseContext,
+	relativeBase = context.currentLine,
+): ParsedLineAddress | undefined {
+	let index = start;
+	let line: number | undefined;
+	const first = raw[index] ?? "";
+
+	if (/^\d$/.test(first)) {
+		const { digits, nextIndex } = readDigits(raw, index);
+		line = Number.parseInt(digits, 10);
+		index = nextIndex;
+	} else if (first === ".") {
+		line = context.currentLine;
+		index += 1;
+	} else if (first === "$") {
+		line = context.lastLine;
+		index += 1;
+	} else if (first === "+" || first === "-") {
+		line = relativeBase;
+	} else {
+		return undefined;
+	}
+
+	while (index < raw.length) {
+		const sign = raw[index];
+		if (sign !== "+" && sign !== "-") {
+			break;
+		}
+		index += 1;
+		const { digits, nextIndex } = readDigits(raw, index);
+		index = nextIndex;
+		const offset = digits.length > 0 ? Number.parseInt(digits, 10) : 1;
+		line += sign === "+" ? offset : -offset;
+	}
+
+	return { line: clampLine(line, context), nextIndex: index };
+}
+
+function parseLineRange(raw: string, context?: VimExParseContext): { range?: VimLineRange | "all"; rest: string } {
+	if (raw.startsWith("%")) {
+		return { range: "all", rest: raw.slice(1).trimStart() };
+	}
+
+	if (!context) {
+		const match = raw.match(/^(\d+)(?:\s*,\s*(\d+))?/);
+		if (!match) {
+			return { rest: raw };
+		}
+
+		const start = Number.parseInt(match[1] ?? "", 10);
+		const end = Number.parseInt(match[2] ?? match[1] ?? "", 10);
+		return {
+			range: { start, end },
+			rest: raw.slice(match[0].length).trimStart(),
+		};
+	}
+
+	const first = parseLineAddress(raw, 0, context);
+	if (!first) {
+		return { rest: raw };
+	}
+
+	let index = first.nextIndex;
+	while (raw[index] === " ") {
+		index += 1;
+	}
+
+	const separator = raw[index];
+	if (separator !== "," && separator !== ";") {
+		return {
+			range: { start: first.line, end: first.line },
+			rest: raw.slice(index).trimStart(),
+		};
+	}
+
+	index += 1;
+	while (raw[index] === " ") {
+		index += 1;
+	}
+
+	const second = parseLineAddress(raw, index, context, separator === ";" ? first.line : context.currentLine);
+	if (!second) {
+		throw new VimInputError(`Missing line address after ${separator}`);
+	}
+
+	return {
+		range: { start: first.line, end: second.line },
+		rest: raw.slice(second.nextIndex).trimStart(),
+	};
+}
+
+function parseDelimitedSegments(raw: string): { pattern: string; replacement: string; flags: string } {
+	if (raw.length === 0) {
+		throw new VimInputError("Missing substitute delimiter");
+	}
+
+	const delimiter = raw[0] ?? "/";
+	const segments: string[] = [];
+	let current = "";
+	let escaped = false;
+
+	for (let index = 1; index < raw.length; index += 1) {
+		const char = raw[index] ?? "";
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			current += char;
+			continue;
+		}
+		if (char === delimiter && segments.length < 2) {
+			segments.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+
+	if (segments.length !== 2) {
+		throw new VimInputError("Substitute command must look like :s/pattern/replacement/flags");
+	}
+
+	return {
+		pattern: segments[0] ?? "",
+		replacement: segments[1] ?? "",
+		flags: current.trim(),
+	};
+}
+
+function parseDestination(raw: string, context?: VimExParseContext): number {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) {
+		throw new VimInputError("Missing destination");
+	}
+
+	if (/^\d+$/.test(trimmed)) {
+		return Number.parseInt(trimmed, 10);
+	}
+
+	if (context) {
+		const address = parseLineAddress(trimmed, 0, context);
+		if (address && trimmed.slice(address.nextIndex).trim().length === 0) {
+			return address.line;
+		}
+	}
+
+	const destination = Number.parseInt(trimmed, 10);
+	if (Number.isNaN(destination)) {
+		throw new VimInputError("Invalid destination");
+	}
+	return destination;
+}
+
+function matchGlobalCommand(rest: string): { pattern: string; command: string; invert: boolean } | undefined {
+	const globalMatch = rest.match(/^(g|v|g!|global|global!|vglobal)\s*([/|#])(.+?)\2(.*)$/);
+	if (!globalMatch) {
+		return undefined;
+	}
+	return {
+		invert: globalMatch[1] === "v" || globalMatch[1] === "vglobal" || globalMatch[1]?.endsWith("!") === true,
+		pattern: globalMatch[3] ?? "",
+		command: (globalMatch[4] ?? "d").trim() || "d",
+	};
+}
+
+function matchDestinationCommand(rest: string, prefixes: readonly string[]): string | undefined {
+	for (const prefix of prefixes) {
+		if (!rest.startsWith(prefix)) {
+			continue;
+		}
+		const suffix = rest.slice(prefix.length);
+		if (suffix.length === 0) {
+			return "";
+		}
+		if (/^\s/.test(suffix) || /^[\d.$+-]/.test(suffix)) {
+			return suffix.trim();
+		}
+	}
+	return undefined;
+}
+
+export function parseExCommand(input: string, context?: VimExParseContext): VimExCommand {
+	const trimmed = input.trim();
+	const normalized = trimmed.startsWith(":") ? trimmed.slice(1).trimStart() : trimmed;
+	if (normalized.length === 0) {
+		throw new VimInputError("Empty ex command");
+	}
+
+	if (/^\d+$/.test(normalized)) {
+		return {
+			kind: "goto-line",
+			line: Number.parseInt(normalized, 10),
+		};
+	}
+
+	if (normalized === "w" || normalized === "write") {
+		return { kind: "write", force: false };
+	}
+	if (normalized === "w!" || normalized === "write!") {
+		return { kind: "write", force: true };
+	}
+	if (normalized === "update" || normalized === "up") {
+		return { kind: "update", force: false };
+	}
+	if (normalized === "update!" || normalized === "up!") {
+		return { kind: "update", force: true };
+	}
+	if (normalized === "wq" || normalized === "x" || normalized === "xit" || normalized === "exit") {
+		return { kind: "write-quit", force: false };
+	}
+	if (normalized === "wq!" || normalized === "x!" || normalized === "xit!" || normalized === "exit!") {
+		return { kind: "write-quit", force: true };
+	}
+	if (normalized === "q" || normalized === "quit") {
+		return { kind: "quit", force: false };
+	}
+	if (normalized === "q!" || normalized === "quit!") {
+		return { kind: "quit", force: true };
+	}
+	if (normalized === "e" || normalized === "edit") {
+		return { kind: "edit", force: false };
+	}
+	if (normalized === "e!" || normalized === "edit!") {
+		return { kind: "edit", force: true };
+	}
+	if (normalized.startsWith("e ") || normalized.startsWith("edit ")) {
+		const path = normalized.startsWith("edit ") ? normalized.slice(5).trim() : normalized.slice(2).trim();
+		return { kind: "edit", force: false, path };
+	}
+	if (normalized.startsWith("e! ") || normalized.startsWith("edit! ")) {
+		const path = normalized.startsWith("edit! ") ? normalized.slice(6).trim() : normalized.slice(3).trim();
+		return { kind: "edit", force: true, path };
+	}
+
+	const global = matchGlobalCommand(normalized);
+	if (global) {
+		return { kind: "global", ...global };
+	}
+
+	const { range, rest } = parseLineRange(normalized, context);
+	if (range && rest.length === 0) {
+		if (range === "all") {
+			throw new VimInputError(":% requires a following command");
+		}
+		return {
+			kind: "goto-line",
+			line: range.start,
+		};
+	}
+
+	const rangedGlobal = matchGlobalCommand(rest);
+	if (rangedGlobal) {
+		return { kind: "global", range, ...rangedGlobal };
+	}
+
+	if (rest === "sort" || rest.startsWith("sort ") || rest.startsWith("sort!")) {
+		const flags = rest.slice(4).trim();
+		return { kind: "sort", range: range ?? undefined, flags };
+	}
+	if (rest === "j" || rest === "join" || rest === "j!" || rest === "join!") {
+		return { kind: "join", range: range ?? undefined, trimWhitespace: !rest.endsWith("!") };
+	}
+
+	if (rest.startsWith("substitute")) {
+		const segments = parseDelimitedSegments(rest.slice("substitute".length));
+		return {
+			kind: "substitute",
+			range,
+			pattern: segments.pattern,
+			replacement: segments.replacement,
+			flags: segments.flags,
+		};
+	}
+
+	if (/^s(?:\W|$)/.test(rest)) {
+		const segments = parseDelimitedSegments(rest.slice(1));
+		return {
+			kind: "substitute",
+			range,
+			pattern: segments.pattern,
+			replacement: segments.replacement,
+			flags: segments.flags,
+		};
+	}
+
+	if (
+		rest === "d" ||
+		rest === "del" ||
+		rest === "delete" ||
+		rest.startsWith("d ") ||
+		rest.startsWith("del ") ||
+		rest.startsWith("delete ")
+	) {
+		return {
+			kind: "delete",
+			range,
+		};
+	}
+
+	if (
+		rest === "y" ||
+		rest === "ya" ||
+		rest === "yank" ||
+		rest.startsWith("y ") ||
+		rest.startsWith("ya ") ||
+		rest.startsWith("yank ")
+	) {
+		return {
+			kind: "yank",
+			range,
+		};
+	}
+
+	if (rest === "pu" || rest === "put" || rest === "pu!" || rest === "put!") {
+		return {
+			kind: "put",
+			range,
+			before: rest.endsWith("!"),
+		};
+	}
+
+	const copyDestination = matchDestinationCommand(rest, ["copy", "co", "t"]);
+	if (copyDestination !== undefined) {
+		const destination = parseDestination(copyDestination, context);
+		return { kind: "copy", range, destination };
+	}
+
+	const moveDestination = matchDestinationCommand(rest, ["move", "mo", "m"]);
+	if (moveDestination !== undefined) {
+		const destination = parseDestination(moveDestination, context);
+		return { kind: "move", range, destination };
+	}
+
+	if (rest === "a" || rest === "append" || rest.startsWith("a ") || rest.startsWith("append ")) {
+		const text = rest.startsWith("append") ? rest.slice(6).trimStart() : rest.slice(1).trimStart();
+		return { kind: "append", range: range === "all" ? undefined : range, text };
+	}
+
+	if (rest === "i" || rest === "insert" || rest.startsWith("i ") || rest.startsWith("insert ")) {
+		const text = rest.startsWith("insert") ? rest.slice(6).trimStart() : rest.slice(1).trimStart();
+		return { kind: "insert-before", range: range === "all" ? undefined : range, text };
+	}
+
+	throw new VimInputError(`Unsupported ex command: ${input}.`);
+}