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

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}.`);
+}