pi-lens 2.0.25 → 2.0.27

package/clients/type-safety-client.js

@@ -0,0 +1,151 @@
+/**
+ * Type Safety Client for pi-lens
+ *
+ * Detects type safety violations that can cause runtime bugs.
+ * Uses the TypeScript compiler API for type-aware analysis.
+ *
+ * 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";
+// --- 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;
+        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 = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                        const exprText = node.expression.getText(sourceFile);
+                        const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
+                        issues.push({
+                            filePath: sourceFile.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(sourceFile, visit);
+    }
+    /**
+     * Get type checker for the source file
+     */
+    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;
+        }
+    }
+}
+// --- Singleton ---
+let instance = null;
+export function getTypeSafetyClient(verbose = false) {
+    if (!instance) {
+        instance = new TypeSafetyClient(verbose);
+    }
+    return instance;
+}

package/clients/type-safety-client.ts

@@ -0,0 +1,210 @@
+/**
+ * Type Safety Client for pi-lens
+ *
+ * Detects type safety violations that can cause runtime bugs.
+ * Uses the TypeScript compiler API for type-aware analysis.
+ *
+ * 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";
+
+// --- Types ---
+
+export interface TypeSafetyIssue {
+	filePath: string;
+	rule: "switch-exhaustiveness" | "null-safety" | "exhaustive-type-guard";
+	line: number;
+	message: string;
+	severity: "error" | "warning";
+	context: string; // Code snippet or type info
+}
+
+export interface TypeSafetyReport {
+	filePath: string;
+	issues: TypeSafetyIssue[];
+}
+
+// --- Client ---
+
+export class TypeSafetyClient {
+	private log: (msg: string) => void;
+
+	constructor(verbose = false) {
+		this.log = verbose
+			? (msg: string) => console.error(`[type-safety] ${msg}`)
+			: () => {};
+	}
+
+	/**
+	 * Check if file is supported (TS/JS)
+	 */
+	isSupportedFile(filePath: string): boolean {
+		const ext = path.extname(filePath).toLowerCase();
+		return [".ts", ".tsx", ".js", ".jsx"].includes(ext);
+	}
+
+	/**
+	 * Analyze type safety issues for a file
+	 */
+	analyzeFile(filePath: string): TypeSafetyReport | null {
+		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: TypeSafetyIssue[] = [];
+
+			// 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
+	 */
+	private checkSwitchExhaustiveness(
+		sourceFile: ts.SourceFile,
+		issues: TypeSafetyIssue[],
+	): void {
+		const checker = this.getTypeChecker(sourceFile);
+		if (!checker) return;
+
+		const visit = (node: ts.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 is string => v !== null);
+
+					// Skip if no literal union (e.g., string | number)
+					if (literalValues.length === 0) return;
+
+					// Get all case clauses
+					const coveredCases = new Set<string>();
+					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 = sourceFile.getLineAndCharacterOfPosition(
+							node.getStart(),
+						).line + 1;
+
+						const exprText = node.expression.getText(sourceFile);
+						const typeStr = missingCases.map((c) => `'${c}'`).join(", ");
+
+						issues.push({
+							filePath: sourceFile.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(sourceFile, visit);
+	}
+
+	/**
+	 * Get type checker for the source file
+	 */
+	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,
+			);
+
+			return program.getTypeChecker();
+		} catch {
+			this.log("Could not create type checker, skipping exhaustiveness check");
+			return null;
+		}
+	}
+
+}
+
+// --- Singleton ---
+
+let instance: TypeSafetyClient | null = null;
+
+export function getTypeSafetyClient(verbose = false): TypeSafetyClient {
+	if (!instance) {
+		instance = new TypeSafetyClient(verbose);
+	}
+	return instance;
+}

package/index.ts

@@ -31,6 +31,10 @@ import { Type } from "@sinclair/typebox";
 import { AstGrepClient } from "./clients/ast-grep-client.js";
 import { BiomeClient } from "./clients/biome-client.js";
 import { ComplexityClient } from "./clients/complexity-client.js";
+import {
+	TypeSafetyClient,
+	getTypeSafetyClient,
+} from "./clients/type-safety-client.js";
 import { DependencyChecker } from "./clients/dependency-checker.js";
 import { GoClient } from "./clients/go-client.js";
 import { JscpdClient } from "./clients/jscpd-client.js";
