ultimate-pi 0.18.1 → 0.19.1

package/.pi/lib/harness-lens/clients/lsp/config.ts

@@ -0,0 +1,216 @@
+/**
+ * LSP Configuration for pi-lens
+ *
+ * Allows users to define custom LSP servers via configuration.
+ *
+ * Config file: .pi/harness/.lens/lsp.json
+ *
+ * Example:
+ * {
+ *   "servers": {
+ *     "my-server": {
+ *       "name": "My Custom LSP",
+ *       "extensions": [".myext"],
+ *       "command": "my-lsp-server",
+ *       "args": ["--stdio"],
+ *       "rootMarkers": ["package.json"]
+ *     }
+ *   }
+ * }
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { launchLSP } from "./launch.js";
+import {
+	createRootDetector,
+	LSP_SERVERS,
+	type LSPServerInfo,
+} from "./server.js";
+
+// --- Types ---
+
+export interface CustomServerConfig {
+	name: string;
+	extensions: string[];
+	command: string;
+	args?: string[];
+	rootMarkers?: string[];
+	env?: Record<string, string>;
+}
+
+export interface LSPConfig {
+	servers?: Record<string, CustomServerConfig>;
+	disabledServers?: string[];
+	/** Files to open at session start to seed lazy LSP indexing (e.g., clangd). */
+	warmFiles?: string[];
+}
+
+interface RegisteredLSPConfig {
+	customServers: LSPServerInfo[];
+	disabledServerIds: Set<string>;
+}
+
+// --- Config Loading ---
+
+const CONFIG_PATHS = [".pi/harness/.lens/lsp.json", "pi-lsp.json"];
+
+/**
+ * Load LSP configuration from file
+ */
+export async function loadLSPConfig(cwd: string): Promise<LSPConfig> {
+	let dir = path.resolve(cwd);
+	while (true) {
+		for (const configPath of CONFIG_PATHS) {
+			const fullPath = path.join(dir, configPath);
+			try {
+				const content = await fs.readFile(fullPath, "utf-8");
+				const config = JSON.parse(content) as LSPConfig;
+				return config;
+			} catch {
+				// File doesn't exist or is invalid, try next
+			}
+		}
+
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+
+	return {};
+}
+
+// --- Custom Server Factory ---
+
+/**
+ * Create LSPServerInfo from user configuration
+ */
+export function createCustomServer(
+	config: CustomServerConfig,
+	id: string,
+): LSPServerInfo {
+	return {
+		id,
+		name: config.name,
+		extensions: config.extensions,
+		root: config.rootMarkers
+			? createRootDetector(config.rootMarkers)
+			: async () => process.cwd(),
+		async spawn(root) {
+			const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
+				cwd: root,
+				env: config.env ? { ...process.env, ...config.env } : process.env,
+			});
+			return { process: proc };
+		},
+	};
+}
+
+// --- Registry Management ---
+
+const EMPTY_CONFIG: RegisteredLSPConfig = {
+	customServers: [],
+	disabledServerIds: new Set(),
+};
+
+const workspaceConfigs = new Map<string, RegisteredLSPConfig>();
+/** In-flight config initialization promises to prevent duplicate concurrent loads */
+const configInFlight = new Map<string, Promise<void>>();
+
+function normalizeWorkspacePath(cwd: string): string {
+	return path.resolve(cwd);
+}
+
+function isSameOrChildPath(filePath: string, candidateRoot: string): boolean {
+	if (filePath === candidateRoot) return true;
+	return filePath.startsWith(`${candidateRoot}${path.sep}`);
+}
+
+function getConfigForFile(filePath: string): RegisteredLSPConfig {
+	const resolvedFilePath = path.resolve(filePath);
+	let bestMatch: { root: string; config: RegisteredLSPConfig } | undefined;
+
+	for (const [root, config] of workspaceConfigs) {
+		if (!isSameOrChildPath(resolvedFilePath, root)) continue;
+		if (!bestMatch || root.length > bestMatch.root.length) {
+			bestMatch = { root, config };
+		}
+	}
+
+	return bestMatch?.config ?? EMPTY_CONFIG;
+}
+
+/**
+ * Initialize LSP configuration (call at session start)
+ * Deduplicates concurrent calls for the same workspace.
+ */
+export async function initLSPConfig(cwd: string): Promise<void> {
+	const normalizedCwd = normalizeWorkspacePath(cwd);
+
+	const existing = configInFlight.get(normalizedCwd);
+	if (existing) return existing;
+
+	const promise = (async () => {
+		const config = await loadLSPConfig(cwd);
+		const customServers: LSPServerInfo[] = [];
+		const disabledServerIds = new Set(config.disabledServers ?? []);
+
+		if (config.servers) {
+			for (const [id, serverConfig] of Object.entries(config.servers)) {
+				try {
+					const server = createCustomServer(serverConfig, id);
+					customServers.push(server);
+				} catch {
+					// pi-lens-ignore: missing-error-propagation — per-server registration, skip bad entries
+				}
+			}
+		}
+
+		workspaceConfigs.set(normalizedCwd, {
+			customServers,
+			disabledServerIds,
+		});
+	})();
+
+	configInFlight.set(normalizedCwd, promise);
+	try {
+		await promise;
+	} finally {
+		configInFlight.delete(normalizedCwd);
+	}
+}
+
+/**
+ * Get all available servers (built-in + custom, minus disabled)
+ */
+export function getAllServers(filePath?: string): LSPServerInfo[] {
+	const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+	const all = [...LSP_SERVERS, ...config.customServers];
+	return all.filter((s) => !config.disabledServerIds.has(s.id));
+}
+
+/**
+ * Check if a server is disabled
+ */
+export function isServerDisabled(serverId: string, filePath?: string): boolean {
+	const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+	return config.disabledServerIds.has(serverId);
+}
+
+// --- Override getServersForFile to include custom servers
+
+export function getServersForFileWithConfig(filePath: string): LSPServerInfo[] {
+	const ext = path.extname(filePath).toLowerCase();
+	const base = path.basename(filePath).toLowerCase();
+	return getAllServers(filePath).filter((server) => {
+		const extensions = server.extensions.map((value) => value.toLowerCase());
+		return extensions.includes(ext) || extensions.includes(base);
+	});
+}
+
+export function resetLSPConfigStateForTests(): void {
+	workspaceConfigs.clear();
+}
+
+// Re-export with config support
+export { getAllServers as getServersForFile };

