@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -17,15 +17,18 @@ export const withFactTree = withTreeSitterRoot;
  * (there is no typescript-compiler fallback by design, #402). Centralising this
  * keeps each provider to just its extraction logic (and de-duplicates the prologue).
  */
-export async function extractFactsFromTree(ctx, store, defaults, extract) {
-    const writeAll = (facts) => {
+export async function extractFactsFromTree(ctx, store, defaults, extract, coverageFact) {
+    const writeAll = (facts, complete) => {
         for (const key of Object.keys(defaults)) {
             store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
         }
+        if (coverageFact) {
+            store.setFileFact(ctx.filePath, coverageFact, complete ? "complete" : "unavailable");
+        }
     };
     const content = store.getFileFact(ctx.filePath, "file.content");
-    if (!content)
-        return writeAll(defaults);
+    if (content == null)
+        return writeAll(defaults, false);
     const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
-    writeAll(parsed.parsed ? parsed.value : defaults);
+    writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
 }

package/node_modules/pi-lens/dist/clients/dispatch/indent-detect.js

@@ -0,0 +1,35 @@
+const DEFAULT_INDENTATION = { style: "space", width: 2 };
+/**
+ * Infer the prevailing indentation convention from lines that are indented.
+ * The detector deliberately has no language knowledge: formatter callers use
+ * it only as a conservative fallback when the repository has no config.
+ */
+export function detectIndentation(content) {
+    const lines = content.split(/\r?\n/);
+    const tabs = lines.filter((line) => /^\t+\S/.test(line)).length;
+    const spaceCounts = lines
+        .map((line) => line.match(/^ +(?=\S)/)?.[0].length ?? 0)
+        .filter((count) => count > 0);
+    if (tabs === 0 && spaceCounts.length === 0)
+        return DEFAULT_INDENTATION;
+    if (tabs > spaceCounts.length)
+        return { style: "tab", width: 1 };
+    if (spaceCounts.length > tabs) {
+        const counts = new Map();
+        for (const count of spaceCounts) {
+            for (const other of spaceCounts) {
+                if (other > count) {
+                    const delta = other - count;
+                    counts.set(delta, (counts.get(delta) ?? 0) + 1);
+                }
+            }
+        }
+        const inferredWidth = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0]?.[0] ?? Math.min(...spaceCounts);
+        return { style: "space", width: inferredWidth <= 8 ? inferredWidth : 2 };
+    }
+    return DEFAULT_INDENTATION;
+}
+/** Whether the content supplied evidence from which a style can be inferred. */
+export function hasDetectableIndentation(content) {
+    return /^(?:\t+| {1,})\S/m.test(content);
+}

package/node_modules/pi-lens/dist/clients/dispatch/inline-suppressions.js

@@ -9,17 +9,17 @@
  * (Python/Ruby/…), comma-separated for multiple rules, on the same line as the
  * diagnostic or the line immediately above it.
  */
+import { normalizeRuleId } from "./rule-id-normalize.js";
 const SUPPRESS_RE = /(?:\/\/|#)\s*pi-lens-ignore:\s*(.+)/;
 /**
  * Normalize a rule id to the form a user writes in a `pi-lens-ignore` comment.
  * The napi scan and the ast-grep LSP tag the same rule as `ast-grep:<id>` /
- * `<id>-js` in some surfaces (see `normalizeRuleForDedup` in lens-diagnostics);
+ * `<id>-js` in some surfaces (see the dedup key in lens-diagnostics);
  * a user's bare `<id>` must still suppress those, so we match the normalized form
- * as well as the raw one.
+ * as well as the raw one. Shared via `rule-id-normalize.ts` so the inline
+ * suppression parser and the project rule policy matcher apply the same
+ * normalization.
  */
-function normalizeSuppressRule(ruleId) {
-    return ruleId.replace(/^ast-grep:/, "").replace(/-js$/, "");
-}
 /**
  * Drop diagnostics suppressed by an inline `pi-lens-ignore: <rule[,rule2]>`
  * comment in `content` (the file the diagnostics belong to). A diagnostic is
@@ -44,8 +44,17 @@ export function applyInlineSuppressions(diagnostics, content) {
         const suppressedLine = i + 1; // same line (1-based)
         const nextLine = i + 2; // next line (1-based)
         for (const ruleId of rules) {
-            suppressed.add(`${suppressedLine}:${ruleId}`);
-            suppressed.add(`${nextLine}:${ruleId}`);
+            // #1087: normalize the COMMENT token too, not just the diagnostic id.
+            // The diagnostic side below matches raw OR normalized, so storing only
+            // the raw comment token made `// pi-lens-ignore: no-eval-js` fail to
+            // suppress a finding surfaced under the normalized `no-eval`, while the
+            // identical `disable: ["no-eval-js"]` config key worked (rule-policy
+            // normalizes both sides). Add the normalized form so the two suppression
+            // surfaces stay symmetric.
+            for (const key of new Set([ruleId, normalizeRuleId(ruleId)])) {
+                suppressed.add(`${suppressedLine}:${key}`);
+                suppressed.add(`${nextLine}:${key}`);
+            }
         }
     }
     if (suppressed.size === 0)
@@ -55,7 +64,7 @@ export function applyInlineSuppressions(diagnostics, content) {
         const line = d.line ?? 1;
         if (suppressed.has(`${line}:${rawId}`))
             return false;
-        const normId = normalizeSuppressRule(rawId);
+        const normId = normalizeRuleId(rawId);
         return normId === rawId || !suppressed.has(`${line}:${normId}`);
     });
 }