pi-lens 3.2.0 → 3.3.1

package/clients/bus/bus.ts

@@ -1,251 +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).
- */
-
-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 };

package/clients/bus/events.js

@@ -1,214 +0,0 @@
-/**
- * Diagnostic Event Types for pi-lens
- *
- * Standardized events for the bus system.
- * These events flow through the system:
- * - Runners publish DiagnosticFound events
- * - LSP clients publish LspDiagnostic events
- * - Aggregators subscribe and build reports
- * - UI subscribes for real-time display
- */
-import { z } from "zod";
-import { BusEvent } from "./bus.js";
-// --- Shared Schemas ---
-export const DiagnosticSeverity = z.enum(["error", "warning", "info", "hint"]);
-export const OutputSemantic = z.enum([
-    "blocking", // Hard stop - must fix
-    "warning", // Soft stop - should fix
-    "fixed", // Auto-fix applied
-    "silent", // Track but don't display
-    "none", // No action needed
-]);
-export const DiagnosticSchema = z.object({
-    id: z.string(), // Unique for deduplication
-    message: z.string(),
-    filePath: z.string(),
-    line: z.number().optional(),
-    column: z.number().optional(),
-    severity: DiagnosticSeverity,
-    semantic: OutputSemantic,
-    tool: z.string(), // Which tool produced this
-    rule: z.string().optional(),
-    fixable: z.boolean().optional(),
-    fixSuggestion: z.string().optional(),
-});
-export const RunnerStatus = z.enum([
-    "starting",
-    "running",
-    "completed",
-    "failed",
-    "skipped",
-]);
-// --- Event Definitions ---
-/**
- * Fired when a runner discovers diagnostics
- * Published by: dispatch runners
- * Subscribed by: aggregators, delta tracker, UI
- */
-export const DiagnosticFound = BusEvent.define("diagnostic.found", z.object({
-    runnerId: z.string(),
-    filePath: z.string(),
-    diagnostics: z.array(DiagnosticSchema),
-    durationMs: z.number(),
-}));
-/**
- * Fired when a file is modified
- * Published by: tool_result handler, file watcher
- * Subscribed by: runner scheduler, cache invalidator
- */
-export const FileModified = BusEvent.define("file.modified", z.object({
-    filePath: z.string(),
-    content: z.string().optional(),
-    changeType: z.enum(["write", "edit", "external"]),
-}));
-/**
- * Fired when a file is created
- * Published by: file watcher
- * Subscribed by: runner scheduler
- */
-export const FileCreated = BusEvent.define("file.created", z.object({
-    filePath: z.string(),
-}));
-/**
- * Fired when a file is deleted
- * Published by: file watcher
- * Subscribed by: cache invalidator
- */
-export const FileDeleted = BusEvent.define("file.deleted", z.object({
-    filePath: z.string(),
-}));
-/**
- * Fired when a runner starts execution
- * Published by: dispatcher
- * Subscribed by: progress UI, metrics
- */
-export const RunnerStarted = BusEvent.define("runner.started", z.object({
-    runnerId: z.string(),
-    filePath: z.string(),
-    timestamp: z.number(),
-}));
-/**
- * Fired when a runner completes
- * Published by: dispatcher
- * Subscribed by: progress UI, metrics aggregator
- */
-export const RunnerCompleted = BusEvent.define("runner.completed", z.object({
-    runnerId: z.string(),
-    filePath: z.string(),
-    status: RunnerStatus,
-    durationMs: z.number(),
-    diagnosticCount: z.number(),
-}));
-/**
- * Fired when LSP publishes diagnostics
- * Published by: LSPClient (via textDocument/publishDiagnostics)
- * Subscribed by: diagnostic aggregator
- */
-export const LspDiagnostic = BusEvent.define("lsp.diagnostic", z.object({
-    serverId: z.string(), // e.g., "typescript", "pyright"
-    filePath: z.string(),
-    diagnostics: z.array(z.object({
-        severity: z.number(), // 1=error, 2=warn, 3=info, 4=hint
-        message: z.string(),
-        range: z.object({
-            start: z.object({ line: z.number(), character: z.number() }),
-            end: z.object({ line: z.number(), character: z.number() }),
-        }),
-        code: z.union([z.string(), z.number()]).optional(),
-        source: z.string().optional(),
-    })),
-    version: z.number().optional(), // Document version for debouncing
-}));
-/**
- * Fired when baseline is updated (for delta mode)
- * Published by: delta tracker
- * Subscribed by: diagnostic filter
- */
-export const BaselineUpdated = BusEvent.define("baseline.updated", z.object({
-    filePath: z.string(),
-    diagnosticIds: z.array(z.string()),
-    timestamp: z.number(),
-}));
-/**
- * Fired when aggregated report is ready
- * Published by: report aggregator
- * Subscribed by: UI, commands
- */
-export const ReportReady = BusEvent.define("report.ready", z.object({
-    filePath: z.string(),
-    report: z.object({
-        blockers: z.array(DiagnosticSchema),
-        warnings: z.array(DiagnosticSchema),
-        fixed: z.array(DiagnosticSchema),
-        silent: z.array(DiagnosticSchema),
-    }),
-    durationMs: z.number(),
-}));
-/**
- * Fired when auto-fix is applied
- * Published by: autofix runner
- * Subscribed by: UI, file watcher
- */
-export const AutoFixApplied = BusEvent.define("autofix.applied", z.object({
-    filePath: z.string(),
-    runnerId: z.string(),
-    fixesApplied: z.number(),
-    fixes: z.array(z.object({
-        line: z.number(),
-        message: z.string(),
-    })),
-}));
-/**
- * Fired when session starts
- * Published by: session_start handler
- * Subscribed by: cache manager, file watcher
- */
-export const SessionStarted = BusEvent.define("session.started", z.object({
-    cwd: z.string(),
-    timestamp: z.number(),
-}));
-/**
- * Fired when turn ends
- * Published by: turn_end handler
- * Subscribed by: batch processor, metrics
- */
-export const TurnEnded = BusEvent.define("turn.ended", z.object({
-    cwd: z.string(),
-    modifiedFiles: z.array(z.string()),
-    timestamp: z.number(),
-}));
-// --- Event Aggregator Helper ---
-export class DiagnosticAggregator {
-    constructor() {
-        this.diagnostics = new Map();
-        this.unsubscribe = null;
-    }
-    start() {
-        this.unsubscribe = DiagnosticFound.subscribe((event) => {
-            const { filePath, diagnostics } = event.properties;
-            const existing = this.diagnostics.get(filePath) ?? [];
-            // Merge and dedupe by id
-            const merged = [...existing, ...diagnostics];
-            const unique = new Map(merged.map(d => [d.id, d]));
-            this.diagnostics.set(filePath, Array.from(unique.values()));
-        });
-    }
-    stop() {
-        this.unsubscribe?.();
-        this.unsubscribe = null;
-    }
-    getForFile(filePath) {
-        return this.diagnostics.get(filePath) ?? [];
-    }
-    getAll() {
-        return new Map(this.diagnostics);
-    }
-    clear(filePath) {
-        if (filePath) {
-            this.diagnostics.delete(filePath);
-        }
-        else {
-            this.diagnostics.clear();
-        }
-    }
-}