pi-lens 3.6.2 → 3.6.4

package/clients/dispatch/runners/ast-grep.js

@@ -1,157 +0,0 @@
-/**
- * ast-grep runner for dispatch system
- *
- * Structural code analysis for detecting patterns like:
- * - redundant state
- * - async/await issues
- * - security anti-patterns
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-// Simple YAML fix: field extractor
-function extractFixFromRule(ruleId, ruleDir) {
-    try {
-        const rulePath = `${ruleDir}/${ruleId}.yml`;
-        if (!fs.existsSync(rulePath))
-            return undefined;
-        const content = fs.readFileSync(rulePath, "utf-8");
-        const fixMatch = content.match(/^fix:\s*\|?([\s\S]*?)(?=^\w|^rule:|Z)/m);
-        if (fixMatch) {
-            return fixMatch[1]
-                .split("\n")
-                .map((line) => line.replace(/^\s*\|?\s*/, ""))
-                .filter((line) => line.length > 0)
-                .join("\n");
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return undefined;
-}
-const astGrepRunner = {
-    id: "ast-grep",
-    appliesTo: ["jsts", "python", "go", "rust", "cxx"],
-    priority: 30,
-    enabledByDefault: false,
-    skipTestFiles: true, // Many rules are noisy in tests
-    async run(ctx) {
-        // Check if ast-grep is available (use npx for local installs)
-        const check = await safeSpawnAsync("npx", ["sg", "--version"], {
-            timeout: 5000,
-        });
-        if (check.error || check.status !== 0) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Find ast-grep config
-        const configPath = findAstGrepConfig(ctx.cwd);
-        if (!configPath) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run ast-grep scan on the file (use npx for local installs)
-        const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
-        const result = await safeSpawnAsync("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 = parseAstGrepOutput(raw, ctx.filePath, configPath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-function findAstGrepConfig(cwd) {
-    const candidates = [
-        "rules/ast-grep-rules/.sgconfig.yml",
-        ".sgconfig.yml",
-        "sgconfig.yml",
-    ];
-    for (const candidate of candidates) {
-        const fullPath = `${cwd}/${candidate}`;
-        if (fs.existsSync(fullPath)) {
-            return fullPath;
-        }
-    }
-    return undefined;
-}
-function parseAstGrepOutput(raw, filePath, _configPath) {
-    const diagnostics = [];
-    // Try to parse as JSON
-    // Determine rule directory for fix: extraction
-    const ruleDir = _configPath
-        ? path.dirname(_configPath).replace("/.sgconfig.yml", "/rules")
-        : path.join(process.cwd(), "rules", "ast-grep-rules", "rules");
-    try {
-        const parsed = JSON.parse(raw);
-        if (Array.isArray(parsed)) {
-            for (const item of parsed) {
-                const line = item.range?.start?.line || 1;
-                const ruleId = item.rule || "unknown";
-                // Build message with inline fix suggestion
-                let message = item.message || item.lines || "";
-                let fixSuggestion;
-                if (item.replacement) {
-                    // Show the actual code change inline in the message
-                    const replacementPreview = item.replacement.length > 40
-                        ? `${item.replacement.substring(0, 40)}...`
-                        : item.replacement;
-                    message += `\n💡 Suggested fix: → "${replacementPreview}"`;
-                    fixSuggestion = `Replace with: ${item.replacement}`;
-                }
-                else {
-                    // Try to get fix: from rule YAML
-                    const ruleFix = extractFixFromRule(ruleId, ruleDir);
-                    if (ruleFix) {
-                        const fixPreview = ruleFix.length > 60 ? `${ruleFix.substring(0, 60)}...` : ruleFix;
-                        message += `\n💡 Suggested fix:\n${fixPreview}`;
-                        fixSuggestion = ruleFix;
-                    }
-                }
-                diagnostics.push({
-                    id: `ast-grep-${line}-${ruleId}`,
-                    message,
-                    filePath,
-                    line,
-                    severity: item.severity === "error" ? "error" : "warning",
-                    semantic: item.severity === "error" ? "blocking" : "warning",
-                    tool: "ast-grep",
-                    rule: ruleId,
-                    fixable: !!item.replacement || !!fixSuggestion,
-                    fixSuggestion,
-                });
-            }
-        }
-    }
-    catch {
-        // Not JSON, try line-by-line parsing
-        const lines = raw.split("\n");
-        for (const line of lines) {
-            if (line.includes(":") && line.includes("L")) {
-                const match = line.match(/L(\d+):?\s*(.+)/);
-                if (match) {
-                    diagnostics.push({
-                        id: `ast-grep-${match[1]}-line`,
-                        message: match[2].trim(),
-                        filePath,
-                        line: parseInt(match[1], 10),
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "ast-grep",
-                    });
-                }
-            }
-        }
-    }
-    return diagnostics;
-}
-export default astGrepRunner;

package/clients/dispatch/runners/biome.js

@@ -1,55 +0,0 @@
-/**
- * Biome runner for dispatch system
- *
- * Requires: @biomejs/biome (npm install -D @biomejs/biome)
- */
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { createBiomeParser } from "./utils/diagnostic-parsers.js";
-import { biome } from "./utils/runner-helpers.js";
-const biomeRunner = {
-    id: "biome-lint",
-    appliesTo: ["jsts", "json"],
-    priority: 10,
-    enabledByDefault: true,
-    async run(ctx) {
-        // Check if biome is available (via PATH, venv, or npx)
-        let cmd = biome.getCommand();
-        let useNpx = false;
-        if (!cmd || !biome.isAvailable(ctx.cwd)) {
-            // Try npx as fallback
-            const npxCheck = await safeSpawnAsync("npx", ["biome", "--version"], {
-                timeout: 5000,
-            });
-            if (!npxCheck.error && npxCheck.status === 0) {
-                cmd = "npx";
-                useNpx = true;
-            }
-            else {
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-        }
-        // IMPORTANT: Never use --write 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.
-        // Auto-format handles formatting on write; this runner only checks.
-        const args = useNpx
-            ? ["biome", "check", ctx.filePath]
-            : ["check", ctx.filePath];
-        const result = await safeSpawnAsync(cmd, args, {
-            timeout: 30000,
-        });
-        const output = result.stdout + result.stderr;
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse diagnostics (never autofix in dispatch to prevent loops)
-        const parseBiomeOutput = createBiomeParser(false);
-        const diagnostics = parseBiomeOutput(output, ctx.filePath);
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-export default biomeRunner;

package/clients/dispatch/runners/config-validation.js

@@ -1,67 +0,0 @@
-/**
- * Config Validation Runner
- *
- * Validates config/environment variable access against actual config files.
- * Detects undefined keys, typos, and missing env vars.
- *
- * Uses Tree-sitter to find config access patterns in code and validates
- * against parsed config files (.env, config.ini, config.yaml, etc.)
- */
-import { createConfigValidator } from "../../config-validator.js";
-const configValidationRunner = {
-    id: "config-validation",
-    appliesTo: ["jsts", "python", "go", "rust"],
-    priority: 8, // Run early, before other linters
-    enabledByDefault: true,
-    async run(ctx) {
-        // Only check supported file extensions
-        const ext = ctx.filePath.match(/\.(py|js|ts|tsx|go|rs)$/);
-        if (!ext) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        try {
-            const validator = await createConfigValidator(ctx.cwd);
-            const result = await validator.validateFile(ctx.filePath);
-            const diagnostics = [];
-            // Report undefined keys as warnings
-            for (const access of result.undefined) {
-                diagnostics.push({
-                    id: `config-undefined:${access.key}`,
-                    message: `Undefined config key: "${access.key}"`,
-                    filePath: ctx.filePath,
-                    line: access.line,
-                    column: access.column,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "config-validation",
-                });
-            }
-            // Report typos with suggestion
-            for (const { access, suggestion } of result.typos) {
-                diagnostics.push({
-                    id: `config-typo:${access.key}`,
-                    message: `Possible typo: "${access.key}" — did you mean "${suggestion}"?`,
-                    filePath: ctx.filePath,
-                    line: access.line,
-                    column: access.column,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "config-validation",
-                });
-            }
-            if (diagnostics.length === 0) {
-                return { status: "succeeded", diagnostics: [], semantic: "none" };
-            }
-            return {
-                status: "failed",
-                diagnostics,
-                semantic: "warning",
-            };
-        }
-        catch (_err) {
-            // Silently fail if validator can't run (e.g., tree-sitter not available)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-    },
-};
-export default configValidationRunner;

package/clients/dispatch/runners/go-vet.js

@@ -1,48 +0,0 @@
-/**
- * Go vet runner for dispatch system
- *
- * Runs `go vet` for Go files to catch common mistakes.
- */
-import { safeSpawn } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
-const goVetRunner = {
-    id: "go-vet",
-    appliesTo: ["go"],
-    priority: 15,
-    enabledByDefault: true,
-    async run(ctx) {
-        // Check if go is available
-        const check = safeSpawn("go", ["version"], {
-            timeout: 5000,
-        });
-        if (check.error || check.status !== 0) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run go vet on the file
-        const result = safeSpawn("go", ["vet", ctx.filePath], {
-            timeout: 30000,
-        });
-        const raw = stripAnsi(result.stdout + result.stderr);
-        if (result.status === 0 && !raw.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse output
-        const diagnostics = parseGoVetOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            // go vet returned non-zero but no parseable output
-            return {
-                status: "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw,
-            };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-export default goVetRunner;

package/clients/dispatch/runners/index.js

@@ -1,47 +0,0 @@
-/**
- * Runner definitions for pi-lens dispatch system
- */
-import { registerRunner } from "../dispatcher.js";
-import architectRunner from "./architect.js";
-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 lspRunner from "./lsp.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)
-// Unified LSP runner for all languages (TypeScript, Python, Go, Rust, etc.) - priority 4
-registerRunner(lspRunner); // Unified LSP type-checking for all languages (priority 4)
-registerRunner(tsLspRunner); // TypeScript type-checking (priority 5) - fallback when --lens-lsp disabled
-registerRunner(pyrightRunner); // Python type-checking (priority 5) - fallback when --lens-lsp disabled
-registerRunner(configValidationRunner); // Config/env validation (priority 8)
-// DISABLED in post-write dispatch - ast-grep-napi can crash. Enabled via /lens-booboo plan only.
-registerRunner(astGrepNapiRunner); // TS/JS structural analysis via NAPI (priority 15, post-write disabled)
-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)
-// DISABLED: registerRunner(astGrepRunner); // Replaced by ast-grep-napi for dispatch
-// CLI ast-grep kept for ast_grep_search/ast_grep_replace tools only
-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/lsp.js

@@ -1,102 +0,0 @@
-/**
- * Unified LSP Runner for pi-lens
- *
- * Handles type checking for ALL LSP-supported languages:
- * - TypeScript/JavaScript (typescript-language-server)
- * - Python (pyright/pylsp)
- * - Go (gopls)
- * - Rust (rust-analyzer)
- * - Ruby, PHP, C#, Java, Kotlin, Swift, Dart, etc.
- *
- * Replaces language-specific runners (ts-lsp, pyright) with a single
- * unified runner that delegates to the LSP service.
- */
-import { getLSPService } from "../../lsp/index.js";
-import { readFileContent } from "./utils.js";
-const lspRunner = {
-    id: "lsp",
-    appliesTo: ["jsts", "python", "go", "rust"], // Core LSP languages
-    priority: 4, // Run before everything (even ts-lsp was priority 5)
-    enabledByDefault: true,
-    async run(ctx) {
-        // Only run if --lens-lsp flag is enabled
-        if (!ctx.pi.getFlag("lens-lsp")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const lspService = getLSPService();
-        // Check if we have LSP available for this file
-        const hasLSP = await lspService.hasLSP(ctx.filePath);
-        if (!hasLSP) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Read file content
-        const content = readFileContent(ctx.filePath);
-        if (!content) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Try to open file in LSP and get diagnostics
-        // If the server fails to spawn or crashes, this will be caught
-        let lspDiags = [];
-        let serverFailed = false;
-        let failureReason = "";
-        try {
-            await lspService.openFile(ctx.filePath, content);
-            // getDiagnostics() internally calls waitForDiagnostics() with bus
-            // subscription + 150ms debounce + 3s timeout
-            lspDiags = await lspService.getDiagnostics(ctx.filePath);
-        }
-        catch (err) {
-            serverFailed = true;
-            failureReason = err instanceof Error ? err.message : String(err);
-            // Check if this is a server spawn/connection error
-            if (failureReason.includes("spawn") ||
-                failureReason.includes("exited") ||
-                failureReason.includes("connection") ||
-                failureReason.includes("JSON RPC")) {
-                // Mark this server as broken so we don't keep trying
-                console.error(`[lsp-runner] LSP server failed for ${ctx.filePath}: ${failureReason}`);
-            }
-        }
-        // If server failed to provide diagnostics, report as failed status
-        if (serverFailed) {
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: `lsp:server-error:0`,
-                        message: `LSP server failed: ${failureReason}`,
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "error",
-                        semantic: "warning", // Don't block - fallback to other runners
-                        tool: "lsp",
-                    },
-                ],
-                semantic: "warning",
-            };
-        }
-        // Convert LSP diagnostics to our format
-        // Defensive: filter out malformed diagnostics that may lack range
-        const diagnostics = lspDiags
-            .filter((d) => d.range?.start?.line !== undefined)
-            .map((d) => ({
-            id: `lsp:${d.code ?? "unknown"}:${d.range.start.line}`,
-            message: d.message,
-            filePath: ctx.filePath,
-            line: d.range.start.line + 1,
-            column: d.range.start.character + 1,
-            severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info",
-            semantic: d.severity === 1 ? "blocking" : "warning",
-            tool: "lsp",
-            code: String(d.code ?? ""),
-        }));
-        const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
-    },
-};
-export default lspRunner;

package/clients/dispatch/runners/oxlint.js

@@ -1,67 +0,0 @@
-/**
- * Oxlint runner for dispatch system
- *
- * Fast JavaScript/TypeScript linter written in Rust.
- * Drop-in replacement for ESLint with better performance.
- *
- * Requires: oxlint (npm install -g oxlint)
- */
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-const oxlint = createAvailabilityChecker("oxlint", ".exe");
-const oxlintRunner = {
-    id: "oxlint",
-    appliesTo: ["jsts"],
-    priority: 12,
-    enabledByDefault: false, // Opt-in: may conflict with ESLint in existing projects
-    skipTestFiles: true,
-    async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
-        // Check if oxlint is available
-        if (!oxlint.isAvailable(cwd)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run oxlint on the file
-        const result = await safeSpawnAsync(oxlint.getCommand(), ["--format", "unix", ctx.filePath], {
-            timeout: 30000,
-        });
-        // Oxlint returns non-zero when issues found
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse Unix format output: file:line:column: message (rule)
-        const diagnostics = parseOxlintOutput(result.stdout + result.stderr, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-function parseOxlintOutput(raw, filePath) {
-    const diagnostics = [];
-    const lines = raw.split("\n");
-    for (const line of lines) {
-        // Parse: file:line:column: message (rule)
-        // Example: src/main.ts:10:5: Unexpected console statement (no-console)
-        const match = line.match(/^(.+):(\d+):(\d+):\s*(.+?)\s*\(([^)]+)\)$/);
-        if (match) {
-            const [, _file, lineStr, _col, message, rule] = match;
-            diagnostics.push({
-                id: `oxlint-${rule}-${lineStr}`,
-                message: `${message} (${rule})`,
-                filePath,
-                line: parseInt(lineStr, 10),
-                severity: "warning",
-                semantic: "warning",
-                tool: "oxlint",
-                rule,
-            });
-        }
-    }
-    return diagnostics;
-}
-export default oxlintRunner;