pi-lens 3.6.2 → 3.6.4

package/clients/runner-tracker.js

@@ -1,152 +0,0 @@
-/**
- * Runner tracker for /lens-booboo and related commands
- *
- * Tracks execution time and findings for each analysis runner,
- * producing a summary of what each runner found.
- */
-export class RunnerTracker {
-    constructor(options) {
-        this.runners = [];
-        this.onProgress = options?.onProgress;
-    }
-    /**
-     * Run a function with timing and tracking
-     */
-    async run(name, runFn, options) {
-        const startMs = Date.now();
-        const index = this.runners.length;
-        const runner = {
-            name,
-            status: "running",
-            findings: 0,
-            elapsedMs: 0,
-        };
-        this.runners.push(runner);
-        // Notify start
-        this.onProgress?.(runner, index);
-        try {
-            const result = await runFn();
-            const elapsedMs = Date.now() - startMs;
-            // Extract findings if result has it
-            const findings = typeof result === "object" &&
-                result !== null &&
-                "findings" in result &&
-                typeof result.findings === "number"
-                ? result.findings
-                : 0;
-            runner.status = "done";
-            runner.elapsedMs = elapsedMs;
-            runner.findings = findings;
-            return result;
-        }
-        catch (err) {
-            const elapsedMs = Date.now() - startMs;
-            runner.status = "error";
-            runner.elapsedMs = elapsedMs;
-            runner.message = String(err);
-            throw err;
-        }
-    }
-    /**
-     * Mark a runner as skipped (for when preconditions aren't met)
-     */
-    skip(name, message) {
-        this.runners.push({
-            name,
-            status: "skipped",
-            findings: 0,
-            elapsedMs: 0,
-            message,
-        });
-    }
-    /**
-     * Update findings for a runner (useful when findings are discovered asynchronously)
-     */
-    updateFindings(runnerName, findings) {
-        const runner = this.runners.find((r) => r.name === runnerName);
-        if (runner) {
-            runner.findings = findings;
-        }
-    }
-    /**
-     * Get all tracked runners
-     */
-    getRunners() {
-        return [...this.runners];
-    }
-    /**
-     * Get summary statistics
-     */
-    getStats() {
-        return {
-            total: this.runners.length,
-            done: this.runners.filter((r) => r.status === "done").length,
-            skipped: this.runners.filter((r) => r.status === "skipped").length,
-            errors: this.runners.filter((r) => r.status === "error").length,
-            totalFindings: this.runners.reduce((sum, r) => sum + r.findings, 0),
-            totalTimeMs: this.runners.reduce((sum, r) => sum + r.elapsedMs, 0),
-        };
-    }
-    /**
-     * Format a single runner result for display
-     */
-    formatRunner(runner, index) {
-        const prefix = index !== undefined ? `[${index + 1}] ` : "";
-        const statusIcon = runner.status === "done"
-            ? "✓"
-            : runner.status === "skipped"
-                ? "⊘"
-                : runner.status === "error"
-                    ? "✗"
-                    : "○";
-        const findings = runner.findings > 0 ? ` (${runner.findings} findings)` : "";
-        const time = this.formatElapsed(runner.elapsedMs);
-        const message = runner.message ? ` — ${runner.message}` : "";
-        return `${prefix}${statusIcon} ${runner.name}${findings} — ${time}${message}`;
-    }
-    /**
-     * Format all runners as a summary table
-     */
-    formatSummary() {
-        const lines = ["📊 Runner Summary:", ""];
-        for (let i = 0; i < this.runners.length; i++) {
-            lines.push(`  ${this.formatRunner(this.runners[i], i)}`);
-        }
-        const stats = this.getStats();
-        lines.push("");
-        lines.push(`  Total: ${stats.totalFindings} findings in ${this.formatElapsed(stats.totalTimeMs)}`);
-        return lines.join("\n");
-    }
-    /**
-     * Format elapsed time in human-readable form
-     */
-    formatElapsed(ms) {
-        if (ms < 1000)
-            return `${ms}ms`;
-        if (ms < 60000)
-            return `${(ms / 1000).toFixed(1)}s`;
-        const mins = Math.floor(ms / 60000);
-        const secs = ((ms % 60000) / 1000).toFixed(0);
-        return `${mins}m${secs.padStart(2, "0")}s`;
-    }
-}
-/**
- * Convenience function to create a tracker and run a sequence
- */
-export async function runSequence(sequence, onProgress) {
-    const tracker = new RunnerTracker({ onProgress });
-    const results = [];
-    for (const item of sequence) {
-        const result = await tracker.run(item.name, item.run, {
-            index: results.length,
-            total: sequence.length,
-        });
-        results.push(result);
-        // Update findings if handler provided
-        if (item.onFindings) {
-            const findings = item.onFindings(result);
-            tracker.updateFindings(item.name, findings);
-        }
-    }
-    return { results, tracker };
-}

