pi-lens 3.3.0 → 3.6.0

package/clients/dispatch/integration.ts

@@ -15,7 +15,7 @@ import {
 	getLatencyReports,
 	type RunnerLatency,
 } from "./dispatcher.js";
-import type { PiAgentAPI } from "./types.js";
+import type { BaselineStore, DispatchResult, PiAgentAPI } from "./types.js";
 
 export type { DispatchLatencyReport, RunnerLatency };
 // Re-export latency tracking types and functions
@@ -24,6 +24,21 @@ export { clearLatencyReports, formatLatencyReport, getLatencyReports };
 // Import runners to register them
 import "./runners/index.js";
 
+// --- Persistent Baseline Store ---
+// Survives across dispatchLint calls within a session.
+// Without this, delta mode is a no-op: every call creates a fresh empty
+// store, so baselines.get() always returns undefined and every issue
+// looks "new" every time.
+const sessionBaselines: BaselineStore = createBaselineStore();
+
+/**
+ * Reset baselines — call on session_start so a new session
+ * starts with a clean slate.
+ */
+export function resetDispatchBaselines(): void {
+	sessionBaselines.clear();
+}
+
 /**
  * Run linting for a file using the declarative dispatch system
  *
@@ -38,7 +53,9 @@ export async function dispatchLint(
 	pi: PiAgentAPI,
 ): Promise<string> {
 	// By default, only run BLOCKING rules for fast feedback on file write
-	const ctx = createDispatchContext(filePath, cwd, pi, undefined, true);
+	// Uses persistent sessionBaselines so delta mode actually filters
+	// pre-existing issues after the first write.
+	const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
 
 	// Import dispatchForFile dynamically to avoid circular deps
 	const { dispatchForFile } = await import("./dispatcher.js");
@@ -55,6 +72,47 @@ export async function dispatchLint(
 	return result.output;
 }
 
+/**
+ * Run linting and return full result (including diagnostics)
+ */
+export async function dispatchLintWithResult(
+	filePath: string,
+	cwd: string,
+	pi: PiAgentAPI,
+): Promise<DispatchResult> {
+	const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
+
+	const { dispatchForFile } = await import("./dispatcher.js");
+	const { getRunnersForKind } = await import("./dispatcher.js");
+	const { TOOL_PLANS } = await import("./plan.js");
+
+	const kind = ctx.kind;
+	if (!kind) {
+		return {
+			diagnostics: [],
+			blockers: [],
+			warnings: [],
+			fixed: [],
+			output: "",
+			hasBlockers: false,
+		};
+	}
+
+	const plan = TOOL_PLANS[kind];
+	if (!plan) {
+		return {
+			diagnostics: [],
+			blockers: [],
+			warnings: [],
+			fixed: [],
+			output: "",
+			hasBlockers: false,
+		};
+	}
+
+	return await dispatchForFile(ctx, plan.groups);
+}
+
 /**
  * Create a baseline store for delta mode tracking
  */

package/clients/dispatch/plan.js

