pi-lens 3.7.1 → 3.8.2

package/clients/tree-sitter-fixer.ts

@@ -0,0 +1,217 @@
+/**
+ * Tree-sitter Fixer
+ *
+ * Calculates text replacements for tree-sitter structural matches.
+ * Used to implement auto-fixes for tree-sitter rules.
+ */
+
+import * as fs from "node:fs";
+
+export interface FixTemplate {
+	action: "remove" | "replace" | "wrap";
+	template?: string; // For replace/wrap: use {{VAR}} for metavariable interpolation
+	replacement?: string; // Simple string replacement
+}
+
+export interface FixEdit {
+	filePath: string;
+	startLine: number;
+	startColumn: number;
+	endLine: number;
+	endColumn: number;
+	oldText: string;
+	newText: string;
+}
+
+export class TreeSitterFixer {
+	/**
+	 * Calculate fix for a structural match
+	 */
+	calculateFix(
+		filePath: string,
+		nodeRange: {
+			startLine: number;
+			startColumn: number;
+			endLine: number;
+			endColumn: number;
+		},
+		nodeText: string,
+		template: FixTemplate,
+		captures: Record<string, string>,
+	): FixEdit | null {
+		switch (template.action) {
+			case "remove":
+				return this.calculateRemove(filePath, nodeRange, nodeText);
+			case "replace":
+				return this.calculateReplace(
+					filePath,
+					nodeRange,
+					nodeText,
+					template,
+					captures,
+				);
+			case "wrap":
+				return this.calculateWrap(
+					filePath,
+					nodeRange,
+					nodeText,
+					template,
+					captures,
+				);
+			default:
+				return null;
+		}
+	}
+
+	/**
+	 * Calculate removal fix (delete the matched node)
+	 */
+	private calculateRemove(
+		filePath: string,
+		nodeRange: {
+			startLine: number;
+			startColumn: number;
+			endLine: number;
+			endColumn: number;
+		},
+		nodeText: string,
+	): FixEdit {
+		return {
+			filePath,
+			startLine: nodeRange.startLine,
+			startColumn: nodeRange.startColumn,
+			endLine: nodeRange.endLine,
+			endColumn: nodeRange.endColumn,
+			oldText: nodeText,
+			newText: "",
+		};
+	}
+
+	/**
+	 * Calculate replacement fix
+	 */
+	private calculateReplace(
+		filePath: string,
+		nodeRange: {
+			startLine: number;
+			startColumn: number;
+			endLine: number;
+			endColumn: number;
+		},
+		nodeText: string,
+		template: FixTemplate,
+		captures: Record<string, string>,
+	): FixEdit | null {
+		let newText = template.replacement || template.template || "";
+
+		// Interpolate captures: {{VAR}} -> capture value
+		for (const [name, value] of Object.entries(captures)) {
+			newText = newText.replace(new RegExp(`\\{\\{${name}\\}\\}`, "g"), value);
+		}
+
+		return {
+			filePath,
+			startLine: nodeRange.startLine,
+			startColumn: nodeRange.startColumn,
+			endLine: nodeRange.endLine,
+			endColumn: nodeRange.endColumn,
+			oldText: nodeText,
+			newText,
+		};
+	}
+
+	/**
+	 * Calculate wrap fix (wrap matched code in new structure)
+	 */
+	private calculateWrap(
+		filePath: string,
+		nodeRange: {
+			startLine: number;
+			startColumn: number;
+			endLine: number;
+			endColumn: number;
+		},
+		nodeText: string,
+		template: FixTemplate,
+		captures: Record<string, string>,
+	): FixEdit | null {
+		if (!template.template) return null;
+
+		let wrapped = template.template;
+
+		// Replace {{BODY}} or similar with the actual code
+		for (const [name, value] of Object.entries(captures)) {
+			wrapped = wrapped.replace(new RegExp(`\\{\\{${name}\\}\\}`, "g"), value);
+		}
+
+		return {
+			filePath,
+			startLine: nodeRange.startLine,
+			startColumn: nodeRange.startColumn,
+			endLine: nodeRange.endLine,
+			endColumn: nodeRange.endColumn,
+			oldText: nodeText,
+			newText: wrapped,
+		};
+	}
+
+	/**
+	 * Apply a fix to a file
+	 */
+	applyFix(edit: FixEdit): void {
+		const content = fs.readFileSync(edit.filePath, "utf-8");
+		const lines = content.split("\n");
+
+		// Calculate absolute positions
+		const startLineIdx = edit.startLine - 1; // 0-indexed
+		const endLineIdx = edit.endLine - 1;
+
+		// Build new content
+		const before = lines.slice(0, startLineIdx).join("\n");
+		const after = lines.slice(endLineIdx + 1).join("\n");
+
+		// Handle same-line case
+		if (startLineIdx === endLineIdx) {
+			const line = lines[startLineIdx];
+			const beforePart = line.slice(0, edit.startColumn);
+			const afterPart = line.slice(edit.endColumn);
+			const newLine = beforePart + edit.newText + afterPart;
+			lines[startLineIdx] = newLine;
+			fs.writeFileSync(edit.filePath, lines.join("\n"), "utf-8");
+			return;
+		}
+
+		// Multi-line replacement
+		const newContent =
+			(before ? before + "\n" : "") +
+			edit.newText +
+			(after ? "\n" + after : "");
+
+		fs.writeFileSync(edit.filePath, newContent, "utf-8");
+	}
+
+	/**
+	 * Check if two edits overlap (can't apply both)
+	 */
+	editsOverlap(edit1: FixEdit, edit2: FixEdit): boolean {
+		if (edit1.filePath !== edit2.filePath) return false;
+
+		// Simple line-based overlap check
+		// More sophisticated would check column ranges too
+		return !(
+			edit1.endLine < edit2.startLine || edit2.endLine < edit1.startLine
+		);
+	}
+
+	/**
+	 * Sort edits by position (top to bottom) for sequential application
+	 */
+	sortEdits(edits: FixEdit[]): FixEdit[] {
+		return [...edits].sort((a, b) => {
+			if (a.startLine !== b.startLine) {
+				return a.startLine - b.startLine;
+			}
+			return a.startColumn - b.startColumn;
+		});
+	}
+}

