pi-lens 2.2.9 → 3.0.0

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

@@ -0,0 +1,298 @@
+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: () => {},
+	};
+}
+
+// Helper for safe file cleanup
+function safeUnlink(filePath: string): void {
+	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") as typeof import("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/python-slop.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
+import {
+	createConfigFinder,
+	isSgAvailable,
+} from "./utils/runner-helpers.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const findSlopConfig = createConfigFinder("python-slop-rules");
+
+const pythonSlopRunner: RunnerDefinition = {
+	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: DispatchContext): Promise<RunnerResult> {
+		// 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: string, filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+
+	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/ruff.js

@@ -4,63 +4,33 @@
  * Ruff handles both formatting and linting for Python files.
  * Supports venv-local installations.
  */
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
+import { ensureTool } from "../../installer/index.js";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
-// Cache ruff availability check
-let ruffAvailable = null;
-let ruffCommand = null;
-/**
- * Find ruff command, checking venv first, then global.
- */
-function findRuffCommand(cwd) {
-    const venvPaths = [
-        ".venv/bin/ruff",
-        "venv/bin/ruff",
-        ".venv/Scripts/ruff.exe",
-        "venv/Scripts/ruff.exe",
-    ];
-    for (const venvPath of venvPaths) {
-        const fullPath = path.join(cwd, venvPath);
-        if (fs.existsSync(fullPath)) {
-            return `"${fullPath}"`;
-        }
-    }
-    return "ruff";
-}
-function isRuffAvailable(cwd) {
-    if (ruffAvailable !== null)
-        return ruffAvailable;
-    const command = findRuffCommand(cwd || process.cwd());
-    const check = spawnSync(command, ["--version"], {
-        encoding: "utf-8",
-        timeout: 5000,
-        shell: true,
-    });
-    ruffAvailable = !check.error && check.status === 0;
-    if (ruffAvailable)
-        ruffCommand = command;
-    return ruffAvailable;
-}
+import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+const ruff = createAvailabilityChecker("ruff", ".exe");
 const ruffRunner = {
     id: "ruff-lint",
     appliesTo: ["python"],
     priority: 10,
     enabledByDefault: true,
     async run(ctx) {
-        // Skip if ruff is not installed
-        if (!isRuffAvailable(ctx.cwd || process.cwd())) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
+        const cwd = ctx.cwd || process.cwd();
+        // Auto-install ruff if not available (it's one of the 4 auto-install tools)
+        if (!ruff.isAvailable(cwd)) {
+            const installed = await ensureTool("ruff");
+            if (!installed) {
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
         }
-        // Run ruff check
-        const args = ctx.autofix
-            ? ["check", "--fix", ctx.filePath]
-            : ["check", ctx.filePath];
-        const result = spawnSync(ruffCommand, args, {
-            encoding: "utf-8",
+        // IMPORTANT: Never use --fix in dispatch runner to prevent infinite loops.
+        // Writing to the file would trigger another tool_result event, which would
+        // call dispatchLint again, creating a feedback loop.
+        // Fixes should be applied through explicit commands or user edits.
+        const args = ["check", ctx.filePath];
+        const result = safeSpawn(ruff.getCommand(), args, {
             timeout: 30000,
-            shell: true,
         });
         const raw = stripAnsi(result.stdout + result.stderr);
         if (result.status === 0) {
@@ -75,27 +45,4 @@ const ruffRunner = {
         };
     },
 };
-function parseRuffOutput(raw, filePath) {
-    const lines = raw.split("\n").filter((l) => l.trim());
-    const diagnostics = [];
-    for (const line of lines) {
-        // Parse ruff output: file:line:col: message (code)
-        const match = line.match(/^(.+?):(\d+):(\d+):\s*(.+?)\s+\((.+?)\)/);
-        if (match) {
-            diagnostics.push({
-                id: `ruff-${match[2]}-${match[5]}`,
-                message: `${match[5]}: ${match[4]}`,
-                filePath,
-                line: parseInt(match[2], 10),
-                column: parseInt(match[3], 10),
-                severity: line.includes("error") ? "error" : "warning",
-                semantic: "warning",
-                tool: "ruff",
-                rule: match[5],
-                fixable: true,
-            });
-        }
-    }
-    return diagnostics;
-}
 export default ruffRunner;

package/clients/dispatch/runners/ruff.ts

@@ -5,56 +5,18 @@
  * Supports venv-local installations.
  */
 
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
+import { ensureTool } from "../../installer/index.js";
+import { safeSpawn } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 import type {
-	Diagnostic,
 	DispatchContext,
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 
-// Cache ruff availability check
-let ruffAvailable: boolean | null = null;
-let ruffCommand: string | null = null;
-
-/**
- * Find ruff command, checking venv first, then global.
- */
-function findRuffCommand(cwd: string): string {
-	const venvPaths = [
-		".venv/bin/ruff",
-		"venv/bin/ruff",
-		".venv/Scripts/ruff.exe",
-		"venv/Scripts/ruff.exe",
-	];
-
-	for (const venvPath of venvPaths) {
-		const fullPath = path.join(cwd, venvPath);
-		if (fs.existsSync(fullPath)) {
-			return `"${fullPath}"`;
-		}
-	}
-
-	return "ruff";
-}
-
-function isRuffAvailable(cwd?: string): boolean {
-	if (ruffAvailable !== null) return ruffAvailable;
-
-	const command = findRuffCommand(cwd || process.cwd());
-	const check = spawnSync(command, ["--version"], {
-		encoding: "utf-8",
-		timeout: 5000,
-		shell: true,
-	});
-
-	ruffAvailable = !check.error && check.status === 0;
-	if (ruffAvailable) ruffCommand = command;
-	return ruffAvailable;
-}
+const ruff = createAvailabilityChecker("ruff", ".exe");
 
 const ruffRunner: RunnerDefinition = {
 	id: "ruff-lint",
@@ -63,20 +25,24 @@ const ruffRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// Skip if ruff is not installed
-		if (!isRuffAvailable(ctx.cwd || process.cwd())) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		const cwd = ctx.cwd || process.cwd();
+
+		// Auto-install ruff if not available (it's one of the 4 auto-install tools)
+		if (!ruff.isAvailable(cwd)) {
+			const installed = await ensureTool("ruff");
+			if (!installed) {
+				return { status: "skipped", diagnostics: [], semantic: "none" };
+			}
 		}
 
-		// Run ruff check
-		const args = ctx.autofix
-			? ["check", "--fix", ctx.filePath]
-			: ["check", ctx.filePath];
+		// IMPORTANT: Never use --fix in dispatch runner to prevent infinite loops.
+		// Writing to the file would trigger another tool_result event, which would
+		// call dispatchLint again, creating a feedback loop.
+		// Fixes should be applied through explicit commands or user edits.
+		const args = ["check", ctx.filePath];
 
-		const result = spawnSync(ruffCommand!, args, {
-			encoding: "utf-8",
+		const result = safeSpawn(ruff.getCommand()!, args, {
 			timeout: 30000,
-			shell: true,
 		});
 
 		const raw = stripAnsi(result.stdout + result.stderr);
@@ -96,30 +62,4 @@ const ruffRunner: RunnerDefinition = {
 	},
 };
 
-function parseRuffOutput(raw: string, filePath: string): Diagnostic[] {
-	const lines = raw.split("\n").filter((l) => l.trim());
-	const diagnostics: Diagnostic[] = [];
-
-	for (const line of lines) {
-		// Parse ruff output: file:line:col: message (code)
-		const match = line.match(/^(.+?):(\d+):(\d+):\s*(.+?)\s+\((.+?)\)/);
-		if (match) {
-			diagnostics.push({
-				id: `ruff-${match[2]}-${match[5]}`,
-				message: `${match[5]}: ${match[4]}`,
-				filePath,
-				line: parseInt(match[2], 10),
-				column: parseInt(match[3], 10),
-				severity: line.includes("error") ? "error" : "warning",
-				semantic: "warning",
-				tool: "ruff",
-				rule: match[5],
-				fixable: true,
-			});
-		}
-	}
-
-	return diagnostics;
-}
-
 export default ruffRunner;