pi-lens 3.6.2 → 3.6.4

package/clients/dispatch/runners/tree-sitter.js

@@ -1,246 +0,0 @@
-/**
- * Tree-sitter Structural Analysis Runner
- *
- * Executes all loaded tree-sitter query files from rules/tree-sitter-queries/
- * for fast AST-based pattern matching.
- * Updated: ast-grep-napi test
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { RuleCache } from "../../cache/rule-cache.js";
-import { normalizeMapKey } from "../../path-utils.js";
-import { TreeSitterClient } from "../../tree-sitter-client.js";
-import { queryLoader, } from "../../tree-sitter-query-loader.js";
-// Module-level singleton: web-tree-sitter WASM must only be initialized once per process.
-// Creating a new TreeSitterClient() on every write resets TRANSFER_BUFFER (a module-level
-// WASM pointer) — concurrent writes race on _ts_init() and corrupt shared WASM state → crash.
-let _sharedClient = null;
-function getSharedClient() {
-    if (!_sharedClient) {
-        _sharedClient = new TreeSitterClient();
-    }
-    return _sharedClient;
-}
-/**
- * Check if a code block is effectively empty (ignoring comments and whitespace)
- */
-function isEmptyBlock(blockContent) {
-    // Remove comments, whitespace, and check if anything remains
-    const cleaned = blockContent
-        .replace(/\/\/.*$/gm, "") // Remove single-line comments
-        .replace(/\/\*[\s\S]*?\*\//g, "") // Remove multi-line comments
-        .replace(/\s+/g, "") // Remove all whitespace
-        .trim();
-    return cleaned.length === 0 || cleaned === "{}";
-}
-/**
- * Extract parameter count from match text
- */
-function countParameters(matchText) {
-    // Count commas in parameter list, or check for non-empty params
-    // Simple heuristic: count commas + 1, or 0 if empty
-    const paramsMatch = matchText.match(/\((.*)\)/);
-    if (!paramsMatch)
-        return 0;
-    const params = paramsMatch[1].trim();
-    if (!params)
-        return 0;
-    return params.split(",").length;
-}
-/**
- * Apply post-filter to determine if a match should be reported
- */
-function applyPostFilter(query, captures) {
-    if (!query.post_filter)
-        return true; // No filter = always include
-    switch (query.post_filter) {
-        case "empty_body": {
-            // Check if the BODY capture is effectively empty
-            const body = captures.BODY || captures.body || "";
-            return isEmptyBlock(body);
-        }
-        case "count_params": {
-            // Check if parameter count meets minimum
-            const minParams = query.post_filter_params?.min_params || 6;
-            // Get PARAMS capture which contains the parameter list like "(a, b, c)"
-            const params = captures.PARAMS || captures.params || captures.PARAM || "";
-            const paramCount = countParameters(params);
-            return paramCount >= minParams;
-        }
-        case "not_dbg_method":
-            // Exclude debug methods (for console-statement)
-            return !/\b(dbg|debug|logDebug)\b/i.test(captures.METHOD || "");
-        default:
-            // Unknown filter - include by default (safer than excluding)
-            return true;
-    }
-}
-/**
- * Check if variable name matches secret patterns
- * This handles the #match? predicate from tree-sitter queries
- */
-function matchesSecretPattern(varName) {
-    const secretPatterns = [
-        /api[_-]?key/i,
-        /api[_-]?secret/i,
-        /password/i,
-        /secret/i,
-        /token/i,
-        /auth/i,
-        /private[_-]?key/i,
-        /access[_-]?token/i,
-        /credentials/i,
-        /aws[_-]?secret/i,
-        /github[_-]?token/i,
-    ];
-    return secretPatterns.some((pattern) => pattern.test(varName));
-}
-const treeSitterRunner = {
-    id: "tree-sitter",
-    appliesTo: ["jsts", "python"],
-    priority: 14, // Between oxlint (12) and ast-grep-napi (15)
-    enabledByDefault: true,
-    skipTestFiles: false, // Run on test files too (structural issues matter there)
-    async run(ctx) {
-        // Use singleton client — WASM must never be re-initialized after first call
-        const client = getSharedClient();
-        if (!client.isAvailable()) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const initialized = await client.init();
-        if (!initialized) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Determine language from file extension
-        const filePath = ctx.filePath;
-        const isPython = filePath.endsWith(".py");
-        const isTypeScript = filePath.endsWith(".ts");
-        const isTSX = filePath.endsWith(".tsx");
-        const isJavaScript = filePath.endsWith(".js") || filePath.endsWith(".jsx");
-        let languageId;
-        if (isPython) {
-            languageId = "python";
-        }
-        else if (isTSX) {
-            languageId = "tsx";
-        }
-        else if (isTypeScript) {
-            languageId = "typescript";
-        }
-        else if (isJavaScript) {
-            languageId = "javascript";
-        }
-        else {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Try cache first, fall back to loading from disk
-        let languageQueries = [];
-        const cache = new RuleCache(languageId);
-        // Get all rule files for this language (use ctx.cwd for project root)
-        const rulesDir = path.join(ctx.cwd, "rules", "tree-sitter-queries", languageId);
-        const ruleFiles = [];
-        if (fs.existsSync(rulesDir)) {
-            ruleFiles.push(...fs
-                .readdirSync(rulesDir)
-                .filter((f) => f.endsWith(".yml"))
-                .map((f) => path.join(rulesDir, f)));
-        }
-        // Try cache
-        const cached = cache.get(ruleFiles);
-        if (cached) {
-            // Use cached queries
-            languageQueries = cached.queries.map((q) => ({
-                ...q,
-                has_fix: false,
-                filePath: "",
-            }));
-        }
-        else {
-            // Load from disk
-            if (!queryLoader.getAllQueries().length) {
-                await queryLoader.loadQueries();
-            }
-            const allQueries = queryLoader.getAllQueries();
-            languageQueries = allQueries.filter((q) => q.language === languageId ||
-                (isJavaScript && q.language === "typescript"));
-            // Save to cache
-            cache.set(ruleFiles, languageQueries.map((q) => ({
-                id: q.id,
-                name: q.name,
-                severity: q.severity,
-                language: q.language,
-                message: q.message,
-                query: q.query,
-                metavars: q.metavars,
-                post_filter: q.post_filter,
-                post_filter_params: q.post_filter_params,
-            })));
-        }
-        if (languageQueries.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = [];
-        // Run each query against the file
-        for (const query of languageQueries) {
-            try {
-                // Extract directory from file path (use path.dirname for cross-platform)
-                const rootDir = path.dirname(filePath);
-                const matches = await client.structuralSearch(query.id, // Use query ID as pattern (findMatchingQuery will resolve it)
-                languageId, rootDir, {
-                    maxResults: 10,
-                    fileFilter: (f) => normalizeMapKey(f) === normalizeMapKey(filePath),
-                });
-                for (const match of matches) {
-                    // Apply post-filter if defined (pass captures for proper filtering)
-                    if (!applyPostFilter(query, match.captures)) {
-                        continue; // Skip this match - filter didn't pass
-                    }
-                    // For hardcoded-secrets, also check variable name pattern
-                    if (query.id === "hardcoded-secrets") {
-                        // Extract variable name from captures
-                        const varName = match.captures?.VARNAME || "";
-                        if (!varName || !matchesSecretPattern(varName)) {
-                            continue; // Skip - no variable name or doesn't match secret patterns
-                        }
-                    }
-                    // Get line/column from match (already 0-indexed from tree-sitter)
-                    const line = match.line;
-                    const column = match.column;
-                    // Map severity to semantic
-                    const semantic = query.severity === "error"
-                        ? "blocking"
-                        : query.severity === "warning"
-                            ? "warning"
-                            : "none";
-                    diagnostics.push({
-                        id: `tree-sitter:${query.id}:${line}`,
-                        message: query.message,
-                        filePath,
-                        line: line + 1, // 1-indexed
-                        column: column + 1, // 1-indexed
-                        severity: query.severity,
-                        semantic,
-                        tool: "tree-sitter",
-                        rule: query.id,
-                    });
-                }
-            }
-            catch (err) {
-                // Individual query failure shouldn't stop other queries
-                console.error(`[tree-sitter] Query ${query.id} failed:`, err);
-            }
-        }
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Check if any blocking issues
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
-    },
-};
-export default treeSitterRunner;
-// test ast-grep-napi re-enable

package/clients/dispatch/runners/ts-lsp.js

@@ -1,125 +0,0 @@
-/**
- * TypeScript LSP runner for dispatch system
- *
- * Uses the new LSP client architecture (Phase 3) when --lens-lsp is enabled.
- * Falls back to built-in TypeScriptClient for backward compatibility.
- *
- * @deprecated The built-in TypeScriptClient is deprecated. Use --lens-lsp for full LSP support.
- */
-import { getLSPService } from "../../lsp/index.js";
-import { TypeScriptClient } from "../../typescript-client.js";
-import { readFileContent } from "./utils.js";
-const tsLspRunner = {
-    id: "ts-lsp",
-    appliesTo: ["jsts"],
-    priority: 5,
-    enabledByDefault: true,
-    async run(ctx) {
-        // Only check TypeScript files
-        if (!ctx.filePath.match(/\.tsx?$/)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // When --lens-lsp is active, the `lsp` runner (priority 4) already
-        // handles TypeScript via the LSP service. Skip to avoid duplicate work.
-        if (ctx.pi.getFlag("lens-lsp")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // DEPRECATED: Fall back to built-in TypeScriptClient
-        // This path is deprecated and will be removed in a future release
-        return runWithBuiltinClient(ctx);
-    },
-};
-/**
- * Run with new LSP client (Phase 3)
- */
-async function runWithLSPClient(ctx) {
-    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" };
-    }
-    // Open file in LSP and get diagnostics
-    await lspService.openFile(ctx.filePath, content);
-    // getDiagnostics() internally calls waitForDiagnostics() with bus
-    // subscription + 150ms debounce + 3s timeout
-    const lspDiags = await lspService.getDiagnostics(ctx.filePath);
-    // 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: `ts-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: "ts-lsp",
-        code: String(d.code ?? ""),
-    }));
-    return {
-        status: "failed",
-        diagnostics,
-        semantic: "blocking",
-    };
-}
-/**
- * Run with deprecated built-in TypeScriptClient
- * @deprecated Use runWithLSPClient instead
- */
-async function runWithBuiltinClient(ctx) {
-    const tsClient = new TypeScriptClient();
-    const content = readFileContent(ctx.filePath);
-    if (!content) {
-        return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    tsClient.updateFile(ctx.filePath, content);
-    const diags = tsClient.getDiagnostics(ctx.filePath);
-    if (diags.length === 0) {
-        return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    // Get code fixes for all errors
-    const allFixes = tsClient.getAllCodeFixes(ctx.filePath);
-    // Convert to diagnostics
-    const diagnostics = [];
-    // The built-in client returns Diagnostic with { range: { start: { line, character } } }
-    for (const d of diags) {
-        // Safely access nested properties
-        if (!d.range?.start)
-            continue;
-        const line = d.range.start.line;
-        const character = d.range.start.character ?? 0;
-        const severity = d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info";
-        const semantic = d.severity === 1 ? "blocking" : "warning";
-        // Find fixes for this line
-        const lineFixes = allFixes.get(line);
-        const fixDescription = lineFixes?.[0]?.description;
-        diagnostics.push({
-            id: `ts:${d.code}:${line}`,
-            message: fixDescription
-                ? `${d.message} [💡 ${fixDescription}]`
-                : d.message,
-            filePath: ctx.filePath,
-            line: line + 1,
-            column: character + 1,
-            severity,
-            semantic,
-            tool: "ts-lsp",
-            fixable: !!lineFixes && lineFixes.length > 0,
-            fixSuggestion: fixDescription,
-        });
-    }
-    return {
-        status: "failed",
-        diagnostics,
-        semantic: "blocking",
-    };
-}
-export default tsLspRunner;

package/clients/dispatch/runners/ts-slop.js

@@ -1,113 +0,0 @@
-/**
- * TypeScript Slop runner for dispatch system
- *
- * Detects "slop" patterns in TypeScript/JavaScript 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 patterns adapted for TypeScript
- */
-import { safeSpawn } from "../../safe-spawn.js";
-import { createConfigFinder, isSgAvailable, } from "./utils/runner-helpers.js";
-const findSlopConfig = createConfigFinder("ts-slop-rules");
-const tsSlopRunner = {
-    id: "ts-slop",
-    // NOTE: TypeScript/JavaScript slop detection is now handled by ast-grep-napi
-    // This CLI runner is kept as fallback for edge cases but disabled by default
-    appliesTo: [], // Disabled - use ast-grep-napi instead
-    priority: 20,
-    enabledByDefault: false,
-    skipTestFiles: true,
-    async run(ctx) {
-        // 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, filePath) {
-    const diagnostics = [];
-    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";
-                const message = item.message || "";
-                // Categorize by severity based on weight from metadata
-                const weight = item.metadata?.weight || 3;
-                const severity = weight >= 4 ? "error" : "warning";
-                const category = item.metadata?.category || "slop";
-                // Add slop category indicator to message
-                let enhancedMessage = `[${category}] ${message}`;
-                if (item.replacement) {
-                    const preview = item.replacement.length > 40
-                        ? `${item.replacement.substring(0, 40)}...`
-                        : item.replacement;
-                    enhancedMessage += `\n💡 Suggested fix: → "${preview}"`;
-                }
-                diagnostics.push({
-                    id: `ts-slop-${line}-${ruleId}`,
-                    message: enhancedMessage,
-                    filePath,
-                    line,
-                    column: item.range?.start?.column || 0,
-                    severity,
-                    semantic: severity === "error" ? "blocking" : "warning",
-                    tool: "ts-slop",
-                    rule: ruleId,
-                    fixable: !!item.replacement,
-                    fixSuggestion: item.replacement,
-                });
-            }
-        }
-    }
-    catch {
-        // JSON parse failed, try line-by-line
-        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: `ts-slop-${match[1]}-line`,
-                        message: `[slop] ${match[2].trim()}`,
-                        filePath,
-                        line: parseInt(match[1], 10),
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "ts-slop",
-                    });
-                }
-            }
-        }
-    }
-    return diagnostics;
-}
-export default tsSlopRunner;