@@ -78,6 +82,7 @@ export default function (pi: ExtensionAPI) {
 	const testRunnerClient = new TestRunnerClient();
 	const metricsClient = new MetricsClient();
 	const complexityClient = new ComplexityClient();
+	const typeSafetyClient = new TypeSafetyClient();
 	const goClient = new GoClient();
 	const rustClient = new RustClient();
 
@@ -662,6 +667,30 @@ export default function (pi: ExtensionAPI) {
 			type: "skip",
 			note: "Renaming requires understanding all variable scopes.",
 		},
+		"no-process-env": {
+			type: "skip",
+			note: "Using process.env directly makes code untestable. Use DI or a config module.",
+		},
+		"no-param-reassign": {
+			type: "agent",
+			note: "Create a new variable instead of reassigning the parameter.",
+		},
+		"no-single-char-var": {
+			type: "skip",
+			note: "Renaming requires understanding the variable's purpose.",
+		},
+		"switch-without-default": {
+			type: "agent",
+			note: "Add a default case to handle unexpected values.",
+		},
+		"no-architecture-violation": {
+			type: "skip",
+			note: "Layer boundary violations require architectural decisions.",
+		},
+		"switch-exhaustiveness": {
+			type: "agent",
+			note: "Add the missing case(s) or a default clause to handle all union values.",
+		},
 	};
 
 	// Derived from RULE_ACTIONS — used to suppress architectural rules from inline hard stops.
@@ -2005,6 +2034,28 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
+		// Type safety checks (switch exhaustiveness, etc.)
+		if (typeSafetyClient.isSupportedFile(filePath)) {
+			const report = typeSafetyClient.analyzeFile(filePath);
+			if (report && report.issues.length > 0) {
+				const errors = report.issues.filter((i) => i.severity === "error");
+				const warnings = report.issues.filter((i) => i.severity === "warning");
+				if (errors.length > 0) {
+					lspOutput += `\n\n🔴 STOP — ${errors.length} type safety violation(s). Fix before continuing:\n`;
+					for (const issue of errors) {
+						lspOutput += `  L${issue.line}: ${issue.message}\n`;
+						lspOutput += `    → Add missing cases or add a default clause\n`;
+					}
+				}
+				if (warnings.length > 0) {
+					lspOutput += `\n\n🟡 ${warnings.length} type safety warning(s):\n`;
+					for (const issue of warnings) {
+						lspOutput += `  L${issue.line}: ${issue.message}\n`;
+					}
+				}
+			}
+		}
+
 		// ast-grep structural analysis — delta mode (only show new violations)
 		if (!pi.getFlag("no-ast-grep") && astGrepClient.isAvailable()) {
 			const after = astGrepClient.scanFile(filePath);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "2.0.25",
+	"version": "2.0.27",
 	"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-architecture-violation.yml

@@ -0,0 +1,15 @@
+id: no-architecture-violation
+language: TypeScript
+message: "Forbidden import — layer boundary violation: importing from database/model layer"
+severity: error
+note: |
+  This import crosses an architectural layer boundary.
+  Use dependency injection or a shared types/interfaces module instead.
+  
+  BAD: import { User } from '../models/user';
+  GOOD: import { User } from '../types/user';
+rule:
+  pattern: import { $$$ } from "$PATH"
+constraints:
+  PATH:
+    regex: ".*models.*|.*database.*|.*prisma.*"

package/rules/ast-grep-rules/rules/no-param-reassign.yml

@@ -0,0 +1,16 @@
+id: no-param-reassign
+language: TypeScript
+message: "Do not reassign function parameters — create a new variable instead"
+severity: warning
+note: |
+  Reassigning parameters makes code harder to debug and reason about.
+  It can cause unexpected side effects when the caller's reference changes.
+  Create a new variable with a descriptive name instead.
+  
+  BAD: function update(user) { user = { ...user, active: true }; }
+  GOOD: function update(user) { const updated = { ...user, active: true }; }
+rule:
+  pattern: |
+    function $FUNC($PARAM, $$$) {
+      $PARAM = $VALUE
+    }

package/rules/ast-grep-rules/rules/no-process-env.yml

@@ -0,0 +1,18 @@
+id: no-process-env
+language: TypeScript
+message: "Do not access process.env directly — use dependency injection or a config module"
+severity: error
+note: |
+  Direct process.env access makes code untestable and tightly coupled to the
+  runtime environment. Use a configuration service or DI container instead.
+  
+  BAD: const dbUrl = process.env.DATABASE_URL;
+  GOOD: constructor(private config: ConfigService) {}
+        const dbUrl = this.config.get('DATABASE_URL');
+  
+  Grade 2.0 — critical architectural violation for testability.
+rule:
+  any:
+    - pattern: process.env.$KEY
+    - pattern: process.env[$KEY]
+    - pattern: Deno.env.get($KEY)

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

@@ -0,0 +1,12 @@
+id: no-single-char-var
+language: TypeScript
+message: "Avoid single-character variable names — use descriptive names"
+severity: info
+note: |
+  Single-character variable names reduce readability.
+  Exception: loop counters (i, j, k) in short loops are acceptable.
+rule:
+  pattern: const $VAR = $VALUE
+constraints:
+  VAR:
+    regex: "^[a-z]$"

package/rules/ast-grep-rules/rules/switch-without-default.yml

@@ -0,0 +1,12 @@
+id: switch-without-default
+language: TypeScript
+message: "Switch statement is missing a default case"
+severity: warning
+note: |
+  Every switch should have a default case. Without it, new enum values won't be caught at runtime.
+rule:
+  all:
+    - pattern: switch ($EXPR) { $$$CASES }
+    - not:
+        has:
+          pattern: "default: $$$"