pi-lens 3.6.2 → 3.6.4

package/clients/typescript-client.js

@@ -1,509 +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";
-// 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() {
-    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 = buildDefaultCompilerOptions();
-/**
- * Walk up from startDir until we find a tsconfig.json, or hit the fs root.
- */
-function findTsConfig(startDir) {
-    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) {
-    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 {
-    constructor() {
-        this.fileVersions = new Map();
-        this.fileContents = new Map();
-        this.languageService = null;
-        this.compilerOptions = DEFAULT_COMPILER_OPTIONS;
-        this.lastTsconfigDir = null;
-        this.initialize();
-    }
-    /**
-     * Normalize file path for consistent cross-platform use
-     */
-    normalizePath(filePath) {
-        return path.resolve(filePath).replace(/\\/g, "/");
-    }
-    /**
-     * Check if a file is a TypeScript/JavaScript file
-     */
-    isTypeScriptFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        return TS_EXTENSIONS.has(ext);
-    }
-    initialize() {
-        const host = {
-            getScriptFileNames: () => Array.from(this.fileContents.keys()),
-            getScriptVersion: (fileName) => {
-                const normalized = fileName.replace(/\\/g, "/");
-                return String(this.fileVersions.get(normalized) ?? 0);
-            },
-            getScriptSnapshot: (fileName) => {
-                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).
-     */
-    refreshCompilerOptions(filePath) {
-        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, content) {
-        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, content) {
-        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) {
-        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() {
-        return Array.from(this.fileContents.keys());
-    }
-    /**
-     * Convert line/character to position offset
-     */
-    lineCharToPosition(content, line, character) {
-        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) {
-        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),
-                code: diag.code,
-                message: ts.flattenDiagnosticMessageText(diag.messageText, "\n"),
-                source: "typescript",
-            };
-        }));
-    }
-    /**
-     * Get hover information at a position
-     */
-    getHover(filePath, line, character) {
-        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.
-     */
-    resolvePosition(filePath, line, character) {
-        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,
-        };
-    }
-    withPosition(filePath, line, character, cb) {
-        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, line, character) {
-        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 };
-            });
-        });
-    }
-    /**
-     * Get type definition
-     */
-    getTypeDefinition(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const defs = ls.getTypeDefinitionAtPosition(normalized, position);
-            if (!defs)
-                return undefined;
-            return this.toLocations(defs, normalized);
-        });
-    }
-    /**
-     * Find references
-     */
-    getReferences(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const references = ls.getReferencesAtPosition(normalized, position);
-            if (!references)
-                return undefined;
-            return this.toLocations(references);
-        });
-    }
-    /** Map TS definition/reference entries to Location objects. */
-    toLocations(entries, fallbackFile) {
-        return entries.map((e) => ({
-            file: e.fileName || fallbackFile || "",
-            line: 0,
-            character: 0,
-        }));
-    }
-    /**
-     * Shared preamble for tree-based LSP queries (symbols, folding).
-     */
-    resolveTree(filePath) {
-        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) {
-        const resolved = this.resolveTree(filePath);
-        if (!resolved)
-            return [];
-        const { tree } = resolved;
-        const symbols = [];
-        const extract = (node, container) => {
-            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, line, character) {
-        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,
-            }));
-        });
-    }
-    /**
-     * Go to implementation
-     */
-    getImplementation(filePath, line, character) {
-        return this.withPosition(filePath, line, character, (normalized, position, ls) => {
-            const implementations = ls.getImplementationAtPosition(normalized, position);
-            if (!implementations)
-                return undefined;
-            return this.toLocations(implementations);
-        });
-    }
-    /**
-     * Get folding ranges
-     */
-    getFoldingRanges(filePath) {
-        const resolved = this.resolveTree(filePath);
-        if (!resolved)
-            return [];
-        const { tree } = resolved;
-        const ranges = [];
-        const findFolds = (node) => {
-            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, line) {
-        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 };
-    }
-    /**
-     * Get quick fixes (code actions) for a diagnostic at a position.
-     * Returns array of fix descriptions with their edit changes.
-     */
-    getCodeFixes(filePath, line, character, errorCodes) {
-        const resolved = this.resolvePosition(filePath, line, character);
-        if (!resolved)
-            return [];
-        const { normalized, position, ls } = resolved;
-        const formatOpts = {
-            indentSize: 2,
-            tabSize: 2,
-            newLineCharacter: "\n",
-            convertTabsToSpaces: true,
-        };
-        const fixes = ls.getCodeFixesAtPosition(normalized, position, position, errorCodes, formatOpts, {});
-        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, precomputedDiags) {
-        const fixesByLine = new Map();
-        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]);
-            if (fixes.length > 0) {
-                fixesByLine.set(diag.range.start.line, fixes);
-            }
-        }
-        return fixesByLine;
-    }
-    symbolKind(kind) {
-        const map = {
-            script: "file",
-            class: "class",
-            interface: "interface",
-            function: "function",
-            method: "method",
-            property: "property",
-            variable: "variable",
-            enum: "enum",
-            module: "module",
-        };
-        return map[kind] || "unknown";
-    }
-    completionKind(kind) {
-        const map = {
-            property: "property",
-            method: "method",
-            class: "class",
-            interface: "interface",
-            enum: "enum",
-            variable: "variable",
-            function: "function",
-            keyword: "keyword",
-        };
-        return map[kind] || "text";
-    }
-}

