pi-lens 3.2.0 → 3.3.1

package/commands/rate.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { formatRateResult } from "./rate.js";
+// Test the formatting functions directly with mock data
+describe("formatRateResult", () => {
+    it("should format a visual score breakdown", () => {
+        const result = {
+            overall: 75,
+            categories: [
+                { name: "Type Safety", score: 85, icon: "🔷", issues: [] },
+                { name: "Complexity", score: 70, icon: "🧩", issues: [] },
+                { name: "Security", score: 100, icon: "🔒", issues: [] },
+                { name: "Architecture", score: 85, icon: "🏗️", issues: [] },
+                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+                { name: "Tests", score: 100, icon: "✅", issues: [] },
+            ],
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("CODE QUALITY SCORE");
+        expect(output).toContain("75/100");
+        expect(output).toContain("Type Safety");
+        expect(output).toContain("Security");
+        expect(output).toContain("Tests");
+    });
+    it("should show correct grade for A", () => {
+        const result = {
+            overall: 95,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 95,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("A");
+    });
+    it("should show correct grade for B", () => {
+        const result = {
+            overall: 85,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 85,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("B");
+    });
+    it("should show correct grade for C", () => {
+        const result = {
+            overall: 75,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 75,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("C");
+    });
+    it("should show issues section when there are problems", () => {
+        const result = {
+            overall: 50,
+            categories: [
+                {
+                    name: "Type Safety",
+                    score: 50,
+                    icon: "🔷",
+                    issues: ["50 untyped identifiers"],
+                },
+                {
+                    name: "Complexity",
+                    score: 50,
+                    icon: "🧩",
+                    issues: ["High complexity: foo.ts"],
+                },
+                { name: "Security", score: 100, icon: "🔒", issues: [] },
+                { name: "Architecture", score: 100, icon: "🏗️", issues: [] },
+                { name: "Dead Code", score: 100, icon: "🗑️", issues: [] },
+                { name: "Tests", score: 100, icon: "✅", issues: [] },
+            ],
+        };
+        const output = formatRateResult(result);
+        expect(output).toContain("Issues to address");
+        expect(output).toContain("Type Safety");
+        expect(output).toContain("/lens-booboo");
+    });
+    it("should not show issues section when clean", () => {
+        const result = {
+            overall: 100,
+            categories: Array(6).fill({
+                name: "Test",
+                score: 100,
+                icon: "✅",
+                issues: [],
+            }),
+        };
+        const output = formatRateResult(result);
+        expect(output).not.toContain("Issues to address");
+    });
+    it("should use colored bars based on score", () => {
+        const resultHigh = {
+            overall: 90,
+            categories: [{ name: "Test", score: 85, icon: "✅", issues: [] }],
+        };
+        const resultLow = {
+            overall: 50,
+            categories: [{ name: "Test", score: 50, icon: "✅", issues: [] }],
+        };
+        const outputHigh = formatRateResult(resultHigh);
+        const outputLow = formatRateResult(resultLow);
+        // High score should have green squares
+        expect(outputHigh).toContain("🟩");
+        // Low score should have red squares
+        expect(outputLow).toContain("🟥");
+    });
+});

package/index.ts

@@ -9,17 +9,9 @@ import { AgentBehaviorClient } from "./clients/agent-behavior-client.js";
 import { ArchitectClient } from "./clients/architect-client.js";
 import { AstGrepClient } from "./clients/ast-grep-client.js";
 import { BiomeClient } from "./clients/biome-client.js";
-import {
-	enableDebug as enableBusDebug,
-	FileModified,
-	initBusIntegration,
-	SessionStarted,
-	TurnEnded,
-} from "./clients/bus/index.js";
 import { CacheManager } from "./clients/cache-manager.js";
 import { ComplexityClient } from "./clients/complexity-client.js";
 import { DependencyChecker } from "./clients/dependency-checker.js";
-import { dispatchLintWithBus } from "./clients/dispatch/bus-dispatcher.js";
 import { dispatchLint } from "./clients/dispatch/integration.js";
 import { createFileTime, FileTimeError } from "./clients/file-time.js";
 import {
@@ -45,7 +37,6 @@ import {
 import { RustClient } from "./clients/rust-client.js";
 import { getSourceFiles } from "./clients/scan-utils.js";
 import { formatSecrets, scanForSecrets } from "./clients/secrets-scanner.js";
-import { dispatchLintWithEffect } from "./clients/services/effect-integration.js";
 import { TestRunnerClient } from "./clients/test-runner-client.js";
 import { TodoScanner } from "./clients/todo-scanner.js";
 import { TypeCoverageClient } from "./clients/type-coverage-client.js";
@@ -124,6 +115,47 @@ function log(msg: string) {
 	if (_verbose) console.error(`[pi-lens] ${msg}`);
 }
 
+/**
+ * Find and delete stale tsconfig.tsbuildinfo files in the project.
+ *
+ * A tsbuildinfo is stale when its `root` array references files that no
+ * longer exist on disk. The TypeScript Language Server reads this cache
+ * on startup and will report phantom "Cannot find module" errors for
+ * every deleted file until the cache is cleared.
+ *
+ * Only called when --lens-lsp is active (that’s when tsserver runs).
+ */
+function cleanStaleTsBuildInfo(cwd: string): string[] {
+	const cleaned: string[] = [];
+	try {
+		// Find all tsbuildinfo files in the project (max depth 3 to avoid crawling)
+		const candidates = nodeFs
+			.readdirSync(cwd)
+			.filter((f) => f.endsWith(".tsbuildinfo"))
+			.map((f) => path.join(cwd, f));
+
+		for (const infoPath of candidates) {
+			try {
+				const data = JSON.parse(nodeFs.readFileSync(infoPath, "utf-8"));
+				const root: string[] = data.root ?? [];
+				const dir = path.dirname(infoPath);
+				const isStale = root.some(
+					(f) => !nodeFs.existsSync(path.resolve(dir, f)),
+				);
+				if (isStale) {
+					nodeFs.unlinkSync(infoPath);
+					cleaned.push(infoPath);
+				}
+			} catch {
+				// Malformed or unreadable — skip
+			}
+		}
+	} catch {
+		// readdirSync failed — skip
+	}
+	return cleaned;
+}
+
 // --- Extension ---
 
 export default function (pi: ExtensionAPI) {
@@ -251,25 +283,6 @@ export default function (pi: ExtensionAPI) {
 		default: false,
 	});
 
-	// Internal flag for development/debugging (not surfaced to users)
-	pi.registerFlag("lens-bus", {
-		description: "[Internal] Enable event bus system",
-		type: "boolean",
-		default: false,
-	});
-
-	pi.registerFlag("lens-bus-debug", {
-		description: "Enable verbose bus event logging",
-		type: "boolean",
-		default: false,
-	});
-
-	pi.registerFlag("lens-effect", {
-		description: "Enable Effect-TS concurrent runner execution (Phase 2)",
-		type: "boolean",
-		default: false,
-	});
-
 	pi.registerFlag("lens-lsp", {
 		description:
 			"Enable LSP (Language Server Protocol) for semantic analysis (Phase 3)",
@@ -782,23 +795,18 @@ export default function (pi: ExtensionAPI) {
 		_verbose = !!pi.getFlag("lens-verbose");
 		dbg("session_start fired");
 
-		// Initialize event bus system (Phase 1)
-		const busEnabled = pi.getFlag("lens-bus");
-		if (busEnabled) {
-			const busDebug = pi.getFlag("lens-bus-debug");
-			initBusIntegration(pi, { debug: !!busDebug });
-			if (busDebug) enableBusDebug(true);
-			SessionStarted.publish({
-				cwd: ctx.cwd ?? process.cwd(),
-				timestamp: Date.now(),
-			});
-			dbg("session_start: bus integration initialized");
-		}
-
 		// Reset session state
 		metricsClient.reset();
 		complexityBaselines.clear();
 
+		// Reset LSP service so the new session starts with fresh diagnostics.
+		// Without this, stale cascade errors from a previous session persist
+		// if the extension module stayed hot between reloads.
+		if (pi.getFlag("lens-lsp")) {
+			resetLSPService();
+			dbg("session_start: LSP service reset");
+		}
+
 		// Log available tools
 		const tools: string[] = [];
 		tools.push("TypeScript LSP"); // Always available
@@ -813,6 +821,22 @@ export default function (pi: ExtensionAPI) {
 		log(`Active tools: ${tools.join(", ")}`);
 		dbg(`session_start tools: ${tools.join(", ")}`);
 
+		// Clean up stale TypeScript build caches before LSP starts.
+		// tsconfig.tsbuildinfo caches the full file list from the last build.
+		// If files have been deleted since then, the LSP reads the stale list
+		// and reports phantom "Cannot find module" cascade errors for files
+		// the agent never touched.
+		if (pi.getFlag("lens-lsp")) {
+			const cleaned = cleanStaleTsBuildInfo(ctx.cwd ?? process.cwd());
+			if (cleaned.length > 0) {
+				ctx.ui.notify(
+					`🧹 Deleted stale TypeScript build cache (${cleaned.map((f) => path.basename(f)).join(", ")}) — phantom errors suppressed.`,
+					"info",
+				);
+				dbg(`session_start: cleaned stale tsbuildinfo: ${cleaned.join(", ")}`);
+			}
+		}
+
 		// Pre-install TypeScript LSP if --lens-lsp flag is set (avoid delay on first use)
 		if (pi.getFlag("lens-lsp")) {
 			dbg("session_start: pre-installing TypeScript LSP...");
@@ -1319,14 +1343,6 @@ export default function (pi: ExtensionAPI) {
 		phaseEnd("format", { formattersUsed, formatChanged });
 
 		// --- Publish file modified event to bus (Phase 1) ---
-		if (pi.getFlag("lens-bus")) {
-			FileModified.publish({
-				filePath,
-				content: fileContent,
-				changeType: event.toolName === "edit" ? "edit" : "write",
-			});
-		}
-
 		// --- LSP integration (Phase 3) ---
 		if (pi.getFlag("lens-lsp") && fileContent) {
 			const lspService = getLSPService();
@@ -1418,18 +1434,7 @@ export default function (pi: ExtensionAPI) {
 		// Phase 2: Replaced ~400 lines of if/else with unified dispatch system
 		dbg(`dispatch: running lint tools for ${filePath}`);
 
-		// Select dispatcher based on flags:
-		// - lens-effect: Effect-TS concurrent execution (Phase 2)
-		// - lens-bus: Bus-enabled dispatcher (Phase 1)
-		// - default: Original sequential dispatcher
-		let dispatchOutput: string;
-		if (pi.getFlag("lens-effect")) {
-			dispatchOutput = await dispatchLintWithEffect(filePath, projectRoot, pi);
-		} else if (pi.getFlag("lens-bus")) {
-			dispatchOutput = await dispatchLintWithBus(filePath, projectRoot, pi);
-		} else {
-			dispatchOutput = await dispatchLint(filePath, projectRoot, pi);
-		}
+		const dispatchOutput = await dispatchLint(filePath, projectRoot, pi);
 
 		if (dispatchOutput) {
 			lspOutput += `\n\n${dispatchOutput}`;
@@ -1447,8 +1452,6 @@ export default function (pi: ExtensionAPI) {
 		}
 		phaseEnd("dispatch_lint", {
 			hasOutput: !!dispatchOutput,
-			effect: pi.getFlag("lens-effect"),
-			bus: pi.getFlag("lens-bus"),
 		});
 
 		// --- Test runner: run corresponding tests on write ---
@@ -1643,15 +1646,6 @@ export default function (pi: ExtensionAPI) {
 		const turnState = cacheManager.readTurnState(cwd);
 		const files = Object.keys(turnState.files);
 
-		// Publish turn ended event to bus (Phase 1)
-		if (pi.getFlag("lens-bus") && files.length > 0) {
-			TurnEnded.publish({
-				cwd,
-				modifiedFiles: files,
-				timestamp: Date.now(),
-			});
-		}
-
 		if (files.length === 0) return;
 
 		dbg(

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.2.0",
+	"version": "3.3.1",
 	"type": "module",
 	"description": "pi extension for real-time code quality — 31 LSP servers, tree-sitter structural analysis, AST pattern matching, auto-install for TypeScript/Python tooling, duplicate detection, complexity metrics, and inline blockers with comprehensive /lens-booboo reports",
 	"repository": {

package/clients/bus/bus.js

@@ -1,191 +0,0 @@
-/**
- * Event Bus for pi-lens
- *
- * Decoupled pub/sub system for diagnostic events.
- * Enables loose coupling between diagnostic producers (runners, LSP clients)
- * and consumers (UI, aggregators, history trackers).
- */
-// --- Internal State ---
-const subscribers = new Map();
-const globalMiddleware = [];
-let eventCount = 0;
-let isDebugEnabled = false;
-// --- Core Functions ---
-function debug(type, event) {
-    if (!isDebugEnabled)
-        return;
-    const timestamp = new Date(event.timestamp).toISOString();
-    console.error(`[bus] [${timestamp}] ${type}: ${event.type}`);
-}
-/**
- * Publish an event to all subscribers
- */
-export function publish(event) {
-    eventCount++;
-    debug("publish", event);
-    // Run through middleware
-    let currentEvent = event;
-    for (const mw of globalMiddleware) {
-        currentEvent = mw(currentEvent);
-        if (!currentEvent)
-            return; // Middleware cancelled the event
-    }
-    const handlers = subscribers.get(event.type);
-    if (!handlers || handlers.size === 0)
-        return;
-    // Notify all subscribers (fire-and-forget for async handlers)
-    for (const handler of handlers) {
-        try {
-            const result = handler(currentEvent);
-            if (result instanceof Promise) {
-                result.catch((err) => {
-                    console.error(`[bus] async handler error for ${event.type}:`, err);
-                });
-            }
-        }
-        catch (err) {
-            console.error(`[bus] handler error for ${event.type}:`, err);
-        }
-    }
-}
-/**
- * Subscribe to a specific event type
- * @returns Unsubscribe function
- */
-export function subscribe(eventType, handler) {
-    if (!subscribers.has(eventType)) {
-        subscribers.set(eventType, new Set());
-    }
-    const handlers = subscribers.get(eventType);
-    handlers.add(handler);
-    debug("subscribe", { type: eventType, properties: {}, timestamp: Date.now() });
-    // Return unsubscribe function
-    return () => {
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-            subscribers.delete(eventType);
-        }
-    };
-}
-/**
- * Subscribe to an event type and automatically unsubscribe after first match
- */
-export function once(eventType, predicate) {
-    return new Promise((resolve) => {
-        const unsubscribe = subscribe(eventType, (event) => {
-            if (!predicate || predicate(event)) {
-                unsubscribe();
-                resolve(event);
-            }
-        });
-    });
-}
-/**
- * Wait for an event with timeout
- */
-export function waitFor(eventType, timeoutMs, predicate) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            unsubscribe();
-            resolve(undefined);
-        }, timeoutMs);
-        const unsubscribe = subscribe(eventType, (event) => {
-            if (!predicate || predicate(event)) {
-                clearTimeout(timer);
-                unsubscribe();
-                resolve(event);
-            }
-        });
-    });
-}
-// --- Middleware ---
-export function addMiddleware(mw) {
-    globalMiddleware.push(mw);
-    return () => {
-        const idx = globalMiddleware.indexOf(mw);
-        if (idx !== -1)
-            globalMiddleware.splice(idx, 1);
-    };
-}
-// --- Utilities ---
-export function enableDebug(enabled = true) {
-    isDebugEnabled = enabled;
-}
-export function getStats() {
-    return {
-        subscriberCount: Array.from(subscribers.values()).reduce((sum, set) => sum + set.size, 0),
-        eventTypes: Array.from(subscribers.keys()),
-        totalEvents: eventCount,
-    };
-}
-export function clearAllSubscribers() {
-    subscribers.clear();
-}
-export var BusEvent;
-(function (BusEvent) {
-    /**
-     * Define a typed event type with Zod schema validation
-     */
-    function define(type, _schema) {
-        return {
-            type,
-            create(properties) {
-                return {
-                    type,
-                    properties,
-                    timestamp: Date.now(),
-                };
-            },
-            subscribe(handler) {
-                return subscribe(type, handler);
-            },
-            publish(properties) {
-                publish({
-                    type,
-                    properties,
-                    timestamp: Date.now(),
-                });
-            },
-        };
-    }
-    BusEvent.define = define;
-    /**
-     * Create a simple event type without schema (for internal use)
-     */
-    function defineSimple(type) {
-        return {
-            type,
-            create(properties) {
-                return {
-                    type,
-                    properties,
-                    timestamp: Date.now(),
-                };
-            },
-            subscribe(handler) {
-                return subscribe(type, handler);
-            },
-            publish(properties) {
-                publish({
-                    type,
-                    properties,
-                    timestamp: Date.now(),
-                });
-            },
-        };
-    }
-    BusEvent.defineSimple = defineSimple;
-    /**
-     * Create a raw event (helper)
-     */
-    function create(type, properties) {
-        return {
-            type,
-            properties,
-            timestamp: Date.now(),
-        };
-    }
-    BusEvent.create = create;
-})(BusEvent || (BusEvent = {}));
-// --- Re-export for convenience ---
-export { subscribe as on, publish as emit };