package/.pi/lib/harness-lens/clients/lsp/edits.ts

@@ -0,0 +1,297 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { uriToPath } from "./path-utils.js";
+
+export interface LSPPosition {
+	line: number;
+	character: number;
+}
+
+export interface LSPRange {
+	start: LSPPosition;
+	end: LSPPosition;
+}
+
+export interface LSPTextEdit {
+	range: LSPRange;
+	newText: string;
+}
+
+interface TextDocumentEdit {
+	textDocument: { uri: string };
+	edits: unknown[];
+}
+
+interface CreateFileOp {
+	kind: "create";
+	uri: string;
+}
+
+interface RenameFileOp {
+	kind: "rename";
+	oldUri: string;
+	newUri: string;
+}
+
+interface DeleteFileOp {
+	kind: "delete";
+	uri: string;
+}
+
+export interface AppliedWorkspaceEdit {
+	descriptions: string[];
+	files: string[];
+}
+
+function isPosition(value: unknown): value is LSPPosition {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		typeof (value as { line?: unknown }).line === "number" &&
+		typeof (value as { character?: unknown }).character === "number"
+	);
+}
+
+function isRange(value: unknown): value is LSPRange {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		isPosition((value as { start?: unknown }).start) &&
+		isPosition((value as { end?: unknown }).end)
+	);
+}
+
+function isTextEdit(value: unknown): value is LSPTextEdit {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		isRange((value as { range?: unknown }).range) &&
+		typeof (value as { newText?: unknown }).newText === "string"
+	);
+}
+
+function isTextDocumentEdit(value: unknown): value is TextDocumentEdit {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		typeof (value as { textDocument?: { uri?: unknown } }).textDocument?.uri ===
+			"string" &&
+		Array.isArray((value as { edits?: unknown }).edits)
+	);
+}
+
+function comparePosition(a: LSPPosition, b: LSPPosition): number {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+
+function formatRange(range: LSPRange): string {
+	return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
+}
+
+export function rangesOverlap(a: LSPRange, b: LSPRange): boolean {
+	return (
+		comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0
+	);
+}
+
+export function applyTextEditsToString(
+	content: string,
+	edits: LSPTextEdit[],
+): string {
+	const sortedEdits = [...edits].sort((a, b) => {
+		const lineDelta = b.range.start.line - a.range.start.line;
+		return lineDelta !== 0
+			? lineDelta
+			: b.range.start.character - a.range.start.character;
+	});
+
+	for (let index = 0; index < sortedEdits.length - 1; index++) {
+		const later = sortedEdits[index]?.range;
+		const earlier = sortedEdits[index + 1]?.range;
+		if (later && earlier && comparePosition(earlier.end, later.start) > 0) {
+			throw new Error(
+				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}`,
+			);
+		}
+	}
+
+	const lines = content.split("\n");
+	for (const edit of sortedEdits) {
+		const { start, end } = edit.range;
+		if (start.line === end.line) {
+			const line = lines[start.line] ?? "";
+			lines[start.line] =
+				line.slice(0, start.character) +
+				edit.newText +
+				line.slice(end.character);
+			continue;
+		}
+
+		const startLine = lines[start.line] ?? "";
+		const endLine = lines[end.line] ?? "";
+		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 flattenWorkspaceTextEdits(edit: {
+	changes?: Record<string, unknown[]>;
+	documentChanges?: unknown[];
+}): Map<string, LSPTextEdit[]> {
+	const out = new Map<string, LSPTextEdit[]>();
+	const push = (uri: string, edits: unknown[]) => {
+		const textEdits = edits.filter(isTextEdit);
+		if (textEdits.length === 0) return;
+		const existing = out.get(uri);
+		if (existing) existing.push(...textEdits);
+		else out.set(uri, [...textEdits]);
+	};
+
+	for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
+		push(uri, edits);
+	}
+
+	for (const change of edit.documentChanges ?? []) {
+		if (isTextDocumentEdit(change)) {
+			push(change.textDocument.uri, change.edits);
+		}
+	}
+
+	return out;
+}
+
+function relativeToCwd(filePath: string, cwd: string): string {
+	const rel = path.relative(cwd, filePath) || path.basename(filePath);
+	return rel.replace(/\\/g, "/");
+}
+
+export function summarizeWorkspaceEdit(
+	edit: {
+		changes?: Record<string, unknown[]>;
+		documentChanges?: unknown[];
+	},
+	cwd: string,
+): string[] {
+	const lines: string[] = [];
+	const textEditsByUri = flattenWorkspaceTextEdits(edit);
+	for (const [uri, edits] of textEditsByUri) {
+		lines.push(
+			`Apply ${edits.length} edit(s) to ${relativeToCwd(uriToPath(uri), cwd)}`,
+		);
+	}
+	for (const change of edit.documentChanges ?? []) {
+		if (typeof change !== "object" || change === null || !("kind" in change))
+			continue;
+		const kind = (change as { kind?: unknown }).kind;
+		if (kind === "create" && typeof (change as CreateFileOp).uri === "string") {
+			lines.push(
+				`Create ${relativeToCwd(uriToPath((change as CreateFileOp).uri), cwd)}`,
+			);
+		} else if (
+			kind === "rename" &&
+			typeof (change as RenameFileOp).oldUri === "string" &&
+			typeof (change as RenameFileOp).newUri === "string"
+		) {
+			lines.push(
+				`Rename ${relativeToCwd(uriToPath((change as RenameFileOp).oldUri), cwd)} → ${relativeToCwd(uriToPath((change as RenameFileOp).newUri), cwd)}`,
+			);
+		} else if (
+			kind === "delete" &&
+			typeof (change as DeleteFileOp).uri === "string"
+		) {
+			lines.push(
+				`Delete ${relativeToCwd(uriToPath((change as DeleteFileOp).uri), cwd)}`,
+			);
+		}
+	}
+	return lines;
+}
+
+export async function applyWorkspaceEdit(
+	edit: {
+		changes?: Record<string, unknown[]>;
+		documentChanges?: unknown[];
+	},
+	cwd: string,
+): Promise<AppliedWorkspaceEdit> {
+	const descriptions: string[] = [];
+	const touchedFiles = new Set<string>();
+	const textEditsByUri = flattenWorkspaceTextEdits(edit);
+
+	try {
+		for (const [uri, edits] of textEditsByUri) {
+			const filePath = uriToPath(uri);
+			const content = await fs.readFile(filePath, "utf-8");
+			const updated = applyTextEditsToString(content, edits);
+			await fs.writeFile(filePath, updated, "utf-8");
+			touchedFiles.add(filePath);
+			descriptions.push(
+				`Applied ${edits.length} edit(s) to ${relativeToCwd(filePath, cwd)}`,
+			);
+		}
+
+		for (const change of edit.documentChanges ?? []) {
+			if (typeof change !== "object" || change === null || !("kind" in change))
+				continue;
+			const kind = (change as { kind?: unknown }).kind;
+			if (
+				kind === "create" &&
+				typeof (change as CreateFileOp).uri === "string"
+			) {
+				const filePath = uriToPath((change as CreateFileOp).uri);
+				await fs.mkdir(path.dirname(filePath), { recursive: true });
+				await fs
+					.writeFile(filePath, "", { flag: "wx" })
+					.catch(async (err: unknown) => {
+						if ((err as { code?: string }).code !== "EEXIST") throw err;
+					});
+				touchedFiles.add(filePath);
+				descriptions.push(`Created ${relativeToCwd(filePath, cwd)}`);
+			} else if (
+				kind === "rename" &&
+				typeof (change as RenameFileOp).oldUri === "string" &&
+				typeof (change as RenameFileOp).newUri === "string"
+			) {
+				const oldPath = uriToPath((change as RenameFileOp).oldUri);
+				const newPath = uriToPath((change as RenameFileOp).newUri);
+				await fs.mkdir(path.dirname(newPath), { recursive: true });
+				await fs.rename(oldPath, newPath);
+				touchedFiles.add(oldPath);
+				touchedFiles.add(newPath);
+				descriptions.push(
+					`Renamed ${relativeToCwd(oldPath, cwd)} → ${relativeToCwd(newPath, cwd)}`,
+				);
+			} else if (
+				kind === "delete" &&
+				typeof (change as DeleteFileOp).uri === "string"
+			) {
+				const filePath = uriToPath((change as DeleteFileOp).uri);
+				await fs.rm(filePath, { recursive: true, force: true });
+				touchedFiles.add(filePath);
+				descriptions.push(`Deleted ${relativeToCwd(filePath, cwd)}`);
+			}
+		}
+	} catch (err) {
+		const already = [...touchedFiles];
+		if (already.length > 0) {
+			const alreadyList = already
+				.map((f) => `  • ${relativeToCwd(f, cwd)}`)
+				.join("\n");
+			throw new Error(
+				`Workspace edit failed mid-application — ${already.length} file(s) already written, no rollback performed:\n${alreadyList}\nCause: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+		throw err;
+	}
+
+	return { descriptions, files: [...touchedFiles] };
+}