pi-lens 3.6.2 → 3.6.4

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

@@ -1,298 +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: () => {},
-	};
-}
-
-// 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/ruff.js

@@ -1,48 +0,0 @@
-/**
- * Ruff runner for dispatch system
- *
- * Ruff handles both formatting and linting for Python files.
- * Supports venv-local installations.
- */
-import { ensureTool } from "../../installer/index.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-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) {
-        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" };
-            }
-        }
-        // 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 = await safeSpawnAsync(ruff.getCommand(), args, {
-            timeout: 30000,
-        });
-        const raw = stripAnsi(result.stdout + result.stderr);
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse diagnostics
-        const diagnostics = parseRuffOutput(raw, ctx.filePath);
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-export default ruffRunner;

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

@@ -1,102 +0,0 @@
-/**
- * Rust clippy runner for dispatch system
- *
- * Runs `cargo clippy` for Rust files to catch common mistakes.
- */
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { safeSpawn } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-const rustClippyRunner = {
-    id: "rust-clippy",
-    appliesTo: ["rust"],
-    priority: 15,
-    enabledByDefault: true,
-    async run(ctx) {
-        // Check if cargo is available
-        const check = safeSpawn("cargo", ["--version"], {
-            timeout: 5000,
-        });
-        if (check.error || check.status !== 0) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Find the package root (where Cargo.toml is)
-        const cargoToml = findCargoToml(ctx.filePath);
-        if (!cargoToml) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run cargo clippy on the package
-        const result = safeSpawn("cargo", ["clippy", "--message-format=json", "-q"], {
-            timeout: 60000,
-            cwd: cargoToml.replace("Cargo.toml", ""),
-        });
-        const raw = stripAnsi(result.stdout + result.stderr);
-        if (result.status === 0 && !raw.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse JSON output
-        const diagnostics = parseClippyOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            // Non-parseable output
-            return {
-                status: "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw.substring(0, 500),
-            };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-function findCargoToml(filePath) {
-    let dir = dirname(filePath);
-    while (dir !== "/" && dir !== ".") {
-        const cargoPath = join(dir, "Cargo.toml");
-        if (existsSync(cargoPath)) {
-            return cargoPath;
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return undefined;
-}
-function parseClippyOutput(raw, filePath) {
-    const diagnostics = [];
-    const lines = raw.split("\n").filter((l) => l.trim());
-    for (const line of lines) {
-        try {
-            const msg = JSON.parse(line);
-            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 a JSON line, skip
-        }
-    }
-    return diagnostics;
-}
-export default rustClippyRunner;

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

@@ -1,89 +0,0 @@
-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

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