pi-lens 3.3.0 → 3.6.0

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

@@ -6,9 +6,15 @@
  * Updated: ast-grep-napi test
  */
 
-import path from "node:path";
+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";
+import {
+	queryLoader,
+	type TreeSitterQuery,
+} from "../../tree-sitter-query-loader.js";
 import type {
 	Diagnostic,
 	DispatchContext,
@@ -27,6 +33,88 @@ function getSharedClient(): TreeSitterClient {
 	return _sharedClient;
 }
 
+/**
+ * Check if a code block is effectively empty (ignoring comments and whitespace)
+ */
+function isEmptyBlock(blockContent: string): boolean {
+	// 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: string): number {
+	// 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: TreeSitterQuery,
+	captures: Record<string, string>,
+): boolean {
+	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: string): boolean {
+	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: RunnerDefinition = {
 	id: "tree-sitter",
 	appliesTo: ["jsts", "python"],
@@ -66,18 +154,68 @@ const treeSitterRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
-		// Load queries if not already loaded
-		if (!queryLoader.getAllQueries().length) {
-			await queryLoader.loadQueries();
-		}
+		// Try cache first, fall back to loading from disk
+		let languageQueries: TreeSitterQuery[] = [];
+		const cache = new RuleCache(languageId);
 
-		// Get all loaded queries for this language
-		const allQueries = queryLoader.getAllQueries();
-		const languageQueries = allQueries.filter(
-			(q) =>
-				q.language === languageId ||
-				(isJavaScript && q.language === "typescript"),
+		// 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: string[] = [];
+		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: "",
+					}) as TreeSitterQuery,
+			);
+		} 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" };
@@ -95,10 +233,27 @@ const treeSitterRunner: RunnerDefinition = {
 					query.id, // Use query ID as pattern (findMatchingQuery will resolve it)
 					languageId,
 					rootDir,
-					{ maxResults: 10, fileFilter: (f) => f === filePath },
+					{
+						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;

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

@@ -19,9 +19,10 @@ const tsLspRunner = {
         if (!ctx.filePath.match(/\.tsx?$/)) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        // Phase 3: Use LSP client if --lens-lsp flag is enabled
+        // 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 runWithLSPClient(ctx);
+            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

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

@@ -29,9 +29,10 @@ const tsLspRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
-		// Phase 3: Use LSP client if --lens-lsp flag is enabled
+		// 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 runWithLSPClient(ctx);
+			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
 		// DEPRECATED: Fall back to built-in TypeScriptClient

package/clients/dispatch/runners/yaml-rule-parser.js

@@ -108,6 +108,46 @@ export function isStructuredRule(rule) {
         rule.rule.not ||
         rule.rule.regex);
 }
+/**
+ * Check if a rule or any of its nested conditions use features
+ * not supported by the NAPI runner (inside, follows, precedes,
+ * stopBy, field, nthChild). Rules using these must be skipped
+ * to prevent false positives from incomplete condition evaluation.
+ */
+export function hasUnsupportedConditions(rule) {
+    if (rule.constraints)
+        return true;
+    if (!rule.rule)
+        return false;
+    return conditionHasUnsupported(rule.rule);
+}
+function conditionHasUnsupported(c) {
+    if (c.inside ||
+        c.follows ||
+        c.precedes ||
+        c.stopBy ||
+        c.field ||
+        c.nthChild) {
+        return true;
+    }
+    if (c.has && conditionHasUnsupported(c.has))
+        return true;
+    if (c.not && conditionHasUnsupported(c.not))
+        return true;
+    if (c.any) {
+        for (const sub of c.any) {
+            if (conditionHasUnsupported(sub))
+                return true;
+        }
+    }
+    if (c.all) {
+        for (const sub of c.all) {
+            if (conditionHasUnsupported(sub))
+                return true;
+        }
+    }
+    return false;
+}
 export function calculateRuleComplexity(condition) {
     if (!condition)
         return 0;
@@ -209,6 +249,14 @@ export function parseSimpleYaml(content) {
                 ? (multilineKey = "message")
                 : (rule.message = stripQuotes(value));
         }
+        else if (key === "constraints") {
+            rule.constraints = {};
+            stack.push({
+                name: "constraints",
+                indent,
+                obj: rule.constraints,
+            });
+        }
         else if (key === "metadata") {
             rule.metadata = {};
             stack.push({ name: "metadata", indent, obj: rule.metadata });
@@ -241,6 +289,21 @@ export function parseSimpleYaml(content) {
             else if (key === "regex") {
                 obj.regex = stripQuotes(value);
             }
+            else if (key === "inside" || key === "follows" || key === "precedes") {
+                // Mark as present for unsupported-condition detection
+                obj[key] = {};
+                stack.push({ name: key, indent, obj: obj[key] });
+            }
+            else if (key === "stopBy") {
+                obj.stopBy = stripQuotes(value) || "end";
+            }
+            else if (key === "field") {
+                obj.field = stripQuotes(value);
+            }
+            else if (key === "nthChild") {
+                obj.nthChild = value || true;
+                stack.push({ name: "nthChild", indent, obj: {} });
+            }
             else if (key === "has" || key === "not") {
                 obj[key] = {};
                 stack.push({ name: key, indent, obj: obj[key] });
@@ -269,14 +332,19 @@ export function parseSimpleYaml(content) {
                             obj: item,
                         });
                         const itemContent = nextTrimmed.substring(2);
-                        if (itemContent.includes(":")) {
-                            const [itemKey, itemVal] = itemContent.split(":", 2);
+                        const colonPos = itemContent.indexOf(":");
+                        if (colonPos !== -1) {
+                            const itemKey = itemContent.substring(0, colonPos);
+                            const itemVal = itemContent.substring(colonPos + 1);
                             if (itemKey.trim() === "pattern") {
                                 item.pattern = stripQuotes(itemVal.trim());
                             }
                             else if (itemKey.trim() === "kind") {
                                 item.kind = itemVal.trim();
                             }
+                            else if (itemKey.trim() === "regex") {
+                                item.regex = stripQuotes(itemVal.trim());
+                            }
                         }
                         else if (itemContent) {
                             item.pattern = stripQuotes(itemContent);

package/clients/dispatch/runners/yaml-rule-parser.ts

@@ -25,6 +25,14 @@ export interface YamlRuleCondition {
 	any?: YamlRuleCondition[];
 	all?: YamlRuleCondition[];
 	not?: YamlRuleCondition;
+	// Conditions parsed but NOT supported by the NAPI runner.
+	// Rules using these are skipped to prevent false positives.
+	inside?: YamlRuleCondition;
+	follows?: YamlRuleCondition;
+	precedes?: YamlRuleCondition;
+	stopBy?: string;
+	field?: string;
+	nthChild?: unknown;
 }
 
 export interface YamlRule {
@@ -34,6 +42,7 @@ export interface YamlRule {
 	message?: string;
 	metadata?: { weight?: number; category?: string };
 	rule?: YamlRuleCondition;
+	constraints?: Record<string, { regex?: string }>;
 }
 
 interface CachedRules {
@@ -164,6 +173,44 @@ export function isStructuredRule(rule: YamlRule): boolean {
 	);
 }
 
+/**
+ * Check if a rule or any of its nested conditions use features
+ * not supported by the NAPI runner (inside, follows, precedes,
+ * stopBy, field, nthChild). Rules using these must be skipped
+ * to prevent false positives from incomplete condition evaluation.
+ */
+export function hasUnsupportedConditions(rule: YamlRule): boolean {
+	if (rule.constraints) return true;
+	if (!rule.rule) return false;
+	return conditionHasUnsupported(rule.rule);
+}
+
+function conditionHasUnsupported(c: YamlRuleCondition): boolean {
+	if (
+		c.inside ||
+		c.follows ||
+		c.precedes ||
+		c.stopBy ||
+		c.field ||
+		c.nthChild
+	) {
+		return true;
+	}
+	if (c.has && conditionHasUnsupported(c.has)) return true;
+	if (c.not && conditionHasUnsupported(c.not)) return true;
+	if (c.any) {
+		for (const sub of c.any) {
+			if (conditionHasUnsupported(sub)) return true;
+		}
+	}
+	if (c.all) {
+		for (const sub of c.all) {
+			if (conditionHasUnsupported(sub)) return true;
+		}
+	}
+	return false;
+}
+
 export function calculateRuleComplexity(
 	condition: YamlRuleCondition | undefined,
 ): number {
@@ -264,6 +311,13 @@ export function parseSimpleYaml(content: string): YamlRule | null {
 			value === "|"
 				? (multilineKey = "message")
 				: (rule.message = stripQuotes(value));
+		} else if (key === "constraints") {
+			rule.constraints = {};
+			stack.push({
+				name: "constraints",
+				indent,
+				obj: rule.constraints as unknown as YamlNode,
+			});
 		} else if (key === "metadata") {
 			rule.metadata = {};
 			stack.push({ name: "metadata", indent, obj: rule.metadata as YamlNode });
@@ -288,6 +342,17 @@ export function parseSimpleYaml(content: string): YamlRule | null {
 				obj.kind = value;
 			} else if (key === "regex") {
 				obj.regex = stripQuotes(value);
+			} else if (key === "inside" || key === "follows" || key === "precedes") {
+				// Mark as present for unsupported-condition detection
+				obj[key] = {} as YamlRuleCondition;
+				stack.push({ name: key, indent, obj: obj[key] as YamlNode });
+			} else if (key === "stopBy") {
+				obj.stopBy = stripQuotes(value) || "end";
+			} else if (key === "field") {
+				obj.field = stripQuotes(value);
+			} else if (key === "nthChild") {
+				obj.nthChild = value || true;
+				stack.push({ name: "nthChild", indent, obj: {} as YamlNode });
 			} else if (key === "has" || key === "not") {
 				obj[key] = {} as YamlRuleCondition;
 				stack.push({ name: key, indent, obj: obj[key] as YamlNode });
@@ -316,12 +381,16 @@ export function parseSimpleYaml(content: string): YamlRule | null {
 						});
 
 						const itemContent = nextTrimmed.substring(2);
-						if (itemContent.includes(":")) {
-							const [itemKey, itemVal] = itemContent.split(":", 2);
+						const colonPos = itemContent.indexOf(":");
+						if (colonPos !== -1) {
+							const itemKey = itemContent.substring(0, colonPos);
+							const itemVal = itemContent.substring(colonPos + 1);
 							if (itemKey.trim() === "pattern") {
 								item.pattern = stripQuotes(itemVal.trim());
 							} else if (itemKey.trim() === "kind") {
 								item.kind = itemVal.trim();
+							} else if (itemKey.trim() === "regex") {
+								item.regex = stripQuotes(itemVal.trim());
 							}
 						} else if (itemContent) {
 							item.pattern = stripQuotes(itemContent);

package/clients/dispatch/types.js

@@ -5,7 +5,7 @@
  * - BLOCKING: Errors that stop the agent (architect, ts-lsp errors)
  * - WARNING: Non-blocking issues (biome warnings, type-safety)
  * - FIXABLE: Issues with auto-fix available
- * - SILENT: Metrics tracked but not shown (complexity, TDR)
+ * - SILENT: Metrics tracked but not shown (complexity)
  * - INFORMATIONAL: Shown in session summary only
  *
  * The dispatcher must handle these semantics consistently.

package/clients/dispatch/types.ts

@@ -5,7 +5,7 @@
  * - BLOCKING: Errors that stop the agent (architect, ts-lsp errors)
  * - WARNING: Non-blocking issues (biome warnings, type-safety)
  * - FIXABLE: Issues with auto-fix available
- * - SILENT: Metrics tracked but not shown (complexity, TDR)
+ * - SILENT: Metrics tracked but not shown (complexity)
  * - INFORMATIONAL: Shown in session summary only
  *
  * The dispatcher must handle these semantics consistently.

package/clients/lsp/__tests__/service.test.js

@@ -430,6 +430,9 @@ function createMockClient(diagnostics = []) {
         documentSymbol: vi.fn().mockResolvedValue([]),
         workspaceSymbol: vi.fn().mockResolvedValue([]),
         implementation: vi.fn().mockResolvedValue([]),
+        prepareCallHierarchy: vi.fn().mockResolvedValue([]),
+        incomingCalls: vi.fn().mockResolvedValue([]),
+        outgoingCalls: vi.fn().mockResolvedValue([]),
         shutdown: vi.fn().mockResolvedValue(undefined),
     };
 }

package/clients/lsp/__tests__/service.test.ts

@@ -522,6 +522,9 @@ function createMockClient(diagnostics: any[] = []): LSPClientInfo {
 		documentSymbol: vi.fn().mockResolvedValue([]),
 		workspaceSymbol: vi.fn().mockResolvedValue([]),
 		implementation: vi.fn().mockResolvedValue([]),
+		prepareCallHierarchy: vi.fn().mockResolvedValue([]),
+		incomingCalls: vi.fn().mockResolvedValue([]),
+		outgoingCalls: vi.fn().mockResolvedValue([]),
 		shutdown: vi.fn().mockResolvedValue(undefined),
 	};
 }

package/clients/lsp/client.js

@@ -263,6 +263,48 @@ export async function createLSPClient(options) {
                 return [];
             }
         },
+        // --- Call Hierarchy Methods ---
+        async prepareCallHierarchy(filePath, line, character) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                const result = await connection.sendRequest("textDocument/prepareCallHierarchy", {
+                    textDocument: { uri },
+                    position: { line, character },
+                });
+                if (!result)
+                    return [];
+                return Array.isArray(result) ? result : [result];
+            }
+            catch {
+                return [];
+            }
+        },
+        async incomingCalls(item) {
+            try {
+                const result = await connection.sendRequest("callHierarchy/incomingCalls", {
+                    item,
+                });
+                if (!result)
+                    return [];
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async outgoingCalls(item) {
+            try {
+                const result = await connection.sendRequest("callHierarchy/outgoingCalls", {
+                    item,
+                });
+                if (!result)
+                    return [];
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
         async shutdown() {
             // Clear pending timers
             for (const timer of pendingDiagnostics.values()) {

package/clients/lsp/client.ts

@@ -59,6 +59,26 @@ export interface LSPSymbol {
 	children?: LSPSymbol[];
 }
 
+// --- Call Hierarchy Types ---
+
+export interface LSPCallHierarchyItem {
+	name: string;
+	kind: number;
+	uri: string;
+	range: LSPLocation["range"];
+	selectionRange: LSPLocation["range"];
+}
+
+export interface LSPCallHierarchyIncomingCall {
+	from: LSPCallHierarchyItem;
+	fromRanges: LSPLocation["range"][];
+}
+
+export interface LSPCallHierarchyOutgoingCall {
+	to: LSPCallHierarchyItem;
+	fromRanges: LSPLocation["range"][];
+}
+
 export interface LSPClientInfo {
 	serverId: string;
 	root: string;
@@ -100,6 +120,16 @@ export interface LSPClientInfo {
 		line: number,
 		character: number,
 	): Promise<LSPLocation[]>;
+	/** Prepare call hierarchy at position */
+	prepareCallHierarchy(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPCallHierarchyItem[]>;
+	/** Find incoming calls (callers) */
+	incomingCalls(item: LSPCallHierarchyItem): Promise<LSPCallHierarchyIncomingCall[]>;
+	/** Find outgoing calls (callees) */
+	outgoingCalls(item: LSPCallHierarchyItem): Promise<LSPCallHierarchyOutgoingCall[]>;
 	shutdown(): Promise<void>;
 }
 
@@ -402,6 +432,55 @@ export async function createLSPClient(options: {
 			}
 		},
 
+		// --- Call Hierarchy Methods ---
+
+		async prepareCallHierarchy(filePath, line, character) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				const result = await connection.sendRequest(
+					"textDocument/prepareCallHierarchy",
+					{
+						textDocument: { uri },
+						position: { line, character },
+					},
+				);
+				if (!result) return [];
+				return Array.isArray(result) ? result : [result];
+			} catch {
+				return [];
+			}
+		},
+
+		async incomingCalls(item) {
+			try {
+				const result = await connection.sendRequest(
+					"callHierarchy/incomingCalls",
+					{
+						item,
+					},
+				);
+				if (!result) return [];
+				return Array.isArray(result) ? result : [];
+			} catch {
+				return [];
+			}
+		},
+
+		async outgoingCalls(item) {
+			try {
+				const result = await connection.sendRequest(
+					"callHierarchy/outgoingCalls",
+					{
+						item,
+					},
+				);
+				if (!result) return [];
+				return Array.isArray(result) ? result : [];
+			} catch {
+				return [];
+			}
+		},
+
 		async shutdown() {
 			// Clear pending timers
 			for (const timer of pendingDiagnostics.values()) {

package/clients/lsp/index.js

@@ -191,6 +191,33 @@ export class LSPService {
             return [];
         return spawned.client.implementation(filePath, line, character);
     }
+    /**
+     * Navigation: prepare call hierarchy at position
+     */
+    async prepareCallHierarchy(filePath, line, character) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return [];
+        return spawned.client.prepareCallHierarchy(filePath, line, character);
+    }
+    /**
+     * Navigation: find incoming calls (callers)
+     */
+    async incomingCalls(item) {
+        const spawned = await this.getClientForFile(item.uri.replace("file://", ""));
+        if (!spawned)
+            return [];
+        return spawned.client.incomingCalls(item);
+    }
+    /**
+     * Navigation: find outgoing calls (callees)
+     */
+    async outgoingCalls(item) {
+        const spawned = await this.getClientForFile(item.uri.replace("file://", ""));
+        if (!spawned)
+            return [];
+        return spawned.client.outgoingCalls(item);
+    }
     /**
      * Get all diagnostics across all tracked files (for cascade checking)
      */