package/clients/typescript-client.test.js

@@ -1,105 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-import { TypeScriptClient } from "./typescript-client.js";
-describe("TypeScriptClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TypeScriptClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ts-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isTypeScriptFile", () => {
-        it("should recognize TypeScript files", () => {
-            expect(client.isTypeScriptFile("test.ts")).toBe(true);
-            expect(client.isTypeScriptFile("test.tsx")).toBe(true);
-        });
-        it("should also recognize JavaScript files (for type checking)", () => {
-            expect(client.isTypeScriptFile("test.js")).toBe(true);
-            expect(client.isTypeScriptFile("test.jsx")).toBe(true);
-        });
-        it("should not recognize non-JS/TS files", () => {
-            expect(client.isTypeScriptFile("test.py")).toBe(false);
-            expect(client.isTypeScriptFile("test.md")).toBe(false);
-        });
-    });
-    describe("updateFile and getDiagnostics", () => {
-        it("should detect type errors", () => {
-            const content = `
-const x: number = "string"; // Type error
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.length).toBeGreaterThan(0);
-            expect(diags.some((d) => d.message.includes("string"))).toBe(true);
-        });
-        it("should not report errors for valid code", () => {
-            const content = `
-const x: number = 42;
-const y: string = "hello";
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            // May have warnings but no errors for valid code
-            const errors = diags.filter((d) => d.severity === 1); // Error severity
-            expect(errors.length).toBe(0);
-        });
-        it("should detect undefined variables", () => {
-            const content = `
-function test() {
-  return undefinedVariable;
-}
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.some((d) => d.message.includes("undefined"))).toBe(true);
-        });
-        it("should detect missing function arguments", () => {
-            const content = `
-function add(a: number, b: number): number {
-  return a + b;
-}
-const result = add(1);
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.updateFile(filePath, content);
-            const diags = client.getDiagnostics(filePath);
-            expect(diags.some((d) => d.message.includes("Expected"))).toBe(true);
-        });
-    });
-    describe("diagnostic severity", () => {
-        it("should have correct severity levels", () => {
-            const diags = [
-                {
-                    range: {
-                        start: { line: 0, character: 0 },
-                        end: { line: 0, character: 10 },
-                    },
-                    severity: 1, // Error
-                    message: "Error message",
-                },
-                {
-                    range: {
-                        start: { line: 1, character: 0 },
-                        end: { line: 1, character: 10 },
-                    },
-                    severity: 2, // Warning
-                    message: "Warning message",
-                },
-            ];
-            // Test that diagnostics have expected structure
-            expect(diags[0].severity).toBe(1); // Error
-            expect(diags[1].severity).toBe(2); // Warning
-            expect(diags[0].message).toContain("Error");
-        });
-    });
-});