pi-lens 2.0.28 → 2.0.29

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [2.0.29] - 2026-03-26
+
+### Added
+- **`clients/ts-service.ts`**: Shared TypeScript service that creates one `ts.Program` per session. Both `complexity-client` and `type-safety-client` now share the same program instead of creating a new one per file. Significant performance improvement on large codebases.
+
+### Removed
+- **3 redundant ast-grep rules** that overlap with Biome: `no-var`, `prefer-template`, `no-useless-concat`. Biome handles these natively with auto-fix. ast-grep no longer duplicates this coverage.
+- **`prefer-const` from RULE_ACTIONS** — no longer needed (Biome handles directly).
+
+### Changed
+- **Consolidated rule overlap**: Biome is now the single source of truth for style/format rules. ast-grep focuses on structural patterns Biome doesn't cover (security, design smells, AI slop).
+
 ## [2.0.27] - 2026-03-26
 
 ### Added

package/README.md

@@ -195,8 +195,8 @@ Each rule includes a `message` and `note` that are shown in diagnostics, so the
 **TypeScript**
 `no-any-type`, `no-as-any`, `no-non-null-assertion`
 
-**Style**
-`no-var`, `prefer-const`, `prefer-template`, `no-useless-concat`, `prefer-nullish-coalescing`, `prefer-optional-chain`, `nested-ternary`, `no-lonely-if`
+**Style** (Biome handles `no-var`, `prefer-const`, `prefer-template`, `no-useless-concat` natively)
+`prefer-nullish-coalescing`, `prefer-optional-chain`, `nested-ternary`, `no-lonely-if`
 
 **Correctness**
 `no-debugger`, `no-throw-string`, `no-return-await`, `no-await-in-loop`, `no-await-in-promise-all`, `require-await`, `empty-catch`, `strict-equality`, `strict-inequality`

package/clients/ts-service.js

@@ -0,0 +1,129 @@
+/**
+ * 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/ts-service.ts

@@ -0,0 +1,160 @@
+/**
+ * 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 path from "node:path";
+import * as ts from "typescript";
+
+export class TypeScriptService {
+	private program: ts.Program | null = null;
+	private checker: ts.TypeChecker | null = null;
+	private files = new Map<string, string>();
+	private log: (msg: string) => void;
+
+	constructor(verbose = false) {
+		this.log = verbose
+			? (msg: string) => console.error(`[ts-service] ${msg}`)
+			: () => {};
+	}
+
+	/**
+	 * Update a file's content in the service
+	 */
+	updateFile(filePath: string, content: string): void {
+		this.files.set(filePath, content);
+		this.invalidate();
+	}
+
+	/**
+	 * Invalidate the program (rebuild on next access)
+	 */
+	invalidate(): void {
+		this.program = null;
+		this.checker = null;
+	}
+
+	/**
+	 * Get the shared type checker (rebuilds program if needed)
+	 */
+	getChecker(): ts.TypeChecker | null {
+		if (this.checker) return this.checker;
+
+		if (this.files.size === 0) return null;
+
+		try {
+			const compilerOptions: ts.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: string): ts.SourceFile | null {
+		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: string): ts.SourceFile | null {
+		// 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(): void {
+		this.files.clear();
+		this.invalidate();
+	}
+}
+
+// --- Singleton ---
+
+let instance: TypeScriptService | null = null;
+
+export function getTypeScriptService(verbose = false): TypeScriptService {
+	if (!instance) {
+		instance = new TypeScriptService(verbose);
+	}
+	return instance;
+}

package/clients/type-safety-client.js

@@ -2,7 +2,7 @@
  * Type Safety Client for pi-lens
  *
  * Detects type safety violations that can cause runtime bugs.
- * Uses the TypeScript compiler API for type-aware analysis.
+ * Uses the shared TypeScriptService for efficient type checking.
  *
  * Checks:
  * - Switch Exhaustiveness: Missing cases in union type switches
