lazycodex-ai 5.1.48 → 5.1.51

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

@@ -0,0 +1,183 @@
+import { dirname, relative, resolve } from "node:path";
+
+import { normalizeTextEdits } from "./workspace-edit-text.js";
+import type {
+	ParsedWorkspaceOperation,
+	ParseFailure,
+	SimulatedWorkspaceEdit,
+} from "./workspace-edit-plan-types.js";
+import type { PlannedWorkspaceOperation, WorkspaceSnapshotEntry } from "./workspace-edit-types.js";
+import { WorkspaceEditValidationError } from "./workspace-edit-types.js";
+
+function isSameOrDescendant(candidate: string, parent: string): boolean {
+	const relativePath = relative(parent, candidate);
+	return relativePath === "" || (!relativePath.startsWith("..") && relativePath !== "..");
+}
+
+function removeVirtualSubtree(virtual: Map<string, WorkspaceSnapshotEntry>, path: string): void {
+	for (const candidate of [...virtual.keys()]) {
+		if (isSameOrDescendant(candidate, path)) virtual.delete(candidate);
+	}
+	virtual.set(path, { kind: "missing" });
+}
+
+function moveVirtualSubtree(virtual: Map<string, WorkspaceSnapshotEntry>, oldPath: string, newPath: string): void {
+	const moved = [...virtual.entries()].filter(([candidate]) => isSameOrDescendant(candidate, oldPath));
+	removeVirtualSubtree(virtual, oldPath);
+	removeVirtualSubtree(virtual, newPath);
+	for (const [candidate, entry] of moved) {
+		const suffix = relative(oldPath, candidate);
+		virtual.set(suffix === "" ? newPath : resolve(newPath, suffix), entry);
+	}
+}
+
+function virtualDirectoryHasChildren(virtual: ReadonlyMap<string, WorkspaceSnapshotEntry>, path: string): boolean {
+	for (const [candidate, entry] of virtual) {
+		if (candidate !== path && entry.kind !== "missing" && isSameOrDescendant(candidate, path)) return true;
+	}
+	return false;
+}
+
+function requireVirtualParent(
+	virtual: ReadonlyMap<string, WorkspaceSnapshotEntry>,
+	path: string,
+	changeIndex: number,
+): void {
+	if (virtual.get(dirname(path))?.kind !== "directory") {
+		throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
+	}
+}
+
+export function simulateOperations(
+	parsed: readonly ParsedWorkspaceOperation[],
+	snapshots: ReadonlyMap<string, WorkspaceSnapshotEntry>,
+): SimulatedWorkspaceEdit {
+	const virtual = new Map(snapshots);
+	const planned: PlannedWorkspaceOperation[] = [];
+	const failures: ParseFailure[] = [];
+	for (const operation of parsed) {
+		try {
+			planned.push(simulateOperation(operation, virtual));
+		} catch (error) {
+			if (error instanceof WorkspaceEditValidationError) {
+				failures.push({ changeIndex: operation.changeIndex, message: error.detail });
+				continue;
+			}
+			throw error;
+		}
+	}
+	return { operations: planned, failures };
+}
+
+function simulateOperation(
+	operation: ParsedWorkspaceOperation,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	switch (operation.kind) {
+		case "text":
+			return simulateText(operation, virtual);
+		case "create":
+			return simulateCreate(operation, virtual);
+		case "rename":
+			return simulateRename(operation, virtual);
+		case "delete":
+			return simulateDelete(operation, virtual);
+	}
+}
+
+function rejectSymbolicLink(operation: Exclude<ParsedWorkspaceOperation, { readonly kind: "text" }>): void {
+	if (operation.followedSymbolicLink) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, "resource operations through symbolic links are unsupported");
+	}
+}
+
+function simulateText(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "text" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	const entry = virtual.get(operation.path);
+	if (entry?.kind !== "file") throw new WorkspaceEditValidationError(operation.changeIndex, `${operation.path} is not a file`);
+	const normalized = normalizeTextEdits(entry.content, operation.edits, operation.changeIndex);
+	virtual.set(operation.path, { kind: "file", content: normalized.text });
+	return {
+		kind: "text",
+		changeIndex: operation.changeIndex,
+		path: operation.path,
+		beforeText: entry.content,
+		afterText: normalized.text,
+		editCount: normalized.edits.length,
+		documentVersion: operation.version,
+	};
+}
+
+function simulateCreate(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "create" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	requireVirtualParent(virtual, operation.path, operation.changeIndex);
+	const target = virtual.get(operation.path) ?? { kind: "missing" };
+	if (target.kind !== "missing") {
+		if (operation.overwrite && target.kind === "file") {
+			virtual.set(operation.path, { kind: "file", content: "" });
+			return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: true };
+		}
+		if (operation.ignoreIfExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `create target already exists: ${operation.path}`);
+	}
+	virtual.set(operation.path, { kind: "file", content: "" });
+	return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: false };
+}
+
+function simulateRename(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "rename" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	const source = virtual.get(operation.oldPath) ?? { kind: "missing" };
+	if (source.kind === "missing") {
+		throw new WorkspaceEditValidationError(operation.changeIndex, `rename source does not exist: ${operation.oldPath}`);
+	}
+	if (operation.oldPath === operation.newPath) return { kind: "noop", changeIndex: operation.changeIndex };
+	if (isSameOrDescendant(operation.newPath, operation.oldPath)) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, "cannot rename a path into its own subtree");
+	}
+	requireVirtualParent(virtual, operation.newPath, operation.changeIndex);
+	const destination = virtual.get(operation.newPath) ?? { kind: "missing" };
+	if (destination.kind !== "missing" && !operation.overwrite) {
+		if (operation.ignoreIfExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `rename target already exists: ${operation.newPath}`);
+	}
+	moveVirtualSubtree(virtual, operation.oldPath, operation.newPath);
+	return {
+		kind: "rename",
+		changeIndex: operation.changeIndex,
+		oldPath: operation.oldPath,
+		newPath: operation.newPath,
+		sourceKind: source.kind,
+		replaceDestination: destination.kind !== "missing",
+	};
+}
+
+function simulateDelete(
+	operation: Extract<ParsedWorkspaceOperation, { readonly kind: "delete" }>,
+	virtual: Map<string, WorkspaceSnapshotEntry>,
+): PlannedWorkspaceOperation {
+	rejectSymbolicLink(operation);
+	const target = virtual.get(operation.path) ?? { kind: "missing" };
+	if (target.kind === "missing") {
+		if (operation.ignoreIfNotExists) return { kind: "noop", changeIndex: operation.changeIndex };
+		throw new WorkspaceEditValidationError(operation.changeIndex, `delete target does not exist: ${operation.path}`);
+	}
+	if (target.kind === "directory" && !operation.recursive && virtualDirectoryHasChildren(virtual, operation.path)) {
+		throw new WorkspaceEditValidationError(operation.changeIndex, `directory is not empty: ${operation.path}`);
+	}
+	removeVirtualSubtree(virtual, operation.path);
+	return {
+		kind: "delete",
+		changeIndex: operation.changeIndex,
+		path: operation.path,
+		targetKind: target.kind,
+		recursive: operation.recursive,
+	};
+}

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

@@ -0,0 +1,55 @@
+import { contextCwd } from "../request-context.js";
+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 {
+	return applyWorkspaceEditDetailed(edit, options).result;
+}
+
+export function workspaceEditFingerprint(edit: WorkspaceEdit, workspaceRoot: string): string | null {
+	const fingerprint = fingerprintWorkspaceEdit(edit, workspaceRoot);
+	return fingerprint.success ? fingerprint.fingerprint : null;
+}

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

@@ -0,0 +1,18 @@
+/** Repository marker: an ancestor containing this always wins over intermediate package markers. */
+export const GIT_WORKSPACE_MARKER = ".git" as const;
+
+/**
+ * Package/project markers. On their own they resolve to the NEAREST marked directory, but inside a
+ * request cwd they are only a fallback: a `.git` ancestor further up collapses nested package roots
+ * (one client per repository instead of one per monorepo package).
+ */
+export const PROJECT_WORKSPACE_MARKERS = [
+	"package.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod",
+	"pom.xml",
+	"build.gradle",
+] as const;
+
+export const WORKSPACE_MARKERS = [GIT_WORKSPACE_MARKER, ...PROJECT_WORKSPACE_MARKERS] as const;