pi-lens 3.8.50 → 3.8.52

package/clients/typescript-client.ts

@@ -1,698 +0,0 @@
-/**
- * TypeScript Language Service Client for pi-local
- *
- * Uses TypeScript's in-process Language Service API for rich code intelligence.
- * This is lighter weight than spawning tsserver and provides the same features.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as ts from "typescript";
-import type {
-	CompletionItem,
-	Diagnostic,
-	DiagnosticSeverity,
-	FoldingRange,
-	HoverInfo,
-	Location,
-	SymbolInfo,
-} from "./types.js";
-
-// TypeScript file extensions
-const TS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
-
-// Default compiler options when no tsconfig is found
-/**
- * Build default CompilerOptions through TypeScript's own config parser so that
- * lib name → file path resolution works correctly in the Language Service.
- * Direct assignment of `lib: ["lib.es2020.d.ts"]` doesn't work because the
- * Language Service looks up those names relative to cwd, not the TS install dir.
- */
-function buildDefaultCompilerOptions(): ts.CompilerOptions {
-	const fakeConfig = {
-		compilerOptions: {
-			target: "ES2020",
-			module: "ESNext",
-			moduleResolution: "bundler",
-			strict: true,
-			esModuleInterop: true,
-			skipLibCheck: true,
-			lib: ["es2020", "dom", "dom.iterable"],
-		},
-	};
-	const parsed = ts.parseJsonConfigFileContent(
-		fakeConfig,
-		ts.sys,
-		process.cwd(),
-	);
-	return { ...parsed.options, skipLibCheck: true };
-}
-
-const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions =
-	buildDefaultCompilerOptions();
-
-/**
- * Walk up from startDir until we find a tsconfig.json, or hit the fs root.
- */
-function findTsConfig(startDir: string): string | null {
-	let dir = startDir;
-	while (true) {
-		const candidate = path.join(dir, "tsconfig.json");
-		if (fs.existsSync(candidate)) return candidate;
-		const parent = path.dirname(dir);
-		if (parent === dir) return null; // reached root
-		dir = parent;
-	}
-}
-
-/**
- * Read and parse a tsconfig.json, returning merged CompilerOptions.
- * Falls back to DEFAULT_COMPILER_OPTIONS on any error.
- */
-function loadCompilerOptions(tsconfigPath: string): ts.CompilerOptions {
-	try {
-		const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-		if (configFile.error) return DEFAULT_COMPILER_OPTIONS;
-		const parsed = ts.parseJsonConfigFileContent(
-			configFile.config,
-			ts.sys,
-			path.dirname(tsconfigPath),
-		);
-		if (parsed.errors.length) return DEFAULT_COMPILER_OPTIONS;
-		// Always set skipLibCheck to avoid noise from node_modules
-		return { ...parsed.options, skipLibCheck: true };
-	} catch (err) {
-		void err;
-		return DEFAULT_COMPILER_OPTIONS;
-	}
-}
-
-export class TypeScriptClient {
-	private fileVersions = new Map<string, number>();
-	private fileContents = new Map<string, string>();
-	private languageService: ts.LanguageService | null = null;
-	private compilerOptions: ts.CompilerOptions = DEFAULT_COMPILER_OPTIONS;
-	private lastTsconfigDir: string | null = null;
-
-	constructor() {
-		this.initialize();
-	}
-
-	/**
-	 * Normalize file path for consistent cross-platform use
-	 */
-	normalizePath(filePath: string): string {
-		return path.resolve(filePath).replace(/\\/g, "/");
-	}
-
-	/**
-	 * Check if a file is a TypeScript/JavaScript file
-	 */
-	isTypeScriptFile(filePath: string): boolean {
-		const ext = path.extname(filePath).toLowerCase();
-		return TS_EXTENSIONS.has(ext);
-	}
-
-	private initialize(): void {
-		const host: ts.LanguageServiceHost = {
-			getScriptFileNames: () => Array.from(this.fileContents.keys()),
-			getScriptVersion: (fileName: string) => {
-				const normalized = fileName.replace(/\\/g, "/");
-				return String(this.fileVersions.get(normalized) ?? 0);
-			},
-			getScriptSnapshot: (fileName: string) => {
-				const normalized = fileName.replace(/\\/g, "/");
-				const content = this.fileContents.get(normalized);
-				if (content) return ts.ScriptSnapshot.fromString(content);
-				try {
-					return ts.ScriptSnapshot.fromString(
-						fs.readFileSync(fileName, "utf-8"),
-					);
-				} catch {
-					return undefined;
-				}
-			},
-			getCurrentDirectory: () => process.cwd(),
-			getCompilationSettings: () => this.compilerOptions,
-			getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
-			fileExists: (fileName) => ts.sys.fileExists(fileName),
-			readFile: (fileName) => {
-				const normalized = fileName.replace(/\\/g, "/");
-				const cached = this.fileContents.get(normalized);
-				if (cached !== undefined) return cached;
-				return ts.sys.readFile(fileName);
-			},
-			directoryExists: (dirName) => ts.sys.directoryExists(dirName),
-			getDirectories: (dir) => ts.sys.getDirectories(dir),
-		};
-
-		this.languageService = ts.createLanguageService(
-			host,
-			ts.createDocumentRegistry(),
-		);
-	}
-
-	/**
-	 * Detect tsconfig for the given file and refresh compilerOptions if the
-	 * project root changed (avoids redundant re-parses across edits to the same project).
-	 */
-	private refreshCompilerOptions(filePath: string): void {
-		const dir = path.dirname(path.resolve(filePath));
-		const tsconfigPath = findTsConfig(dir);
-		const key = tsconfigPath ?? dir;
-		if (key === this.lastTsconfigDir) return; // same project, no change
-		this.lastTsconfigDir = key;
-		this.compilerOptions = tsconfigPath
-			? loadCompilerOptions(tsconfigPath)
-			: DEFAULT_COMPILER_OPTIONS;
-	}
-
-	/**
-	 * Add a file to the language service
-	 */
-	addFile(filePath: string, content: string): void {
-		const normalized = this.normalizePath(filePath);
-		this.fileContents.set(normalized, content);
-		this.fileVersions.set(
-			normalized,
-			(this.fileVersions.get(normalized) || 0) + 1,
-		);
-	}
-
-	/**
-	 * Update a file's content — also refreshes compilerOptions if project changed
-	 */
-	updateFile(filePath: string, content: string): void {
-		this.refreshCompilerOptions(filePath);
-		const normalized = this.normalizePath(filePath);
-		this.fileVersions.set(
-			normalized,
-			(this.fileVersions.get(normalized) ?? 0) + 1,
-		);
-		this.fileContents.set(normalized, content);
-	}
-
-	/**
-	 * Ensure a file is loaded from disk (refreshes cache)
-	 */
-	ensureFile(filePath: string): void {
-		const normalized = this.normalizePath(filePath);
-		try {
-			const diskContent = fs.readFileSync(filePath, "utf-8");
-			const cachedContent = this.fileContents.get(normalized);
-			if (cachedContent !== diskContent) {
-				this.updateFile(filePath, diskContent);
-			}
-		} catch (err) {
-			void err;
-		}
-	}
-
-	/**
-	 * Get all tracked files
-	 */
-	getTrackedFiles(): string[] {
-		return Array.from(this.fileContents.keys());
-	}
-
-	/**
-	 * Convert line/character to position offset
-	 */
-	lineCharToPosition(content: string, line: number, character: number): number {
-		const lines = content.split("\n");
-		let position = 0;
-		for (let i = 0; i < Math.min(line, lines.length); i++) {
-			position += lines[i].length + 1;
-		}
-		return position + character;
-	}
-
-	/**
-	 * Get diagnostics (errors and warnings) for a file
-	 */
-	getDiagnostics(filePath: string): Diagnostic[] {
-		this.refreshCompilerOptions(filePath);
-		const normalized = this.normalizePath(filePath);
-		this.ensureFile(filePath);
-		if (!this.languageService) return [];
-
-		const syntactic = this.languageService.getSyntacticDiagnostics(normalized);
-		const semantic = this.languageService.getSemanticDiagnostics(normalized);
-
-		return (
-			[...syntactic, ...semantic]
-				.filter((diag) => diag.file && diag.start !== undefined)
-				// Filter cross-file "redeclare" noise — happens when non-module scripts
-				// share global scope across multiple tracked files (TS2300, TS2451)
-				.filter((diag) => {
-					if (diag.code !== 2300 && diag.code !== 2451) return true;
-					// Only keep if the related information points back to the same file
-					const related = diag.relatedInformation ?? [];
-					return related.every(
-						(r) =>
-							!r.file || this.normalizePath(r.file.fileName) === normalized,
-					);
-				})
-				.map((diag) => {
-					const startPos = diag.file?.getLineAndCharacterOfPosition(
-						diag.start!,
-					)!;
-					const endPos = diag.file?.getLineAndCharacterOfPosition(
-						diag.start! + diag.length!,
-					)!;
-					return {
-						range: {
-							start: { line: startPos.line, character: startPos.character },
-							end: { line: endPos.line, character: endPos.character },
-						},
-						severity: (diag.category === ts.DiagnosticCategory.Error
-							? 1
-							: 2) as DiagnosticSeverity,
-						code: diag.code,
-						message: ts.flattenDiagnosticMessageText(diag.messageText, "\n"),
-						source: "typescript",
-					};
-				})
-		);
-	}
-
-	/**
-	 * Get hover information at a position
-	 */
-	getHover(
-		filePath: string,
-		line: number,
-		character: number,
-	): HoverInfo | null {
-		const resolved = this.resolvePosition(filePath, line, character);
-		if (!resolved) return null;
-		const { normalized, position, ls } = resolved;
-		const info = ls.getQuickInfoAtPosition(normalized, position);
-		if (!info) return null;
-
-		return {
-			type: ts.displayPartsToString(info.displayParts),
-			documentation: info.documentation
-				? ts.displayPartsToString(info.documentation)
-				: undefined,
-		};
-	}
-
-	/**
-	 * Shared preamble for position-based LSP queries.
-	 * Returns null if prerequisites are not met.
-	 */
-	private resolvePosition(
-		filePath: string,
-		line: number,
-		character: number,
-	): {
-		normalized: string;
-		position: number;
-		ls: import("typescript").LanguageService;
-	} | null {
-		const normalized = this.normalizePath(filePath);
-		this.ensureFile(filePath);
-		if (!this.languageService) return null;
-		const content = this.fileContents.get(normalized);
-		if (!content) return null;
-		return {
-			normalized,
-			position: this.lineCharToPosition(content, line, character),
-			ls: this.languageService,
-		};
-	}
-
-	private withPosition<T>(
-		filePath: string,
-		line: number,
-		character: number,
-		cb: (
-			normalized: string,
-			position: number,
-			ls: ts.LanguageService,
-		) => T | undefined,
-	): T | [] {
-		const resolved = this.resolvePosition(filePath, line, character);
-		if (!resolved) return [];
-		const { normalized, position, ls } = resolved;
-		return cb(normalized, position, ls) ?? [];
-	}
-
-	/**
-	 * Go to definition
-	 */
-	getDefinition(filePath: string, line: number, character: number): Location[] {
-		return this.withPosition(
-			filePath,
-			line,
-			character,
-			(normalized, position, ls) => {
-				const definitions = ls.getDefinitionAtPosition(normalized, position);
-				if (!definitions) return undefined;
-
-				return definitions.map((def) => {
-					if (def.textSpan) {
-						const defFile = def.fileName || normalized;
-						const defContent = this.fileContents.get(defFile) || "";
-						if (defContent) {
-							const lines = defContent
-								.substring(0, def.textSpan.start)
-								.split("\n");
-							return {
-								file: defFile,
-								line: lines.length - 1,
-								character: lines[lines.length - 1].length,
-							};
-						}
-					}
-					return { file: def.fileName, line: 0, character: 0 };
-				});
-			},
-		) as Location[];
-	}
-
-	/**
-	 * Get type definition
-	 */
-	getTypeDefinition(
-		filePath: string,
-		line: number,
-		character: number,
-	): Location[] {
-		return this.withPosition(
-			filePath,
-			line,
-			character,
-			(normalized, position, ls) => {
-				const defs = ls.getTypeDefinitionAtPosition(normalized, position);
-				if (!defs) return undefined;
-				return this.toLocations(defs, normalized);
-			},
-		) as Location[];
-	}
-
-	/**
-	 * Find references
-	 */
-	getReferences(filePath: string, line: number, character: number): Location[] {
-		return this.withPosition(
-			filePath,
-			line,
-			character,
-			(normalized, position, ls) => {
-				const references = ls.getReferencesAtPosition(normalized, position);
-				if (!references) return undefined;
-				return this.toLocations(references);
-			},
-		) as Location[];
-	}
-
-	/** Map TS definition/reference entries to Location objects. */
-	private toLocations(
-		entries: ReadonlyArray<{ fileName: string }>,
-		fallbackFile?: string,
-	): Location[] {
-		return entries.map((e) => ({
-			file: e.fileName || fallbackFile || "",
-			line: 0,
-			character: 0,
-		}));
-	}
-
-	/**
-	 * Shared preamble for tree-based LSP queries (symbols, folding).
-	 */
-	private resolveTree(
-		filePath: string,
-	): { normalized: string; tree: import("typescript").NavigationTree } | null {
-		const normalized = this.normalizePath(filePath);
-		this.ensureFile(filePath);
-		if (!this.languageService) return null;
-		const tree = this.languageService.getNavigationTree(normalized);
-		if (!tree) return null;
-		return { normalized, tree };
-	}
-
-	/**
-	 * Get document symbols
-	 */
-	getSymbols(filePath: string): SymbolInfo[] {
-		const resolved = this.resolveTree(filePath);
-		if (!resolved) return [];
-		const { tree } = resolved;
-
-		const symbols: SymbolInfo[] = [];
-
-		const extract = (node: any, container?: string) => {
-			if (node.span) {
-				symbols.push({
-					name: node.text,
-					kind: this.symbolKind(node.kind),
-					line: 0,
-					containerName: container,
-				});
-			}
-			if (node.childItems) {
-				for (const child of node.childItems) {
-					extract(child, node.text);
-				}
-			}
-		};
-
-		extract(tree);
-		return symbols;
-	}
-
-	/**
-	 * Get completions at a position
-	 */
-	getCompletions(
-		filePath: string,
-		line: number,
-		character: number,
-	): CompletionItem[] {
-		return this.withPosition(
-			filePath,
-			line,
-			character,
-			(normalized, position, ls) => {
-				const completions = ls.getCompletionsAtPosition(
-					normalized,
-					position,
-					{},
-				);
-				if (!completions) return undefined;
-				return completions.entries.slice(0, 50).map((entry) => ({
-					name: entry.name,
-					kind: this.completionKind(entry.kind),
-					sortText: entry.sortText,
-				}));
-			},
-		) as CompletionItem[];
-	}
-
-	/**
-	 * Go to implementation
-	 */
-	getImplementation(
-		filePath: string,
-		line: number,
-		character: number,
-	): Location[] {
-		return this.withPosition(
-			filePath,
-			line,
-			character,
-			(normalized, position, ls) => {
-				const implementations = ls.getImplementationAtPosition(
-					normalized,
-					position,
-				);
-				if (!implementations) return undefined;
-				return this.toLocations(implementations);
-			},
-		) as Location[];
-	}
-
-	/**
-	 * Get folding ranges
-	 */
-	getFoldingRanges(filePath: string): FoldingRange[] {
-		const resolved = this.resolveTree(filePath);
-		if (!resolved) return [];
-		const { tree } = resolved;
-
-		const ranges: FoldingRange[] = [];
-
-		const findFolds = (node: any) => {
-			if (!node?.span) return;
-
-			if (node.kind === "function" || node.kind === "class") {
-				ranges.push({
-					startLine: 0,
-					endLine: 0,
-					kind: node.kind,
-				});
-			}
-
-			if (node.childItems) {
-				for (const child of node.childItems) {
-					findFolds(child);
-				}
-			}
-		};
-
-		findFolds(tree);
-		return ranges;
-	}
-
-	/**
-	 * Explain an error at a specific line
-	 */
-	explainError(
-		filePath: string,
-		line: number,
-	): { message: string; code?: number } | null {
-		const diagnostics = this.getDiagnostics(filePath);
-		const errorAtLine = diagnostics.find(
-			(d) => d.range.start.line === line && d.severity === 1,
-		);
-		if (!errorAtLine) return null;
-		return { message: errorAtLine.message, code: errorAtLine.code as number };
-	}
-
-	/**
-	 * Get quick fixes (code actions) for a diagnostic at a position.
-	 * Returns array of fix descriptions with their edit changes.
-	 */
-	getCodeFixes(
-		filePath: string,
-		line: number,
-		character: number,
-		errorCodes: number[],
-	): Array<{
-		description: string;
-		changes: Array<{
-			fileName: string;
-			textChanges: ReadonlyArray<{
-				span: { start: number; length: number };
-				newText: string;
-			}>;
-		}>;
-	}> {
-		const resolved = this.resolvePosition(filePath, line, character);
-		if (!resolved) return [];
-		const { normalized, position, ls } = resolved;
-
-		const formatOpts: ts.FormatCodeSettings = {
-			indentSize: 2,
-			tabSize: 2,
-			newLineCharacter: "\n",
-			convertTabsToSpaces: true,
-		};
-
-		const fixes = ls.getCodeFixesAtPosition(
-			normalized,
-			position,
-			position,
-			errorCodes,
-			formatOpts,
-			{}, // preferences
-		);
-
-		if (!fixes) return [];
-
-		return fixes.map((fix) => ({
-			description: fix.description,
-			changes:
-				fix.changes?.map((change) => ({
-					fileName: change.fileName,
-					textChanges: change.textChanges,
-				})) || [],
-		}));
-	}
-
-	/**
-	 * Get all quick fixes for all diagnostics in a file.
-	 * Returns a map of diagnostic line → fixes.
-	 */
-	/**
-	 * Accept pre-computed diagnostics to avoid a second getSemanticDiagnostics call
-	 * when the caller already has them (saves ~1–2s on large files).
-	 */
-	getAllCodeFixes(
-		filePath: string,
-		precomputedDiags?: Diagnostic[],
-	): Map<
-		number,
-		Array<{
-			description: string;
-			changes: Array<{
-				fileName: string;
-				textChanges: ReadonlyArray<{
-					span: { start: number; length: number };
-					newText: string;
-				}>;
-			}>;
-		}>
-	> {
-		const fixesByLine = new Map<
-			number,
-			Array<{
-				description: string;
-				changes: Array<{
-					fileName: string;
-					textChanges: ReadonlyArray<{
-						span: { start: number; length: number };
-						newText: string;
-					}>;
-				}>;
-			}>
-		>();
-
-		const diagnostics = precomputedDiags ?? this.getDiagnostics(filePath);
-		for (const diag of diagnostics) {
-			if (diag.severity !== 1 || diag.code === undefined) continue;
-			const fixes = this.getCodeFixes(
-				filePath,
-				diag.range.start.line,
-				diag.range.start.character,
-				[diag.code as number],
-			);
-			if (fixes.length > 0) {
-				fixesByLine.set(diag.range.start.line, fixes);
-			}
-		}
-		return fixesByLine;
-	}
-
-	private symbolKind(kind: string): string {
-		const map: Record<string, string> = {
-			script: "file",
-			class: "class",
-			interface: "interface",
-			function: "function",
-			method: "method",
-			property: "property",
-			variable: "variable",
-			enum: "enum",
-			module: "module",
-		};
-		return map[kind] || "unknown";
-	}
-
-	private completionKind(kind: string): string {
-		const map: Record<string, string> = {
-			property: "property",
-			method: "method",
-			class: "class",
-			interface: "interface",
-			enum: "enum",
-			variable: "variable",
-			function: "function",
-			keyword: "keyword",
-		};
-		return map[kind] || "text";
-	}
-}