pi-lens 3.6.2 → 3.6.4

package/clients/dispatch/dispatcher.js

@@ -1,381 +0,0 @@
-/**
- * Declarative Tool Dispatcher for pi-lens
- *
- * Redesigned to handle the full complexity of pi-lens's tool_result handler:
- * - Multiple tools with different semantics (blocking, warning, silent)
- * - Delta mode (baseline tracking)
- * - Autofix handling
- * - Output aggregation and formatting
- *
- * Key abstractions:
- * - RunnerDefinition: A tool that can be run
- * - Diagnostic: Structured issue representation
- * - OutputSemantic: How to display (blocking, warning, silent, etc.)
- * - BaselineStore: Track pre-existing issues for delta mode
- */
-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 ---
-// DEBUG TEST EDIT - Testing dispatch logging
-export function createBaselineStore() {
-    const baselines = new Map();
-    return {
-        get(filePath) {
-            return baselines.get(normalizeMapKey(filePath));
-        },
-        set(filePath, diagnostics) {
-            baselines.set(normalizeMapKey(filePath), diagnostics);
-        },
-        clear() {
-            baselines.clear();
-        },
-    };
-}
-// --- Runner Registry ---
-const globalRegistry = new Map();
-export function registerRunner(runner) {
-    if (globalRegistry.has(runner.id))
-        return; // Already registered, skip silently
-    globalRegistry.set(runner.id, runner);
-}
-export function getRunner(id) {
-    return globalRegistry.get(id);
-}
-export function getRunnersForKind(kind, filePath) {
-    if (!kind)
-        return [];
-    const runners = [];
-    const isTest = filePath ? isTestFile(filePath) : false;
-    for (const runner of globalRegistry.values()) {
-        // Skip runners that shouldn't run on test files
-        if (isTest && runner.skipTestFiles)
-            continue;
-        if (runner.appliesTo.includes(kind) || runner.appliesTo.length === 0) {
-            runners.push(runner);
-        }
-    }
-    return runners.sort((a, b) => a.priority - b.priority);
-}
-export function listRunners() {
-    return Array.from(globalRegistry.values());
-}
-/**
- * Clear all registered runners. Used primarily for testing.
- */
-export function clearRunnerRegistry() {
-    globalRegistry.clear();
-}
-// --- Tool Availability Cache ---
-const toolCache = new Map();
-function checkToolAvailability(command) {
-    if (toolCache.has(command)) {
-        return toolCache.get(command);
-    }
-    try {
-        const result = safeSpawn(command, ["--version"], {
-            timeout: 5000,
-        });
-        const available = result.status === 0;
-        toolCache.set(command, available);
-        return available;
-    }
-    catch {
-        toolCache.set(command, false);
-        return false;
-    }
-}
-// --- Dispatch Context Factory ---
-export function createDispatchContext(filePath, cwd, pi, baselines, blockingOnly) {
-    // Normalize path for consistent Map key usage on Windows
-    const normalizedFilePath = normalizeMapKey(filePath);
-    const kind = detectFileKind(normalizedFilePath);
-    return {
-        filePath: normalizedFilePath,
-        cwd,
-        kind,
-        pi,
-        autofix: !!(pi.getFlag("autofix-biome") || pi.getFlag("autofix-ruff")),
-        deltaMode: !pi.getFlag("no-delta"),
-        baselines: baselines ?? createBaselineStore(),
-        blockingOnly,
-        async hasTool(command) {
-            return checkToolAvailability(command);
-        },
-        log(message) {
-            console.error(`[dispatch] ${message}`);
-        },
-    };
-}
-// --- Delta Mode Logic ---
-/**
- * Filter diagnostics to only show NEW issues (delta mode)
- */
-function filterDelta(after, before, keyFn) {
-    const beforeSet = new Set((before ?? []).map(keyFn));
-    const afterSet = new Set(after.map(keyFn));
-    const fixed = (before ?? []).filter((d) => !afterSet.has(keyFn(d)));
-    const newItems = after.filter((d) => !beforeSet.has(keyFn(d)));
-    return { new: newItems, fixed };
-}
-const latencyReports = [];
-export function getLatencyReports() {
-    return [...latencyReports];
-}
-export function clearLatencyReports() {
-    latencyReports.length = 0;
-}
-export function formatLatencyReport(report) {
-    const lines = [];
-    lines.push(`\n═══════════════════════════════════════════════════════════════`);
-    lines.push(`📊 DISPATCH LATENCY REPORT: ${report.filePath.split("/").pop()}`);
-    lines.push(`   Kind: ${report.fileKind || "unknown"} | Total: ${report.totalDurationMs}ms`);
-    lines.push(`───────────────────────────────────────────────────────────────`);
-    lines.push(`Runner                          Duration  Status    Issues  Semantic`);
-    lines.push(`───────────────────────────────────────────────────────────────`);
-    for (const r of report.runners) {
-        const name = r.runnerId.padEnd(30);
-        const dur = `${r.durationMs}ms`.padStart(8);
-        const status = r.status.padStart(9);
-        const issues = String(r.diagnosticCount).padStart(6);
-        const sem = r.semantic.padStart(8);
-        const slowMarker = r.durationMs > 500 ? " 🔥" : r.durationMs > 100 ? " ⚡" : "";
-        lines.push(`${name}${dur}${status}${issues}${sem}${slowMarker}`);
-    }
-    lines.push(`───────────────────────────────────────────────────────────────`);
-    lines.push(`Total: ${report.runners.length} runners | Stopped early: ${report.stoppedEarly}`);
-    lines.push(`Diagnostics: ${report.totalDiagnostics} (${report.blockers} blockers, ${report.warnings} warnings)`);
-    // Show top 3 slowest
-    const sorted = [...report.runners].sort((a, b) => b.durationMs - a.durationMs);
-    if (sorted.length > 0 && sorted[0].durationMs > 100) {
-        lines.push(`\n🐌 Slowest runners:`);
-        for (const r of sorted.slice(0, 3)) {
-            if (r.durationMs > 50) {
-                lines.push(`   ${r.runnerId}: ${r.durationMs}ms (${r.status})`);
-            }
-        }
-    }
-    lines.push(`═══════════════════════════════════════════════════════════════`);
-    return lines.join("\n");
-}
-// --- Main Dispatch Function ---
-export async function dispatchForFile(ctx, groups) {
-    const _overallStart = Date.now();
-    const allDiagnostics = [];
-    const _fixed = [];
-    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,
-            runners: allRunnerIds.join(","),
-        },
-    });
-    for (const group of groups) {
-        if (stopped && ctx.pi.getFlag("stop-on-error")) {
-            break;
-        }
-        // Filter runners by kind if specified
-        const runnerIds = group.filterKinds
-            ? group.runnerIds.filter((id) => {
-                const runner = getRunner(id);
-                return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
-            })
-            : group.runnerIds;
-        const semantic = group.semantic ?? "warning";
-        for (const runnerId of runnerIds) {
-            const runnerStart = Date.now();
-            const runner = getRunner(runnerId);
-            if (!runner) {
-                runnerLatencies.push({
-                    runnerId,
-                    startTime: runnerStart,
-                    endTime: Date.now(),
-                    durationMs: 0,
-                    status: "skipped",
-                    diagnosticCount: 0,
-                    semantic: "unknown",
-                });
-                logLatency({
-                    type: "runner",
-                    filePath: ctx.filePath,
-                    runnerId,
-                    durationMs: 0,
-                    status: "not_registered",
-                    diagnosticCount: 0,
-                    semantic: "unknown",
-                });
-                continue;
-            }
-            // Check preconditions
-            if (runner.when && !(await runner.when(ctx))) {
-                runnerLatencies.push({
-                    runnerId,
-                    startTime: runnerStart,
-                    endTime: Date.now(),
-                    durationMs: Date.now() - runnerStart,
-                    status: "when_skipped",
-                    diagnosticCount: 0,
-                    semantic: runner.id,
-                });
-                logLatency({
-                    type: "runner",
-                    filePath: ctx.filePath,
-                    runnerId,
-                    durationMs: 0,
-                    status: "when_skipped",
-                    diagnosticCount: 0,
-                    semantic: "when_condition",
-                });
-                continue;
-            }
-            const result = await runRunner(ctx, runner, semantic);
-            const runnerEnd = Date.now();
-            const duration = runnerEnd - runnerStart;
-            // Track latency for this runner
-            runnerLatencies.push({
-                runnerId,
-                startTime: runnerStart,
-                endTime: runnerEnd,
-                durationMs: duration,
-                status: result.status,
-                diagnosticCount: result.diagnostics.length,
-                semantic: result.semantic ?? semantic,
-            });
-            // IMMEDIATE LOG: Each runner result (for debugging)
-            logLatency({
-                type: "runner",
-                filePath: ctx.filePath,
-                runnerId,
-                durationMs: duration,
-                status: result.status,
-                diagnosticCount: result.diagnostics.length,
-                semantic: result.semantic ?? semantic,
-            });
-            // Apply delta mode filtering
-            let diagnostics = result.diagnostics;
-            if (ctx.deltaMode && result.semantic !== "silent") {
-                const before = ctx.baselines.get(ctx.filePath);
-                if (before) {
-                    const filtered = filterDelta(diagnostics, before, (d) => d.id);
-                    diagnostics = filtered.new;
-                    // TODO: Track fixed diagnostics
-                }
-                // Update baseline
-                ctx.baselines.set(ctx.filePath, [...allDiagnostics, ...diagnostics]);
-            }
-            allDiagnostics.push(...diagnostics);
-            // Check for blockers - use result semantic (not group default) and check individual diagnostics
-            const resultSemantic = result.semantic ?? semantic;
-            if (resultSemantic === "blocking" && diagnostics.length > 0) {
-                stopped = true;
-            }
-            // Also check if any individual diagnostic is blocking
-            if (diagnostics.some((d) => d.semantic === "blocking")) {
-                stopped = true;
-            }
-        }
-    }
-    // Categorize results
-    const blockers = allDiagnostics.filter((d) => d.semantic === "blocking");
-    const warnings = allDiagnostics.filter((d) => d.semantic === "warning" || d.semantic === "none");
-    const fixedItems = allDiagnostics.filter((d) => d.semantic === "fixed");
-    // Format output — only blocking issues shown inline
-    // Warnings tracked but not shown (noise) — surfaced via /lens-booboo
-    let output = formatDiagnostics(blockers, "blocking");
-    output += formatDiagnostics(fixedItems, "fixed");
-    // Generate and store latency report
-    const overallEnd = Date.now();
-    const latencyReport = {
-        filePath: ctx.filePath,
-        fileKind: ctx.kind,
-        overallStartMs: _overallStart,
-        overallEndMs: overallEnd,
-        totalDurationMs: overallEnd - _overallStart,
-        runners: runnerLatencies,
-        stoppedEarly: stopped,
-        totalDiagnostics: allDiagnostics.length,
-        blockers: blockers.length,
-        warnings: warnings.length,
-    };
-    // Store for later analysis
-    latencyReports.push(latencyReport);
-    // Keep only last 100 reports to prevent memory bloat
-    if (latencyReports.length > 100) {
-        latencyReports.shift();
-    }
-    // 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",
-        filePath: ctx.filePath,
-        durationMs: latencyReport.totalDurationMs,
-        result: "dispatch_complete",
-        metadata: {
-            runners: runnerLatencies.map((r) => ({
-                id: r.runnerId,
-                duration: r.durationMs,
-                status: r.status,
-            })),
-            totalDiagnostics: allDiagnostics.length,
-            blockers: blockers.length,
-        },
-    });
-    return {
-        diagnostics: allDiagnostics,
-        blockers,
-        warnings,
-        fixed: fixedItems,
-        output,
-        hasBlockers: blockers.length > 0,
-    };
-}
-// --- Run Single Runner ---
-async function runRunner(ctx, runner, defaultSemantic) {
-    try {
-        const result = await runner.run(ctx);
-        return {
-            ...result,
-            semantic: result.semantic ?? defaultSemantic,
-        };
-    }
-    catch (error) {
-        ctx.log(`Runner ${runner.id} failed: ${error}`);
-        return {
-            status: "failed",
-            diagnostics: [],
-            semantic: defaultSemantic,
-        };
-    }
-}
-// --- Simple Integration Helper ---
-export async function dispatchLint(filePath, cwd, pi, baselines) {
-    // By default, only run BLOCKING rules for fast feedback on file write
-    const ctx = createDispatchContext(filePath, cwd, pi, baselines, true);
-    // Get runners for this file kind
-    const runners = getRunnersForKind(ctx.kind);
-    if (runners.length === 0) {
-        return "";
-    }
-    // Create groups from registered runners (all in fallback mode)
-    const groups = [
-        {
-            mode: "fallback",
-            runnerIds: runners.map((r) => r.id),
-        },
-    ];
-    const result = await dispatchForFile(ctx, groups);
-    return result.output;
-}

