@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.1

package/src/vim/buffer.ts

@@ -1,309 +0,0 @@
-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

@@ -1,382 +0,0 @@
-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}.`);
-}