package/clients/tree-sitter-navigator.ts

@@ -0,0 +1,329 @@
+/**
+ * Tree-sitter AST Navigator
+ *
+ * Provides tree traversal utilities for context-aware analysis:
+ * - Parent/sibling navigation
+ * - Scope detection (test vs production)
+ * - Variable shadowing detection
+ * - Context-aware filtering
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: AST node type from web-tree-sitter
+export type ASTNode = any;
+
+export interface ScopeContext {
+	isTestBlock: boolean;
+	isLoop: boolean;
+	isAsync: boolean;
+	functionDepth: number;
+	scopeChain: string[];
+}
+
+export class TreeSitterNavigator {
+	/**
+	 * Find parent node of a specific type
+	 */
+	findParent(node: ASTNode, type: string | string[]): ASTNode | null {
+		let current = node.parent;
+		const types = Array.isArray(type) ? type : [type];
+
+		while (current) {
+			if (types.includes(current.type)) {
+				return current;
+			}
+			current = current.parent;
+		}
+		return null;
+	}
+
+	/**
+	 * Check if node is inside a specific type of parent
+	 */
+	isInside(node: ASTNode, type: string | string[]): boolean {
+		return this.findParent(node, type) !== null;
+	}
+
+	/**
+	 * Get all ancestors of a node
+	 */
+	getAncestors(node: ASTNode): ASTNode[] {
+		const ancestors: ASTNode[] = [];
+		let current = node.parent;
+
+		while (current) {
+			ancestors.push(current);
+			current = current.parent;
+		}
+
+		return ancestors;
+	}
+
+	/**
+	 * Detect if we're in a test block (it, describe, test, etc.)
+	 */
+	isInTestBlock(node: ASTNode): boolean {
+		const testPatterns = [
+			"call_expression", // it(), describe(), test()
+		];
+
+		let current = node.parent;
+		while (current) {
+			if (testPatterns.includes(current.type)) {
+				// Check if the call is a test function
+				const callName = this.getCallName(current);
+				if (
+					callName &&
+					/^\b(it|describe|test|before|after|beforeEach|afterEach)\b/.test(
+						callName,
+					)
+				) {
+					return true;
+				}
+			}
+			current = current.parent;
+		}
+		return false;
+	}
+
+	/**
+	 * Get the name of a call expression (e.g., "it" from it("test", ...))
+	 */
+	getCallName(node: ASTNode): string | null {
+		if (node.type !== "call_expression") return null;
+
+		const func = node.children[0];
+		if (!func) return null;
+
+		if (func.type === "identifier") {
+			return func.text;
+		}
+
+		if (func.type === "member_expression") {
+			// Handle cases like describe.skip, it.only, etc.
+			const parts: string[] = [];
+			for (const child of func.children) {
+				if (
+					child.type === "identifier" ||
+					child.type === "property_identifier"
+				) {
+					parts.push(child.text);
+				}
+			}
+			return parts.join(".");
+		}
+
+		return null;
+	}
+
+	/**
+	 * Detect if we're inside a try/catch block
+	 * Use as post_filter: not_in_try_catch to enforce "must be wrapped"
+	 */
+	isInTryCatch(node: ASTNode): boolean {
+		// try_statement: TypeScript, JavaScript, Python
+		// begin:         Ruby (begin/rescue/ensure)
+		// rescue:        Ruby inline rescue modifier
+		return this.isInside(node, ["try_statement", "begin", "rescue"]);
+	}
+
+	/**
+	 * Detect if we're inside a loop (for, while, forEach)
+	 */
+	isInLoop(node: ASTNode): boolean {
+		return this.isInside(node, [
+			"for_statement",
+			"while_statement",
+			"do_statement",
+			"for_in_statement",
+			"for_of_statement",
+		]);
+	}
+
+	/**
+	 * Detect if we're in an async context (async function or contains await)
+	 */
+	isInAsyncContext(node: ASTNode): boolean {
+		// Check parent function for async keyword
+		const functionTypes = [
+			"function_declaration",
+			"function_expression",
+			"arrow_function",
+			"method_definition",
+		];
+
+		let current = node.parent;
+		while (current) {
+			if (functionTypes.includes(current.type)) {
+				// Check for async keyword
+				if (current.children?.some((c: ASTNode) => c.text === "async")) {
+					return true;
+				}
+			}
+			current = current.parent;
+		}
+		return false;
+	}
+
+	/**
+	 * Get scope chain (list of function/block scopes enclosing this node)
+	 */
+	getScopeChain(node: ASTNode): string[] {
+		const chain: string[] = [];
+		let current = node.parent;
+
+		while (current) {
+			if (
+				[
+					"function_declaration",
+					"function_expression",
+					"arrow_function",
+					"method_definition",
+					"block",
+					"statement_block",
+				].includes(current.type)
+			) {
+				const name = this.getNodeName(current);
+				if (name) {
+					chain.push(name);
+				} else {
+					chain.push(`<${current.type}>`);
+				}
+			}
+			current = current.parent;
+		}
+
+		return chain;
+	}
+
+	/**
+	 * Get name of a function/class node
+	 */
+	getNodeName(node: ASTNode): string | null {
+		// Try to find name identifier
+		for (const child of node.children || []) {
+			if (child.type === "identifier" && child.isNamed) {
+				return child.text;
+			}
+		}
+
+		// For member definitions, check name field
+		if (node.type === "method_definition") {
+			const nameNode = node.children?.find(
+				(c: ASTNode) => c.type === "property_identifier",
+			);
+			return nameNode?.text || null;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Check if a variable is shadowed in current scope
+	 */
+	isShadowed(node: ASTNode, varName: string): boolean {
+		// Navigate up to find if this variable name is redeclared
+		let current = node.parent;
+
+		while (current) {
+			// Check for variable declarations
+			if (
+				["variable_declaration", "lexical_declaration"].includes(current.type)
+			) {
+				// Check if this declaration shadows our variable
+				const declarator = current.children?.find(
+					(c: ASTNode) => c.type === "variable_declarator",
+				);
+				if (declarator) {
+					const idNode = declarator.children?.find(
+						(c: ASTNode) => c.type === "identifier",
+					);
+					if (idNode?.text === varName) {
+						return true;
+					}
+				}
+			}
+
+			// Check function parameters
+			if (
+				[
+					"function_declaration",
+					"function_expression",
+					"arrow_function",
+					"method_definition",
+				].includes(current.type)
+			) {
+				const params = current.children?.find(
+					(c: ASTNode) => c.type === "formal_parameters",
+				);
+				if (params) {
+					for (const param of params.children || []) {
+						if (param.type === "identifier" && param.text === varName) {
+							return true;
+						}
+					}
+				}
+			}
+
+			current = current.parent;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Get comprehensive scope context for a node
+	 */
+	getScopeContext(node: ASTNode): ScopeContext {
+		const ancestors = this.getAncestors(node);
+		const functionDepth = ancestors.filter((a) =>
+			[
+				"function_declaration",
+				"function_expression",
+				"arrow_function",
+				"method_definition",
+			].includes(a.type),
+		).length;
+
+		return {
+			isTestBlock: this.isInTestBlock(node),
+			isLoop: this.isInLoop(node),
+			isAsync: this.isInAsyncContext(node),
+			functionDepth,
+			scopeChain: this.getScopeChain(node),
+		};
+	}
+
+	/**
+	 * Find sibling nodes (nodes at the same level)
+	 */
+	getSiblings(node: ASTNode): ASTNode[] {
+		if (!node.parent) return [];
+		return node.parent.children?.filter((c: ASTNode) => c !== node) || [];
+	}
+
+	/**
+	 * Get previous sibling
+	 */
+	getPreviousSibling(node: ASTNode): ASTNode | null {
+		if (!node.parent) return null;
+		const siblings = node.parent.children || [];
+		const index = siblings.indexOf(node);
+		if (index > 0) {
+			return siblings[index - 1];
+		}
+		return null;
+	}
+
+	/**
+	 * Get next sibling
+	 */
+	getNextSibling(node: ASTNode): ASTNode | null {
+		if (!node.parent) return null;
+		const siblings = node.parent.children || [];
+		const index = siblings.indexOf(node);
+		if (index >= 0 && index < siblings.length - 1) {
+			return siblings[index + 1];
+		}
+		return null;
+	}
+}

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

@@ -7,9 +7,7 @@
 
 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));
+import { resolvePackagePath } from "./package-root.js";
 
 export interface TreeSitterQuery {
 	id: string;
@@ -24,6 +22,15 @@ export interface TreeSitterQuery {
 	post_filter?: string;
 	// biome-ignore lint/suspicious/noExplicitAny: Flexible filter params
 	post_filter_params?: Record<string, any>;
+	/**
+	 * Native tree-sitter predicates for filtering (#eq?, #match?)
+	 * These run in WASM and are faster than post-filters
+	 */
+	predicates?: Array<{
+		type: "eq" | "match" | "any-of";
+		var: string;
+		value: string | string[];
+	}>;
 	tags?: string[];
 	has_fix: boolean;
 	fix_action?: string;
@@ -56,38 +63,45 @@ export class TreeSitterQueryLoader {
 	async loadQueries(): Promise<Map<string, TreeSitterQuery[]>> {
 		if (this.loaded) return this.queries;
 
-		const queriesDir = path.join(process.cwd(), "rules", "tree-sitter-queries");
+		// Load from user's project rules AND package built-in rules (coexist)
+		const queryDirs = [
+			...new Set([
+				path.join(process.cwd(), "rules", "tree-sitter-queries"),
+				resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries"),
+			]),
+		];
+
+		for (const queriesDir of queryDirs) {
+			if (!fs.existsSync(queriesDir)) {
+				this.dbg(`Queries directory not found: ${queriesDir}`);
+				continue;
+			}
 
-		if (!fs.existsSync(queriesDir)) {
-			this.dbg(`Queries directory not found: ${queriesDir}`);
-			return this.queries;
-		}
+			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"));
 
-		// 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: TreeSitterQuery[] = [];
-
-			for (const file of queryFiles) {
-				const filePath = path.join(langDir, file);
-				const query = this.parseQueryFile(filePath, lang);
-				if (query) {
-					langQueries.push(query);
+				const langQueries = this.queries.get(lang) ?? [];
+
+				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}`);
+				if (langQueries.length > 0) {
+					this.queries.set(lang, langQueries);
+					this.dbg(`Loaded ${langQueries.length} queries for ${lang}`);
+				}
 			}
 		}
 
@@ -133,6 +147,14 @@ export class TreeSitterQueryLoader {
 					: undefined,
 				// biome-ignore lint/suspicious/noExplicitAny: Post filter params
 				post_filter_params: parsed.post_filter_params as any,
+				// Parse predicates if present
+				predicates: Array.isArray(parsed.predicates)
+					? parsed.predicates.map((p: any) => ({
+							type: p.type,
+							var: p.var,
+							value: p.value,
+						}))
+					: undefined,
 				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,
@@ -364,7 +386,8 @@ export class TreeSitterQueryLoader {
 						return query;
 					break;
 				case "console-statement":
-					if (pattern.includes("console")) return query;
+					if (pattern.includes("console") && !pattern.includes("test"))
+						return query;
 					break;
 				case "long-parameter-list":
 					if (pattern.includes("PARAMS")) return query;