oh-my-opencode 4.18.0 → 4.18.1

package/packages/lsp-core/src/lsp/workspace-edit-snapshot.ts

@@ -0,0 +1,53 @@
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+import { snapshotPath } from "./workspace-edit-path.js";
+import type { ParsedWorkspaceOperation } from "./workspace-edit-plan-types.js";
+import type { WorkspaceSnapshotEntry } from "./workspace-edit-types.js";
+
+class WorkspaceSnapshotBuilder {
+	private readonly snapshots = new Map<string, WorkspaceSnapshotEntry>();
+
+	constructor(private readonly workspaceRoot: string) {}
+
+	build(operations: readonly ParsedWorkspaceOperation[]): ReadonlyMap<string, WorkspaceSnapshotEntry> {
+		this.add(this.workspaceRoot, false);
+		for (const operation of operations) {
+			switch (operation.kind) {
+				case "rename":
+					this.add(operation.oldPath, true);
+					this.add(operation.newPath, true);
+					break;
+				case "delete":
+					this.add(operation.path, true);
+					break;
+				case "text":
+				case "create":
+					this.add(operation.path, false);
+					break;
+			}
+		}
+		return this.snapshots;
+	}
+
+	private add(path: string, includeChildren: boolean): void {
+		let candidate = path;
+		while (true) {
+			const existing = this.snapshots.get(candidate);
+			if (existing === undefined || (includeChildren && existing.kind === "directory" && existing.children === undefined)) {
+				this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path));
+			}
+			if (candidate === this.workspaceRoot) break;
+			candidate = dirname(candidate);
+		}
+		if (!includeChildren || !existsSync(path) || !lstatSync(path).isDirectory()) return;
+		for (const child of readdirSync(path)) this.add(resolve(path, child), true);
+	}
+}
+
+export function snapshotOperations(
+	operations: readonly ParsedWorkspaceOperation[],
+	workspaceRoot: string,
+): ReadonlyMap<string, WorkspaceSnapshotEntry> {
+	return new WorkspaceSnapshotBuilder(workspaceRoot).build(operations);
+}

package/packages/lsp-core/src/lsp/workspace-edit-text.ts

@@ -0,0 +1,125 @@
+import type { Position, Range, TextEdit } from "./types.js";
+import { type NormalizedTextEditResult, WorkspaceEditValidationError } from "./workspace-edit-types.js";
+
+interface IndexedTextEdit {
+	readonly edit: TextEdit;
+	readonly index: number;
+}
+
+interface PositionValidationContext {
+	readonly lines: readonly string[];
+	readonly changeIndex: number;
+}
+
+function comparePosition(left: Position, right: Position): number {
+	return left.line === right.line ? left.character - right.character : left.line - right.line;
+}
+
+function positionsEqual(left: Position, right: Position): boolean {
+	return left.line === right.line && left.character === right.character;
+}
+
+function rangesEqual(left: Range, right: Range): boolean {
+	return positionsEqual(left.start, right.start) && positionsEqual(left.end, right.end);
+}
+
+function isEmptyRange(range: Range): boolean {
+	return positionsEqual(range.start, range.end);
+}
+
+function formatRange(range: Range): string {
+	return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
+}
+
+function validatePosition(position: Position, label: string, context: PositionValidationContext): void {
+	const { lines, changeIndex } = context;
+	if (!Number.isInteger(position.line) || !Number.isInteger(position.character)) {
+		throw new WorkspaceEditValidationError(changeIndex, `${label} position must use integer line and character`);
+	}
+	if (position.line < 0 || position.character < 0) {
+		throw new WorkspaceEditValidationError(changeIndex, `${label} position cannot be negative`);
+	}
+	const line = lines[position.line];
+	if (line === undefined) {
+		throw new WorkspaceEditValidationError(changeIndex, `${label} line ${position.line} is outside the document`);
+	}
+	if (position.character > line.length) {
+		throw new WorkspaceEditValidationError(
+			changeIndex,
+			`${label} character ${position.character} is outside line ${position.line}`,
+		);
+	}
+}
+
+function validateRange(range: Range, lines: readonly string[], changeIndex: number): void {
+	const context: PositionValidationContext = { lines, changeIndex };
+	validatePosition(range.start, "start", context);
+	validatePosition(range.end, "end", context);
+	if (comparePosition(range.start, range.end) > 0) {
+		throw new WorkspaceEditValidationError(changeIndex, `range ${formatRange(range)} ends before it starts`);
+	}
+}
+
+function sortAndDeduplicate(edits: readonly TextEdit[]): readonly TextEdit[] {
+	const sorted = edits
+		.map<IndexedTextEdit>((edit, index) => ({ edit, index }))
+		.sort((left, right) => {
+			const positionOrder = comparePosition(right.edit.range.start, left.edit.range.start);
+			return positionOrder === 0 ? right.index - left.index : positionOrder;
+		});
+	const unique: TextEdit[] = [];
+	for (const entry of sorted) {
+		const previous = unique.at(-1);
+		if (
+			previous !== undefined &&
+			!isEmptyRange(entry.edit.range) &&
+			rangesEqual(previous.range, entry.edit.range) &&
+			previous.newText === entry.edit.newText
+		) {
+			continue;
+		}
+		unique.push(entry.edit);
+	}
+	return unique;
+}
+
+function validateNoOverlap(edits: readonly TextEdit[], changeIndex: number): void {
+	for (let index = 0; index < edits.length - 1; index += 1) {
+		const later = edits[index];
+		const earlier = edits[index + 1];
+		if (later === undefined || earlier === undefined) continue;
+		if (comparePosition(earlier.range.end, later.range.start) > 0) {
+			throw new WorkspaceEditValidationError(
+				changeIndex,
+				`overlapping edits ${formatRange(earlier.range)} and ${formatRange(later.range)}`,
+			);
+		}
+	}
+}
+
+function applyNormalizedTextEdits(content: string, edits: readonly TextEdit[]): string {
+	const lines = content.split("\n");
+	for (const edit of edits) {
+		const { start, end } = edit.range;
+		const startLine = lines[start.line];
+		const endLine = lines[end.line];
+		if (startLine === undefined || endLine === undefined) continue;
+		const replacement = startLine.slice(0, start.character) + edit.newText + endLine.slice(end.character);
+		lines.splice(start.line, end.line - start.line + 1, ...replacement.split("\n"));
+	}
+	return lines.join("\n");
+}
+
+export function normalizeTextEdits(
+	content: string,
+	edits: readonly TextEdit[],
+	changeIndex: number,
+): NormalizedTextEditResult {
+	const lines = content.split("\n");
+	for (const edit of edits) {
+		validateRange(edit.range, lines, changeIndex);
+	}
+	const normalized = sortAndDeduplicate(edits);
+	validateNoOverlap(normalized, changeIndex);
+	return { edits: normalized, text: applyNormalizedTextEdits(content, normalized) };
+}

