pi-lens 3.2.0 → 3.3.1

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

@@ -0,0 +1,230 @@
+/**
+ * Tests for oxlint runner
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+/**
+ * Delay helper for Windows file cleanup
+ * Windows may hold file handles briefly after process exit
+ */
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createMockContext(filePath, overrides = {}) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "jsts",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: { getFlag: () => false, ...overrides.pi },
+        hasTool: async () => false,
+        log: () => { },
+        ...overrides,
+    };
+}
+describe("oxlint runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const oxlintModule = await import("./oxlint.js");
+        const runner = oxlintModule.default;
+        expect(runner.id).toBe("oxlint");
+        expect(runner.appliesTo).toEqual(["jsts"]);
+        expect(runner.priority).toBe(12);
+        expect(runner.enabledByDefault).toBe(false); // Opt-in initially
+        expect(runner.skipTestFiles).toBe(true);
+    });
+    it("should detect oxlint availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("oxlint", ["--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBeTruthy(); // May or may not be installed
+    });
+    it("should detect common lint issues", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_test_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `// Test file with issues
+function test() {
+	// Double negation
+	const flag = !!value;
+	
+	// Unused variable
+	const unused = 42;
+	
+	// Console statement
+	console.log("test");
+}
+`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // If oxlint is installed, should detect issues
+            // If not installed, will be skipped
+            if (result.status !== "skipped") {
+                // Should detect at least some issues (console, unused vars, etc.)
+                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+                expect(result.diagnostics.some((d) => d.tool === "oxlint" &&
+                    (d.message.includes("console") ||
+                        d.message.includes("unused") ||
+                        d.message.includes("!!")))).toBe(true);
+            }
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should respect no-oxlint flag", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_flag_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `function test() { console.log("test"); }`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            // Create context with no-oxlint flag set to true
+            const ctxWithFlag = createMockContext(tmpFile, {
+                pi: { getFlag: (name) => name === "no-oxlint" },
+            });
+            const result = await runner.run(ctxWithFlag);
+            expect(result.status).toBe("skipped");
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should provide fix suggestions when available", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_fix_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `// File with auto-fixable issues
+const x = !!value;
+`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped" && result.diagnostics.length > 0) {
+                // Some issues should be fixable
+                const fixableDiags = result.diagnostics.filter((d) => d.fixable);
+                // At least some diagnostics should have fixes
+                expect(fixableDiags.length).toBeGreaterThanOrEqual(0);
+            }
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should pass clean TypeScript files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_ok_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `// Clean TypeScript file
+function greet(name: string): string {
+	return \`Hello, \${name}!\`;
+}
+
+const result = greet("world");
+export { greet };
+`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                // Clean files should have no issues
+                expect(result.diagnostics.length).toBe(0);
+                expect(result.status).toBe("succeeded");
+            }
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should handle JSON output correctly", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_json_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `const unused = 1;`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (result.status !== "skipped") {
+                // All diagnostics should have required fields
+                for (const diag of result.diagnostics) {
+                    expect(diag.id).toBeDefined();
+                    expect(diag.message).toBeDefined();
+                    expect(diag.tool).toBe("oxlint");
+                    expect(diag.line).toBeGreaterThanOrEqual(1);
+                    expect(diag.severity).toMatch(/^(error|warning|info)$/);
+                }
+            }
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should skip when oxlint is not available", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_skip_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `const x = 1;`);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            // Check if oxlint is available
+            const { spawnSync } = require("node:child_process");
+            const checkResult = spawnSync("oxlint", ["--version"], {
+                encoding: "utf-8",
+                timeout: 5000,
+                shell: true,
+            });
+            const isAvailable = !checkResult.error && checkResult.status === 0;
+            const result = await runner.run(createMockContext(tmpFile));
+            if (!isAvailable) {
+                expect(result.status).toBe("skipped");
+                expect(result.diagnostics).toHaveLength(0);
+            }
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+    it("should handle parsing errors gracefully", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `oxlint_parse_${Date.now()}.ts`);
+        // Intentionally malformed file
+        fs.writeFileSync(tmpFile, `const x = `);
+        try {
+            const oxlintModule = await import("./oxlint.js");
+            const runner = oxlintModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should handle parse errors without crashing
+            expect(["succeeded", "failed", "skipped"]).toContain(result.status);
+        }
+        finally {
+            // Windows may hold file handles briefly - add small delay
+            await delay(100);
+            if (fs.existsSync(tmpFile)) {
+                fs.unlinkSync(tmpFile);
+            }
+        }
+    });
+});

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

