pi-lens 3.1.2 → 3.2.0

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

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/shellcheck.test.js

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

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

@@ -1,158 +0,0 @@
-/**
- * Tests for spellcheck runner (typos-cli)
- */
-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: "markdown",
-        autofix: false,
-        deltaMode: false,
-        baselines: { get: () => [], add: () => { }, save: () => { } },
-        pi: {},
-        hasTool: async () => false,
-        log: () => { },
-    };
-}
-describe("spellcheck runner", () => {
-    const require = createRequire(import.meta.url);
-    it("should have correct runner definition", async () => {
-        const spellcheckModule = await import("./spellcheck.js");
-        const runner = spellcheckModule.default;
-        expect(runner.id).toBe("spellcheck");
-        expect(runner.appliesTo).toEqual(["markdown"]);
-        expect(runner.priority).toBe(30);
-        expect(runner.enabledByDefault).toBe(true);
-        expect(runner.skipTestFiles).toBe(false); // Check docs in test files too
-    });
-    it("should detect typos-cli availability", () => {
-        const { spawnSync } = require("node:child_process");
-        const result = spawnSync("typos", ["--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 typos in markdown content", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_test_${Date.now()}.md`);
-        fs.writeFileSync(tmpFile, `# README
-
-This is a documnet about recieving data.
-The seperation of concerns is important.
-`);
-        try {
-            const spellcheckModule = await import("./spellcheck.js");
-            const runner = spellcheckModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            // If typos-cli is installed, should detect typos
-            // If not installed, will be skipped
-            if (result.status !== "skipped") {
-                // Should detect at least "documnet" and "recieving"
-                expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
-                expect(result.diagnostics.some((d) => d.tool === "typos" &&
-                    (d.message.includes("documnet") ||
-                        d.message.includes("recieving") ||
-                        d.message.includes("seperation")))).toBe(true);
-            }
-        }
-        finally {
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should suggest corrections for typos", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_fix_${Date.now()}.md`);
-        fs.writeFileSync(tmpFile, `# Test
-
-This is a recieving test.
-`);
-        try {
-            const spellcheckModule = await import("./spellcheck.js");
-            const runner = spellcheckModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (result.status !== "skipped" && result.diagnostics.length > 0) {
-                // Should have fix suggestions
-                const fixableDiags = result.diagnostics.filter((d) => d.fixable);
-                expect(fixableDiags.length).toBeGreaterThanOrEqual(1);
-                expect(fixableDiags.some((d) => d.fixSuggestion?.toLowerCase().includes("receive"))).toBe(true);
-            }
-        }
-        finally {
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should pass clean markdown files", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_ok_${Date.now()}.md`);
-        fs.writeFileSync(tmpFile, `# Clean README
-
-This is a correct document about receiving data.
-The separation of concerns is important.
-All spelling is proper in this file.
-`);
-        try {
-            const spellcheckModule = await import("./spellcheck.js");
-            const runner = spellcheckModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            if (result.status !== "skipped") {
-                // Should have no typos
-                expect(result.diagnostics.length).toBe(0);
-                expect(result.status).toBe("succeeded");
-            }
-        }
-        finally {
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should handle JSON parse errors gracefully", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_json_${Date.now()}.md`);
-        fs.writeFileSync(tmpFile, `# Test\n\nSimple file.`);
-        try {
-            const spellcheckModule = await import("./spellcheck.js");
-            const runner = spellcheckModule.default;
-            const result = await runner.run(createMockContext(tmpFile));
-            // Should not crash on JSON parse issues
-            expect(["succeeded", "failed", "skipped"]).toContain(result.status);
-        }
-        finally {
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-    it("should skip when typos-cli is not available", async () => {
-        const tmpFile = path.join(process.env.TEMP || "/tmp", `spellcheck_skip_${Date.now()}.md`);
-        fs.writeFileSync(tmpFile, `# Test\n\nContent with typo: recieve.`);
-        try {
-            const spellcheckModule = await import("./spellcheck.js");
-            const runner = spellcheckModule.default;
-            // Check if typos is available
-            const { spawnSync } = require("node:child_process");
-            const checkResult = spawnSync("typos", ["--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 {
-            if (fs.existsSync(tmpFile)) {
-                fs.unlinkSync(tmpFile);
-            }
-        }
-    });
-});