@@ -31,10 +31,12 @@ export const TOOL_PLANS = {
             // Tree-sitter native structural analysis (blocking rules: constructor-super, dangerouslySetInnerHTML, etc.)
             { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
             // AST structural analysis (blocking: no-dupe-keys, no-hardcoded-secrets, jwt-no-verify, etc.)
-            // DISABLED in post-write - ast-grep-napi can crash. Runs via /lens-booboo only.
-            // { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
+            // Only error-severity rules fire inline (blockingOnly=true). Warnings are booboo-only.
+            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
             // Type safety checks (has some blocking errors)
             { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
+            // Similarity detection — warns about duplicated/reusable code
+            { mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
             // Note: ast-grep CLI kept for ast_grep_search/ast_grep_replace tools only
             // Note: biome, oxlint handled by direct auto-fix calls in index.ts (not in dispatch)
             // Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
@@ -163,6 +165,7 @@ export const FULL_LINT_PLANS = {
                 filterKinds: ["jsts"],
             },
             { mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
+            { mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
             { mode: "fallback", runnerIds: ["architect"], filterKinds: ["jsts"] },
         ],
     },

package/clients/dispatch/plan.ts

@@ -35,10 +35,12 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 			// Tree-sitter native structural analysis (blocking rules: constructor-super, dangerouslySetInnerHTML, etc.)
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
 			// AST structural analysis (blocking: no-dupe-keys, no-hardcoded-secrets, jwt-no-verify, etc.)
-			// DISABLED in post-write - ast-grep-napi can crash. Runs via /lens-booboo only.
-			// { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
+			// Only error-severity rules fire inline (blockingOnly=true). Warnings are booboo-only.
+			{ mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
 			// Type safety checks (has some blocking errors)
 			{ mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
+			// Similarity detection — warns about duplicated/reusable code
+			{ mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
 			// Note: ast-grep CLI kept for ast_grep_search/ast_grep_replace tools only
 			// Note: biome, oxlint handled by direct auto-fix calls in index.ts (not in dispatch)
 			// Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
@@ -178,6 +180,7 @@ export const FULL_LINT_PLANS: Record<string, ToolPlan> = {
 				filterKinds: ["jsts"],
 			},
 			{ mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
+			{ mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
 			{ mode: "fallback", runnerIds: ["architect"], filterKinds: ["jsts"] },
 		],
 	},

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

@@ -8,7 +8,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { calculateRuleComplexity, isStructuredRule, loadYamlRules, MAX_BLOCKING_RULE_COMPLEXITY, } from "./yaml-rule-parser.js";
+import { calculateRuleComplexity, hasUnsupportedConditions, isOverlyBroadPattern, isStructuredRule, loadYamlRules, MAX_BLOCKING_RULE_COMPLEXITY, } from "./yaml-rule-parser.js";
 // Lazy load the napi package
 let sg;
 let sgLoadAttempted = false;
@@ -32,6 +32,14 @@ const SUPPORTED_EXTS = [".ts", ".tsx", ".js", ".jsx", ".css", ".html", ".htm"];
 const MAX_MATCHES_PER_RULE = 10;
 /** Maximum total diagnostics per file to prevent output spam */
 const MAX_TOTAL_DIAGNOSTICS = 50;
+/** Rules already covered by tree-sitter runner (priority 14, runs first) */
+const TREE_SITTER_OVERLAP = new Set([
+    "constructor-super",
+    "empty-catch",
+    "long-parameter-list",
+    "nested-ternary",
+    "no-dupe-class-members",
+]);
 /** Maximum AST depth to traverse to prevent stack overflow on deeply nested files */
 const MAX_AST_DEPTH = 50;
 /** Maximum recursion depth for structured rule execution */
@@ -59,76 +67,170 @@ function getLang(filePath, sgModule) {
     }
 }
 /**
- * Execute a structured rule using manual AST traversal
+ * Check if a single node matches a condition (without searching descendants).
+ * In ast-grep semantics:
+ * - pattern/kind/regex: check the node itself
+ * - all: node must match ALL sub-conditions
+ * - any: node must match at least ONE sub-condition
+ * - not: node must NOT match the sub-condition
+ * - has: node must have a DESCENDANT matching the sub-condition
  */
-function executeStructuredRule(rootNode, condition, matches = [], depth = 0) {
+function nodeMatchesCondition(node, condition, depth = 0) {
     if (depth > MAX_RULE_DEPTH)
-        return matches;
-    let candidates = [];
+        return false;
+    // Check kind constraint
+    if (condition.kind && node.kind() !== condition.kind)
+        return false;
+    // Check pattern constraint (node itself must match)
     if (condition.pattern) {
+        try {
+            const matches = node.findAll(condition.pattern);
+            // Check if the node itself is among the matches (same start position)
+            const nodeRange = node.range();
+            let selfMatch = false;
+            for (const m of matches) {
+                const mr = m.range();
+                if (mr.start.line === nodeRange.start.line &&
+                    mr.start.column === nodeRange.start.column &&
+                    mr.end.line === nodeRange.end.line &&
+                    mr.end.column === nodeRange.end.column) {
+                    selfMatch = true;
+                    break;
+                }
+            }
+            if (!selfMatch)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Check regex constraint
+    if (condition.regex) {
+        try {
+            const text = node.text();
+            if (!new RegExp(condition.regex).test(text))
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Check has (descendant must match)
+    if (condition.has) {
+        const descendants = findMatchingNodes(node, condition.has, depth + 1);
+        if (descendants.length === 0)
+            return false;
+    }
+    // Check not (node must NOT match this condition)
+    if (condition.not) {
+        if (nodeMatchesCondition(node, condition.not, depth + 1))
+            return false;
+    }
+    // Check all (node must match ALL sub-conditions)
+    if (condition.all) {
+        for (const sub of condition.all) {
+            if (!nodeMatchesCondition(node, sub, depth + 1))
+                return false;
+        }
+    }
+    // Check any (node must match at least one sub-condition)
+    if (condition.any) {
+        let anyMatch = false;
+        for (const sub of condition.any) {
+            if (nodeMatchesCondition(node, sub, depth + 1)) {
+                anyMatch = true;
+                break;
+            }
+        }
+        if (!anyMatch)
+            return false;
+    }
+    return true;
+}
+/**
+ * Find all nodes in the tree that match a condition.
+ * This is the "search" function - traverses the tree and checks each node.
+ */
+function findMatchingNodes(rootNode, condition, depth = 0) {
+    if (depth > MAX_RULE_DEPTH)
+        return [];
+    const matches = [];
+    // Optimization: if the condition has a kind, only check nodes of that kind
+    // If it has a pattern, use findAll for initial candidates
+    let candidates;
+    if (condition.pattern && !condition.all && !condition.any) {
+        // Use findAll for pattern-only conditions (fast path)
         try {
             candidates = rootNode.findAll(condition.pattern);
         }
         catch {
-            return matches;
+            return [];
         }
     }
-    else if (condition.kind) {
+    else if (condition.kind && !condition.all && !condition.any) {
+        // Use findByKind for kind-only conditions (fast path)
         candidates = findByKind(rootNode, condition.kind, 0);
     }
+    else if (condition.all) {
+        // For `all`, find the narrowest sub-condition to generate candidates
+        candidates = getCandidatesForAll(rootNode, condition.all);
+    }
+    else if (condition.any) {
+        // For `any`, union candidates from all sub-conditions
+        const seen = new Set();
+        candidates = [];
+        for (const sub of condition.any) {
+            const subMatches = findMatchingNodes(rootNode, sub, depth + 1);
+            for (const m of subMatches) {
+                const r = m.range();
+                const key = `${r.start.line}:${r.start.column}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    candidates.push(m);
+                }
+            }
+        }
+    }
     else {
+        // Fallback: traverse all nodes
         candidates = getAllNodes(rootNode, 0);
     }
     for (const candidate of candidates) {
-        const node = candidate;
-        let matchesCondition = true;
-        if (condition.has && matchesCondition) {
-            const subMatches = executeStructuredRule(node, condition.has, [], depth + 1);
-            if (subMatches.length === 0)
-                matchesCondition = false;
-        }
-        if (condition.not && matchesCondition) {
-            const subMatches = executeStructuredRule(node, condition.not, [], depth + 1);
-            if (subMatches.length > 0)
-                matchesCondition = false;
-        }
-        if (condition.any && matchesCondition) {
-            let anyMatches = false;
-            for (const subCondition of condition.any) {
-                const subMatches = executeStructuredRule(node, subCondition, [], depth + 1);
-                if (subMatches.length > 0) {
-                    anyMatches = true;
-                    break;
-                }
-            }
-            if (!anyMatches)
-                matchesCondition = false;
+        if (nodeMatchesCondition(candidate, condition, depth)) {
+            matches.push(candidate);
         }
-        if (condition.all && matchesCondition) {
-            for (const subCondition of condition.all) {
-                const subMatches = executeStructuredRule(node, subCondition, [], depth + 1);
-                if (subMatches.length === 0) {
-                    matchesCondition = false;
-                    break;
-                }
-            }
+    }
+    return matches;
+}
+/**
+ * For an `all` condition, find the narrowest sub-condition to generate
+ * initial candidates. This avoids scanning all nodes when one sub-condition
+ * has a specific kind or pattern.
+ */
+function getCandidatesForAll(rootNode, subs) {
+    // Prefer kind-based narrowing first, then pattern-based
+    for (const sub of subs) {
+        if (sub.kind) {
+            return findByKind(rootNode, sub.kind, 0);
         }
-        if (condition.regex && matchesCondition) {
+    }
+    for (const sub of subs) {
+        if (sub.pattern) {
             try {
-                const text = node.text();
-                const regex = new RegExp(condition.regex);
-                if (!regex.test(text))
-                    matchesCondition = false;
-            }
-            catch {
-                matchesCondition = false;
+                return rootNode.findAll(sub.pattern);
             }
-        }
-        if (matchesCondition) {
-            matches.push(node);
+            catch { }
         }
     }
-    return matches;
+    // No narrowing possible, scan all
+    return getAllNodes(rootNode, 0);
+}
+/**
+ * Legacy wrapper - execute a structured rule using the new two-phase approach.
+ */
+function executeStructuredRule(rootNode, condition, matches = [], depth = 0) {
+    return findMatchingNodes(rootNode, condition, depth);
 }
 /**
  * Find all nodes of a specific kind with depth limit
@@ -161,9 +263,7 @@ const astGrepNapiRunner = {
     id: "ast-grep-napi",
     appliesTo: ["jsts"],
     priority: 15,
-    // Post-write disabled in plan.ts (removed from TOOL_PLANS.jsts.groups).
-    // Still enabled for /lens-booboo via FULL_LINT_PLANS.
-    enabledByDefault: false,
+    enabledByDefault: true,
     skipTestFiles: true,
     async run(ctx) {
         if (!canHandle(ctx.filePath)) {
@@ -219,6 +319,21 @@ const astGrepNapiRunner = {
                 continue;
             }
             for (const rule of rules) {
+                // Skip rules already handled by tree-sitter runner (priority 14)
+                if (TREE_SITTER_OVERLAP.has(rule.id))
+                    continue;
+                // Skip rules using conditions we can't execute (inside, follows,
+                // precedes, stopBy, field, nthChild, constraints). Running these
+                // with only partial condition evaluation causes false positives.
+                if (hasUnsupportedConditions(rule))
+                    continue;
+                // Skip rules whose top-level pattern is overly broad ($NAME, $X, etc.)
+                // without additional structural constraints to narrow matches.
+                if (rule.rule &&
+                    isOverlyBroadPattern(rule.rule.pattern) &&
+                    !isStructuredRule(rule)) {
+                    continue;
+                }
                 const lang = rule.language?.toLowerCase();
                 if (lang && lang !== "typescript" && lang !== "javascript") {
                     continue;
@@ -253,8 +368,7 @@ const astGrepNapiRunner = {
                             break;
                         const node = match;
                         const range = node.range();
-                        const weight = rule.metadata?.weight || 3;
-                        const severity = weight >= 4 ? "error" : "warning";
+                        const severity = rule.severity === "error" ? "error" : "warning";
                         diagnostics.push({
                             id: `ast-grep-napi-${range.start.line}-${rule.id}`,
                             message: `[${rule.metadata?.category || "slop"}] ${rule.message || rule.id}`,
@@ -276,10 +390,15 @@ const astGrepNapiRunner = {
                 }
             }
         }
+        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
         return {
             status: "succeeded",
             diagnostics,
-            semantic: diagnostics.length > 0 ? "warning" : "none",
+            semantic: hasBlocking
+                ? "blocking"
+                : diagnostics.length > 0
+                    ? "warning"
+                    : "none",
         };
     },
 };

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

@@ -64,7 +64,8 @@ function riskyOperation() {
             console.log("NAPI result diagnostics count:", napiResult.diagnostics?.length);
             // Should complete successfully (not skipped, not failed)
             expect(napiResult.status).toBe("succeeded");
-            expect(napiResult.semantic).toBe("warning"); // Has findings, so marked as warning
+            // Semantic reflects the highest severity: "blocking" if any error-severity rules matched
+            expect(["warning", "blocking"]).toContain(napiResult.semantic);
             // Log findings
             console.log("NAPI found:", napiResult.diagnostics.length, "issues");
             console.log("\n=== NAPI FINDINGS ===");

package/clients/dispatch/runners/ast-grep-napi.test.ts

@@ -83,7 +83,8 @@ function riskyOperation() {
 
 			// Should complete successfully (not skipped, not failed)
 			expect(napiResult.status).toBe("succeeded");
-			expect(napiResult.semantic).toBe("warning"); // Has findings, so marked as warning
+			// Semantic reflects the highest severity: "blocking" if any error-severity rules matched
+			expect(["warning", "blocking"]).toContain(napiResult.semantic);
 
 			// Log findings
 			console.log("NAPI found:", napiResult.diagnostics.length, "issues");