package/clients/dispatch/dispatcher.test.js

@@ -1,116 +0,0 @@
-/**
- * Tests for declarative dispatch system
- */
-import { beforeEach, describe, expect, it } from "vitest";
-import { createDispatchContext, getRunner, getRunnersForKind, listRunners, registerRunner, } from "./dispatcher.js";
-// --- Test Runners ---
-const testRunner1 = {
-    id: "test-runner-1",
-    appliesTo: ["jsts", "python"],
-    priority: 10,
-    enabledByDefault: true,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-const testRunner2 = {
-    id: "test-runner-2",
-    appliesTo: ["python"],
-    priority: 20,
-    enabledByDefault: true,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-const testRunnerWithCondition = {
-    id: "test-runner-conditional",
-    appliesTo: ["jsts"],
-    priority: 5,
-    enabledByDefault: false,
-    when: async (ctx) => ctx.autofix,
-    async run() {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-// --- Tests ---
-describe("Runner Registry", () => {
-    beforeEach(() => {
-        // Note: In a real test suite, we'd reset the registry between tests
-        registerRunner(testRunner1);
-        registerRunner(testRunner2);
-        registerRunner(testRunnerWithCondition);
-    });
-    it("should register a runner", () => {
-        const runner = getRunner("test-runner-1");
-        expect(runner).toBeDefined();
-        expect(runner?.id).toBe("test-runner-1");
-    });
-    it("should return undefined for unknown runner", () => {
-        const runner = getRunner("unknown-runner");
-        expect(runner).toBeUndefined();
-    });
-    it("should get runners for a specific kind", () => {
-        const jstsRunners = getRunnersForKind("jsts");
-        expect(jstsRunners.length).toBeGreaterThan(0);
-        expect(jstsRunners.some((r) => r.id === "test-runner-1")).toBe(true);
-    });
-    it("should return runners sorted by priority", () => {
-        const jstsRunners = getRunnersForKind("jsts");
-        const priorities = jstsRunners.map((r) => r.priority ?? 100);
-        for (let i = 1; i < priorities.length; i++) {
-            expect(priorities[i - 1]).toBeLessThanOrEqual(priorities[i]);
-        }
-    });
-    it("should list all registered runners", () => {
-        const all = listRunners();
-        expect(all.length).toBeGreaterThanOrEqual(3);
-    });
-    it("should reject duplicate registrations", () => {
-        // This should log an error but not throw
-        expect(() => registerRunner(testRunner1)).not.toThrow();
-    });
-});
-describe("Dispatch Context", () => {
-    it("should create a dispatch context", () => {
-        const mockPi = { getFlag: (flag) => flag === "autofix" };
-        const ctx = createDispatchContext("test.ts", "/project", mockPi);
-        // 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);
-    });
-    it("should detect file kind", () => {
-        const mockPi = { getFlag: () => false };
-        const ctxTs = createDispatchContext("test.ts", "/project", mockPi);
-        expect(ctxTs.kind).toBe("jsts");
-        const ctxPy = createDispatchContext("test.py", "/project", mockPi);
-        expect(ctxPy.kind).toBe("python");
-        const ctxGo = createDispatchContext("test.go", "/project", mockPi);
-        expect(ctxGo.kind).toBe("go");
-    });
-    it("should respect autofix flag", () => {
-        const mockPiNoFix = { getFlag: (_f) => false };
-        const ctx1 = createDispatchContext("test.ts", "/project", mockPiNoFix);
-        expect(ctx1.autofix).toBe(false);
-        const mockPiWithFix = { getFlag: (f) => f === "autofix-biome" };
-        const ctx2 = createDispatchContext("test.ts", "/project", mockPiWithFix);
-        expect(ctx2.autofix).toBe(true);
-    });
-});
-describe("Conditional Runners", () => {
-    beforeEach(() => {
-        registerRunner(testRunnerWithCondition);
-    });
-    it("should respect when condition", async () => {
-        const runner = getRunner("test-runner-conditional");
-        expect(runner).toBeDefined();
-        const mockPiNoFix = { getFlag: () => false };
-        const ctxNoFix = createDispatchContext("test.ts", "/project", mockPiNoFix);
-        // When autofix is false, the condition should return false
-        if (runner?.when) {
-            const shouldRun = await runner.when(ctxNoFix);
-            expect(shouldRun).toBe(false);
-        }
-    });
-});

package/clients/dispatch/dispatcher.test.ts

@@ -1,149 +0,0 @@
-/**
- * Tests for declarative dispatch system
- */
-
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-	createDispatchContext,
-	getRunner,
-	getRunnersForKind,
-	listRunners,
-	registerRunner,
-} from "./dispatcher.js";
-import type { RunnerDefinition, RunnerResult } from "./types.js";
-
-// --- Test Runners ---
-
-const testRunner1: RunnerDefinition = {
-	id: "test-runner-1",
-	appliesTo: ["jsts", "python"],
-	priority: 10,
-	enabledByDefault: true,
-	async run(): Promise<RunnerResult> {
-		return { status: "succeeded", diagnostics: [], semantic: "none" };
-	},
-};
-
-const testRunner2: RunnerDefinition = {
-	id: "test-runner-2",
-	appliesTo: ["python"],
-	priority: 20,
-	enabledByDefault: true,
-	async run(): Promise<RunnerResult> {
-		return { status: "succeeded", diagnostics: [], semantic: "none" };
-	},
-};
-
-const testRunnerWithCondition: RunnerDefinition = {
-	id: "test-runner-conditional",
-	appliesTo: ["jsts"],
-	priority: 5,
-	enabledByDefault: false,
-	when: async (ctx) => ctx.autofix,
-	async run(): Promise<RunnerResult> {
-		return { status: "succeeded", diagnostics: [], semantic: "none" };
-	},
-};
-
-// --- Tests ---
-
-describe("Runner Registry", () => {
-	beforeEach(() => {
-		// Note: In a real test suite, we'd reset the registry between tests
-		registerRunner(testRunner1);
-		registerRunner(testRunner2);
-		registerRunner(testRunnerWithCondition);
-	});
-
-	it("should register a runner", () => {
-		const runner = getRunner("test-runner-1");
-		expect(runner).toBeDefined();
-		expect(runner?.id).toBe("test-runner-1");
-	});
-
-	it("should return undefined for unknown runner", () => {
-		const runner = getRunner("unknown-runner");
-		expect(runner).toBeUndefined();
-	});
-
-	it("should get runners for a specific kind", () => {
-		const jstsRunners = getRunnersForKind("jsts");
-		expect(jstsRunners.length).toBeGreaterThan(0);
-		expect(jstsRunners.some((r) => r.id === "test-runner-1")).toBe(true);
-	});
-
-	it("should return runners sorted by priority", () => {
-		const jstsRunners = getRunnersForKind("jsts");
-		const priorities = jstsRunners.map((r) => r.priority ?? 100);
-		for (let i = 1; i < priorities.length; i++) {
-			expect(priorities[i - 1]).toBeLessThanOrEqual(priorities[i]);
-		}
-	});
-
-	it("should list all registered runners", () => {
-		const all = listRunners();
-		expect(all.length).toBeGreaterThanOrEqual(3);
-	});
-
-	it("should reject duplicate registrations", () => {
-		// This should log an error but not throw
-		expect(() => registerRunner(testRunner1)).not.toThrow();
-	});
-});
-
-describe("Dispatch Context", () => {
-	it("should create a dispatch context", () => {
-		const mockPi = { getFlag: (flag: string) => flag === "autofix" };
-
-		const ctx = createDispatchContext("test.ts", "/project", mockPi);
-
-		// 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);
-	});
-
-	it("should detect file kind", () => {
-		const mockPi = { getFlag: () => false };
-
-		const ctxTs = createDispatchContext("test.ts", "/project", mockPi);
-		expect(ctxTs.kind).toBe("jsts");
-
-		const ctxPy = createDispatchContext("test.py", "/project", mockPi);
-		expect(ctxPy.kind).toBe("python");
-
-		const ctxGo = createDispatchContext("test.go", "/project", mockPi);
-		expect(ctxGo.kind).toBe("go");
-	});
-
-	it("should respect autofix flag", () => {
-		const mockPiNoFix = { getFlag: (_f: string) => false };
-		const ctx1 = createDispatchContext("test.ts", "/project", mockPiNoFix);
-		expect(ctx1.autofix).toBe(false);
-
-		const mockPiWithFix = { getFlag: (f: string) => f === "autofix-biome" };
-		const ctx2 = createDispatchContext("test.ts", "/project", mockPiWithFix);
-		expect(ctx2.autofix).toBe(true);
-	});
-});
-
-describe("Conditional Runners", () => {
-	beforeEach(() => {
-		registerRunner(testRunnerWithCondition);
-	});
-
-	it("should respect when condition", async () => {
-		const runner = getRunner("test-runner-conditional");
-		expect(runner).toBeDefined();
-
-		const mockPiNoFix = { getFlag: () => false };
-		const ctxNoFix = createDispatchContext("test.ts", "/project", mockPiNoFix);
-
-		// When autofix is false, the condition should return false
-		if (runner?.when) {
-			const shouldRun = await runner.when(ctxNoFix);
-			expect(shouldRun).toBe(false);
-		}
-	});
-});