package/clients/rust-client.js

@@ -1,205 +0,0 @@
-/**
- * Rust Client for pi-lens
- *
- * Provides Rust type checking and linting via cargo check and clippy.
- *
- * Requires: cargo (rustup)
- * Docs: https://doc.rust-lang.org/cargo/
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawn } from "./safe-spawn.js";
-// --- Common install paths ---
-const CARGO_WINDOWS_PATHS = [
-    path.join(process.env.USERPROFILE || "", ".cargo", "bin", "cargo.exe"),
-    "C:\\cargo\\bin\\cargo.exe",
-    "cargo.exe", // PATH
-];
-const CARGO_UNIX_PATHS = [
-    path.join(process.env.HOME || "", ".cargo", "bin", "cargo"),
-    "/usr/local/cargo/bin/cargo",
-    "/usr/bin/cargo",
-    "cargo", // PATH
-];
-// --- Client ---
-export class RustClient {
-    constructor(verbose = false) {
-        this.cargoAvailable = null;
-        this.cargoPath = null;
-        this.log = verbose
-            ? (msg) => console.error(`[rust] ${msg}`)
-            : () => { };
-    }
-    /**
-     * Find cargo executable path
-     */
-    findCargoPath() {
-        if (this.cargoPath)
-            return this.cargoPath;
-        const paths = process.platform === "win32" ? CARGO_WINDOWS_PATHS : CARGO_UNIX_PATHS;
-        for (const p of paths) {
-            try {
-                if (p.includes("\\") || p.includes("/")) {
-                    if (fs.existsSync(p)) {
-                        this.cargoPath = p;
-                        return p;
-                    }
-                }
-                else {
-                    const result = safeSpawn(p, ["--version"], {
-                        timeout: 3000,
-                    });
-                    if (!result.error && result.status === 0) {
-                        this.cargoPath = p;
-                        return p;
-                    }
-                }
-            }
-            catch (err) {
-                void err;
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if cargo is installed
-     */
-    isAvailable() {
-        if (this.cargoAvailable !== null)
-            return this.cargoAvailable;
-        this.cargoAvailable = this.findCargoPath() !== null;
-        if (this.cargoAvailable) {
-            this.log(`Cargo found: ${this.cargoPath}`);
-        }
-        return this.cargoAvailable;
-    }
-    /**
-     * Check if a file is a Rust file
-     */
-    isRustFile(filePath) {
-        return path.extname(filePath).toLowerCase() === ".rs";
-    }
-    /**
-     * Run cargo check on the project
-     */
-    checkFile(filePath, cwd) {
-        const cargoExe = this.findCargoPath();
-        if (!cargoExe)
-            return [];
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
-            return [];
-        try {
-            const result = safeSpawn(cargoExe, ["check", "--message-format", "json"], {
-                timeout: 60000,
-                cwd,
-            });
-            const output = result.stdout || "";
-            return this.parseJsonOutput(output, absolutePath);
-        }
-        catch (err) {
-            this.log(`Check error: ${err.message}`);
-            return [];
-        }
-    }
-    /**
-     * Run clippy for additional lints
-     */
-    clippyCheck(cwd) {
-        if (!this.isAvailable())
-            return [];
-        try {
-            const result = safeSpawn("cargo", ["clippy", "--message-format", "json"], {
-                timeout: 60000,
-                cwd,
-            });
-            const output = result.stdout || "";
-            return this.parseJsonOutput(output, "");
-        }
-        catch (err) {
-            this.log(`Clippy error: ${err.message}`);
-            return [];
-        }
-    }
-    /**
-     * Format diagnostics for LLM consumption
-     */
-    formatDiagnostics(diags, maxItems = 10) {
-        if (diags.length === 0)
-            return "";
-        const errors = diags.filter((d) => d.severity === "error");
-        const warnings = diags.filter((d) => d.severity === "warning");
-        let output = `[Rust] ${diags.length} issue(s)`;
-        if (errors.length)
-            output += ` — ${errors.length} error(s)`;
-        if (warnings.length)
-            output += ` — ${warnings.length} warning(s)`;
-        output += ":\n";
-        for (const d of diags.slice(0, maxItems)) {
-            const loc = `L${d.line}:${d.column}`;
-            const code = d.code ? ` [${d.code}]` : "";
-            output += `  [${d.severity}] ${loc} ${d.message.slice(0, 200)}${code}\n`;
-        }
-        if (diags.length > maxItems) {
-            output += `  ... and ${diags.length - maxItems} more\n`;
-        }
-        return output;
-    }
-    // --- Internal ---
-    parseJsonOutput(output, filterFile) {
-        if (!output.trim())
-            return [];
-        const diags = [];
-        const lines = output.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-            try {
-                const msg = JSON.parse(line);
-                if (msg.reason === "compiler-message" && msg.message) {
-                    const { level, message, spans, code } = msg.message;
-                    // Only include errors and warnings
-                    if (level !== "error" && level !== "warning" && level !== "note") {
-                        continue;
-                    }
-                    // Get location from spans
-                    if (spans && spans.length > 0) {
-                        for (const span of spans) {
-                            const file = span.file_name;
-                            // Filter to specific file if provided
-                            if (filterFile &&
-                                path.resolve(file) !== path.resolve(filterFile)) {
-                                continue;
-                            }
-                            diags.push({
-                                line: span.line_start,
-                                column: span.column_start - 1,
-                                endLine: span.line_end,
-                                endColumn: span.column_end - 1,
-                                severity: level,
-                                message: message.slice(0, 300),
-                                code,
-                                file: path.resolve(file),
-                            });
-                        }
-                    }
-                    else {
-                        // No span info, add as general diagnostic
-                        diags.push({
-                            line: 1,
-                            column: 0,
-                            endLine: 1,
-                            endColumn: 0,
-                            severity: level,
-                            message: message.slice(0, 300),
-                            code,
-                            file: filterFile || "",
-                        });
-                    }
-                }
-            }
-            catch (err) {
-                void err;
-            } // Skip non-JSON lines
-        }
-        return diags;
-    }
-}

package/clients/rust-client.test.js

@@ -1,108 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RustClient } from "./rust-client.js";
-import { setupTestEnvironment } from "./test-utils.js";
-describe("RustClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new RustClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-rust-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isRustFile", () => {
-        it("should recognize Rust files", () => {
-            expect(client.isRustFile("main.rs")).toBe(true);
-            expect(client.isRustFile("lib.rs")).toBe(true);
-        });
-        it("should not recognize non-Rust files", () => {
-            expect(client.isRustFile("main.ts")).toBe(false);
-            expect(client.isRustFile("main.py")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check cargo availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("checkFile", () => {
-        it("should return empty array for non-existent files", () => {
-            if (!client.isAvailable())
-                return;
-            const result = client.checkFile("/nonexistent/file.rs", tmpDir);
-            expect(result).toEqual([]);
-        });
-        it("should return array for valid Rust files", () => {
-            if (!client.isAvailable())
-                return;
-            // Need a Cargo.toml for cargo to work
-            fs.writeFileSync(path.join(tmpDir, "Cargo.toml"), `
-[package]
-name = "test"
-version = "0.1.0"
-edition = "2021"
-`);
-            fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
-            fs.writeFileSync(path.join(tmpDir, "src", "main.rs"), `
-fn main() {
-    println!("Hello, world!");
-}
-`);
-            const result = client.checkFile(path.join(tmpDir, "src", "main.rs"), tmpDir);
-            expect(Array.isArray(result)).toBe(true);
-        });
-    });
-    describe("formatDiagnostics", () => {
-        it("should format diagnostics for display", () => {
-            const diags = [
-                {
-                    line: 3,
-                    column: 0,
-                    endLine: 3,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "cannot find value `x` in this scope",
-                    code: "E0425",
-                    file: "main.rs",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("Rust");
-            expect(formatted).toContain("1 issue");
-            expect(formatted).toContain("E0425");
-        });
-        it("should show error and warning counts", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Error",
-                    file: "test.rs",
-                },
-                {
-                    line: 2,
-                    column: 0,
-                    endLine: 2,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Warning",
-                    file: "test.rs",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("1 error(s)");
-            expect(formatted).toContain("1 warning(s)");
-        });
-    });
-});

package/clients/rust-client.test.ts

@@ -1,130 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RustClient } from "./rust-client.js";
-import { setupTestEnvironment } from "./test-utils.js";
-
-describe("RustClient", () => {
-	let client: RustClient;
-	let tmpDir: string;
-	let cleanup: () => void;
-
-	beforeEach(() => {
-		client = new RustClient();
-		({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-rust-test-"));
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	afterEach(() => {
-		cleanup();
-	});
-
-	describe("isRustFile", () => {
-		it("should recognize Rust files", () => {
-			expect(client.isRustFile("main.rs")).toBe(true);
-			expect(client.isRustFile("lib.rs")).toBe(true);
-		});
-
-		it("should not recognize non-Rust files", () => {
-			expect(client.isRustFile("main.ts")).toBe(false);
-			expect(client.isRustFile("main.py")).toBe(false);
-		});
-	});
-
-	describe("isAvailable", () => {
-		it("should check cargo availability", () => {
-			const available = client.isAvailable();
-			expect(typeof available).toBe("boolean");
-		});
-	});
-
-	describe("checkFile", () => {
-		it("should return empty array for non-existent files", () => {
-			if (!client.isAvailable()) return;
-			const result = client.checkFile("/nonexistent/file.rs", tmpDir);
-			expect(result).toEqual([]);
-		});
-
-		it("should return array for valid Rust files", () => {
-			if (!client.isAvailable()) return;
-
-			// Need a Cargo.toml for cargo to work
-			fs.writeFileSync(
-				path.join(tmpDir, "Cargo.toml"),
-				`
-[package]
-name = "test"
-version = "0.1.0"
-edition = "2021"
-`,
-			);
-			fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
-			fs.writeFileSync(
-				path.join(tmpDir, "src", "main.rs"),
-				`
-fn main() {
-    println!("Hello, world!");
-}
-`,
-			);
-
-			const result = client.checkFile(
-				path.join(tmpDir, "src", "main.rs"),
-				tmpDir,
-			);
-			expect(Array.isArray(result)).toBe(true);
-		});
-	});
-
-	describe("formatDiagnostics", () => {
-		it("should format diagnostics for display", () => {
-			const diags = [
-				{
-					line: 3,
-					column: 0,
-					endLine: 3,
-					endColumn: 10,
-					severity: "error" as const,
-					message: "cannot find value `x` in this scope",
-					code: "E0425",
-					file: "main.rs",
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("Rust");
-			expect(formatted).toContain("1 issue");
-			expect(formatted).toContain("E0425");
-		});
-
-		it("should show error and warning counts", () => {
-			const diags = [
-				{
-					line: 1,
-					column: 0,
-					endLine: 1,
-					endColumn: 10,
-					severity: "error" as const,
-					message: "Error",
-					file: "test.rs",
-				},
-				{
-					line: 2,
-					column: 0,
-					endLine: 2,
-					endColumn: 10,
-					severity: "warning" as const,
-					message: "Warning",
-					file: "test.rs",
-				},
-			];
-
-			const formatted = client.formatDiagnostics(diags);
-			expect(formatted).toContain("1 error(s)");
-			expect(formatted).toContain("1 warning(s)");
-		});
-	});
-});