@@ -12,6 +12,7 @@
 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) {
@@ -53,6 +54,11 @@ export class TypeSafetyClient {
         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);
@@ -94,11 +100,11 @@ export class TypeSafetyClient {
                     // Find missing cases
                     const missingCases = literalValues.filter((v) => !coveredCases.has(v));
                     if (missingCases.length > 0 && !hasDefault) {
-                        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-                        const exprText = node.expression.getText(sourceFile);
+                        const line = programSourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                        const exprText = node.expression.getText(programSourceFile);
                         const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
                         issues.push({
-                            filePath: sourceFile.fileName,
+                            filePath: programSourceFile.fileName,
                             rule: "switch-exhaustiveness",
                             line,
                             message: `Switch on '${exprText}' is not exhaustive. Missing cases: ${typeStr}`,
@@ -110,35 +116,21 @@ export class TypeSafetyClient {
             }
             ts.forEachChild(node, visit);
         };
-        ts.forEachChild(sourceFile, visit);
+        ts.forEachChild(programSourceFile, visit);
     }
     /**
-     * Get type checker for the source file
+     * Get type checker from shared service
      */
     getTypeChecker(sourceFile) {
-        try {
-            const compilerOptions = {
-                target: ts.ScriptTarget.Latest,
-                module: ts.ModuleKind.ESNext,
-                strict: true,
-                noEmit: true,
-                skipLibCheck: true,
-            };
-            // Create a host that uses our pre-parsed source file
-            const host = ts.createCompilerHost(compilerOptions);
-            const originalGetSourceFile = host.getSourceFile;
-            host.getSourceFile = (fileName, languageVersion) => {
-                if (fileName === sourceFile.fileName)
-                    return sourceFile;
-                return originalGetSourceFile(fileName, languageVersion);
-            };
-            const program = ts.createProgram([sourceFile.fileName], compilerOptions, host);
-            return program.getTypeChecker();
-        }
-        catch {
-            this.log("Could not create type checker, skipping exhaustiveness check");
-            return null;
+        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 ---

package/clients/type-safety-client.ts

@@ -2,7 +2,7 @@
  * Type Safety Client for pi-lens
  *
  * Detects type safety violations that can cause runtime bugs.
- * Uses the TypeScript compiler API for type-aware analysis.
+ * Uses the shared TypeScriptService for efficient type checking.
  *
  * Checks:
  * - Switch Exhaustiveness: Missing cases in union type switches
@@ -13,6 +13,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as ts from "typescript";
+import { getTypeScriptService } from "./ts-service.js";
 
 // --- Types ---
 
@@ -87,6 +88,11 @@ export class TypeSafetyClient {
 		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: ts.Node) => {
 			if (ts.isSwitchStatement(node)) {
 				const exprType = checker.getTypeAtLocation(node.expression);
@@ -137,15 +143,15 @@ export class TypeSafetyClient {
 					);
 
 					if (missingCases.length > 0 && !hasDefault) {
-						const line = sourceFile.getLineAndCharacterOfPosition(
+						const line = programSourceFile.getLineAndCharacterOfPosition(
 							node.getStart(),
 						).line + 1;
 
-						const exprText = node.expression.getText(sourceFile);
+						const exprText = node.expression.getText(programSourceFile);
 						const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
 
 						issues.push({
-							filePath: sourceFile.fileName,
+							filePath: programSourceFile.fileName,
 							rule: "switch-exhaustiveness",
 							line,
 							message: `Switch on '${exprText}' is not exhaustive. Missing cases: ${typeStr}`,
@@ -159,41 +165,24 @@ export class TypeSafetyClient {
 			ts.forEachChild(node, visit);
 		};
 
-		ts.forEachChild(sourceFile, visit);
+		ts.forEachChild(programSourceFile, visit);
 	}
 
 	/**
-	 * Get type checker for the source file
+	 * Get type checker from shared service
 	 */
 	private getTypeChecker(sourceFile: ts.SourceFile): ts.TypeChecker | null {
-		try {
-			const compilerOptions: ts.CompilerOptions = {
-				target: ts.ScriptTarget.Latest,
-				module: ts.ModuleKind.ESNext,
-				strict: true,
-				noEmit: true,
-				skipLibCheck: true,
-			};
-
-			// Create a host that uses our pre-parsed source file
-			const host = ts.createCompilerHost(compilerOptions);
-			const originalGetSourceFile = host.getSourceFile;
-			host.getSourceFile = (fileName, languageVersion) => {
-				if (fileName === sourceFile.fileName) return sourceFile;
-				return originalGetSourceFile(fileName, languageVersion);
-			};
-
-			const program = ts.createProgram(
-				[sourceFile.fileName],
-				compilerOptions,
-				host,
-			);
+		const tsService = getTypeScriptService();
 
-			return program.getTypeChecker();
-		} catch {
-			this.log("Could not create type checker, skipping exhaustiveness check");
-			return null;
+		// 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;
 	}
 
 }

package/index.ts

@@ -613,11 +613,7 @@ export default function (pi: ExtensionAPI) {
 		string,
 		{ type: "biome" | "agent" | "skip"; note: string }
 	> = {
-		"no-var": { type: "biome", note: "auto-fixed by Biome --write" },
-		"prefer-template": { type: "biome", note: "auto-fixed by Biome --write" },
-		"no-useless-concat": { type: "biome", note: "auto-fixed by Biome --write" },
 		"no-lonely-if": { type: "biome", note: "auto-fixed by Biome --write" },
-		"prefer-const": { type: "biome", note: "auto-fixed by Biome --write" },
 		"empty-catch": {
 			type: "agent",
 			note: "Add this.log('Error: ' + err.message) to the catch block",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "2.0.28",
+	"version": "2.0.29",
 	"description": "Real-time code quality feedback for pi — TypeScript LSP, Biome, ast-grep, Ruff, complexity metrics, duplicate detection. Includes automated fix loop (/lens-booboo-fix) and interactive architectural refactoring (/lens-booboo-refactor) with browser-based interviews.",
 	"repository": {
 		"type": "git",

package/rules/ast-grep-rules/rules/no-useless-concat.yml

@@ -1,17 +0,0 @@
-id: no-useless-concat
-language: TypeScript
-message: "Unnecessary string concatenation with adjacent string literals"
-severity: warning
-note: |
-  Adjacent string literals should be combined into a single string literal
-  rather than concatenated with the + operator.
-rule:
-  all:
-    - pattern: $A + $B
-    - any:
-        - has:
-            kind: string
-            pattern: "$A"
-        - has:
-            kind: string
-            pattern: "$B"

package/rules/ast-grep-rules/rules/no-var.yml

@@ -1,10 +0,0 @@
-id: no-var
-language: TypeScript
-message: "Use 'const' or 'let' instead of 'var'"
-severity: warning
-note: |
-  var has function scope and can lead to unexpected hoisting behavior.
-  Use const for values that don't change, let for values that do.
-rule:
-  pattern: var $X = $Y
-fix: let $X = $Y

package/rules/ast-grep-rules/rules/prefer-template.yml

@@ -1,20 +0,0 @@
-id: prefer-template
-language: TypeScript
-message: "Use template literals instead of string concatenation"
-severity: warning
-note: |
-  Template literals are more readable and less error-prone than string
-  concatenation with the + operator.
-rule:
-  all:
-    - pattern: $A + $B
-    - any:
-        - inside:
-            kind: binary_expression
-            has:
-              pattern: $A + $B
-              any:
-                - has:
-                    kind: string
-                - has:
-                    kind: template_string