pi-lens 2.2.9 → 3.0.0

package/clients/bus/events.js

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

package/clients/bus/events.ts

@@ -0,0 +1,279 @@
+/**
+ * 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 type DiagnosticSeverity = z.infer<typeof DiagnosticSeverity>;
+
+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 type OutputSemantic = z.infer<typeof OutputSemantic>;
+
+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 type Diagnostic = z.infer<typeof DiagnosticSchema>;
+
+export const RunnerStatus = z.enum([
+	"starting",
+	"running",
+	"completed",
+	"failed",
+	"skipped",
+]);
+export type RunnerStatus = z.infer<typeof RunnerStatus>;
+
+// --- 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 {
+	private diagnostics = new Map<string, Diagnostic[]>();
+	private unsubscribe: (() => void) | null = 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: string): Diagnostic[] {
+		return this.diagnostics.get(filePath) ?? [];
+	}
+
+	getAll(): Map<string, Diagnostic[]> {
+		return new Map(this.diagnostics);
+	}
+
+	clear(filePath?: string) {
+		if (filePath) {
+			this.diagnostics.delete(filePath);
+		} else {
+			this.diagnostics.clear();
+		}
+	}
+}

package/clients/bus/index.js

@@ -0,0 +1,8 @@
+/**
+ * Bus Module - Event-driven architecture for pi-lens
+ *
+ * Export all bus-related functionality.
+ */
+export * from "./bus.js";
+export * from "./events.js";
+export * from "./integration.js";

package/clients/bus/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Bus Module - Event-driven architecture for pi-lens
+ * 
+ * Export all bus-related functionality.
+ */
+
+export * from "./bus.js";
+export * from "./events.js";
+export * from "./integration.js";

package/clients/bus/integration.js

@@ -0,0 +1,158 @@
+/**
+ * Bus Integration for pi-lens
+ *
+ * Connects the event bus system to the existing pi-lens architecture.
+ * This provides:
+ * - Event aggregation for diagnostic collection
+ * - Real-time progress tracking
+ * - Hook integration for tool_result handler
+ */
+import { RunnerStarted, RunnerCompleted, ReportReady, FileModified, DiagnosticAggregator, } from "./events.js";
+import { enableDebug } from "./bus.js";
+const state = {
+    aggregator: new DiagnosticAggregator(),
+    runnerInProgress: new Set(),
+    lastReport: new Map(),
+    isEnabled: false,
+};
+// --- Event Subscribers ---
+let unsubscribers = [];
+/**
+ * Initialize the bus integration
+ * Call this from session_start handler
+ */
+export function initBusIntegration(pi, options) {
+    if (state.isEnabled)
+        return; // Already initialized
+    if (options?.debug) {
+        enableDebug(true);
+    }
+    // Start the diagnostic aggregator
+    state.aggregator.start();
+    // Subscribe to runner progress events for UI feedback
+    const unsubRunnerStarted = RunnerStarted.subscribe((event) => {
+        const { runnerId, filePath } = event.properties;
+        state.runnerInProgress.add(`${runnerId}:${filePath}`);
+    });
+    const unsubRunnerCompleted = RunnerCompleted.subscribe((event) => {
+        const { runnerId, filePath, durationMs, diagnosticCount } = event.properties;
+        state.runnerInProgress.delete(`${runnerId}:${filePath}`);
+        // Log slow runners in debug mode
+        if (options?.debug && durationMs > 5000) {
+            console.error(`[bus] Slow runner: ${runnerId} took ${durationMs}ms for ${filePath}`);
+        }
+        // Log runners that found issues
+        if (diagnosticCount > 0) {
+            console.error(`[bus] ${runnerId} found ${diagnosticCount} issues in ${filePath}`);
+        }
+    });
+    // Cache reports for quick retrieval
+    const unsubReportReady = ReportReady.subscribe((event) => {
+        const { filePath, report, durationMs } = event.properties;
+        // Store the report
+        state.lastReport.set(filePath, {
+            output: formatReport(report, durationMs),
+            timestamp: Date.now(),
+        });
+    });
+    // Track file modifications to clear stale data
+    const unsubFileModified = FileModified.subscribe((event) => {
+        const { filePath } = event.properties;
+        // Clear cached report for modified file
+        state.lastReport.delete(filePath);
+        // Clear diagnostics aggregator for this file (will be repopulated)
+        state.aggregator.clear(filePath);
+    });
+    // Store unsubscribers for cleanup
+    unsubscribers = [
+        unsubRunnerStarted,
+        unsubRunnerCompleted,
+        unsubReportReady,
+        unsubFileModified,
+    ];
+    state.isEnabled = true;
+    console.error("[pi-lens] Bus integration initialized");
+}
+/**
+ * Shutdown the bus integration
+ * Call this when the extension is disabled
+ */
+export function shutdownBusIntegration() {
+    if (!state.isEnabled)
+        return;
+    // Stop all subscribers
+    for (const unsub of unsubscribers) {
+        unsub();
+    }
+    unsubscribers = [];
+    // Stop the aggregator
+    state.aggregator.stop();
+    // Clear all state
+    state.runnerInProgress.clear();
+    state.lastReport.clear();
+    state.aggregator.clear();
+    state.isEnabled = false;
+}
+// --- Helper Functions ---
+function formatReport(report, durationMs) {
+    const lines = [];
+    if (report.blockers.length > 0) {
+        lines.push(`🔴 STOP — ${report.blockers.length} issue(s) must be fixed:`);
+        for (const d of report.blockers.slice(0, 5)) {
+            const line = d.line ? `L${d.line}: ` : "";
+            lines.push(`  ${line}${d.message.split("\n")[0]}`);
+        }
+        if (report.blockers.length > 5) {
+            lines.push(`  ... and ${report.blockers.length - 5} more`);
+        }
+    }
+    if (report.fixed.length > 0) {
+        lines.push(`✅ Auto-fixed ${report.fixed.length} issue(s)`);
+    }
+    if (lines.length > 0) {
+        lines.push(`(completed in ${durationMs}ms)`);
+    }
+    return lines.join("\n");
+}
+// --- API for index.ts ---
+/**
+ * Get aggregated diagnostics for a file
+ */
+export function getDiagnosticsForFile(filePath) {
+    return state.aggregator.getForFile(filePath);
+}
+/**
+ * Get the last report output for a file
+ */
+export function getLastReport(filePath) {
+    return state.lastReport.get(filePath)?.output;
+}
+/**
+ * Check if any runners are currently in progress for a file
+ */
+export function hasRunnersInProgress(filePath) {
+    if (filePath) {
+        for (const key of state.runnerInProgress) {
+            if (key.endsWith(`:${filePath}`))
+                return true;
+        }
+        return false;
+    }
+    return state.runnerInProgress.size > 0;
+}
+/**
+ * Get list of runners in progress
+ */
+export function getRunnersInProgress() {
+    return Array.from(state.runnerInProgress).map((key) => {
+        const [runnerId, filePath] = key.split(":");
+        return { runnerId, filePath };
+    });
+}
+/**
+ * Clear all cached data
+ */
+export function clearBusCache() {
+    state.lastReport.clear();
+    state.aggregator.clear();
+}