pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/rust-clippy.js

@@ -3,7 +3,7 @@
  *
  * Runs `cargo clippy` for Rust files to catch common mistakes.
  */
-import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 const rustClippyRunner = {
     id: "rust-clippy",
@@ -12,10 +12,8 @@ const rustClippyRunner = {
     enabledByDefault: true,
     async run(ctx) {
         // Check if cargo is available
-        const check = spawnSync("cargo", ["--version"], {
-            encoding: "utf-8",
+        const check = safeSpawn("cargo", ["--version"], {
             timeout: 5000,
-            shell: true,
         });
         if (check.error || check.status !== 0) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -26,10 +24,8 @@ const rustClippyRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         // Run cargo clippy on the package
-        const result = spawnSync("cargo", ["clippy", "--message-format=json", "-q"], {
-            encoding: "utf-8",
+        const result = safeSpawn("cargo", ["clippy", "--message-format=json", "-q"], {
             timeout: 60000,
-            shell: true,
             cwd: cargoToml.replace("Cargo.toml", ""),
         });
         const raw = stripAnsi(result.stdout + result.stderr);
@@ -57,8 +53,8 @@ const rustClippyRunner = {
 function findCargoToml(filePath) {
     const { dirname, join } = require("node:path");
     const { existsSync } = require("node:fs");
-    let dir = filePath;
-    for (let i = 0; i < 10; i++) {
+    let dir = dirname(filePath);
+    while (dir !== "/" && dir !== ".") {
         const cargoPath = join(dir, "Cargo.toml");
         if (existsSync(cargoPath)) {
             return cargoPath;
@@ -70,35 +66,35 @@ function findCargoToml(filePath) {
     }
     return undefined;
 }
-function parseClippyOutput(raw, targetFile) {
+function parseClippyOutput(raw, filePath) {
     const diagnostics = [];
-    const lines = raw.split("\n");
+    const lines = raw.split("\n").filter((l) => l.trim());
     for (const line of lines) {
-        if (!line.trim())
-            continue;
         try {
             const msg = JSON.parse(line);
-            if (msg.message?.spans) {
-                for (const span of msg.message.spans) {
-                    if (span.file_name?.includes(targetFile.replace(/\\/g, "/"))) {
-                        const diagFilePath = targetFile;
-                        diagnostics.push({
-                            id: `clippy-${span.line_start || 0}-${msg.message.code?.code || "unknown"}`,
-                            message: msg.message.message,
-                            filePath: diagFilePath,
-                            line: span.line_start,
-                            column: span.column_start,
-                            severity: msg.level === "error" ? "error" : "warning",
-                            semantic: msg.level === "error" ? "blocking" : "warning",
-                            tool: "clippy",
-                            rule: msg.message.code?.code || "clippy",
-                        });
-                    }
-                }
-            }
+            if (msg.reason !== "compiler-message")
+                continue;
+            const message = msg.message;
+            if (!message)
+                continue;
+            // Only include messages for this file or project-wide
+            const span = message.spans?.[0];
+            if (!span)
+                continue;
+            diagnostics.push({
+                id: `clippy-${message.code?.code || "unknown"}`,
+                message: message.message || "Clippy warning",
+                filePath: span.file || filePath,
+                line: span.line_start || 0,
+                column: span.column_start || 0,
+                severity: message.level === "error" ? "error" : "warning",
+                semantic: message.level === "error" ? "blocking" : "warning",
+                tool: "rust-clippy",
+                rule: message.code?.code,
+            });
         }
         catch {
-            // Not JSON, skip
+            // Not a JSON line, skip
         }
     }
     return diagnostics;

package/clients/dispatch/runners/rust-clippy.ts

@@ -5,6 +5,7 @@
  */
 
 import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 import type {
 	Diagnostic,
@@ -21,10 +22,8 @@ const rustClippyRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Check if cargo is available
-		const check = spawnSync("cargo", ["--version"], {
-			encoding: "utf-8",
+		const check = safeSpawn("cargo", ["--version"], {
 			timeout: 5000,
-			shell: true,
 		});
 
 		if (check.error || check.status !== 0) {
@@ -38,13 +37,11 @@ const rustClippyRunner: RunnerDefinition = {
 		}
 
 		// Run cargo clippy on the package
-		const result = spawnSync(
+		const result = safeSpawn(
 			"cargo",
 			["clippy", "--message-format=json", "-q"],
 			{
-				encoding: "utf-8",
 				timeout: 60000,
-				shell: true,
 				cwd: cargoToml.replace("Cargo.toml", ""),
 			},
 		);
@@ -80,8 +77,8 @@ function findCargoToml(filePath: string): string | undefined {
 	const { dirname, join } = require("node:path");
 	const { existsSync } = require("node:fs");
 
-	let dir = filePath;
-	for (let i = 0; i < 10; i++) {
+	let dir = dirname(filePath);
+	while (dir !== "/" && dir !== ".") {
 		const cargoPath = join(dir, "Cargo.toml");
 		if (existsSync(cargoPath)) {
 			return cargoPath;
@@ -90,38 +87,39 @@ function findCargoToml(filePath: string): string | undefined {
 		if (parent === dir) break;
 		dir = parent;
 	}
+
 	return undefined;
 }
 
-function parseClippyOutput(raw: string, targetFile: string): Diagnostic[] {
+function parseClippyOutput(raw: string, filePath: string): Diagnostic[] {
 	const diagnostics: Diagnostic[] = [];
-	const lines = raw.split("\n");
+	const lines = raw.split("\n").filter((l) => l.trim());
 
 	for (const line of lines) {
-		if (!line.trim()) continue;
-
 		try {
 			const msg = JSON.parse(line);
-			if (msg.message?.spans) {
-				for (const span of msg.message.spans) {
-					if (span.file_name?.includes(targetFile.replace(/\\/g, "/"))) {
-						const diagFilePath = targetFile;
-						diagnostics.push({
-							id: `clippy-${span.line_start || 0}-${msg.message.code?.code || "unknown"}`,
-							message: msg.message.message,
-							filePath: diagFilePath,
-							line: span.line_start,
-							column: span.column_start,
-							severity: msg.level === "error" ? "error" : "warning",
-							semantic: msg.level === "error" ? "blocking" : "warning",
-							tool: "clippy",
-							rule: msg.message.code?.code || "clippy",
-						});
-					}
-				}
-			}
+			if (msg.reason !== "compiler-message") continue;
+
+			const message = msg.message;
+			if (!message) continue;
+
+			// Only include messages for this file or project-wide
+			const span = message.spans?.[0];
+			if (!span) continue;
+
+			diagnostics.push({
+				id: `clippy-${message.code?.code || "unknown"}`,
+				message: message.message || "Clippy warning",
+				filePath: span.file || filePath,
+				line: span.line_start || 0,
+				column: span.column_start || 0,
+				severity: message.level === "error" ? "error" : "warning",
+				semantic: message.level === "error" ? "blocking" : "warning",
+				tool: "rust-clippy",
+				rule: message.code?.code,
+			});
 		} catch {
-			// Not JSON, skip
+			// Not a JSON line, skip
 		}
 	}
 

package/clients/dispatch/runners/scan_codebase.test.js

@@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+// Find all TS files
+function findTsFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        // Skip node_modules, .git, etc
+        if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".pi-lens") {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...findTsFiles(fullPath));
+        }
+        else if (entry.isFile() && fullPath.endsWith(".ts") && !fullPath.endsWith(".test.ts")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function createContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "jsts",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+describe("Codebase scan with NAPI runner", () => {
+    it("should scan all TypeScript files and report findings", async () => {
+        const tsFiles = findTsFiles(process.cwd());
+        console.log(`\nFound ${tsFiles.length} TypeScript files to scan\n`);
+        const runner = (await import("./ast-grep-napi.js")).default;
+        const allIssues = [];
+        let totalTime = 0;
+        let filesWithIssues = 0;
+        for (let i = 0; i < Math.min(tsFiles.length, 50); i++) { // Limit to 50 for test speed
+            const file = tsFiles[i];
+            const ctx = createContext(file);
+            const start = Date.now();
+            const result = await runner.run(ctx);
+            const elapsed = Date.now() - start;
+            totalTime += elapsed;
+            if (result.diagnostics.length > 0) {
+                filesWithIssues++;
+                console.log(`${path.relative(process.cwd(), file)} (${elapsed}ms):`);
+                for (const d of result.diagnostics.slice(0, 5)) { // Show max 5 per file
+                    const line = d.line ?? 0;
+                    const rule = d.rule ?? "unknown";
+                    const message = d.message?.split('\n')[0] ?? "";
+                    console.log(`  Line ${line}: [${rule}] ${message}`);
+                    allIssues.push({
+                        file: path.relative(process.cwd(), file),
+                        line,
+                        rule,
+                        message,
+                    });
+                }
+                if (result.diagnostics.length > 5) {
+                    console.log(`  ... and ${result.diagnostics.length - 5} more`);
+                }
+            }
+        }
+        console.log(`\n=== SUMMARY (first 50 files) ===`);
+        console.log(`Files scanned: ${Math.min(tsFiles.length, 50)}/${tsFiles.length}`);
+        console.log(`Total time: ${totalTime}ms`);
+        console.log(`Files with issues: ${filesWithIssues}`);
+        console.log(`Total issues: ${allIssues.length}`);
+        console.log(`Avg time per file: ${(totalTime / Math.min(tsFiles.length, 50)).toFixed(1)}ms`);
+        // Group by rule
+        const byRule = {};
+        for (const issue of allIssues) {
+            byRule[issue.rule] = (byRule[issue.rule] || 0) + 1;
+        }
+        console.log(`\n=== BY RULE ===`);
+        for (const [rule, count] of Object.entries(byRule).sort((a, b) => b[1] - a[1])) {
+            console.log(`  ${rule}: ${count}`);
+        }
+        // This test should pass - we're just scanning
+        expect(true).toBe(true);
+    }, 60000); // 60 second timeout for scanning
+});

package/clients/dispatch/runners/scan_codebase.test.ts

@@ -0,0 +1,105 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import type { DispatchContext } from "../types.js";
+
+// Find all TS files
+function findTsFiles(dir: string): string[] {
+	const files: string[] = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		
+		// Skip node_modules, .git, etc
+		if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".pi-lens") {
+			continue;
+		}
+		
+		if (entry.isDirectory()) {
+			files.push(...findTsFiles(fullPath));
+		} else if (entry.isFile() && fullPath.endsWith(".ts") && !fullPath.endsWith(".test.ts")) {
+			files.push(fullPath);
+		}
+	}
+	
+	return files;
+}
+
+function createContext(filePath: string): DispatchContext {
+	return {
+		filePath,
+		cwd: process.cwd(),
+		kind: "jsts",
+		autofix: false,
+		deltaMode: false,
+		baselines: { get: () => [], add: () => {}, save: () => {} } as any,
+		pi: {} as any,
+		hasTool: async () => false,
+		log: () => {},
+	};
+}
+
+describe("Codebase scan with NAPI runner", () => {
+	it("should scan all TypeScript files and report findings", async () => {
+		const tsFiles = findTsFiles(process.cwd());
+		console.log(`\nFound ${tsFiles.length} TypeScript files to scan\n`);
+		
+		const runner = (await import("./ast-grep-napi.js")).default;
+		
+		const allIssues: Array<{ file: string; line: number; rule: string; message: string }> = [];
+		let totalTime = 0;
+		let filesWithIssues = 0;
+		
+		for (let i = 0; i < Math.min(tsFiles.length, 50); i++) { // Limit to 50 for test speed
+			const file = tsFiles[i];
+			const ctx = createContext(file);
+			
+			const start = Date.now();
+			const result = await runner.run(ctx);
+			const elapsed = Date.now() - start;
+			totalTime += elapsed;
+			
+			if (result.diagnostics.length > 0) {
+				filesWithIssues++;
+				console.log(`${path.relative(process.cwd(), file)} (${elapsed}ms):`);
+				for (const d of result.diagnostics.slice(0, 5)) { // Show max 5 per file
+					const line = d.line ?? 0;
+					const rule = d.rule ?? "unknown";
+					const message = d.message?.split('\n')[0] ?? "";
+					console.log(`  Line ${line}: [${rule}] ${message}`);
+					allIssues.push({
+						file: path.relative(process.cwd(), file),
+						line,
+						rule,
+						message,
+					});
+				}
+				if (result.diagnostics.length > 5) {
+					console.log(`  ... and ${result.diagnostics.length - 5} more`);
+				}
+			}
+		}
+		
+		console.log(`\n=== SUMMARY (first 50 files) ===`);
+		console.log(`Files scanned: ${Math.min(tsFiles.length, 50)}/${tsFiles.length}`);
+		console.log(`Total time: ${totalTime}ms`);
+		console.log(`Files with issues: ${filesWithIssues}`);
+		console.log(`Total issues: ${allIssues.length}`);
+		console.log(`Avg time per file: ${(totalTime / Math.min(tsFiles.length, 50)).toFixed(1)}ms`);
+		
+		// Group by rule
+		const byRule: Record<string, number> = {};
+		for (const issue of allIssues) {
+			byRule[issue.rule] = (byRule[issue.rule] || 0) + 1;
+		}
+		
+		console.log(`\n=== BY RULE ===`);
+		for (const [rule, count] of Object.entries(byRule).sort((a, b) => b[1] - a[1])) {
+			console.log(`  ${rule}: ${count}`);
+		}
+		
+		// This test should pass - we're just scanning
+		expect(true).toBe(true);
+	}, 60000); // 60 second timeout for scanning
+});

package/clients/dispatch/runners/shellcheck.js

@@ -0,0 +1,147 @@
+/**
+ * Shellcheck runner for dispatch system
+ *
+ * Industry-standard linter for shell scripts (bash, sh, zsh).
+ * Detects syntax errors, undefined variables, quoting issues, and best practices.
+ *
+ * Why shellcheck?
+ * - Industry standard (used in CI/CD everywhere)
+ * - Comprehensive checks (syntax, variables, quotes, best practices)
+ * - JSON output for easy parsing
+ * - Available on all platforms (apt, brew, cargo, etc.)
+ *
+ * Alternative considered: bash-language-server
+ * - LSP approach like OpenCode uses
+ * - Richer features but heavier
+ * - shellcheck is simpler and faster for basic linting
+ *
+ * Install: apt install shellcheck, brew install shellcheck, or cargo install shellcheck
+ *
+ * Config: .shellcheckrc (optional, zero-config works)
+ */
+import { safeSpawn } from "../../safe-spawn.js";
+import { createAvailabilityChecker, createConfigFinder, } from "./utils/runner-helpers.js";
+const shellcheck = createAvailabilityChecker("shellcheck", ".exe");
+const findShellcheckConfig = createConfigFinder(".shellcheckrc");
+/**
+ * Parse shellcheck JSON output
+ *
+ * Format: Array of check objects
+ * [{
+ *   "file": "script.sh",
+ *   "line": 10,
+ *   "endLine": 10,
+ *   "column": 5,
+ *   "endColumn": 10,
+ *   "level": "warning",
+ *   "code": 2154,
+ *   "message": "var is referenced but not assigned.",
+ *   "fix": null
+ * }]
+ *
+ * Levels: "error", "warning", "info", "style"
+ */
+function parseShellcheckOutput(raw, filePath) {
+    const diagnostics = [];
+    if (!raw.trim()) {
+        return diagnostics;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return diagnostics;
+        }
+        for (const item of parsed) {
+            if (!item.message || !item.line)
+                continue;
+            // Map shellcheck levels to our severity
+            const severityMap = {
+                error: "error",
+                warning: "warning",
+                info: "info",
+                style: "info",
+            };
+            const severity = severityMap[item.level || "warning"] || "warning";
+            const ruleCode = item.code ? `SC${item.code}` : "unknown";
+            diagnostics.push({
+                id: `shellcheck-${item.line}-${ruleCode}`,
+                message: `[${ruleCode}] ${item.message}`,
+                filePath,
+                line: item.line,
+                column: item.column || 1,
+                severity,
+                semantic: severity === "error" ? "blocking" : "warning",
+                tool: "shellcheck",
+                rule: ruleCode,
+                fixable: !!item.fix,
+            });
+        }
+    }
+    catch {
+        // JSON parse failed, return empty
+        return diagnostics;
+    }
+    return diagnostics;
+}
+const shellcheckRunner = {
+    id: "shellcheck",
+    appliesTo: ["shell"],
+    priority: 20,
+    enabledByDefault: true,
+    skipTestFiles: false, // Shell scripts in test directories should still be checked
+    async run(ctx) {
+        // Skip if shellcheck is not installed
+        if (!shellcheck.isAvailable(ctx.cwd || process.cwd())) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Check if user explicitly disabled shellcheck
+        if (ctx.pi.getFlag("no-shellcheck")) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Determine shell dialect from file extension
+        const shellDialect = ctx.filePath.endsWith(".zsh")
+            ? "bash"
+            : ctx.filePath.endsWith(".fish")
+                ? "bash"
+                : ctx.filePath.endsWith(".sh")
+                    ? "bash"
+                    : "bash"; // Default to bash for generic shell files
+        // Build args
+        // --format json: JSON output
+        // --shell: Specify shell dialect (bash, sh, zsh, ksh, busybox)
+        // --severity: Minimum severity (we'll filter ourselves)
+        const args = [
+            "--format",
+            "json",
+            "--shell",
+            shellDialect,
+        ];
+        // Check for config file
+        const configPath = findShellcheckConfig(ctx.cwd);
+        if (!configPath) {
+            // No config file, use default settings
+            // Exclude "style" and "info" by default to reduce noise
+            args.push("--severity", "warning");
+        }
+        args.push(ctx.filePath);
+        const result = safeSpawn(shellcheck.getCommand(), args, {
+            timeout: 15000,
+        });
+        // shellcheck exits with code 1 if issues found, 0 if clean
+        if (result.status === 0 && !result.stdout?.trim()) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        // Parse diagnostics
+        const raw = result.stdout + result.stderr;
+        const diagnostics = parseShellcheckOutput(raw, ctx.filePath);
+        if (diagnostics.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        return {
+            status: "failed",
+            diagnostics,
+            semantic: "warning",
+        };
+    },
+};
+export default shellcheckRunner;

package/clients/dispatch/runners/shellcheck.test.js

@@ -0,0 +1,98 @@
+/**
+ * Tests for shellcheck runner
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "shell",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+// Helper for safe file cleanup
+function safeUnlink(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors on Windows
+    }
+}
+describe("shellcheck runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const shellcheckModule = await import("./shellcheck.js");
+        const runner = shellcheckModule.default;
+        expect(runner.id).toBe("shellcheck");
+        expect(runner.appliesTo).toEqual(["shell"]);
+        expect(runner.priority).toBe(20);
+        expect(runner.enabledByDefault).toBe(true);
+        expect(runner.skipTestFiles).toBe(false);
+    });
+    it("should detect shellcheck availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("shellcheck", ["--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBeTruthy();
+    });
+    it("should detect undefined variable", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `shellcheck_test_${Date.now()}.sh`);
+        fs.writeFileSync(tmpFile, ["#!/bin/bash", "# Test script with issues", 'echo "\$UNDEFINED_VAR"', ""].join("\n"));
+        try {
+            const shellcheckModule = await import("./shellcheck.js");
+            const runner = shellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+                expect(result.diagnostics.some((d) => d.tool === "shellcheck" &&
+                    (d.message.includes("undefined") ||
+                        d.message.includes("SC2154")))).toBe(true);
+            }
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should pass clean shell scripts", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `shellcheck_ok_${Date.now()}.sh`);
+        fs.writeFileSync(tmpFile, [
+            "#!/bin/bash",
+            "# Clean shell script",
+            "set -euo pipefail",
+            "",
+            "main() {",
+            '    local name="\${1:-world}"',
+            '    echo "Hello, \${name}!"',
+            "}",
+            "",
+            'main "\$@"',
+            "",
+        ].join("\n"));
+        try {
+            const shellcheckModule = await import("./shellcheck.js");
+            const runner = shellcheckModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                expect(result.diagnostics.length).toBe(0);
+                expect(result.status).toBe("succeeded");
+            }
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+});