pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/index.js

@@ -3,22 +3,42 @@
  */
 import { registerRunner } from "../dispatcher.js";
 import architectRunner from "./architect.js";
-// Import all runners
 import astGrepRunner from "./ast-grep.js";
+// Import all runners
+import astGrepNapiRunner from "./ast-grep-napi.js";
 import biomeRunner from "./biome.js";
+import configValidationRunner from "./config-validation.js";
 import goVetRunner from "./go-vet.js";
+import oxlintRunner from "./oxlint.js";
 import pyrightRunner from "./pyright.js";
+import pythonSlopRunner from "./python-slop.js";
 import ruffRunner from "./ruff.js";
 import rustClippyRunner from "./rust-clippy.js";
+import shellcheckRunner from "./shellcheck.js";
+// Import similarity runner
+import similarityRunner from "./similarity.js";
+import spellcheckRunner from "./spellcheck.js";
+// Import tree-sitter runner
+import treeSitterRunner from "./tree-sitter.js";
 import tsLspRunner from "./ts-lsp.js";
+import tsSlopRunner from "./ts-slop.js";
 import typeSafetyRunner from "./type-safety.js";
 // Register all runners (ordered by priority)
-registerRunner(tsLspRunner); // TypeScript type-checking
-registerRunner(pyrightRunner); // Python type-checking
-registerRunner(biomeRunner);
-registerRunner(ruffRunner);
-registerRunner(typeSafetyRunner);
-registerRunner(astGrepRunner);
-registerRunner(architectRunner);
-registerRunner(goVetRunner);
-registerRunner(rustClippyRunner);
+registerRunner(tsLspRunner); // TypeScript type-checking (priority 5)
+registerRunner(pyrightRunner); // Python type-checking (priority 5)
+registerRunner(configValidationRunner); // Config/env validation (priority 8)
+registerRunner(astGrepNapiRunner); // TS/JS structural analysis via NAPI (priority 15)
+registerRunner(biomeRunner); // Biome formatting/linting (priority 10)
+registerRunner(oxlintRunner); // Oxlint fast JS/TS linter (priority 12)
+registerRunner(treeSitterRunner); // Tree-sitter structural analysis (priority 14)
+registerRunner(ruffRunner); // Python linting (priority 10)
+registerRunner(tsSlopRunner); // DISABLED - TypeScript slop via CLI (disabled, use NAPI)
+registerRunner(pythonSlopRunner); // Python slop via CLI (priority 25)
+registerRunner(typeSafetyRunner); // Type safety checks (priority 20)
+registerRunner(shellcheckRunner); // Shell script linting (priority 20)
+registerRunner(astGrepRunner); // Other languages via CLI (priority 30)
+registerRunner(similarityRunner); // Semantic reuse detection (priority 35)
+registerRunner(architectRunner); // Architectural rules (priority 40)
+registerRunner(spellcheckRunner); // Spellcheck for markdown/docs (priority 30)
+registerRunner(goVetRunner); // Go analysis (priority 50)
+registerRunner(rustClippyRunner); // Rust analysis (priority 50)

package/clients/dispatch/runners/index.ts

@@ -4,23 +4,43 @@
 
 import { registerRunner } from "../dispatcher.js";
 import architectRunner from "./architect.js";
-// Import all runners
 import astGrepRunner from "./ast-grep.js";
+// Import all runners
+import astGrepNapiRunner from "./ast-grep-napi.js";
 import biomeRunner from "./biome.js";
+import configValidationRunner from "./config-validation.js";
 import goVetRunner from "./go-vet.js";
+import oxlintRunner from "./oxlint.js";
 import pyrightRunner from "./pyright.js";
+import pythonSlopRunner from "./python-slop.js";
 import ruffRunner from "./ruff.js";
 import rustClippyRunner from "./rust-clippy.js";
+import shellcheckRunner from "./shellcheck.js";
+// Import similarity runner
+import similarityRunner from "./similarity.js";
+import spellcheckRunner from "./spellcheck.js";
+// Import tree-sitter runner
+import treeSitterRunner from "./tree-sitter.js";
 import tsLspRunner from "./ts-lsp.js";
+import tsSlopRunner from "./ts-slop.js";
 import typeSafetyRunner from "./type-safety.js";
 
 // Register all runners (ordered by priority)
-registerRunner(tsLspRunner); // TypeScript type-checking
-registerRunner(pyrightRunner); // Python type-checking
-registerRunner(biomeRunner);
-registerRunner(ruffRunner);
-registerRunner(typeSafetyRunner);
-registerRunner(astGrepRunner);
-registerRunner(architectRunner);
-registerRunner(goVetRunner);
-registerRunner(rustClippyRunner);
+registerRunner(tsLspRunner); // TypeScript type-checking (priority 5)
+registerRunner(pyrightRunner); // Python type-checking (priority 5)
+registerRunner(configValidationRunner); // Config/env validation (priority 8)
+registerRunner(astGrepNapiRunner); // TS/JS structural analysis via NAPI (priority 15)
+registerRunner(biomeRunner); // Biome formatting/linting (priority 10)
+registerRunner(oxlintRunner); // Oxlint fast JS/TS linter (priority 12)
+registerRunner(treeSitterRunner); // Tree-sitter structural analysis (priority 14)
+registerRunner(ruffRunner); // Python linting (priority 10)
+registerRunner(tsSlopRunner); // DISABLED - TypeScript slop via CLI (disabled, use NAPI)
+registerRunner(pythonSlopRunner); // Python slop via CLI (priority 25)
+registerRunner(typeSafetyRunner); // Type safety checks (priority 20)
+registerRunner(shellcheckRunner); // Shell script linting (priority 20)
+registerRunner(astGrepRunner); // Other languages via CLI (priority 30)
+registerRunner(similarityRunner); // Semantic reuse detection (priority 35)
+registerRunner(architectRunner); // Architectural rules (priority 40)
+registerRunner(spellcheckRunner); // Spellcheck for markdown/docs (priority 30)
+registerRunner(goVetRunner); // Go analysis (priority 50)
+registerRunner(rustClippyRunner); // Rust analysis (priority 50)

