pi-lens 2.0.26 → 2.0.28

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [2.0.27] - 2026-03-26
+
+### Added
+- **`switch-exhaustiveness` check**: New type safety rule detects missing cases in union type switches. Uses TypeScript compiler API for type-aware analysis. Reports as inline blocker: `🔴 STOP — Switch on 'X' is not exhaustive. Missing cases: 'Y'`.
+- **`clients/type-safety-client.ts`**: New client for type safety checks. Extensible for future checks (null safety, exhaustive type guards).
+
+### Changed
+- **Type safety violations added to inline feedback**: Missing switch cases now block the agent mid-task, same as TypeScript errors.
+- **Type safety violations in `/lens-booboo-fix`**: Marked as agent-fixable (add missing case or default clause).
+
+## [2.0.26] - 2026-03-26
+
+### Added
+- **5 new ast-grep rules** for AI slop detection:
+  - `no-process-env`: Block direct `process.env` access (use DI or config module) — error level
+  - `no-param-reassign`: Detect function parameter reassignment — warning level
+  - `no-single-char-var`: Flag single-character variable names — info level
+  - `switch-without-default`: Ensure switch statements have default case — warning level
+  - `no-architecture-violation`: Block cross-layer imports (models/db) — error level
+
+### Changed
+- **RULE_ACTIONS updated** for new rules:
+  - `agent` type (inline + booboo-fix): `no-param-reassign`, `switch-without-default`, `switch-exhaustiveness`
+  - `skip` type (booboo-refactor only): `no-process-env`, `no-single-char-var`, `no-architecture-violation`
+
 ## [2.0.24] - 2026-03-26
 
 ### Changed

package/README.md

@@ -202,11 +202,17 @@ Each rule includes a `message` and `note` that are shown in diagnostics, so the
 `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`
 
 **Patterns**
-`no-console-log`, `no-alert`, `no-delete-operator`, `no-shadow`, `no-star-imports`, `switch-needs-default`
+`no-console-log`, `no-alert`, `no-delete-operator`, `no-shadow`, `no-star-imports`, `switch-needs-default`, `switch-without-default`
+
+**Type Safety** (type-aware checks via `type-safety-client.ts`)
+`switch-exhaustiveness` — detects missing cases in union type switches (inline blocker)
 
 **Design Smells**
 `long-method`, `long-parameter-list`, `large-class`
 
+**AI Slop Detection**
+`no-param-reassign`, `no-single-char-var`, `no-process-env`, `no-architecture-violation`
+
 ---
 
 ## External dependencies summary

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();
 
@@ -682,6 +687,10 @@ export default function (pi: ExtensionAPI) {
 			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.
@@ -2025,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.26",
+	"version": "2.0.28",
 	"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",