pi-lens 3.6.2 → 3.6.4

package/clients/tree-sitter-query-loader.js

@@ -1,355 +0,0 @@
-/**
- * Tree-sitter Query Loader
- *
- * Loads tree-sitter queries from YAML files in rules/tree-sitter-queries/
- * and provides them to the TreeSitterClient.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export class TreeSitterQueryLoader {
-    constructor(verbose = false) {
-        this.queries = new Map();
-        this.loaded = false;
-        this.verbose = verbose;
-    }
-    /** Debug logging helper */
-    dbg(msg) {
-        if (this.verbose) {
-            console.error(`[query-loader] ${msg}`);
-        }
-    }
-    /**
-     * Load all queries from the rules/tree-sitter-queries directory
-     */
-    async loadQueries() {
-        if (this.loaded)
-            return this.queries;
-        const queriesDir = path.join(process.cwd(), "rules", "tree-sitter-queries");
-        if (!fs.existsSync(queriesDir)) {
-            this.dbg(`Queries directory not found: ${queriesDir}`);
-            return this.queries;
-        }
-        // Load queries from each language subdirectory
-        const languageDirs = fs
-            .readdirSync(queriesDir, { withFileTypes: true })
-            .filter((d) => d.isDirectory())
-            .map((d) => d.name);
-        for (const lang of languageDirs) {
-            const langDir = path.join(queriesDir, lang);
-            const queryFiles = fs
-                .readdirSync(langDir)
-                .filter((f) => f.endsWith(".yml"));
-            const langQueries = [];
-            for (const file of queryFiles) {
-                const filePath = path.join(langDir, file);
-                const query = this.parseQueryFile(filePath, lang);
-                if (query) {
-                    langQueries.push(query);
-                }
-            }
-            if (langQueries.length > 0) {
-                this.queries.set(lang, langQueries);
-                this.dbg(`Loaded ${langQueries.length} queries for ${lang}`);
-            }
-        }
-        this.loaded = true;
-        return this.queries;
-    }
-    /**
-     * Parse a single YAML query file
-     */
-    parseQueryFile(filePath, language) {
-        try {
-            const content = fs.readFileSync(filePath, "utf-8");
-            // Simple YAML parsing (extract key: value pairs)
-            const parsed = this.parseYaml(content);
-            if (!parsed.id || !parsed.query) {
-                this.dbg(`Invalid query file: ${filePath}`);
-                return null;
-            }
-            return {
-                id: String(parsed.id),
-                name: String(parsed.name || parsed.id),
-                severity: this.parseSeverity(parsed.severity),
-                category: String(parsed.category || "general"),
-                language: String(parsed.language || language),
-                message: String(parsed.message || `Pattern: ${parsed.id}`),
-                description: parsed.description
-                    ? String(parsed.description)
-                    : undefined,
-                query: this.extractMultilineValue(content, "query") || String(parsed.query),
-                metavars: Array.isArray(parsed.metavars)
-                    ? parsed.metavars.map(String)
-                    : this.extractMetavars(String(parsed.query)),
-                post_filter: parsed.post_filter
-                    ? String(parsed.post_filter)
-                    : undefined,
-                // biome-ignore lint/suspicious/noExplicitAny: Post filter params
-                post_filter_params: parsed.post_filter_params,
-                tags: Array.isArray(parsed.tags) ? parsed.tags.map(String) : undefined,
-                has_fix: parsed.has_fix === true || parsed.has_fix === "true",
-                fix_action: parsed.fix_action ? String(parsed.fix_action) : undefined,
-                filePath,
-            };
-        }
-        catch (err) {
-            this.dbg(`Failed to parse ${filePath}: ${err}`);
-            return null;
-        }
-    }
-    /**
-     * Simple YAML parser for our query files
-     */
-    parseYaml(content) {
-        const result = {};
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const match = line.match(/^([a-z_]+):\s*(.*)$/);
-            if (match) {
-                const key = match[1];
-                let value = match[2].trim();
-                // Handle arrays inline: metavars: [A, B, C]
-                if (value.startsWith("[") && value.endsWith("]")) {
-                    value = value
-                        .slice(1, -1)
-                        .split(",")
-                        .map((s) => s.trim().replace(/^["']|["']$/g, ""));
-                }
-                // Handle multi-line arrays: metavars:\n  - A\n  - B
-                else if (value === "") {
-                    // Check if next lines are array items (  - item)
-                    const arrayItems = [];
-                    const baseIndent = line.match(/^(\s*)/)?.[0].length || 0;
-                    for (let j = i + 1; j < lines.length; j++) {
-                        const nextLine = lines[j];
-                        const nextIndent = nextLine.match(/^(\s*)/)?.[0].length || 0;
-                        // Stop if we hit a line with same or less indent (new key)
-                        if (nextIndent <= baseIndent && nextLine.match(/^[a-z_]+:/)) {
-                            break;
-                        }
-                        // Check if it's an array item
-                        const itemMatch = nextLine.match(/^\s+-\s*(.+)$/);
-                        if (itemMatch) {
-                            // Strip inline comments and trim
-                            const item = itemMatch[1].trim().replace(/\s*#.*$/, "");
-                            if (item)
-                                arrayItems.push(item);
-                        }
-                    }
-                    if (arrayItems.length > 0) {
-                        value = arrayItems;
-                    }
-                }
-                // Handle booleans
-                else if (value === "true")
-                    value = true;
-                else if (value === "false")
-                    value = false;
-                // Strip quotes from strings
-                else if (value.startsWith('"') && value.endsWith('"')) {
-                    value = value.slice(1, -1);
-                }
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-    /**
-     * Extract a multiline value (like query) from YAML
-     */
-    extractMultilineValue(content, key) {
-        const lines = content.split("\n");
-        let startLine = -1;
-        let startIndent = 0;
-        const keyPrefix = `${key}:`;
-        // Find the key line
-        for (let i = 0; i < lines.length; i++) {
-            const trimmed = lines[i].trimStart();
-            if (trimmed.startsWith(keyPrefix)) {
-                startLine = i;
-                startIndent = lines[i].length - trimmed.length;
-                const afterKey = trimmed.slice(keyPrefix.length).trim();
-                // If there's content on the same line (not just |), return it
-                if (afterKey && afterKey !== "|")
-                    return afterKey;
-                break;
-            }
-        }
-        if (startLine === -1)
-            return null;
-        // Collect all lines until we hit a new key with same or less indent
-        const valueLines = [];
-        for (let i = startLine + 1; i < lines.length; i++) {
-            const line = lines[i];
-            // Track empty lines
-            if (!line.trim()) {
-                valueLines.push("");
-                continue;
-            }
-            // Check indent
-            const indentMatch = line.match(/^(\s*)/);
-            const indent = indentMatch ? indentMatch[1].length : 0;
-            const trimmed = line.trim();
-            // Stop at new key with same or less indent (but not at comments)
-            if (indent <= startIndent &&
-                trimmed.match(/^[a-z_]+:/) &&
-                !trimmed.startsWith("#")) {
-                break;
-            }
-            // Skip comment lines (they're not part of the value)
-            if (trimmed.startsWith("#"))
-                continue;
-            // This is part of the multiline value
-            valueLines.push(line.slice(startIndent));
-        }
-        // Clean up - remove trailing empty lines
-        while (valueLines.length > 0 && !valueLines[valueLines.length - 1].trim()) {
-            valueLines.pop();
-        }
-        return valueLines.length > 0 ? valueLines.join("\n") : null;
-    }
-    /**
-     * Parse severity string to valid type
-     */
-    parseSeverity(value) {
-        if (value === "error")
-            return "error";
-        if (value === "warning")
-            return "warning";
-        if (value === "info")
-            return "info";
-        return "warning"; // default
-    }
-    /**
-     * Extract @VAR patterns from query string
-     */
-    extractMetavars(query) {
-        const matches = query.match(/@([A-Z_][A-Z0-9_]*)/g);
-        if (!matches)
-            return [];
-        return [...new Set(matches.map((m) => m.slice(1)))];
-    }
-    /**
-     * Get queries for a specific language
-     */
-    getQueriesForLanguage(language) {
-        return this.queries.get(language) || [];
-    }
-    /**
-     * Get a specific query by ID
-     */
-    getQueryById(id) {
-        for (const langQueries of this.queries.values()) {
-            const query = langQueries.find((q) => q.id === id);
-            if (query)
-                return query;
-        }
-        return undefined;
-    }
-    /**
-     * Find matching query for a pattern string
-     */
-    findMatchingQuery(pattern, language) {
-        const langQueries = this.getQueriesForLanguage(language);
-        // Check for pattern keywords
-        for (const query of langQueries) {
-            // Match by ID
-            if (pattern.includes(query.id))
-                return query;
-            // Match by keywords in pattern
-            switch (query.id) {
-                case "empty-catch":
-                    if (pattern.includes("empty-catch") || pattern.includes("catch {}"))
-                        return query;
-                    break;
-                case "debugger-statement":
-                    if (pattern.includes("debugger"))
-                        return query;
-                    break;
-                case "await-in-loop":
-                    if (pattern.includes("await-in-loop") || pattern.includes("await"))
-                        return query;
-                    break;
-                case "hardcoded-secrets":
-                    if (pattern.includes("hardcoded") ||
-                        pattern.includes("api_key") ||
-                        pattern.includes("password"))
-                        return query;
-                    break;
-                case "dangerously-set-inner-html":
-                    if (pattern.includes("dangerously") || pattern.includes("innerHTML"))
-                        return query;
-                    break;
-                case "nested-ternary":
-                    if (pattern.includes("ternary") || pattern.includes("? :"))
-                        return query;
-                    break;
-                case "no-eval":
-                    if (pattern.includes("eval") && !pattern.includes("console"))
-                        return query;
-                    break;
-                case "deep-promise-chain":
-                    if (pattern.includes(".then") && pattern.includes(".catch"))
-                        return query;
-                    break;
-                case "console-statement":
-                    if (pattern.includes("console"))
-                        return query;
-                    break;
-                case "long-parameter-list":
-                    if (pattern.includes("PARAMS"))
-                        return query;
-                    break;
-                // Python queries
-                case "bare-except":
-                    if (pattern.includes("bare-except") || pattern.includes("except:"))
-                        return query;
-                    break;
-                case "mutable-default-arg":
-                    if (pattern.includes("mutable") || pattern.includes("default"))
-                        return query;
-                    break;
-                case "wildcard-import":
-                    if (pattern.includes("wildcard") || pattern.includes("import *"))
-                        return query;
-                    break;
-                case "eval-exec":
-                    if (pattern.includes("eval") || pattern.includes("exec"))
-                        return query;
-                    break;
-                case "is-vs-equals":
-                    if (pattern.includes("is") || pattern.includes("equals"))
-                        return query;
-                    break;
-                case "unreachable-except":
-                    if (pattern.includes("unreachable") || pattern.includes("except"))
-                        return query;
-                    break;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get all loaded queries
-     */
-    getAllQueries() {
-        const all = [];
-        for (const queries of this.queries.values()) {
-            all.push(...queries);
-        }
-        return all;
-    }
-    /**
-     * Reload queries from disk
-     */
-    async reload() {
-        this.queries.clear();
-        this.loaded = false;
-        await this.loadQueries();
-    }
-}
-// Singleton instance
-export const queryLoader = new TreeSitterQueryLoader();

package/clients/tree-sitter-symbol-extractor.js

@@ -1,289 +0,0 @@
-/**
- * Symbol extraction via tree-sitter queries
- * Extracts definitions and references from source files
- */
-import * as path from "node:path";
-// Tree-sitter query patterns for symbol extraction
-const SYMBOL_QUERIES = {
-    typescript: {
-        defs: `
-      ;; Function declarations: function foo(params) { }
-      (function_declaration
-        name: (identifier) @funcName
-        parameters: (formal_parameters) @funcParams
-        body: (statement_block) @funcBody) @funcDef
-      
-      ;; Arrow functions: const foo = (params) => { }
-      (variable_declarator
-        name: (identifier) @arrowName
-        value: (arrow_function
-          parameters: (formal_parameters) @arrowParams
-          body: (_) @arrowBody)) @arrowDef
-      
-      ;; Class declarations: class Foo { }
-      (class_declaration
-        name: (type_identifier) @className) @classDef
-      
-      ;; Method definitions: class Foo { bar() { } }
-      (method_definition
-        name: (property_identifier) @methodName
-        parameters: (formal_parameters) @methodParams) @methodDef
-      
-      ;; Interface declarations: interface Foo { }
-      (interface_declaration
-        name: (type_identifier) @interfaceName) @interfaceDef
-      
-      ;; Type alias: type Foo = ...
-      (type_alias_declaration
-        name: (type_identifier) @typeName) @typeDef
-    `,
-        refs: `
-      ;; Function/method calls: foo() or obj.bar()
-      (call_expression
-        function: (identifier) @callIdent) @callRef
-      
-      (call_expression
-        function: (member_expression
-          object: (_)
-          property: (property_identifier) @callMethod)) @callMethodRef
-      
-      ;; New expressions: new Foo()
-      (new_expression
-        constructor: (identifier) @newIdent) @newRef
-      
-      ;; Type references: type T = Foo
-      (type_identifier) @typeIdent
-    `,
-    },
-    python: {
-        defs: `
-      ;; Function definitions: def foo(params):
-      (function_definition
-        name: (identifier) @funcName
-        parameters: (parameters) @funcParams) @funcDef
-      
-      ;; Class definitions: class Foo:
-      (class_definition
-        name: (identifier) @className) @classDef
-      
-      ;; Method definitions (within class)
-      (class_definition
-        body: (block
-          (function_definition
-            name: (identifier) @methodName
-            parameters: (parameters) @methodParams) @methodDef))
-    `,
-        refs: `
-      ;; Function calls: foo() or obj.bar()
-      (call
-        function: (identifier) @callIdent) @callRef
-      
-      (call
-        function: (attribute
-          object: (_)
-          attribute: (identifier) @callMethod)) @callMethodRef
-    `,
-    },
-    rust: {
-        defs: `
-      ;; Function definitions: fn foo(params) { }
-      (function_item
-        name: (identifier) @funcName
-        parameters: (parameters) @funcParams) @funcDef
-      
-      ;; Struct definitions: struct Foo { }
-      (struct_item
-        name: (type_identifier) @structName) @structDef
-      
-      ;; Impl blocks: impl Foo { fn bar() { } }
-      (impl_item
-        type: (type_identifier) @implType
-        body: (declaration_list
-          (function_item
-            name: (identifier) @implMethodName) @implMethodDef))
-    `,
-        refs: `
-      ;; Function calls: foo() or obj.bar()
-      (call_expression
-        function: (identifier) @callIdent) @callRef
-      
-      (call_expression
-        function: (field_expression
-          value: (_)
-          field: (field_identifier) @callField)) @callFieldRef
-    `,
-    },
-};
-export class TreeSitterSymbolExtractor {
-    constructor(languageId, client) {
-        this.languageId = languageId;
-        this.client = client;
-    }
-    async init() {
-        try {
-            // Get language from client
-            const language = this.client.getLanguage(this.languageId);
-            if (!language)
-                return false;
-            const { Query } = await import("web-tree-sitter");
-            const queries = SYMBOL_QUERIES[this.languageId];
-            if (!queries)
-                return false;
-            // biome-ignore lint/suspicious/noExplicitAny: Language type
-            this.defQuery = new Query(language, queries.defs);
-            // biome-ignore lint/suspicious/noExplicitAny: Language type
-            this.refQuery = new Query(language, queries.refs);
-            return true;
-        }
-        catch (err) {
-            console.error(`[symbol-extractor] Failed to init ${this.languageId}:`, err);
-            return false;
-        }
-    }
-    /**
-     * Extract symbols from a parsed tree-sitter tree
-     */
-    extract(
-    // biome-ignore lint/suspicious/noExplicitAny: Tree type
-    tree, filePath, content) {
-        const symbols = [];
-        const refs = [];
-        const relativePath = path.relative(process.cwd(), filePath);
-        // Extract definitions
-        const defMatches = this.defQuery.matches(tree.rootNode);
-        for (const match of defMatches) {
-            const symbol = this.parseDefMatch(match, relativePath, content);
-            if (symbol)
-                symbols.push(symbol);
-        }
-        // Extract references
-        const refMatches = this.refQuery.matches(tree.rootNode);
-        for (const match of refMatches) {
-            const ref = this.parseRefMatch(match, relativePath);
-            if (ref)
-                refs.push(ref);
-        }
-        return { symbols, refs };
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: Match type
-    parseDefMatch(match, filePath, content) {
-        const captures = {};
-        for (const capture of match.captures) {
-            captures[capture.name] = {
-                text: capture.node.text,
-                // biome-ignore lint/suspicious/noExplicitAny: Node type
-                node: capture.node,
-            };
-        }
-        // Determine kind and name
-        let name;
-        let kind;
-        let params;
-        let defNode;
-        if (captures.funcName) {
-            name = captures.funcName.text;
-            kind = "function";
-            params = captures.funcParams?.text;
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.funcDef?.node;
-        }
-        else if (captures.arrowName) {
-            name = captures.arrowName.text;
-            kind = "function";
-            params = captures.arrowParams?.text;
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.arrowDef?.node;
-        }
-        else if (captures.className) {
-            name = captures.className.text;
-            kind = "class";
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.classDef?.node;
-        }
-        else if (captures.methodName) {
-            name = captures.methodName.text;
-            kind = "method";
-            params = captures.methodParams?.text;
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.methodDef?.node;
-        }
-        else if (captures.interfaceName) {
-            name = captures.interfaceName.text;
-            kind = "interface";
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.interfaceDef?.node;
-        }
-        else if (captures.typeName) {
-            name = captures.typeName.text;
-            kind = "type";
-            // biome-ignore lint/suspicious/noExplicitAny: Node type
-            defNode = captures.typeDef?.node;
-        }
-        if (!name || !kind || !defNode)
-            return null;
-        // Check if exported (basic heuristic: has export keyword before it)
-        const isExported = this.isExported(defNode, content);
-        const signature = params ? this.extractSignature(params, kind) : undefined;
-        return {
-            id: `${filePath}:${name}`,
-            name,
-            kind,
-            filePath,
-            line: defNode.startPosition.row + 1,
-            column: defNode.startPosition.column + 1,
-            signature,
-            isExported,
-        };
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: Match type
-    parseRefMatch(match, filePath) {
-        let name;
-        let refNode;
-        for (const capture of match.captures) {
-            if (capture.name.endsWith("Ident") ||
-                capture.name.endsWith("Method") ||
-                capture.name.endsWith("Field")) {
-                name = capture.node.text;
-                // biome-ignore lint/suspicious/noExplicitAny: Node type
-                refNode = capture.node;
-            }
-            if (capture.name.endsWith("Ref") && !refNode) {
-                // biome-ignore lint/suspicious/noExplicitAny: Node type
-                refNode = capture.node;
-            }
-        }
-        if (!name || !refNode)
-            return null;
-        return {
-            symbolId: `${filePath}:${name}`, // Will be resolved later
-            filePath,
-            line: refNode.startPosition.row + 1,
-            column: refNode.startPosition.column + 1,
-        };
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: Node type
-    isExported(node, content) {
-        // Simple heuristic: check for "export" keyword before the node
-        const lines = content.split("\n");
-        const lineIdx = node.startPosition.row;
-        const line = lines[lineIdx] || "";
-        return line.includes("export") || this.hasExportModifier(node, content);
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: Node type
-    hasExportModifier(_node, _content) {
-        // TODO: Implement proper export modifier detection
-        // For now, use simple line-based check
-        return false;
-    }
-    extractSignature(paramsText, kind) {
-        if (kind === "function" || kind === "method") {
-            // Clean up params: remove comments, normalize whitespace
-            return paramsText
-                .replace(/\/\*[\s\S]*?\*\//g, "")
-                .replace(/\/\/.*$/gm, "")
-                .replace(/\s+/g, " ")
-                .trim();
-        }
-        return undefined;
-    }
-}