pi-lens 3.1.2 → 3.2.0

package/clients/dispatch/bus-dispatcher.ts

@@ -1,30 +1,22 @@
-/**
- * Bus-Integrated Dispatcher for pi-lens
- * 
- * Bridges the declarative dispatch system with the event bus.
- * 
- * Changes from original dispatcher:
- * - Publishes events for each runner lifecycle phase
- * - Supports concurrent execution with progress tracking
- * - Integrates with DiagnosticAggregator for results
- */
-
 import {
+	type Diagnostic,
 	DiagnosticFound,
-	RunnerStarted,
-	RunnerCompleted,
-	AutoFixApplied,
 	FileModified,
-	ReportReady,
-	type Diagnostic,
 	type OutputSemantic,
+	ReportReady,
+	RunnerCompleted,
+	RunnerStarted,
 } from "../bus/events.js";
-import { publish } from "../bus/bus.js";
-import { formatDiagnostic, formatDiagnostics, EMOJI } from "./utils/format-utils.js";
+import { formatDiagnostics } from "./utils/format-utils.js";
 // Import runners to register them
 import "./runners/index.js";
 
-import type { DispatchContext, RunnerDefinition, RunnerResult, RunnerGroup } from "./types.js";
+import type {
+	DispatchContext,
+	RunnerDefinition,
+	RunnerGroup,
+	RunnerResult,
+} from "./types.js";
 
 // --- Enhanced Dispatch Result ---
 
