pi-lens 3.6.2 → 3.6.4

package/clients/ts-service.js

@@ -1,129 +0,0 @@
-/**
- * Shared TypeScript Service for pi-lens
- *
- * Creates a single ts.Program per session that is shared across all clients
- * (complexity-client, type-safety-client). Avoids creating a new program per file.
- */
-import * as fs from "node:fs";
-import * as ts from "typescript";
-export class TypeScriptService {
-    constructor(verbose = false) {
-        this.program = null;
-        this.checker = null;
-        this.files = new Map();
-        this.log = verbose
-            ? (msg) => console.error(`[ts-service] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Update a file's content in the service
-     */
-    updateFile(filePath, content) {
-        this.files.set(filePath, content);
-        this.invalidate();
-    }
-    /**
-     * Invalidate the program (rebuild on next access)
-     */
-    invalidate() {
-        this.program = null;
-        this.checker = null;
-    }
-    /**
-     * Get the shared type checker (rebuilds program if needed)
-     */
-    getChecker() {
-        if (this.checker)
-            return this.checker;
-        if (this.files.size === 0)
-            return null;
-        try {
-            const compilerOptions = {
-                target: ts.ScriptTarget.Latest,
-                module: ts.ModuleKind.ESNext,
-                strict: true,
-                noEmit: true,
-                skipLibCheck: true,
-                lib: ["es2020"],
-            };
-            const host = ts.createCompilerHost(compilerOptions);
-            // Override getSourceFile to return our cached files
-            const originalGetSourceFile = host.getSourceFile;
-            host.getSourceFile = (fileName, languageVersion) => {
-                // Check if we have this file cached
-                const cachedContent = this.files.get(fileName);
-                if (cachedContent !== undefined) {
-                    return ts.createSourceFile(fileName, cachedContent, languageVersion, true);
-                }
-                // Fall back to default (for lib files, etc.)
-                return originalGetSourceFile(fileName, languageVersion);
-            };
-            // Override fileExists and readFile
-            const originalFileExists = host.fileExists;
-            host.fileExists = (fileName) => {
-                if (this.files.has(fileName))
-                    return true;
-                return originalFileExists(fileName);
-            };
-            const originalReadFile = host.readFile;
-            host.readFile = (fileName) => {
-                const cached = this.files.get(fileName);
-                if (cached !== undefined)
-                    return cached;
-                return originalReadFile(fileName);
-            };
-            const fileNames = [...this.files.keys()];
-            this.program = ts.createProgram(fileNames, compilerOptions, host);
-            this.checker = this.program.getTypeChecker();
-            this.log(`Program created with ${fileNames.length} files`);
-            return this.checker;
-        }
-        catch (error) {
-            this.log(`Error creating program: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * Get source file for a path
-     */
-    getSourceFile(filePath) {
-        const content = this.files.get(filePath);
-        if (!content) {
-            // Try to read from disk
-            try {
-                const diskContent = fs.readFileSync(filePath, "utf-8");
-                this.files.set(filePath, diskContent);
-                return ts.createSourceFile(filePath, diskContent, ts.ScriptTarget.Latest, true);
-            }
-            catch {
-                return null;
-            }
-        }
-        return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    }
-    /**
-     * Get source file from program (for type checking)
-     */
-    getSourceFileFromProgram(filePath) {
-        // Ensure program is built
-        const checker = this.getChecker();
-        if (!checker || !this.program)
-            return null;
-        return this.program.getSourceFile(filePath) ?? null;
-    }
-    /**
-     * Clear all cached files
-     */
-    clear() {
-        this.files.clear();
-        this.invalidate();
-    }
-}
-// --- Singleton ---
-let instance = null;
-export function getTypeScriptService(verbose = false) {
-    if (!instance) {
-        instance = new TypeScriptService(verbose);
-    }
-    return instance;
-}

package/clients/type-coverage-client.js

@@ -1,127 +0,0 @@
-/**
- * TypeCoverage Client for pi-lens
- *
- * Measures what percentage of TypeScript identifiers are properly typed
- * (i.e. not implicitly or explicitly `any`). Complements the LSP — the LSP
- * catches hard errors, this catches type weakness.
- *
- * Requires: npm install -D type-coverage
- * Docs: https://github.com/plantain-00/type-coverage
- */
-import * as path from "node:path";
-import { safeSpawn } from "./safe-spawn.js";
-// --- Client ---
-export class TypeCoverageClient {
-    constructor(verbose = false) {
-        this.available = null;
-        this.log = verbose
-            ? (msg) => console.error(`[type-coverage] ${msg}`)
-            : () => { };
-    }
-    isAvailable() {
-        if (this.available !== null)
-            return this.available;
-        const result = safeSpawn("npx", ["type-coverage", "--version"], {
-            timeout: 10000,
-        });
-        this.available = !result.error && result.status === 0;
-        return this.available;
-    }
-    /**
-     * Run type-coverage on the project at cwd.
-     * Uses --detail to get per-identifier locations for untyped names.
-     * Uses --strict to count `any` casts as untyped.
-     */
-    scan(cwd) {
-        if (!this.isAvailable()) {
-            return {
-                success: false,
-                percentage: 0,
-                typed: 0,
-                total: 0,
-                untypedLocations: [],
-            };
-        }
-        try {
-            const result = safeSpawn("npx", [
-                "type-coverage",
-                "--detail",
-                "--strict",
-                "--ignore-files",
-                "**/*.d.ts",
-            ], {
-                timeout: 30000,
-                cwd,
-            });
-            const output = (result.stdout ?? "") + (result.stderr ?? "");
-            return this.parseOutput(output, cwd);
-        }
-        catch (err) {
-            this.log(`Scan error: ${err.message}`);
-            return {
-                success: false,
-                percentage: 0,
-                typed: 0,
-                total: 0,
-                untypedLocations: [],
-            };
-        }
-    }
-    formatResult(result, maxLocations = 10) {
-        if (!result.success)
-            return "";
-        const pct = result.percentage.toFixed(1);
-        let icon = "✗";
-        if (result.percentage >= 95)
-            icon = "✓";
-        else if (result.percentage >= 80)
-            icon = "⚠";
-        let output = `[type-coverage] ${icon} ${pct}% typed (${result.typed}/${result.total} identifiers)`;
-        if (result.untypedLocations.length === 0) {
-            output += " — fully typed\n";
-            return output;
-        }
-        output += `:\n`;
-        for (const loc of result.untypedLocations.slice(0, maxLocations)) {
-            output += `  ${path.basename(loc.file)}:${loc.line}:${loc.column} — ${loc.name}\n`;
-        }
-        if (result.untypedLocations.length > maxLocations) {
-            output += `  ... and ${result.untypedLocations.length - maxLocations} more\n`;
-        }
-        return output;
-    }
-    // --- Internal ---
-    parseOutput(output, cwd) {
-        const untypedLocations = [];
-        // Parse detail lines: "path/to/file.ts:line:col: name"
-        const detailPattern = /^(.+):(\d+):(\d+):\s+(.+)$/gm;
-        let match;
-        while ((match = detailPattern.exec(output)) !== null) {
-            const [, file, line, col, name] = match;
-            // Skip the summary line which also matches the pattern
-            if (name.includes("%") || name.includes("/"))
-                continue;
-            untypedLocations.push({
-                file: path.resolve(cwd, file),
-                line: parseInt(line, 10),
-                column: parseInt(col, 10),
-                name: name.trim(),
-            });
-        }
-        // Parse summary: "(3979 / 4100) 97.04%"
-        const summaryMatch = output.match(/\((\d+)\s*\/\s*(\d+)\)\s*([\d.]+)%/);
-        if (!summaryMatch) {
-            return {
-                success: false,
-                percentage: 0,
-                typed: 0,
-                total: 0,
-                untypedLocations: [],
-            };
-        }
-        const typed = parseInt(summaryMatch[1], 10);
-        const total = parseInt(summaryMatch[2], 10);
-        const percentage = parseFloat(summaryMatch[3]);
-        return { success: true, percentage, typed, total, untypedLocations };
-    }
-}

package/clients/type-coverage-client.test.js

@@ -1,105 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { setupTestEnvironment } from "./test-utils.js";
-import { TypeCoverageClient } from "./type-coverage-client.js";
-describe("TypeCoverageClient", () => {
-    let client;
-    let _tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TypeCoverageClient();
-        ({ tmpDir: _tmpDir, cleanup } = setupTestEnvironment("pi-lens-typecoverage-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isAvailable", () => {
-        it("should check type-coverage availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("formatResult", () => {
-        it("should return empty string when not successful", () => {
-            const result = {
-                success: false,
-                percentage: 0,
-                typed: 0,
-                total: 0,
-                untypedLocations: [],
-            };
-            expect(client.formatResult(result)).toBe("");
-        });
-        it("should show coverage percentage", () => {
-            const result = {
-                success: true,
-                percentage: 95,
-                typed: 95,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("95.0%");
-            expect(formatted).toContain("95/100");
-        });
-        it("should show warning for low coverage", () => {
-            const result = {
-                success: true,
-                percentage: 80,
-                typed: 80,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("⚠");
-        });
-        it("should show checkmark for high coverage", () => {
-            const result = {
-                success: true,
-                percentage: 100,
-                typed: 100,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("✓");
-        });
-        it("should show untyped locations", () => {
-            const result = {
-                success: true,
-                percentage: 90,
-                typed: 90,
-                total: 100,
-                untypedLocations: [
-                    { file: "test.ts", line: 10, column: 5, name: "x" },
-                    { file: "test.ts", line: 20, column: 8, name: "y" },
-                ],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("test.ts:10");
-            expect(formatted).toContain("test.ts:20");
-            expect(formatted).toContain("x");
-            expect(formatted).toContain("y");
-        });
-        it("should truncate long untyped location lists", () => {
-            const locations = Array.from({ length: 20 }, (_, i) => ({
-                file: `file${i}.ts`,
-                line: i + 1,
-                column: 0,
-                name: `var${i}`,
-            }));
-            const result = {
-                success: true,
-                percentage: 80,
-                typed: 80,
-                total: 100,
-                untypedLocations: locations,
-            };
-            const formatted = client.formatResult(result, 10);
-            expect(formatted).toContain("...");
-            expect(formatted).toContain("10 more");
-        });
-    });
-});

package/clients/type-coverage-client.test.ts

@@ -1,125 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { setupTestEnvironment } from "./test-utils.js";
-import { TypeCoverageClient } from "./type-coverage-client.js";
-
-describe("TypeCoverageClient", () => {
-	let client: TypeCoverageClient;
-	let _tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new TypeCoverageClient();
-		({ tmpDir: _tmpDir, cleanup } = setupTestEnvironment(
-			"pi-lens-typecoverage-test-",
-		));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isAvailable", () => {
-		it("should check type-coverage availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("formatResult", () => {
-		it("should return empty string when not successful", () => {
-			const result = {
-				success: false,
-				percentage: 0,
-				typed: 0,
-				total: 0,
-				untypedLocations: [],
-			};
-
-			expect(client.formatResult(result)).toBe("");
-		});
-
-		it("should show coverage percentage", () => {
-			const result = {
-				success: true,
-				percentage: 95,
-				typed: 95,
-				total: 100,
-				untypedLocations: [],
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("95.0%");
-			expect(formatted).toContain("95/100");
-		});
-
-		it("should show warning for low coverage", () => {
-			const result = {
-				success: true,
-				percentage: 80,
-				typed: 80,
-				total: 100,
-				untypedLocations: [],
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("⚠");
-		});
-
-		it("should show checkmark for high coverage", () => {
-			const result = {
-				success: true,
-				percentage: 100,
-				typed: 100,
-				total: 100,
-				untypedLocations: [],
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("✓");
-		});
-
-		it("should show untyped locations", () => {
-			const result = {
-				success: true,
-				percentage: 90,
-				typed: 90,
-				total: 100,
-				untypedLocations: [
-					{ file: "test.ts", line: 10, column: 5, name: "x" },
-					{ file: "test.ts", line: 20, column: 8, name: "y" },
-				],
-			};
-
-			const formatted = client.formatResult(result);
-			expect(formatted).toContain("test.ts:10");
-			expect(formatted).toContain("test.ts:20");
-			expect(formatted).toContain("x");
-			expect(formatted).toContain("y");
-		});
-
-		it("should truncate long untyped location lists", () => {
-			const locations = Array.from({ length: 20 }, (_, i) => ({
-				file: `file${i}.ts`,
-				line: i + 1,
-				column: 0,
-				name: `var${i}`,
-			}));
-
-			const result = {
-				success: true,
-				percentage: 80,
-				typed: 80,
-				total: 100,
-				untypedLocations: locations,
-			};
-
-			const formatted = client.formatResult(result, 10);
-			expect(formatted).toContain("...");
-			expect(formatted).toContain("10 more");
-		});
-	});
-});

package/clients/type-safety-client.js

@@ -1,138 +0,0 @@
-/**
- * Type Safety Client for pi-lens
- *
- * Detects type safety violations that can cause runtime bugs.
- * Uses the shared TypeScriptService for efficient type checking.
- *
- * Checks:
- * - Switch Exhaustiveness: Missing cases in union type switches
- * - Null Safety: Potential null/undefined dereferences (future)
- * - Exhaustive Type Guards: Incomplete instanceof checks (future)
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as ts from "typescript";
-import { getTypeScriptService } from "./ts-service.js";
-// --- Client ---
-export class TypeSafetyClient {
-    constructor(verbose = false) {
-        this.log = verbose
-            ? (msg) => console.error(`[type-safety] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Check if file is supported (TS/JS)
-     */
-    isSupportedFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        return [".ts", ".tsx", ".js", ".jsx"].includes(ext);
-    }
-    /**
-     * Analyze type safety issues for a file
-     */
-    analyzeFile(filePath) {
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return null;
-        try {
-            const content = fs.readFileSync(absolutePath, "utf-8");
-            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-            const issues = [];
-            // Check switch exhaustiveness
-            this.checkSwitchExhaustiveness(sourceFile, issues);
-            return { filePath: absolutePath, issues };
-        }
-        catch (error) {
-            this.log(`Error analyzing ${filePath}: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * Check for switch statements that don't exhaust all union cases
-     */
-    checkSwitchExhaustiveness(sourceFile, issues) {
-        const checker = this.getTypeChecker(sourceFile);
-        if (!checker)
-            return;
-        // Use the source file from the program (has proper type information)
-        const tsService = getTypeScriptService();
-        const programSourceFile = tsService.getSourceFileFromProgram(sourceFile.fileName);
-        if (!programSourceFile)
-            return;
-        const visit = (node) => {
-            if (ts.isSwitchStatement(node)) {
-                const exprType = checker.getTypeAtLocation(node.expression);
-                // Only check union types (literal unions and object unions)
-                if (exprType.isUnion()) {
-                    const unionTypes = exprType.types;
-                    // Get all literal values from the union
-                    const literalValues = unionTypes
-                        .filter((t) => t.isLiteral() || t.flags & ts.TypeFlags.BooleanLiteral)
-                        .map((t) => {
-                        if (t.isLiteral()) {
-                            return String(t.value);
-                        }
-                        // Boolean literals
-                        if (t.flags & ts.TypeFlags.BooleanLiteral) {
-                            return checker.typeToString(t);
-                        }
-                        return null;
-                    })
-                        .filter((v) => v !== null);
-                    // Skip if no literal union (e.g., string | number)
-                    if (literalValues.length === 0)
-                        return;
-                    // Get all case clauses
-                    const coveredCases = new Set();
-                    for (const clause of node.caseBlock.clauses) {
-                        if (ts.isCaseClause(clause)) {
-                            const caseType = checker.getTypeAtLocation(clause.expression);
-                            if (caseType.isLiteral()) {
-                                coveredCases.add(String(caseType.value));
-                            }
-                            else if (caseType.flags & ts.TypeFlags.BooleanLiteral) {
-                                coveredCases.add(checker.typeToString(caseType));
-                            }
-                        }
-                    }
-                    // Check for hasDefault
-                    const hasDefault = node.caseBlock.clauses.some((c) => ts.isDefaultClause(c));
-                    // Find missing cases
-                    const missingCases = literalValues.filter((v) => !coveredCases.has(v));
-                    if (missingCases.length > 0 && !hasDefault) {
-                        const line = programSourceFile.getLineAndCharacterOfPosition(node.getStart())
-                            .line + 1;
-                        const exprText = node.expression.getText(programSourceFile);
-                        const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
-                        issues.push({
-                            filePath: programSourceFile.fileName,
-                            rule: "switch-exhaustiveness",
-                            line,
-                            message: `Switch on '${exprText}' is not exhaustive. Missing cases: ${typeStr}`,
-                            severity: "error",
-                            context: `Type has ${literalValues.length} cases, ${coveredCases.size} covered, ${missingCases.length} missing`,
-                        });
-                    }
-                }
-            }
-            ts.forEachChild(node, visit);
-        };
-        ts.forEachChild(programSourceFile, visit);
-    }
-    /**
-     * Get type checker from shared service
-     */
-    getTypeChecker(sourceFile) {
-        const tsService = getTypeScriptService();
-        // Update the file in the shared service
-        const content = fs.readFileSync(sourceFile.fileName, "utf-8");
-        tsService.updateFile(sourceFile.fileName, content);
-        const checker = tsService.getChecker();
-        if (!checker) {
-            this.log("Could not get type checker, skipping exhaustiveness check");
-        }
-        return checker;
-    }
-}
-// --- Singleton ---
-const _instance = null;

package/clients/types.js

@@ -1,11 +0,0 @@
-/**
- * LSP Types - Core types for the pi-local LSP client
- * Simplified from the full LSP spec to what we actually need
- */
-export var DiagnosticSeverity;
-(function (DiagnosticSeverity) {
-    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
-    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
-    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
-    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
-})(DiagnosticSeverity || (DiagnosticSeverity = {}));