package/packages/lsp-core/src/lsp/workspace-edit-types.ts

@@ -0,0 +1,121 @@
+import type { TextEdit, WorkspaceEdit } from "./types.js";
+
+export interface ApplyResult {
+	readonly success: boolean;
+	readonly filesModified: readonly string[];
+	readonly totalEdits: number;
+	readonly errors: readonly string[];
+	readonly failedChange?: number;
+	readonly lateAbort?: boolean;
+}
+
+export interface LspRenameResult {
+	readonly edit: WorkspaceEdit | null;
+	readonly apply: ApplyResult;
+}
+
+export type WorkspaceSnapshotEntry =
+	| { readonly kind: "missing" }
+	| { readonly kind: "file"; readonly content: string }
+	| { readonly kind: "directory"; readonly children?: readonly string[] };
+
+export type PlannedWorkspaceOperation =
+	| {
+			readonly kind: "text";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly beforeText: string;
+			readonly afterText: string;
+			readonly editCount: number;
+			readonly documentVersion: number | null;
+	  }
+	| {
+			readonly kind: "create";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly replaced: boolean;
+	  }
+	| {
+			readonly kind: "rename";
+			readonly changeIndex: number;
+			readonly oldPath: string;
+			readonly newPath: string;
+			readonly sourceKind: "file" | "directory";
+			readonly replaceDestination: boolean;
+	  }
+	| {
+			readonly kind: "delete";
+			readonly changeIndex: number;
+			readonly path: string;
+			readonly targetKind: "file" | "directory";
+			readonly recursive: boolean;
+	  }
+	| { readonly kind: "noop"; readonly changeIndex: number };
+
+export interface WorkspaceEditPlan {
+	readonly workspaceRoot: string;
+	readonly operations: readonly PlannedWorkspaceOperation[];
+	readonly snapshots: ReadonlyMap<string, WorkspaceSnapshotEntry>;
+	readonly firstChangeByPath: ReadonlyMap<string, number>;
+	readonly reportedPathByCanonical: ReadonlyMap<string, string>;
+	readonly fingerprint: string;
+}
+
+export type WorkspaceEditPlanResult =
+	| { readonly success: true; readonly plan: WorkspaceEditPlan }
+	| { readonly success: false; readonly result: ApplyResult };
+
+export type WorkspaceMutation =
+	| {
+			readonly kind: "text";
+			readonly path: string;
+			readonly beforeText: string;
+			readonly afterText: string;
+	  }
+	| { readonly kind: "create"; readonly path: string; readonly replaced: boolean }
+	| {
+			readonly kind: "rename";
+			readonly oldPath: string;
+			readonly newPath: string;
+			readonly sourceKind: "file" | "directory";
+	  }
+	| { readonly kind: "delete"; readonly path: string; readonly targetKind: "file" | "directory" };
+
+export interface WorkspaceMutationDelta {
+	readonly operations: readonly WorkspaceMutation[];
+	readonly changedPaths: readonly string[];
+}
+
+export interface WorkspaceEditCommit {
+	readonly result: ApplyResult;
+	readonly delta: WorkspaceMutationDelta;
+	readonly fingerprint: string | null;
+}
+
+export interface WorkspaceEditCommitIo {
+	readonly writeFile: (path: string, content: string) => void;
+	readonly rename: (oldPath: string, newPath: string) => void;
+	readonly remove: (path: string, recursive: boolean) => void;
+}
+
+export interface ApplyWorkspaceEditOptions {
+	readonly workspaceRoot?: string;
+	readonly signal?: AbortSignal;
+	readonly io?: Partial<WorkspaceEditCommitIo>;
+}
+
+export interface NormalizedTextEditResult {
+	readonly edits: readonly TextEdit[];
+	readonly text: string;
+}
+
+export class WorkspaceEditValidationError extends Error {
+	override readonly name = "WorkspaceEditValidationError";
+
+	constructor(
+		readonly changeIndex: number,
+		readonly detail: string,
+	) {
+		super(`change ${changeIndex}: ${detail}`);
+	}
+}