@@ -0,0 +1,98 @@
+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: "python",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+describe("pyright runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const pyrightModule = await import("./pyright.js");
+        const runner = pyrightModule.default;
+        expect(runner.id).toBe("pyright");
+        expect(runner.appliesTo).toEqual(["python"]);
+        expect(runner.priority).toBe(5); // Higher priority than ruff
+        expect(runner.enabledByDefault).toBe(true);
+    });
+    it("should detect pyright availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("npx", ["pyright", "--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBe("available");
+    });
+    it("should type-check Python files and find errors", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `pyright_test_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `def add(x: int, y: int) -> int:
+    return x + y
+
+result: str = add(1, 2)
+
+def greet(name: str) -> str:
+    return "Hello " + name
+
+greet(123)
+`);
+        try {
+            const pyrightModule = await import("./pyright.js");
+            const runner = pyrightModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(2);
+            expect(result.diagnostics.some((d) => d.tool === "pyright")).toBe(true);
+            expect(result.diagnostics.some((d) => d.severity === "error")).toBe(true);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    });
+    it("should pass valid Python files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `pyright_test_ok_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `def add(x: int, y: int) -> int:
+    return x + y
+
+result: str = str(add(1, 2))
+
+def greet(name: str) -> str:
+    return "Hello " + name
+
+greet("world")
+`);
+        try {
+            const pyrightModule = await import("./pyright.js");
+            const runner = pyrightModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.status).toBe("succeeded");
+            expect(result.diagnostics.length).toBe(0);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    });
+});

package/clients/dispatch/runners/python-slop.test.js

@@ -0,0 +1,203 @@
+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: "python",
+        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("python-slop runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const slopModule = await import("./python-slop.js");
+        const runner = slopModule.default;
+        expect(runner.id).toBe("python-slop");
+        expect(runner.appliesTo).toEqual(["python"]);
+        expect(runner.priority).toBe(25);
+        expect(runner.enabledByDefault).toBe(true);
+        expect(runner.skipTestFiles).toBe(true);
+    });
+    it("should detect ast-grep availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("npx", ["sg", "--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBe("available");
+    });
+    it("should detect verbose range-len pattern", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_range_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: using range(len()) instead of enumerate
+def process_items(items):
+    for i in range(len(items)):
+        print(items[i])
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("range(len") &&
+                d.message.includes("enumerate"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect manual min/max pattern", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_minmax_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: manual min/max instead of built-in
+def find_max(a, b):
+    if a > b:
+        m = a
+    else:
+        m = b
+    return m
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                (d.message.includes("min") || d.message.includes("max")))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect defensive None guard", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_guard_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: defensive None guard
+def process(data):
+    if data is None:
+        return None
+    return data.upper()
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                (d.message.includes("defensive") ||
+                    d.message.includes("guard")))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect list comprehension ceremony", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_list_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: redundant list comprehension
+def convert(items):
+    return [x for x in items]
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("list") &&
+                d.message.includes("unnecessary"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect chained comparison opportunity", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_chain_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: could use chained comparison
+def check_range(x, a, b):
+    return a < x and x < b
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("chained"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should pass clean Python files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_ok_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Clean Python code
+def process_items(items):
+    """Process items using proper Python idioms."""
+    for i, item in enumerate(items):
+        print(f"{i}: {item}")
+
+def find_max(a, b):
+    return max(a, b)
+
+def check_range(x, min_val, max_val):
+    return min_val < x < max_val
+
+def convert(items):
+    return list(items)
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should have no slop issues
+            const slopIssues = result.diagnostics.filter((d) => d.tool === "python-slop");
+            expect(slopIssues.length).toBe(0);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should categorize by weight correctly", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_weight_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Multiple slop patterns - weight 3 and weight 4
+def bad_code(items):
+    # Weight 3: range(len)
+    for i in range(len(items)):
+        print(items[i])
+    
+    # Weight 3: redundant list comprehension  
+    return [x for x in items]
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should detect at least the range(len) pattern
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            // All should be warnings (weight 3)
+            const warnings = result.diagnostics.filter((d) => d.severity === "warning");
+            expect(warnings.length).toBeGreaterThanOrEqual(1);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+});

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
+});