pi-lens 3.8.74 → 4.0.0

package/rules/ast-grep-rules/rules/no-bare-host-path-in-win32-branch.yml

@@ -0,0 +1,25 @@
+id: no-bare-host-path-in-win32-branch
+language: TypeScript
+severity: warning
+message: "Use win32 path operations inside a branch committed to Windows path semantics"
+note: |
+  A branch guarded by isWindowsPath/isFullyQualifiedWin32 has committed to
+  Windows path parsing. Host-default dirname/basename/join/relative/sep
+  follows the process OS and is wrong for a Windows-shaped path on POSIX.
+
+  SCOPE (review-verified, #1339): same-function consequence only. The
+  original #1150 defect — a bare dirname inside an UNGUARDED helper that
+  the guarded branch calls (cross-function) — is NOT reachable by this
+  engine and stays review-enforced via AGENTS.md defect-shape 2. The
+  rule's fixture file encodes that miss as a documented negative; flip it
+  to a positive only if cross-function reach is ever added. What this
+  rule does catch is the in-branch shape (#1152 class).
+rule:
+  all:
+    - kind: if_statement
+    - has:
+        field: condition
+        regex: "\\b(isWindowsPath|isFullyQualifiedWin32)\\s*\\("
+    - has:
+        field: consequence
+        regex: "(?s)\\bpath\\.(dirname|basename|join|relative)\\s*\\(|\\bpath\\.sep\\b|(^|[^.])\\b(dirname|basename|join|relative)\\s*\\("

package/rules/ast-grep-rules/rules/no-nested-links.yml

@@ -8,6 +8,12 @@ note: |
 rule:
   all:
     - kind: jsx_element
+    - has:
+        field: open_tag
+        kind: jsx_opening_element
+        has:
+          field: name
+          regex: "^a$"
     - has:
         kind: jsx_element
         stopBy: end
@@ -20,6 +26,7 @@ rule:
   not:
     inside:
       kind: jsx_element
+      stopBy: end
       has:
         field: open_tag
         kind: jsx_opening_element

package/rules/ast-grep-rules/rules/no-raw-json-store-write.yml

@@ -0,0 +1,30 @@
+id: no-raw-json-store-write
+language: TypeScript
+severity: warning
+message: "Use the atomic write seam for JSON stores instead of writeFileSync"
+note: |
+  JSON-backed durable state must be committed through clients/durable-store.ts
+  when read-modify-write isolation is required; that seam publishes through
+  clients/atomic-write.ts. This rule covers the direct
+  writeFileSync(path, JSON.stringify(data)) shape. Build scripts and the
+  installer's wx lock writes are intentionally outside this rule's scope.
+ignores:
+  - "**/clients/atomic-write.ts"
+  - "**/clients/installer/index.ts"
+  - "**/scripts/**"
+rule:
+  any:
+    - pattern: writeFileSync($PATH, JSON.stringify($$$ARGS))
+    - pattern: $FS.writeFileSync($PATH, JSON.stringify($$$ARGS))
+    - pattern: writeFileSync($PATH, JSON.stringify($$$ARGS), $OPTS)
+    - pattern: $FS.writeFileSync($PATH, JSON.stringify($$$ARGS), $OPTS)
+    - kind: expression_statement
+      has:
+        pattern: writeFileSync($PATH, $PAYLOAD)
+      follows:
+        pattern: const $PAYLOAD = JSON.stringify($DATA)
+    - kind: expression_statement
+      has:
+        pattern: $FS.writeFileSync($PATH, $PAYLOAD)
+      follows:
+        pattern: const $PAYLOAD = JSON.stringify($DATA)

package/rules/ast-grep-rules/rules/no-win32-isabsolute-for-qualification.yml

@@ -0,0 +1,23 @@
+id: no-win32-isabsolute-for-qualification
+language: TypeScript
+severity: warning
+message: "Use isFullyQualified for path qualification instead of win32.isAbsolute"
+note: |
+  Qualification must follow the input path's shape. Use clients/path-utils.ts
+  isFullyQualified(), which distinguishes drive-absolute, UNC, rooted-relative,
+  POSIX-absolute, and relative paths across host operating systems. The
+  implementation of isFullyQualified itself is excluded because it is the
+  compatibility seam that owns the win32 parser call.
+
+  SCOPE (review-verified, #1349): direct call forms only --
+  path.win32.isAbsolute(...) and a destructured win32.isAbsolute(...). An
+  ALIASED parser (const w = path.win32; w.isAbsolute(p) -- the shape the
+  actual pre-#1330 defect used) is beyond the engine's reach and stays
+  review-enforced; the fixture file encodes that miss as a documented
+  negative, matching the #1339 precedent.
+ignores:
+  - "**/clients/path-utils.ts"
+rule:
+  any:
+    - pattern: path.win32.isAbsolute($P)
+    - pattern: win32.isAbsolute($P)

package/rules/tree-sitter-queries/tsx/no-nested-links.yml

@@ -18,15 +18,13 @@ query: |
   (jsx_element
     open_tag: (jsx_opening_element
       (identifier) @OUTER
-      (#eq? @OUTER "a"))
-    (jsx_element
-      open_tag: (jsx_opening_element
-        (identifier) @INNER
-        (#eq? @INNER "a"))))
+      (#eq? @OUTER "a"))) @OUTER_ELEMENT
 
 metavars:
   - OUTER
-  - INNER
+  - OUTER_ELEMENT
+
+post_filter: no_nested_anchor_chain
 
 tags:
   - correctness

package/rules/tree-sitter-queries/typescript/duplicate-function-arg.yml

@@ -22,8 +22,8 @@ description: |
 
 query: |
   (formal_parameters
-    (required_parameter (identifier) @PARAM1)
-    (required_parameter (identifier) @NAME))
+    (_ pattern: (_) @PARAM1)
+    (_ pattern: (_) @NAME))
 
 metavars:
   - PARAM1

package/scripts/analyze-pi-lens-logs.mjs

@@ -8,6 +8,7 @@
  *   ~/.pi-lens/cascade*.log          JSONL impact-cascade logs
  *   ~/.pi-lens/read-guard*.log       JSONL read-guard friction logs
  *   ~/.pi-lens/tree-sitter*.log      JSONL structural runner logs
+ *   ~/.pi-lens/extension*.log        JSONL extension diagnostics and console-guard telemetry
  *   ~/.pi-lens/actionable-warnings*.log  JSONL advisory pipeline (inject/suppress)
  *   ~/.pi-lens/ast-grep-tools*.log   JSONL MCP ast-grep search/replace telemetry
  *   ~/.pi-lens/logs/*.jsonl          JSONL diagnostic findings
@@ -18,10 +19,12 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
+import { minimatch } from "minimatch";
 
 const DEFAULT_ROOT = path.join(os.homedir(), ".pi-lens");
 const DEFAULT_SINCE = "2d";
 const DEFAULT_LIMIT = 12;
+const DEFAULT_EXCLUDE_GLOBS = ["**/AppData/Local/Temp/claude/**", "**/heap-corpus*/**", "**/.plegma/work/**"];
 
 const args = parseArgs(process.argv.slice(2));
 const root = path.resolve(expandHome(args.root ?? DEFAULT_ROOT));
@@ -30,6 +33,10 @@ const limit =
 	Number.parseInt(args.limit ?? `${DEFAULT_LIMIT}`, 10) || DEFAULT_LIMIT;
 const outputJson = Boolean(args.json);
 const includeArchived = Boolean(args.archived);
+const excludeGlobs = [
+	...DEFAULT_EXCLUDE_GLOBS,
+	...(Array.isArray(args.exclude) ? args.exclude : args.exclude ? [args.exclude] : []),
+];
 
 const thresholds = {
 	startupSlowMs: Number.parseInt(args.startupSlowMs ?? "500", 10),
@@ -83,7 +90,14 @@ function parseArgs(argv) {
 			const key = arg.slice(2);
 			const next = argv[i + 1];
 			if (!next || next.startsWith("--")) out[key] = "true";
-			else out[key] = argv[++i];
+			else if (key === "exclude") {
+				const value = argv[++i];
+				out.exclude = out.exclude
+					? Array.isArray(out.exclude)
+						? [...out.exclude, value]
+						: [out.exclude, value]
+					: value;
+			} else out[key] = argv[++i];
 		}
 	}
 	return out;
@@ -158,6 +172,7 @@ function createState(files) {
 		window: { since: since?.toISOString() ?? "all", root },
 		files,
 		parseErrors: counter(),
+		excludedRows: 0,
 		seen: counter(),
 		projects: counter(),
 		smellTotals: counter(),
@@ -557,6 +572,10 @@ async function analyzeSessionStart(files, state) {
 			const ts = dateOf(match[1]);
 			if (!inWindow(ts)) return;
 			const message = match[2];
+			if (isExcludedText(message)) {
+				state.excludedRows++;
+				return;
+			}
 			state.seen.inc("sessionstart");
 
 			const cwd = /session_start cwd:\s*(.*)$/.exec(message)?.[1];
@@ -722,13 +741,45 @@ async function forEachJsonLine(file, bucket, state, visitor) {
 	await forEachLine(file, async (line) => {
 		if (!line.trim()) return;
 		try {
-			visitor(JSON.parse(line));
+			const entry = JSON.parse(line);
+			if (isExcludedEntry(entry)) {
+				state.excludedRows++;
+				return;
+			}
+			visitor(entry);
 		} catch {
 			state.parseErrors.inc(`${bucket}:${path.basename(file)}`);
 		}
 	});
 }
 
+function isExcludedEntry(entry) {
+	return pathValues(entry).some((value) =>
+		excludeGlobs.some((glob) =>
+			minimatch(value, glob, { nocase: true, dot: true }),
+		),
+	);
+}
+
+function pathValues(value, key = "") {
+	if (typeof value === "string") {
+		return /(file|path|cwd|root|project)/i.test(key) ? [normalizePath(value)] : [];
+	}
+	if (!value || typeof value !== "object") return [];
+	return Object.entries(value).flatMap(([childKey, child]) =>
+		pathValues(child, childKey),
+	);
+}
+
+function isExcludedText(text) {
+	const cwd = /session_start cwd:\s*(.*)$/.exec(text)?.[1];
+	return cwd
+		? excludeGlobs.some((glob) =>
+				minimatch(normalizePath(cwd), glob, { nocase: true, dot: true }),
+			)
+		: false;
+}
+
 async function forEachLine(file, visitor) {
 	if (!fs.existsSync(file)) return;
 	const rl = readline.createInterface({
@@ -1129,6 +1180,7 @@ function buildReport(state) {
 			Object.entries(state.files).map(([key, list]) => [key, list.length]),
 		),
 		rowsSeen: state.seen.toJSON(),
+		rowsExcluded: state.excludedRows,
 		parseErrors: state.parseErrors.toJSON(),
 		projects: state.projects.top(limit),
 		smells,
@@ -1232,6 +1284,7 @@ function printReport(report) {
 			.map(([k, v]) => `${k}=${v}`)
 			.join(", ")}`,
 	);
+	console.log(`${report.rowsExcluded} rows excluded (synthetic corpora)`);
 	if (Object.keys(report.parseErrors).length)
 		console.log(`parse errors: ${JSON.stringify(report.parseErrors)}`);
 

package/dist/clients/ast-grep-parser.js

@@ -1,86 +0,0 @@
-import * as path from "node:path";
-export class AstGrepParser {
-    getRuleDescription;
-    mapSeverity;
-    constructor(getRuleDescription, mapSeverity) {
-        this.getRuleDescription = getRuleDescription;
-        this.mapSeverity = mapSeverity;
-    }
-    parseOutput(output, filterFile) {
-        const resolvedFilterFile = path.resolve(filterFile);
-        try {
-            const items = JSON.parse(output);
-            if (Array.isArray(items)) {
-                return items
-                    .map((item) => this.parseDiagnostic(item, resolvedFilterFile))
-                    .filter((d) => d !== null);
-            }
-        }
-        catch (err) {
-            void err;
-        }
-        return output
-            .split(/\r?\n/)
-            .filter((l) => l.trim())
-            .map((line) => {
-            try {
-                return this.parseDiagnostic(JSON.parse(line), resolvedFilterFile);
-            }
-            catch (err) {
-                void err;
-                return null;
-            }
-        })
-            .filter((d) => d !== null);
-    }
-    parseDiagnostic(item, filterFile) {
-        if (item.labels?.length) {
-            return this.parseNewFormat(item, filterFile);
-        }
-        if (item.spans?.length) {
-            return this.parseLegacyFormat(item, filterFile);
-        }
-        return null;
-    }
-    parseNewFormat(item, filterFile) {
-        const label = item.labels.find((l) => l.style === "primary") || item.labels[0];
-        const filePath = path.resolve(label.file || filterFile);
-        if (filePath !== filterFile)
-            return null;
-        const start = label.range?.start || { line: 0, column: 0 };
-        const end = label.range?.end || start;
-        return {
-            line: start.line + 1,
-            column: start.column,
-            endLine: end.line + 1,
-            endColumn: end.column,
-            severity: this.mapSeverity(item.severity),
-            message: item.message || "Unknown issue",
-            rule: item.ruleId || "unknown",
-            ruleDescription: this.getRuleDescription(item.ruleId || "unknown"),
-            file: filePath,
-        };
-    }
-    parseLegacyFormat(item, filterFile) {
-        const span = item.spans?.[0];
-        if (!span)
-            return null;
-        const filePath = path.resolve(span.file || filterFile);
-        if (filePath !== filterFile)
-            return null;
-        const start = span.range?.start || { line: 0, column: 0 };
-        const end = span.range?.end || start;
-        const ruleId = item.name || item.ruleId || "unknown";
-        return {
-            line: start.line + 1,
-            column: start.column,
-            endLine: end.line + 1,
-            endColumn: end.column,
-            severity: this.mapSeverity(item.severity || item.Severity || "warning"),
-            message: item.Message?.text || item.message || "Unknown issue",
-            rule: ruleId,
-            ruleDescription: this.getRuleDescription(ruleId),
-            file: filePath,
-        };
-    }
-}