pi-lens 2.2.9 → 3.0.0

package/clients/ruff-client.js

@@ -7,10 +7,10 @@
  * Requires: pip install ruff
  * Docs: https://docs.astral.sh/ruff/
  */
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Client ---
 export class RuffClient {
     constructor(verbose = false) {
@@ -26,10 +26,8 @@ export class RuffClient {
         if (this.ruffAvailable !== null)
             return this.ruffAvailable;
         try {
-            const result = spawnSync("ruff", ["--version"], {
-                encoding: "utf-8",
+            const result = safeSpawn("ruff", ["--version"], {
                 timeout: 5000,
-                shell: true,
             });
             this.ruffAvailable = !result.error && result.status === 0;
             if (this.ruffAvailable) {
@@ -58,7 +56,7 @@ export class RuffClient {
         if (!fs.existsSync(absolutePath))
             return [];
         try {
-            const result = spawnSync("ruff", [
+            const result = safeSpawn("ruff", [
                 "check",
                 "--output-format",
                 "json",
@@ -66,9 +64,7 @@ export class RuffClient {
                 "py310",
                 absolutePath,
             ], {
-                encoding: "utf-8",
                 timeout: 10000,
-                shell: true,
             });
             // ruff exits 1 when it finds issues (normal)
             const output = result.stdout || "";
@@ -91,10 +87,8 @@ export class RuffClient {
         if (!fs.existsSync(absolutePath))
             return "";
         try {
-            const result = spawnSync("ruff", ["format", "--check", "--diff", absolutePath], {
-                encoding: "utf-8",
+            const result = safeSpawn("ruff", ["format", "--check", "--diff", absolutePath], {
                 timeout: 10000,
-                shell: true,
             });
             // ruff format --check exits 1 when changes needed
             if (result.status === 0)
@@ -136,10 +130,8 @@ export class RuffClient {
         try {
             const beforeDiags = this.checkFile(filePath);
             const fixableCount = beforeDiags.filter((d) => d.fixable).length;
-            const result = spawnSync("ruff", ["check", "--fix", absolutePath], {
-                encoding: "utf-8",
+            const result = safeSpawn("ruff", ["check", "--fix", absolutePath], {
                 timeout: 15000,
-                shell: true,
             });
             if (result.error) {
                 return {
@@ -160,6 +152,56 @@ export class RuffClient {
             return { success: false, changed: false, fixed: 0, error: err.message };
         }
     }
+    /**
+     * Fix multiple Python files at once (much faster than file-by-file)
+     */
+    fixFiles(filePaths) {
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: "Ruff not available",
+            };
+        }
+        // Filter to existing Python files
+        const validFiles = filePaths
+            .map(f => path.resolve(f))
+            .filter(f => fs.existsSync(f) && f.endsWith(".py"));
+        if (validFiles.length === 0) {
+            return { success: true, fixed: 0, changed: 0 };
+        }
+        try {
+            // Count fixable issues before fixing
+            let totalFixable = 0;
+            for (const file of validFiles) {
+                const diags = this.checkFile(file);
+                totalFixable += diags.filter(d => d.fixable).length;
+            }
+            // Run ruff once on all files - much faster than per file
+            const result = safeSpawn("ruff", ["check", "--fix", ...validFiles], {
+                timeout: 60000, // Longer timeout for batch
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    fixed: 0,
+                    changed: 0,
+                    error: result.error.message,
+                };
+            }
+            this.log(`Fixed ${totalFixable} issue(s) in ${validFiles.length} file(s)`);
+            return { success: true, fixed: totalFixable, changed: validFiles.length };
+        }
+        catch (err) {
+            return {
+                success: false,
+                fixed: 0,
+                changed: 0,
+                error: err.message,
+            };
+        }
+    }
     /**
      * Format a Python file (writes to disk)
      */
@@ -171,10 +213,8 @@ export class RuffClient {
             return { success: false, changed: false, error: "File not found" };
         const content = fs.readFileSync(absolutePath, "utf-8");
         try {
-            const result = spawnSync("ruff", ["format", absolutePath], {
-                encoding: "utf-8",
+            const result = safeSpawn("ruff", ["format", absolutePath], {
                 timeout: 10000,
-                shell: true,
             });
             if (result.error) {
                 return { success: false, changed: false, error: result.error.message };

package/clients/ruff-client.ts

@@ -12,6 +12,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -56,10 +57,8 @@ export class RuffClient {
 		if (this.ruffAvailable !== null) return this.ruffAvailable;
 
 		try {
-			const result = spawnSync("ruff", ["--version"], {
-				encoding: "utf-8",
+			const result = safeSpawn("ruff", ["--version"], {
 				timeout: 5000,
-				shell: true,
 			});
 			this.ruffAvailable = !result.error && result.status === 0;
 			if (this.ruffAvailable) {
@@ -90,7 +89,7 @@ export class RuffClient {
 		if (!fs.existsSync(absolutePath)) return [];
 
 		try {
-			const result = spawnSync(
+			const result = safeSpawn(
 				"ruff",
 				[
 					"check",
@@ -101,9 +100,7 @@ export class RuffClient {
 					absolutePath,
 				],
 				{
-					encoding: "utf-8",
 					timeout: 10000,
-					shell: true,
 				},
 			);
 
@@ -128,13 +125,11 @@ export class RuffClient {
 		if (!fs.existsSync(absolutePath)) return "";
 
 		try {
-			const result = spawnSync(
+			const result = safeSpawn(
 				"ruff",
 				["format", "--check", "--diff", absolutePath],
 				{
-					encoding: "utf-8",
 					timeout: 10000,
-					shell: true,
 				},
 			);
 
@@ -187,10 +182,8 @@ export class RuffClient {
 			const beforeDiags = this.checkFile(filePath);
 			const fixableCount = beforeDiags.filter((d) => d.fixable).length;
 
-			const result = spawnSync("ruff", ["check", "--fix", absolutePath], {
-				encoding: "utf-8",
+			const result = safeSpawn("ruff", ["check", "--fix", absolutePath], {
 				timeout: 15000,
-				shell: true,
 			});
 
 			if (result.error) {
@@ -217,6 +210,72 @@ export class RuffClient {
 		}
 	}
 
+	/**
+	 * Fix multiple Python files at once (much faster than file-by-file)
+	 */
+	fixFiles(filePaths: string[]): {
+		success: boolean;
+		fixed: number;
+		changed: number;
+		error?: string;
+	} {
+		if (!this.isAvailable()) {
+			return {
+				success: false,
+				fixed: 0,
+				changed: 0,
+				error: "Ruff not available",
+			};
+		}
+
+		// Filter to existing Python files
+		const validFiles = filePaths
+			.map(f => path.resolve(f))
+			.filter(f => fs.existsSync(f) && f.endsWith(".py"));
+
+		if (validFiles.length === 0) {
+			return { success: true, fixed: 0, changed: 0 };
+		}
+
+		try {
+			// Count fixable issues before fixing
+			let totalFixable = 0;
+			for (const file of validFiles) {
+				const diags = this.checkFile(file);
+				totalFixable += diags.filter(d => d.fixable).length;
+			}
+
+			// Run ruff once on all files - much faster than per file
+			const result = safeSpawn(
+				"ruff",
+				["check", "--fix", ...validFiles],
+				{
+					timeout: 60000, // Longer timeout for batch
+				},
+			);
+
+			if (result.error) {
+				return {
+					success: false,
+					fixed: 0,
+					changed: 0,
+					error: result.error.message,
+				};
+			}
+
+			this.log(`Fixed ${totalFixable} issue(s) in ${validFiles.length} file(s)`);
+
+			return { success: true, fixed: totalFixable, changed: validFiles.length };
+		} catch (err: any) {
+			return {
+				success: false,
+				fixed: 0,
+				changed: 0,
+				error: err.message,
+			};
+		}
+	}
+
 	/**
 	 * Format a Python file (writes to disk)
 	 */
@@ -235,10 +294,8 @@ export class RuffClient {
 		const content = fs.readFileSync(absolutePath, "utf-8");
 
 		try {
-			const result = spawnSync("ruff", ["format", absolutePath], {
-				encoding: "utf-8",
+			const result = safeSpawn("ruff", ["format", absolutePath], {
 				timeout: 10000,
-				shell: true,
 			});
 
 			if (result.error) {

package/clients/runner-tracker.js

@@ -0,0 +1,152 @@
+/**
+ * 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/runner-tracker.ts

@@ -0,0 +1,213 @@
+/**
+ * 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 interface TrackedRunner {
+	name: string;
+	status: "running" | "done" | "skipped" | "error";
+	findings: number;
+	elapsedMs: number;
+	message?: string;
+	/** Severity indicator for the runner (derived from findings) */
+	severity?: "error" | "warning" | "info";
+}
+
+export interface RunOptions {
+	/** Index in the sequence (for "[2/9]" style progress) */
+	index?: number;
+	/** Total number of runners (for "[2/9]" style progress) */
+	total?: number;
+}
+
+export class RunnerTracker {
+	private runners: TrackedRunner[] = [];
+	private onProgress?: (runner: TrackedRunner, index: number) => void;
+
+	constructor(options?: { onProgress?: (runner: TrackedRunner, index: number) => void }) {
+		this.onProgress = options?.onProgress;
+	}
+
+	/**
+	 * Run a function with timing and tracking
+	 */
+	async run<T>(
+		name: string,
+		runFn: () => Promise<T> | T,
+		options?: RunOptions,
+	): Promise<T> {
+		const startMs = Date.now();
+		const index = this.runners.length;
+		const runner: TrackedRunner = {
+			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 as { findings?: number }).findings === "number"
+					? (result as { findings: number }).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: string, message?: string): void {
+		this.runners.push({
+			name,
+			status: "skipped",
+			findings: 0,
+			elapsedMs: 0,
+			message,
+		});
+	}
+
+	/**
+	 * Update findings for a runner (useful when findings are discovered asynchronously)
+	 */
+	updateFindings(runnerName: string, findings: number): void {
+		const runner = this.runners.find((r) => r.name === runnerName);
+		if (runner) {
+			runner.findings = findings;
+		}
+	}
+
+	/**
+	 * Get all tracked runners
+	 */
+	getRunners(): TrackedRunner[] {
+		return [...this.runners];
+	}
+
+	/**
+	 * Get summary statistics
+	 */
+	getStats(): {
+		total: number;
+		done: number;
+		skipped: number;
+		errors: number;
+		totalFindings: number;
+		totalTimeMs: number;
+	} {
+		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: TrackedRunner, index?: number): string {
+		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(): string {
+		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
+	 */
+	private formatElapsed(ms: number): string {
+		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<T>(
+	sequence: Array<{
+		name: string;
+		run: () => Promise<T> | T;
+		onFindings?: (result: T) => number;
+	}>,
+	onProgress?: (runner: TrackedRunner, index: number) => void,
+): Promise<{ results: T[]; tracker: RunnerTracker }> {
+	const tracker = new RunnerTracker({ onProgress });
+	const results: T[] = [];
+
+	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

@@ -6,9 +6,9 @@
  * Requires: cargo (rustup)
  * Docs: https://doc.rust-lang.org/cargo/
  */
-import { spawnSync } from "node:child_process";
 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"),
@@ -46,10 +46,8 @@ export class RustClient {
                     }
                 }
                 else {
-                    const result = spawnSync(p, ["--version"], {
-                        encoding: "utf-8",
+                    const result = safeSpawn(p, ["--version"], {
                         timeout: 3000,
-                        shell: true,
                     });
                     if (!result.error && result.status === 0) {
                         this.cargoPath = p;
@@ -92,12 +90,9 @@ export class RustClient {
         if (!fs.existsSync(absolutePath))
             return [];
         try {
-            const cargoCmd = cargoExe.includes(" ") ? `"${cargoExe}"` : cargoExe;
-            const result = spawnSync(cargoCmd, ["check", "--message-format", "json"], {
-                encoding: "utf-8",
+            const result = safeSpawn(cargoExe, ["check", "--message-format", "json"], {
                 timeout: 60000,
                 cwd,
-                shell: true,
             });
             const output = result.stdout || "";
             return this.parseJsonOutput(output, absolutePath);
@@ -114,11 +109,9 @@ export class RustClient {
         if (!this.isAvailable())
             return [];
         try {
-            const result = spawnSync("cargo", ["clippy", "--message-format", "json"], {
-                encoding: "utf-8",
+            const result = safeSpawn("cargo", ["clippy", "--message-format", "json"], {
                 timeout: 60000,
                 cwd,
-                shell: true,
             });
             const output = result.stdout || "";
             return this.parseJsonOutput(output, "");