package/packages/lsp-core/src/lsp/workspace-edit.characterization.test.ts

@@ -0,0 +1,95 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { applyWorkspaceEdit } from "./workspace-edit.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("applyWorkspaceEdit preserved behavior", () => {
+	it("#given a valid text edit #when applied #then the file and ApplyResult remain compatible", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "source.ts");
+		writeFileSync(source, "const before = 1;\n", "utf-8");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				changes: {
+					[pathToFileURL(source).href]: [
+						{
+							range: { start: { line: 0, character: 6 }, end: { line: 0, character: 12 } },
+							newText: "after",
+						},
+					],
+				},
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result).toEqual({ success: true, filesModified: [source], totalEdits: 1, errors: [] });
+		expect(readFileSync(source, "utf-8")).toBe("const after = 1;\n");
+	});
+
+	it("#given a resource rename #when applied #then content moves and the destination is reported", () => {
+		// given
+		const workspace = makeTempDirectory();
+		const source = join(workspace, "before.ts");
+		const destination = join(workspace, "after.ts");
+		writeFileSync(source, "export const value = 1;\n", "utf-8");
+
+		// when
+		const result = applyWorkspaceEdit(
+			{
+				documentChanges: [
+					{ kind: "rename", oldUri: pathToFileURL(source).href, newUri: pathToFileURL(destination).href },
+				],
+			},
+			{ workspaceRoot: workspace },
+		);
+
+		// then
+		expect(result).toEqual({ success: true, filesModified: [destination], totalEdits: 0, errors: [] });
+		expect(existsSync(source)).toBe(false);
+		expect(readFileSync(destination, "utf-8")).toBe("export const value = 1;\n");
+	});
+
+	it("#given an empty workspace edit #when applied #then it remains a successful no-op", () => {
+		// given
+		const workspace = makeTempDirectory();
+
+		// when
+		const result = applyWorkspaceEdit({}, { workspaceRoot: workspace });
+
+		// then
+		expect(result).toEqual({ success: true, filesModified: [], totalEdits: 0, errors: [] });
+	});
+
+	it("#given no workspace edit #when applied #then the existing failure remains explicit", () => {
+		// given
+		const workspace = makeTempDirectory();
+
+		// when
+		const result = applyWorkspaceEdit(null, { workspaceRoot: workspace });
+
+		// then
+		expect(result).toEqual({ success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] });
+	});
+});
+
+function makeTempDirectory(): string {
+	const directory = mkdtempSync(join(tmpdir(), "lsp-workspace-characterization-"));
+	tempDirectories.push(directory);
+	return directory;
+}

package/packages/lsp-core/src/lsp/workspace-edit.ts