@@ -53,7 +45,7 @@ async function runRunner(
 	defaultSemantic: OutputSemantic,
 ): Promise<RunnerResult & { durationMs: number }> {
 	const startTime = Date.now();
-	
+
 	// Publish runner started event
 	RunnerStarted.publish({
 		runnerId: runner.id,
@@ -62,6 +54,15 @@ async function runRunner(
 	});
 
 	try {
+		// Check when() condition async-safely (sync filter in caller can't await Promises)
+		if (runner.when && !(await runner.when(ctx))) {
+			return {
+				status: "skipped",
+				diagnostics: [],
+				semantic: defaultSemantic,
+				durationMs: Date.now() - startTime,
+			};
+		}
 		const result = await runner.run(ctx);
 		const durationMs = Date.now() - startTime;
 
@@ -77,7 +78,8 @@ async function runRunner(
 
 		// Publish runner completed event
 		// Map "succeeded" to "completed" for the event status
-		const eventStatus = result.status === "succeeded" ? "completed" : result.status;
+		const eventStatus =
+			result.status === "succeeded" ? "completed" : result.status;
 		RunnerCompleted.publish({
 			runnerId: runner.id,
 			filePath: ctx.filePath,
@@ -137,10 +139,11 @@ export async function dispatchConcurrent(
 				})
 			: group.runnerIds;
 
+		// Note: when() is async — must be awaited. Filter it out here synchronously
+		// (runners without when always run; runners with when are checked inside runRunner).
 		const runners = runnerIds
 			.map((id) => getRunner(id))
-			.filter((r): r is RunnerDefinition => r !== undefined)
-			.filter((r) => (r.when ? r.when(ctx) : true));
+			.filter((r): r is RunnerDefinition => r !== undefined);
 
 		const semantic = group.semantic ?? "warning";
 
@@ -226,7 +229,10 @@ export async function dispatchConcurrent(
 export async function dispatchLintWithBus(
 	filePath: string,
 	cwd: string,
-	pi: { getFlag(flag: string): string | boolean | undefined; log?: (msg: string) => void },
+	pi: {
+		getFlag(flag: string): string | boolean | undefined;
+		log?: (msg: string) => void;
+	},
 ): Promise<string> {
 	const { createDispatchContext } = await import("./dispatcher.js");
 	const { getRunnersForKind } = await import("./dispatcher.js");
@@ -238,7 +244,8 @@ export async function dispatchLintWithBus(
 		changeType: "external",
 	});
 
-	const ctx = createDispatchContext(filePath, cwd, pi);
+	// blockingOnly=true: post-write dispatch only reports blocking errors (same as standard dispatchLint)
+	const ctx = createDispatchContext(filePath, cwd, pi, undefined, true);
 
 	const kind = ctx.kind;
 	if (!kind) return "";

package/clients/dispatch/dispatcher.js

@@ -16,6 +16,7 @@
 import { detectFileKind } from "../file-kinds.js";
 import { isTestFile } from "../file-utils.js";
 import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
 import { safeSpawn } from "../safe-spawn.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- In-Memory Baseline Store ---
@@ -24,10 +25,10 @@ export function createBaselineStore() {
     const baselines = new Map();
     return {
         get(filePath) {
-            return baselines.get(filePath);
+            return baselines.get(normalizeMapKey(filePath));
         },
         set(filePath, diagnostics) {
-            baselines.set(filePath, diagnostics);
+            baselines.set(normalizeMapKey(filePath), diagnostics);
         },
         clear() {
             baselines.clear();
@@ -37,10 +38,8 @@ export function createBaselineStore() {
 // --- Runner Registry ---
 const globalRegistry = new Map();
 export function registerRunner(runner) {
-    if (globalRegistry.has(runner.id)) {
-        console.error(`[dispatch] Duplicate runner: ${runner.id}`);
-        return;
-    }
+    if (globalRegistry.has(runner.id))
+        return; // Already registered, skip silently
     globalRegistry.set(runner.id, runner);
 }
 export function getRunner(id) {
@@ -91,9 +90,11 @@ function checkToolAvailability(command) {
 }
 // --- Dispatch Context Factory ---
 export function createDispatchContext(filePath, cwd, pi, baselines, blockingOnly) {
-    const kind = detectFileKind(filePath);
+    // Normalize path for consistent Map key usage on Windows
+    const normalizedFilePath = normalizeMapKey(filePath);
+    const kind = detectFileKind(normalizedFilePath);
     return {
-        filePath,
+        filePath: normalizedFilePath,
         cwd,
         kind,
         pi,
@@ -168,12 +169,17 @@ export async function dispatchForFile(ctx, groups) {
     let stopped = false;
     const runnerLatencies = [];
     // Debug logging goes to latency log only (not console - avoid noise)
+    const allRunnerIds = groups.flatMap((g) => g.runnerIds);
     logLatency({
         type: "phase",
         filePath: ctx.filePath,
         phase: "dispatch_start",
         durationMs: 0,
-        metadata: { groupCount: groups.length, kind: ctx.kind },
+        metadata: {
+            groupCount: groups.length,
+            kind: ctx.kind,
+            runners: allRunnerIds.join(","),
+        },
     });
     for (const group of groups) {
         if (stopped && ctx.pi.getFlag("stop-on-error")) {
@@ -256,10 +262,6 @@ export async function dispatchForFile(ctx, groups) {
                 diagnosticCount: result.diagnostics.length,
                 semantic: result.semantic ?? semantic,
             });
-            // Log slow runners immediately for real-time debugging
-            if (duration > 500) {
-                ctx.log(`⚠️ SLOW RUNNER: ${runnerId} took ${duration}ms (${result.status}, ${result.diagnostics.length} issues)`);
-            }
             // Apply delta mode filtering
             let diagnostics = result.diagnostics;
             if (ctx.deltaMode && result.semantic !== "silent") {
@@ -312,18 +314,9 @@ export async function dispatchForFile(ctx, groups) {
     if (latencyReports.length > 100) {
         latencyReports.shift();
     }
-    // Log each runner as separate entry for detailed analysis
-    for (const runner of runnerLatencies) {
-        logLatency({
-            type: "runner",
-            filePath: ctx.filePath,
-            runnerId: runner.runnerId,
-            durationMs: runner.durationMs,
-            status: runner.status,
-            diagnosticCount: runner.diagnosticCount,
-            semantic: runner.semantic,
-        });
-    }
+    // Runner latencies already logged immediately after execution (line ~329)
+    // The runnerLatencies array is stored in latencyReport for aggregate analysis
+    // No need to log again here - would create duplicates in the log
     // Log summary to latency log only (not console - avoid noise)
     logLatency({
         type: "tool_result",

package/clients/dispatch/dispatcher.test.ts

@@ -97,7 +97,8 @@ describe("Dispatch Context", () => {
 
 		const ctx = createDispatchContext("test.ts", "/project", mockPi);
 
-		expect(ctx.filePath).toBe("test.ts");
+		// Path is normalized to absolute path (Windows compatibility)
+		expect(ctx.filePath).toContain("test.ts");
 		expect(ctx.cwd).toBe("/project");
 		expect(ctx.autofix).toBe(false);
 		expect(ctx.deltaMode).toBe(true);

package/clients/dispatch/dispatcher.ts

@@ -18,6 +18,7 @@ import type { FileKind } from "../file-kinds.js";
 import { detectFileKind } from "../file-kinds.js";
 import { isTestFile } from "../file-utils.js";
 import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
 import { safeSpawn } from "../safe-spawn.js";
 import type {
 	BaselineStore,
@@ -40,10 +41,10 @@ export function createBaselineStore(): BaselineStore {
 
 	return {
 		get(filePath) {
-			return baselines.get(filePath);
+			return baselines.get(normalizeMapKey(filePath));
 		},
 		set(filePath, diagnostics) {
-			baselines.set(filePath, diagnostics);
+			baselines.set(normalizeMapKey(filePath), diagnostics);
 		},
 		clear() {
 			baselines.clear();
@@ -56,10 +57,7 @@ export function createBaselineStore(): BaselineStore {
 const globalRegistry = new Map<string, RunnerDefinition>();
 
 export function registerRunner(runner: RunnerDefinition): void {
-	if (globalRegistry.has(runner.id)) {
-		console.error(`[dispatch] Duplicate runner: ${runner.id}`);
-		return;
-	}
+	if (globalRegistry.has(runner.id)) return; // Already registered, skip silently
 	globalRegistry.set(runner.id, runner);
 }
 
@@ -127,10 +125,12 @@ export function createDispatchContext(
 	baselines?: BaselineStore,
 	blockingOnly?: boolean,
 ): DispatchContext {
-	const kind = detectFileKind(filePath);
+	// Normalize path for consistent Map key usage on Windows
+	const normalizedFilePath = normalizeMapKey(filePath);
+	const kind = detectFileKind(normalizedFilePath);
 
 	return {
-		filePath,
+		filePath: normalizedFilePath,
 		cwd,
 		kind,
 		pi,
@@ -267,12 +267,17 @@ export async function dispatchForFile(
 	const runnerLatencies: RunnerLatency[] = [];
 
 	// Debug logging goes to latency log only (not console - avoid noise)
+	const allRunnerIds = groups.flatMap((g) => g.runnerIds);
 	logLatency({
 		type: "phase",
 		filePath: ctx.filePath,
 		phase: "dispatch_start",
 		durationMs: 0,
-		metadata: { groupCount: groups.length, kind: ctx.kind },
+		metadata: {
+			groupCount: groups.length,
+			kind: ctx.kind,
+			runners: allRunnerIds.join(","),
+		},
 	});
 
 	for (const group of groups) {
@@ -364,13 +369,6 @@ export async function dispatchForFile(
 				semantic: result.semantic ?? semantic,
 			});
 
-			// Log slow runners immediately for real-time debugging
-			if (duration > 500) {
-				ctx.log(
-					`⚠️ SLOW RUNNER: ${runnerId} took ${duration}ms (${result.status}, ${result.diagnostics.length} issues)`,
-				);
-			}
-
 			// Apply delta mode filtering
 			let diagnostics = result.diagnostics;
 			if (ctx.deltaMode && result.semantic !== "silent") {
@@ -437,18 +435,9 @@ export async function dispatchForFile(
 		latencyReports.shift();
 	}
 
-	// Log each runner as separate entry for detailed analysis
-	for (const runner of runnerLatencies) {
-		logLatency({
-			type: "runner",
-			filePath: ctx.filePath,
-			runnerId: runner.runnerId,
-			durationMs: runner.durationMs,
-			status: runner.status,
-			diagnosticCount: runner.diagnosticCount,
-			semantic: runner.semantic,
-		});
-	}
+	// Runner latencies already logged immediately after execution (line ~329)
+	// The runnerLatencies array is stored in latencyReport for aggregate analysis
+	// No need to log again here - would create duplicates in the log
 
 	// Log summary to latency log only (not console - avoid noise)
 	logLatency({

package/clients/dispatch/plan.js

@@ -11,6 +11,13 @@
  */
 /**
  * Tool plans organized by purpose
+ *
+ * CORE PRINCIPLE: File write only runs BLOCKING tools
+ * - Type checking (LSP) - blocking errors
+ * - Security/correctness lint - blocking errors
+ * - Auto-format/auto-fix handled by direct calls in index.ts (not here)
+ *
+ * Warning-only tools run on /lens-booboo command only
  */
 export const TOOL_PLANS = {
     /**
@@ -19,17 +26,18 @@ export const TOOL_PLANS = {
     jsts: {
         name: "JavaScript/TypeScript Linting",
         groups: [
-            // TypeScript LSP always runs first - blocks on errors
-            { mode: "all", runnerIds: ["ts-lsp"], filterKinds: ["jsts"] },
-            // Then biome or oxlint for fast linting (user preference)
-            { mode: "fallback", runnerIds: ["biome-lint", "oxlint"] },
-            // Fast structural analysis via NAPI (replaces CLI - 100x faster)
-            { mode: "all", runnerIds: ["ast-grep-napi"] },
-            // Type safety checks
-            { mode: "fallback", runnerIds: ["type-safety"] },
+            // LSP type checking (unified for all languages) - priority 4, blocking errors
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["jsts"] },
+            // Tree-sitter native structural analysis (blocking rules: constructor-super, dangerouslySetInnerHTML, etc.)
+            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
+            // AST structural analysis (blocking: no-dupe-keys, no-hardcoded-secrets, jwt-no-verify, etc.)
+            // DISABLED in post-write - ast-grep-napi can crash. Runs via /lens-booboo only.
+            // { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
+            // Type safety checks (has some blocking errors)
+            { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
             // Note: ast-grep CLI kept for ast_grep_search/ast_grep_replace tools only
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+            // Note: biome, oxlint handled by direct auto-fix calls in index.ts (not in dispatch)
+            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -38,10 +46,13 @@ export const TOOL_PLANS = {
     python: {
         name: "Python Linting",
         groups: [
-            // Ruff handles both formatting and linting
-            { mode: "fallback", runnerIds: ["ruff-lint"] },
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+            // Pyright type checking (standard mode - no LSP flag needed)
+            // Provides Python type errors in standard pi mode
+            { mode: "all", runnerIds: ["pyright"], filterKinds: ["python"] },
+            // LSP type checking (unified) - when --lens-lsp enabled
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["python"] },
+            // Note: ruff handled by direct auto-fix calls in index.ts (not in dispatch)
+            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -50,10 +61,11 @@ export const TOOL_PLANS = {
     go: {
         name: "Go Linting",
         groups: [
-            // Go vet
-            { mode: "fallback", runnerIds: ["go-vet"] },
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+            // LSP type checking (gopls)
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["go"] },
+            // Go vet for additional checks (warning only, but low cost)
+            { mode: "fallback", runnerIds: ["go-vet"], filterKinds: ["go"] },
+            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -62,10 +74,11 @@ export const TOOL_PLANS = {
     rust: {
         name: "Rust Linting",
         groups: [
-            // Cargo clippy
-            { mode: "fallback", runnerIds: ["rust-clippy"] },
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+            // LSP type checking (rust-analyzer)
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["rust"] },
+            // Cargo clippy for additional checks
+            { mode: "fallback", runnerIds: ["rust-clippy"], filterKinds: ["rust"] },
+            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -74,8 +87,7 @@ export const TOOL_PLANS = {
     cxx: {
         name: "C/C++ Linting",
         groups: [
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+        // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -84,8 +96,8 @@ export const TOOL_PLANS = {
     json: {
         name: "JSON Processing",
         groups: [
-            // Biome handles JSON well
-            { mode: "fallback", runnerIds: ["biome-lint"] },
+        // Note: Biome handles JSON formatting via direct call in index.ts
+        // No additional linting needed for JSON
         ],
     },
     /**
@@ -94,7 +106,7 @@ export const TOOL_PLANS = {
     markdown: {
         name: "Markdown Processing",
         groups: [
-            // Spellcheck for typos
+            // Spellcheck for typos (warning only, but useful)
             { mode: "fallback", runnerIds: ["spellcheck"] },
         ],
     },
@@ -104,10 +116,9 @@ export const TOOL_PLANS = {
     shell: {
         name: "Shell Script Linting",
         groups: [
-            // Shellcheck for bash/sh/zsh linting
+            // Shellcheck for bash/sh/zsh linting (has blocking errors for syntax)
             { mode: "fallback", runnerIds: ["shellcheck"] },
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+            // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
     /**
@@ -116,8 +127,7 @@ export const TOOL_PLANS = {
     cmake: {
         name: "CMake Processing",
         groups: [
-            // Architectural rules
-            { mode: "fallback", runnerIds: ["architect"] },
+        // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
         ],
     },
 };
@@ -133,3 +143,38 @@ export function getToolPlan(kind) {
 export function getAllToolPlans() {
     return TOOL_PLANS;
 }
+/**
+ * Full lint plan for /lens-booboo command (includes warning-only tools)
+ * This includes ALL runners for comprehensive analysis
+ */
+export const FULL_LINT_PLANS = {
+    ...TOOL_PLANS,
+    // Override jsts to include warning-only tools
+    jsts: {
+        name: "JavaScript/TypeScript Full Lint",
+        groups: [
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["jsts"] },
+            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
+            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
+            // Warning-only tools (for full lint, not file write)
+            {
+                mode: "fallback",
+                runnerIds: ["biome-lint", "oxlint"],
+                filterKinds: ["jsts"],
+            },
+            { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
+            { mode: "fallback", runnerIds: ["architect"], filterKinds: ["jsts"] },
+        ],
+    },
+    // Override python to include warning-only tools
+    python: {
+        name: "Python Full Lint",
+        groups: [
+            { mode: "all", runnerIds: ["lsp"], filterKinds: ["python"] },
+            // Warning-only tools
+            { mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
+            { mode: "fallback", runnerIds: ["python-slop"], filterKinds: ["python"] },
+            { mode: "fallback", runnerIds: ["architect"], filterKinds: ["python"] },
+        ],
+    },
+};