pi-lens 2.2.9 → 3.0.0

package/clients/biome-client.ts

@@ -8,10 +8,10 @@
  * Docs: https://biomejs.dev/
  */
 
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -57,10 +57,8 @@ export class BiomeClient {
 		if (this.biomeAvailable !== null) return this.biomeAvailable;
 
 		// Try npx biome first (works without global install)
-		const result = spawnSync("npx", ["@biomejs/biome", "--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["@biomejs/biome", "--version"], {
 			timeout: 10000,
-			shell: true,
 		});
 
 		this.biomeAvailable = !result.error && result.status === 0;
@@ -105,7 +103,7 @@ export class BiomeClient {
 		if (!absolutePath) return [];
 
 		try {
-			const result = spawnSync(
+			const result = safeSpawn(
 				"npx",
 				[
 					"@biomejs/biome",
@@ -115,9 +113,7 @@ export class BiomeClient {
 					absolutePath,
 				],
 				{
-					encoding: "utf-8",
 					timeout: 15000,
-					shell: true,
 				},
 			);
 
@@ -126,8 +122,10 @@ export class BiomeClient {
 			if (!output.trim()) return [];
 
 			return this.parseDiagnostics(output, absolutePath);
-		} catch (err: any) {
-			this.log(`Check error: ${err.message}`);
+		} catch (err) {
+			this.log(
+				`Check error: ${err instanceof Error ? err.message : String(err)}`,
+			);
 			return [];
 		}
 	}
@@ -151,13 +149,11 @@ export class BiomeClient {
 		const content = fs.readFileSync(absolutePath, "utf-8");
 
 		try {
-			const result = spawnSync(
+			const result = safeSpawn(
 				"npx",
 				["@biomejs/biome", "format", "--write", absolutePath],
 				{
-					encoding: "utf-8",
 					timeout: 15000,
-					shell: true,
 				},
 			);
 
@@ -174,8 +170,12 @@ export class BiomeClient {
 			}
 
 			return { success: true, changed };
-		} catch (err: any) {
-			return { success: false, changed: false, error: err.message };
+		} catch (err) {
+			return {
+				success: false,
+				changed: false,
+				error: err instanceof Error ? err.message : String(err),
+			};
 		}
 	}
 
@@ -205,7 +205,7 @@ export class BiomeClient {
 			const fixableCount = beforeDiags.filter((d) => d.fixable).length;
 
 			// Apply fixes
-			const result = spawnSync(
+			const result = safeSpawn(
 				"npx",
 				[
 					"@biomejs/biome",
@@ -215,9 +215,7 @@ export class BiomeClient {
 					absolutePath,
 				],
 				{
-					encoding: "utf-8",
 					timeout: 15000,
-					shell: true,
 				},
 			);
 
@@ -240,8 +238,93 @@ export class BiomeClient {
 			}
 
 			return { success: true, changed, fixed: fixableCount };
-		} catch (err: any) {
-			return { success: false, changed: false, fixed: 0, error: err.message };
+		} catch (err) {
+			return {
+				success: false,
+				changed: false,
+				fixed: 0,
+				error: err instanceof Error ? err.message : String(err),
+			};
+		}
+	}
+
+	/**
+	 * Fix multiple files at once (much faster than file-by-file)
+	 */
+	fixFiles(filePaths: string[]): {
+		success: boolean;
+		fixed: number;
+		changed: number;
+		error?: string;
+	} {
+		if (!this.isAvailable()) {
+			return {
+				success: false,
+				fixed: 0,
+				changed: 0,
+				error: "Biome not available",
+			};
+		}
+
+		// Filter to existing files
+		const validFiles = filePaths
+			.map(f => path.resolve(f))
+			.filter(f => fs.existsSync(f));
+
+		if (validFiles.length === 0) {
+			return { success: true, fixed: 0, changed: 0 };
+		}
+
+		try {
+			// Count fixable issues before fixing
+			let totalFixable = 0;
+			for (const file of validFiles) {
+				const diags = this.checkFile(file);
+				totalFixable += diags.filter(d => d.fixable).length;
+			}
+
+			// Run biome once on all files - much faster than npx per file
+			const result = safeSpawn(
+				"npx",
+				[
+					"@biomejs/biome",
+					"check",
+					"--write",
+					"--unsafe",
+					...validFiles,
+				],
+				{
+					timeout: 60000, // Longer timeout for batch
+				},
+			);
+
+			if (result.error) {
+				return {
+					success: false,
+					fixed: 0,
+					changed: 0,
+					error: result.error.message,
+				};
+			}
+
+			// Count how many files actually changed
+			let changedCount = 0;
+			for (const file of validFiles) {
+				// We don't know exactly which files changed without re-reading,
+				// so we report total files processed
+				changedCount++;
+			}
+
+			this.log(`Fixed ${totalFixable} issue(s) in ${validFiles.length} file(s)`);
+
+			return { success: true, fixed: totalFixable, changed: changedCount };
+		} catch (err) {
+			return {
+				success: false,
+				fixed: 0,
+				changed: 0,
+				error: err instanceof Error ? err.message : String(err),
+			};
 		}
 	}
 
@@ -291,13 +374,11 @@ export class BiomeClient {
 
 		try {
 			// Get formatted output without writing
-			const result = spawnSync(
+			const result = safeSpawn(
 				"npx",
 				["@biomejs/biome", "format", absolutePath],
 				{
-					encoding: "utf-8",
 					timeout: 15000,
-					shell: true,
 				},
 			);
 

package/clients/bus/bus.js

@@ -0,0 +1,191 @@
+/**
+ * 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 };

package/clients/bus/bus.ts

@@ -0,0 +1,251 @@
+/**
+ * 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).
+ */
+
+import type { z } from "zod";
+
+// --- Types ---
+
+export interface BusEvent<T = unknown> {
+	type: string;
+	properties: T;
+	timestamp: number;
+}
+
+export type EventHandler<T> = (event: BusEvent<T>) => void | Promise<void>;
+
+// --- Internal State ---
+
+const subscribers = new Map<string, Set<EventHandler<unknown>>>();
+const globalMiddleware: Array<(event: BusEvent) => BusEvent | undefined> = [];
+
+let eventCount = 0;
+let isDebugEnabled = false;
+
+// --- Core Functions ---
+
+function debug(type: string, event: BusEvent) {
+	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<T>(event: BusEvent<T>): void {
+	eventCount++;
+	debug("publish", event as BusEvent<unknown>);
+
+	// Run through middleware
+	let currentEvent: BusEvent | undefined = event as BusEvent;
+	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 as BusEvent<unknown>);
+			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<T>(
+	eventType: string,
+	handler: EventHandler<T>,
+): () => void {
+	if (!subscribers.has(eventType)) {
+		subscribers.set(eventType, new Set());
+	}
+
+	const handlers = subscribers.get(eventType)!;
+	handlers.add(handler as EventHandler<unknown>);
+
+	debug("subscribe", { type: eventType, properties: {}, timestamp: Date.now() });
+
+	// Return unsubscribe function
+	return () => {
+		handlers.delete(handler as EventHandler<unknown>);
+		if (handlers.size === 0) {
+			subscribers.delete(eventType);
+		}
+	};
+}
+
+/**
+ * Subscribe to an event type and automatically unsubscribe after first match
+ */
+export function once<T>(
+	eventType: string,
+	predicate?: (event: BusEvent<T>) => boolean,
+): Promise<BusEvent<T>> {
+	return new Promise((resolve) => {
+		const unsubscribe = subscribe<T>(eventType, (event) => {
+			if (!predicate || predicate(event)) {
+				unsubscribe();
+				resolve(event);
+			}
+		});
+	});
+}
+
+/**
+ * Wait for an event with timeout
+ */
+export function waitFor<T>(
+	eventType: string,
+	timeoutMs: number,
+	predicate?: (event: BusEvent<T>) => boolean,
+): Promise<BusEvent<T> | undefined> {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			unsubscribe();
+			resolve(undefined);
+		}, timeoutMs);
+
+		const unsubscribe = subscribe<T>(eventType, (event) => {
+			if (!predicate || predicate(event)) {
+				clearTimeout(timer);
+				unsubscribe();
+				resolve(event);
+			}
+		});
+	});
+}
+
+// --- Middleware ---
+
+export function addMiddleware(
+	mw: (event: BusEvent) => BusEvent | undefined,
+): () => void {
+	globalMiddleware.push(mw);
+	return () => {
+		const idx = globalMiddleware.indexOf(mw);
+		if (idx !== -1) globalMiddleware.splice(idx, 1);
+	};
+}
+
+// --- Utilities ---
+
+export function enableDebug(enabled = true): void {
+	isDebugEnabled = enabled;
+}
+
+export function getStats(): {
+	subscriberCount: number;
+	eventTypes: string[];
+	totalEvents: number;
+} {
+	return {
+		subscriberCount: Array.from(subscribers.values()).reduce(
+			(sum, set) => sum + set.size,
+			0,
+		),
+		eventTypes: Array.from(subscribers.keys()),
+		totalEvents: eventCount,
+	};
+}
+
+export function clearAllSubscribers(): void {
+	subscribers.clear();
+}
+
+// --- Event Factory ---
+
+export interface EventDefinition<T> {
+	type: string;
+	create(properties: T): BusEvent<T>;
+	subscribe(handler: EventHandler<T>): () => void;
+	publish(properties: T): void;
+}
+
+export namespace BusEvent {
+	/**
+	 * Define a typed event type with Zod schema validation
+	 */
+	export function define<T>(
+		type: string,
+		_schema: z.ZodType<T>,
+	): EventDefinition<T> {
+		return {
+			type,
+			create(properties): BusEvent<T> {
+				return {
+					type,
+					properties,
+					timestamp: Date.now(),
+				};
+			},
+			subscribe(handler: EventHandler<T>): () => void {
+				return subscribe(type, handler);
+			},
+			publish(properties: T): void {
+				publish({
+					type,
+					properties,
+					timestamp: Date.now(),
+				});
+			},
+		};
+	}
+
+	/**
+	 * Create a simple event type without schema (for internal use)
+	 */
+	export function defineSimple<T>(type: string): EventDefinition<T> {
+		return {
+			type,
+			create(properties: T): BusEvent<T> {
+				return {
+					type,
+					properties,
+					timestamp: Date.now(),
+				};
+			},
+			subscribe(handler: EventHandler<T>): () => void {
+				return subscribe(type, handler);
+			},
+			publish(properties: T): void {
+				publish({
+					type,
+					properties,
+					timestamp: Date.now(),
+				});
+			},
+		};
+	}
+
+	/**
+	 * Create a raw event (helper)
+	 */
+	export function create<T>(type: string, properties: T): BusEvent<T> {
+		return {
+			type,
+			properties,
+			timestamp: Date.now(),
+		};
+	}
+}
+
+// --- Re-export for convenience ---
+export { subscribe as on, publish as emit };