package/clients/dispatch/runners/type-safety.js

@@ -1,142 +0,0 @@
-/**
- * Type safety runner for dispatch system
- *
- * Checks for:
- * - Switch exhaustiveness
- * - Missing return statements
- * - Type safety issues
- */
-import { readFileContent } from "./utils.js";
-const typeSafetyRunner = {
-    id: "type-safety",
-    appliesTo: ["jsts"],
-    priority: 20,
-    enabledByDefault: true,
-    async run(ctx) {
-        // Only check TypeScript files
-        if (!ctx.filePath.match(/\.tsx?$/)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const content = readFileContent(ctx.filePath);
-        if (!content) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = [];
-        // Check for switch exhaustiveness patterns
-        diagnostics.push(...checkSwitchExhaustiveness(content, ctx.filePath));
-        // Check for missing return patterns
-        diagnostics.push(...checkMissingReturns(content, ctx.filePath));
-        // Check for any type usage
-        diagnostics.push(...checkAnyTypeUsage(content, ctx.filePath));
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
-    },
-};
-function checkSwitchExhaustiveness(content, filePath) {
-    const diagnostics = [];
-    const switchRegex = /switch\s*\(\s*(\w+)\s*\)\s*\{/g;
-    let match;
-    while ((match = switchRegex.exec(content)) !== null) {
-        const switchStart = match.index;
-        const switchVar = match[1];
-        // Find the switch block
-        let braceCount = 0;
-        const blockStart = content.indexOf("{", switchStart);
-        let blockEnd = blockStart;
-        while (blockEnd < content.length && braceCount >= 0) {
-            if (content[blockEnd] === "{")
-                braceCount++;
-            if (content[blockEnd] === "}")
-                braceCount--;
-            blockEnd++;
-        }
-        const switchBlock = content.slice(blockStart, blockEnd);
-        // Check if it has a default case
-        if (!/\bdefault\s*:/.test(switchBlock)) {
-            const caseCount = (switchBlock.match(/\bcase\s+/g) || []).length;
-            if (caseCount > 2) {
-                const lineNum = content.slice(0, switchStart).split("\n").length;
-                diagnostics.push({
-                    id: `switch-${lineNum}-${switchVar}`,
-                    message: `Switch on '${switchVar}' has ${caseCount} cases but no default`,
-                    filePath,
-                    line: lineNum,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "type-safety",
-                    rule: "switch-exhaustiveness",
-                    fixSuggestion: "Add 'default: break;' or use exhaustive checking",
-                });
-            }
-        }
-    }
-    return diagnostics;
-}
-function checkMissingReturns(content, filePath) {
-    const diagnostics = [];
-    const funcRegex = /function\s+(\w+)\s*\([^)]*\)\s*:\s*([^\s{]+)\s*\{/g;
-    let match;
-    while ((match = funcRegex.exec(content)) !== null) {
-        const returnType = match[2].trim();
-        if (returnType === "void" ||
-            returnType === "never" ||
-            returnType.includes("Promise<void>")) {
-            continue;
-        }
-        const funcStart = match.index;
-        const funcName = match[1];
-        // Find function block
-        let braceCount = 0;
-        const blockStart = content.indexOf("{", funcStart);
-        let blockEnd = blockStart;
-        while (blockEnd < content.length && braceCount >= 0) {
-            if (content[blockEnd] === "{")
-                braceCount++;
-            if (content[blockEnd] === "}")
-                braceCount--;
-            blockEnd++;
-        }
-        const funcBlock = content.slice(blockStart, blockEnd);
-        if (!/\breturn\b/.test(funcBlock)) {
-            const lineNum = content.slice(0, funcStart).split("\n").length;
-            diagnostics.push({
-                id: `missing-return-${lineNum}-${funcName}`,
-                message: `Function '${funcName}' returns '${returnType}' but has no return statement`,
-                filePath,
-                line: lineNum,
-                severity: "error",
-                semantic: "blocking",
-                tool: "type-safety",
-                rule: "missing-return",
-            });
-        }
-    }
-    return diagnostics;
-}
-function checkAnyTypeUsage(content, filePath) {
-    const diagnostics = [];
-    const anyRegex = /:\s*any\b|as\s+any\b/g;
-    let match;
-    while ((match = anyRegex.exec(content)) !== null) {
-        const lineNum = content.slice(0, match.index).split("\n").length;
-        diagnostics.push({
-            id: `any-type-${lineNum}`,
-            message: "Avoid 'any' type — use 'unknown' or define a proper interface",
-            filePath,
-            line: lineNum,
-            severity: "warning",
-            semantic: "warning",
-            tool: "type-safety",
-            rule: "no-any-type",
-        });
-    }
-    return diagnostics;
-}
-export default typeSafetyRunner;