package/clients/dispatch/runners/oxlint.js

@@ -0,0 +1,141 @@
+/**
+ * Oxlint runner for dispatch system
+ *
+ * Fast Rust-based JavaScript/TypeScript linter from the Oxc project.
+ * Zero-config by default, compatible with ESLint rules.
+ *
+ * Why oxlint?
+ * - ~100x faster than ESLint (Rust-based)
+ * - Zero-config (works out of the box)
+ * - Growing rule set (eslint, typescript, react, unicorn, etc.)
+ * - JSON output for programmatic use
+ *
+ * Comparison:
+ * - vs Biome: Similar performance, different rule philosophy
+ * - vs ESLint: Much faster, fewer rules but catching up
+ *
+ * Install: npm install -D oxlint
+ * Or: cargo install oxlint
+ *
+ * Config: .oxlintrc.json (optional, zero-config works)
+ */
+import { safeSpawn } from "../../safe-spawn.js";
+import { createAvailabilityChecker, createConfigFinder } from "./utils/runner-helpers.js";
+const oxlint = createAvailabilityChecker("oxlint", ".exe");
+const findOxlintConfig = createConfigFinder(".oxlintrc.json");
+/**
+ * Parse oxlint JSON output
+ *
+ * Format: Array of diagnostic objects
+ * [{
+ *   "ruleId": "no-unused-vars",
+ *   "severity": 2,
+ *   "message": "'foo' is assigned a value but never used.",
+ *   "line": 10,
+ *   "column": 7,
+ *   "nodeType": "Identifier",
+ *   "messageId": "unusedVar",
+ *   "endLine": 10,
+ *   "endColumn": 10,
+ *   "fix": { "range": [95, 108], "text": "" }
+ * }]
+ */
+function parseOxlintOutput(raw, filePath) {
+    const diagnostics = [];
+    if (!raw.trim()) {
+        return diagnostics;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return diagnostics;
+        }
+        for (const item of parsed) {
+            if (!item.message || !item.line)
+                continue;
+            const severity = item.severity === 2 ? "error" : "warning";
+            diagnostics.push({
+                id: `oxlint-${item.line}-${item.ruleId || "unknown"}`,
+                message: item.message,
+                filePath,
+                line: item.line,
+                column: item.column || 1,
+                severity,
+                semantic: severity === "error" ? "blocking" : "warning",
+                tool: "oxlint",
+                rule: item.ruleId,
+                fixable: !!item.fix,
+                fixSuggestion: item.fix?.text,
+            });
+        }
+    }
+    catch {
+        // If JSON parsing fails, try line-based parsing for CLI output
+        const lines = raw.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            // Try to match: file.ts:10:7: Error message [ruleId]
+            const match = line.match(/^(\d+):(\d+)\s+(.+?)\s*\[(\w+)\]$/);
+            if (match) {
+                diagnostics.push({
+                    id: `oxlint-${match[1]}-${match[4]}`,
+                    message: `${match[4]}: ${match[3]}`,
+                    filePath,
+                    line: parseInt(match[1], 10),
+                    column: parseInt(match[2], 10),
+                    severity: "warning",
+                    semantic: "warning",
+                    tool: "oxlint",
+                    rule: match[4],
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+const oxlintRunner = {
+    id: "oxlint",
+    appliesTo: ["jsts"],
+    priority: 12, // Between biome (10) and slop (25)
+    enabledByDefault: false, // Opt-in initially - let users choose between biome/oxlint
+    skipTestFiles: true, // Test files often use patterns that trigger false positives
+    async run(ctx) {
+        // Skip if oxlint is not installed
+        if (!oxlint.isAvailable(ctx.cwd || process.cwd())) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Check if user explicitly disabled oxlint (keep biome as primary)
+        if (ctx.pi.getFlag("no-oxlint")) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Build args
+        // --format json: JSON output
+        // --config: Only if config file exists (zero-config otherwise)
+        const args = ["--format", "json"];
+        // Check for config file
+        const configPath = findOxlintConfig(ctx.cwd);
+        if (configPath) {
+            args.push("--config", configPath);
+        }
+        // Add file path
+        args.push(ctx.filePath);
+        const result = safeSpawn(oxlint.getCommand(), args, {
+            timeout: 10000, // Fast - should complete quickly
+        });
+        // oxlint exits with code 1 if issues found, 0 if clean
+        if (result.status === 0 && !result.stdout?.trim()) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        // Parse diagnostics
+        const raw = result.stdout + result.stderr;
+        const diagnostics = parseOxlintOutput(raw, ctx.filePath);
+        if (diagnostics.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        return {
+            status: "failed",
+            diagnostics,
+            semantic: "warning",
+        };
+    },
+};
+export default oxlintRunner;

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