@@ -1,206 +1,55 @@
-import { existsSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
 import { contextCwd } from "../request-context.js";
-import type { TextEdit, WorkspaceEdit } from "./types.js";
-
-export interface ApplyResult {
-	success: boolean;
-	filesModified: string[];
-	totalEdits: number;
-	errors: string[];
-}
-
-interface FileApplyResult {
-	success: boolean;
-	editCount: number;
-	error?: string;
-}
-
-export interface ApplyWorkspaceEditOptions {
-	readonly workspaceRoot?: string;
-}
-
-type PathValidationResult =
-	| { readonly success: true; readonly path: string }
-	| { readonly success: false; readonly error: string };
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function isPathInsideWorkspace(filePath: string, workspaceRoot: string): boolean {
-	const relativePath = relative(workspaceRoot, filePath);
-	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-
-function realpathForValidation(filePath: string): string {
-	if (existsSync(filePath)) return realpathSync(filePath);
-	const parent = dirname(filePath);
-	return resolve(realpathSync(parent), relative(parent, filePath));
-}
-
-function uriToWorkspacePath(uri: string, workspaceRoot: string): PathValidationResult {
-	let filePath: string;
-	try {
-		filePath = fileURLToPath(uri);
-	} catch (error) {
-		return { success: false, error: `non-file URI ${uri}: ${errorMessage(error)}` };
-	}
-
-	let validatedPath: string;
-	try {
-		validatedPath = realpathForValidation(filePath);
-	} catch (error) {
-		return { success: false, error: `${filePath}: ${errorMessage(error)}` };
-	}
-
-	if (!isPathInsideWorkspace(validatedPath, workspaceRoot)) {
-		return { success: false, error: `${filePath}: outside workspace ${workspaceRoot}` };
-	}
-
-	return { success: true, path: filePath };
-}
-
-function applyTextEditsToFile(filePath: string, edits: TextEdit[]): FileApplyResult {
-	try {
-		const content = readFileSync(filePath, "utf-8");
-		const lines = content.split("\n");
-
-		const sortedEdits = [...edits].sort((a, b) => {
-			if (b.range.start.line !== a.range.start.line) {
-				return b.range.start.line - a.range.start.line;
-			}
-			return b.range.start.character - a.range.start.character;
-		});
-
-		for (const edit of sortedEdits) {
-			const startLine = edit.range.start.line;
-			const startChar = edit.range.start.character;
-			const endLine = edit.range.end.line;
-			const endChar = edit.range.end.character;
-
-			if (startLine === endLine) {
-				const line = lines[startLine] ?? "";
-				lines[startLine] = line.substring(0, startChar) + edit.newText + line.substring(endChar);
-			} else {
-				const firstLine = lines[startLine] ?? "";
-				const lastLine = lines[endLine] ?? "";
-				const newContent = firstLine.substring(0, startChar) + edit.newText + lastLine.substring(endChar);
-				lines.splice(startLine, endLine - startLine + 1, ...newContent.split("\n"));
-			}
-		}
-
-		writeFileSync(filePath, lines.join("\n"), "utf-8");
-		return { success: true, editCount: edits.length };
-	} catch (err) {
-		return {
-			success: false,
-			editCount: 0,
-			error: err instanceof Error ? err.message : String(err),
-		};
-	}
+import type { WorkspaceEdit } from "./types.js";
+import { commitWorkspaceEditPlan } from "./workspace-edit-commit.js";
+import { fingerprintWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit-plan.js";
+import type {
+	ApplyResult,
+	ApplyWorkspaceEditOptions,
+	WorkspaceEditCommit,
+	WorkspaceMutationDelta,
+} from "./workspace-edit-types.js";
+
+export type {
+	ApplyResult,
+	ApplyWorkspaceEditOptions,
+	LspRenameResult,
+	PlannedWorkspaceOperation,
+	WorkspaceEditCommit,
+	WorkspaceEditCommitIo,
+	WorkspaceEditPlan,
+	WorkspaceEditPlanResult,
+	WorkspaceMutation,
+	WorkspaceMutationDelta,
+} from "./workspace-edit-types.js";
+export { commitWorkspaceEditPlan } from "./workspace-edit-commit.js";
+export { fingerprintWorkspaceEdit, planWorkspaceEdit } from "./workspace-edit-plan.js";
+
+const EMPTY_DELTA: WorkspaceMutationDelta = { operations: [], changedPaths: [] };
+
+function noEditCommit(): WorkspaceEditCommit {
+	return {
+		result: { success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] },
+		delta: EMPTY_DELTA,
+		fingerprint: null,
+	};
+}
+
+export function applyWorkspaceEditDetailed(
+	edit: WorkspaceEdit | null,
+	options: ApplyWorkspaceEditOptions = {},
+): WorkspaceEditCommit {
+	if (!edit) return noEditCommit();
+	const workspaceRoot = options.workspaceRoot ?? contextCwd();
+	const planned = planWorkspaceEdit(edit, workspaceRoot);
+	if (!planned.success) return { result: planned.result, delta: EMPTY_DELTA, fingerprint: null };
+	return commitWorkspaceEditPlan(planned.plan, options);
 }
 
 export function applyWorkspaceEdit(edit: WorkspaceEdit | null, options: ApplyWorkspaceEditOptions = {}): ApplyResult {
-	if (!edit) {
-		return { success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] };
-	}
-
-	const result: ApplyResult = { success: true, filesModified: [], totalEdits: 0, errors: [] };
-	const workspaceRoot = realpathSync(options.workspaceRoot ?? contextCwd());
-
-	if (edit.changes) {
-		for (const [uri, edits] of Object.entries(edit.changes)) {
-			const validatedPath = uriToWorkspacePath(uri, workspaceRoot);
-			if (!validatedPath.success) {
-				result.success = false;
-				result.errors.push(validatedPath.error);
-				continue;
-			}
-			const applyResult = applyTextEditsToFile(validatedPath.path, edits);
-
-			if (applyResult.success) {
-				result.filesModified.push(validatedPath.path);
-				result.totalEdits += applyResult.editCount;
-			} else {
-				result.success = false;
-				result.errors.push(`${validatedPath.path}: ${applyResult.error}`);
-			}
-		}
-	}
-
-	if (edit.documentChanges) {
-		for (const change of edit.documentChanges) {
-			if (!("kind" in change)) {
-				const validatedPath = uriToWorkspacePath(change.textDocument.uri, workspaceRoot);
-				if (!validatedPath.success) {
-					result.success = false;
-					result.errors.push(validatedPath.error);
-					continue;
-				}
-				const applyResult = applyTextEditsToFile(validatedPath.path, change.edits);
-
-				if (applyResult.success) {
-					result.filesModified.push(validatedPath.path);
-					result.totalEdits += applyResult.editCount;
-				} else {
-					result.success = false;
-					result.errors.push(`${validatedPath.path}: ${applyResult.error}`);
-				}
-				continue;
-			}
-
-			if (change.kind === "create") {
-				try {
-					const validatedPath = uriToWorkspacePath(change.uri, workspaceRoot);
-					if (!validatedPath.success) {
-						result.success = false;
-						result.errors.push(`Create ${change.uri}: ${validatedPath.error}`);
-						continue;
-					}
-					writeFileSync(validatedPath.path, "", "utf-8");
-					result.filesModified.push(validatedPath.path);
-				} catch (err) {
-					result.success = false;
-					result.errors.push(`Create ${change.uri}: ${String(err)}`);
-				}
-			} else if (change.kind === "rename") {
-				try {
-					const oldPath = uriToWorkspacePath(change.oldUri, workspaceRoot);
-					const newPath = uriToWorkspacePath(change.newUri, workspaceRoot);
-					if (!oldPath.success || !newPath.success) {
-						const error = oldPath.success ? (newPath.success ? "invalid URI" : newPath.error) : oldPath.error;
-						result.success = false;
-						result.errors.push(`Rename ${change.oldUri}: ${error}`);
-						continue;
-					}
-					const content = readFileSync(oldPath.path, "utf-8");
-					writeFileSync(newPath.path, content, "utf-8");
-					unlinkSync(oldPath.path);
-					result.filesModified.push(newPath.path);
-				} catch (err) {
-					result.success = false;
-					result.errors.push(`Rename ${change.oldUri}: ${String(err)}`);
-				}
-			} else if (change.kind === "delete") {
-				try {
-					const validatedPath = uriToWorkspacePath(change.uri, workspaceRoot);
-					if (!validatedPath.success) {
-						result.success = false;
-						result.errors.push(`Delete ${change.uri}: ${validatedPath.error}`);
-						continue;
-					}
-					unlinkSync(validatedPath.path);
-					result.filesModified.push(validatedPath.path);
-				} catch (err) {
-					result.success = false;
-					result.errors.push(`Delete ${change.uri}: ${String(err)}`);
-				}
-			}
-		}
-	}
+	return applyWorkspaceEditDetailed(edit, options).result;
+}
 
-	return result;
+export function workspaceEditFingerprint(edit: WorkspaceEdit, workspaceRoot: string): string | null {
+	const fingerprint = fingerprintWorkspaceEdit(edit, workspaceRoot);
+	return fingerprint.success ? fingerprint.fingerprint : null;
 }