pi-lens 3.6.2 → 3.6.4

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

@@ -1,98 +0,0 @@
-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/pyright.test.ts

@@ -1,121 +0,0 @@
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-import type { DispatchContext } from "../types.js";
-
-function createMockContext(filePath: string): DispatchContext {
-	return {
-		filePath,
-		cwd: process.cwd(),
-		kind: "python" as any,
-		autofix: false,
-		deltaMode: false,
-		baselines: { get: () => [], add: () => {}, save: () => {} } as any,
-		pi: {} as any,
-		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") as typeof import("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.js

@@ -1,97 +0,0 @@
-/**
- * Python Slop runner for dispatch system
- *
- * Detects "slop" patterns in Python code:
- * - Verbose patterns (ceremony that adds no value)
- * - Defensive over-checking (excessive guards)
- * - Manual reimplementation of builtins
- * - Unnecessary object allocations
- *
- * Based on slop-code-bench: https://github.com/SprocketLab/slop-code-bench
- */
-import { safeSpawn } from "../../safe-spawn.js";
-import { createConfigFinder, isSgAvailable, } from "./utils/runner-helpers.js";
-const findSlopConfig = createConfigFinder("python-slop-rules");
-const pythonSlopRunner = {
-    id: "python-slop",
-    appliesTo: ["python"],
-    priority: 25, // Between pyright (5) and ruff (10)
-    enabledByDefault: true,
-    skipTestFiles: true, // Slop rules can be noisy in test files
-    async run(ctx) {
-        // Check if ast-grep is available
-        if (!isSgAvailable()) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Find slop config
-        const configPath = findSlopConfig(ctx.cwd);
-        if (!configPath) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run ast-grep scan
-        const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
-        const result = safeSpawn("npx", args, {
-            timeout: 30000,
-        });
-        const raw = result.stdout + result.stderr;
-        if (result.status === 0 && !raw.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse results
-        const diagnostics = parseSlopOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-function parseSlopOutput(raw, filePath) {
-    const diagnostics = [];
-    try {
-        // Try to parse as JSON first
-        const data = JSON.parse(raw);
-        const items = Array.isArray(data) ? data : [data];
-        for (const item of items) {
-            const rule = item.rule || "slop";
-            const message = item.message || "Pattern detected";
-            const severity = item.severity || "warning";
-            diagnostics.push({
-                id: `python-slop-${rule}`,
-                message,
-                filePath,
-                line: item.start?.line || 0,
-                column: item.start?.column || 0,
-                severity: severity === "error" ? "error" : "warning",
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "python-slop",
-                rule,
-            });
-        }
-    }
-    catch {
-        // Not JSON, try line-by-line parsing
-        const lines = raw.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-            // Try to extract line numbers from typical output formats
-            const match = line.match(/:(\d+):/);
-            if (match) {
-                diagnostics.push({
-                    id: "python-slop-pattern",
-                    message: line.trim(),
-                    filePath,
-                    line: parseInt(match[1], 10),
-                    column: 0,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "python-slop",
-                });
-            }
-        }
-    }
-    return diagnostics;
-}
-export default pythonSlopRunner;

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

@@ -1,203 +0,0 @@
-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);
-        }
-    });
-});