pi-lens 3.8.65 → 3.8.67

package/dist/clients/dispatch/facts/import-facts.js

@@ -1,151 +1,198 @@
-import { ts } from "../../deps/typescript.js";
 import { logLatency } from "../../latency-logger.js";
-function detectModuleType(sourceFile) {
-    let hasEsm = false;
-    let hasCjs = false;
-    function visit(node) {
-        if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-            hasEsm = true;
+import { childrenOfType, firstChildOfType, parseFactTree, walk, } from "./tree-sitter-facts.js";
+// JS/TS extensions this provider handles (→ tree-sitter typescript/tsx/javascript
+// grammars via resolveTreeSitterLanguage). Ported off the `typescript` compiler API
+// onto tree-sitter (#402) — the parse is served from the shared, cached client.
+const JSTS_EXTS = new Set([
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+]);
+function stripQuotes(raw) {
+    return raw.replace(/^["'`]+|["'`]+$/g, "");
+}
+/** Parse a top-level `import_statement` node into an ImportEntry. */
+function parseStaticImport(node, moduleType) {
+    const sourceNode = firstChildOfType(node, "string");
+    if (!sourceNode)
+        return null;
+    const source = stripQuotes(sourceNode.text);
+    const clause = firstChildOfType(node, "import_clause");
+    if (!clause) {
+        // `import "reflect-metadata";` — side-effect only, no bindings.
+        return { source, names: [], moduleType };
+    }
+    const entry = { source, names: [], moduleType };
+    for (const child of clause.children ?? []) {
+        if (!child)
+            continue;
+        if (child.type === "identifier") {
+            // `import React from ...` — default binding is a bare identifier.
+            entry.defaultName = child.text;
         }
-        else if (ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === "require" &&
-            node.arguments.length === 1 &&
-            ts.isStringLiteral(node.arguments[0])) {
-            hasCjs = true;
+        else if (child.type === "namespace_import") {
+            // `import * as fs from ...`
+            const id = firstChildOfType(child, "identifier");
+            if (id)
+                entry.namespace = id.text;
         }
-        else if (ts.isPropertyAccessExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === "module" &&
-            node.name.text === "exports") {
-            hasCjs = true;
+        else if (child.type === "named_imports") {
+            // `import { a, b as c } from ...` — the local binding is the alias when
+            // present (last identifier of the specifier), else the imported name.
+            for (const spec of childrenOfType(child, "import_specifier")) {
+                const ids = childrenOfType(spec, "identifier");
+                const local = ids.length ? ids[ids.length - 1].text : undefined;
+                if (local)
+                    entry.names.push(local);
+            }
         }
-        ts.forEachChild(node, visit);
     }
-    ts.forEachChild(sourceFile, visit);
-    if (hasEsm && !hasCjs)
-        return "esm";
-    if (hasCjs && !hasEsm)
-        return "cjs";
-    if (hasEsm || hasCjs)
-        return "esm"; // mixed — treat as ESM (static imports present)
-    return "unknown";
+    return entry;
 }
-function collectDynamicImports(sourceFile, moduleType) {
-    const entries = [];
-    function visit(node) {
-        // import('specifier') — dynamic ESM import
-        if (ts.isCallExpression(node) &&
-            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-            node.arguments.length === 1 &&
-            ts.isStringLiteral(node.arguments[0])) {
-            entries.push({
-                source: node.arguments[0].text,
-                names: [],
-                isDynamic: true,
-                moduleType,
-            });
-        }
-        // require('specifier') — CJS import
-        else if (ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === "require" &&
-            node.arguments.length === 1 &&
-            ts.isStringLiteral(node.arguments[0])) {
-            entries.push({
-                source: node.arguments[0].text,
-                names: [],
-                moduleType: "cjs",
-            });
-        }
-        ts.forEachChild(node, visit);
+/** Parse a top-level `export_statement` into a ReExportEntry, or null if it isn't a
+ *  re-export (a plain `export const x` has no `from` source). */
+function parseReExport(node) {
+    const sourceNode = firstChildOfType(node, "string");
+    if (!sourceNode)
+        return null; // not `export ... from '...'`
+    const source = stripQuotes(sourceNode.text);
+    const clause = firstChildOfType(node, "export_clause");
+    if (!clause) {
+        // `export * from '...'`
+        return { source, names: [] };
     }
-    ts.forEachChild(sourceFile, visit);
-    return entries;
-}
-function collectReExports(sourceFile) {
-    const entries = [];
-    for (const stmt of sourceFile.statements) {
-        if (!ts.isExportDeclaration(stmt) || !stmt.moduleSpecifier)
-            continue;
-        const source = stmt.moduleSpecifier.text;
-        if (!stmt.exportClause) {
-            // export * from '...'
-            entries.push({ source, names: [] });
-        }
-        else if (ts.isNamedExports(stmt.exportClause)) {
-            const names = stmt.exportClause.elements.map((e) => e.name.text);
-            entries.push({ source, names });
-        }
+    const names = [];
+    for (const spec of childrenOfType(clause, "export_specifier")) {
+        const ids = childrenOfType(spec, "identifier");
+        // Exported name is the alias when present (`a as b` → b), else the name.
+        const name = ids.length ? ids[ids.length - 1].text : undefined;
+        if (name)
+            names.push(name);
     }
-    return entries;
+    return { source, names };
 }
-const EXT_TO_SCRIPT_KIND = {
-    ".ts": ts.ScriptKind.TS,
-    ".tsx": ts.ScriptKind.TSX,
-    ".mts": ts.ScriptKind.TS,
-    ".cts": ts.ScriptKind.TS,
-    ".js": ts.ScriptKind.JS,
-    ".jsx": ts.ScriptKind.JSX,
-    ".mjs": ts.ScriptKind.JS,
-    ".cjs": ts.ScriptKind.JS,
-};
 export const importFactProvider = {
     id: "fact.file.imports",
     provides: ["file.imports", "file.reexports"],
     requires: ["file.content"],
     appliesTo(ctx) {
         const ext = ctx.filePath.slice(ctx.filePath.lastIndexOf(".")).toLowerCase();
-        return ext in EXT_TO_SCRIPT_KIND;
+        return JSTS_EXTS.has(ext);
     },
-    run(ctx, store) {
+    async run(ctx, store) {
         const content = store.getFileFact(ctx.filePath, "file.content");
-        if (!content) {
+        const setEmpty = () => {
             store.setFileFact(ctx.filePath, "file.imports", []);
             store.setFileFact(ctx.filePath, "file.reexports", []);
+        };
+        if (!content) {
+            setEmpty();
             return;
         }
-        const ext = ctx.filePath.slice(ctx.filePath.lastIndexOf(".")).toLowerCase();
-        const scriptKind = EXT_TO_SCRIPT_KIND[ext] ?? ts.ScriptKind.JS;
-        const sourceFile = ts.createSourceFile(ctx.filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
-        const moduleType = detectModuleType(sourceFile);
-        const imports = [];
-        // Static import declarations
-        for (const stmt of sourceFile.statements) {
-            if (!ts.isImportDeclaration(stmt))
-                continue;
-            const source = stmt.moduleSpecifier.text;
-            const clause = stmt.importClause;
-            if (!clause) {
-                imports.push({ source, names: [], moduleType });
+        // Grammar unavailable / parse failed / wasm aborted — degrade to empty
+        // (there is no typescript-compiler fallback by design, #402).
+        const root = await parseFactTree(ctx.filePath, content);
+        if (!root) {
+            setEmpty();
+            return;
+        }
+        // --- module-type detection + static import/re-export node collection ---
+        let hasEsm = false;
+        let hasCjs = false;
+        const importNodes = [];
+        const reExportNodes = [];
+        for (const child of root.children ?? []) {
+            if (!child)
                 continue;
+            if (child.type === "import_statement") {
+                hasEsm = true;
+                importNodes.push(child);
             }
-            const entry = { source, names: [], moduleType };
-            if (clause.name) {
-                entry.defaultName = clause.name.text;
+            else if (child.type === "export_statement") {
+                const isReExport = Boolean(firstChildOfType(child, "string"));
+                // `export { x }` / `export * from` / `export { x } from` are ESM
+                // declarations (like TS's isExportDeclaration); `export const x` /
+                // `export default` (a wrapped declaration) is NOT counted here.
+                if (isReExport || firstChildOfType(child, "export_clause")) {
+                    hasEsm = true;
+                }
+                if (isReExport)
+                    reExportNodes.push(child);
             }
-            if (clause.namedBindings) {
-                if (ts.isNamespaceImport(clause.namedBindings)) {
-                    entry.namespace = clause.namedBindings.name.text;
+        }
+        // --- dynamic import() / require() / module.exports (anywhere in the tree) ---
+        const dynamicRaw = [];
+        walk(root, (node) => {
+            if (node.type === "call_expression") {
+                const callee = node.children?.[0];
+                const args = firstChildOfType(node, "arguments");
+                const strArg = args ? firstChildOfType(args, "string") : undefined;
+                if (!strArg)
+                    return; // non-string arg (e.g. template literal) — skip
+                const source = stripQuotes(strArg.text);
+                if (callee?.type === "import") {
+                    dynamicRaw.push({ source, kind: "import" });
                 }
-                else {
-                    entry.names = clause.namedBindings.elements.map((e) => e.name.text);
+                else if (callee?.type === "identifier" && callee.text === "require") {
+                    dynamicRaw.push({ source, kind: "require" });
+                    hasCjs = true;
                 }
             }
-            imports.push(entry);
+            else if (node.type === "member_expression") {
+                // module.exports = ...
+                const obj = node.children?.[0];
+                if (obj?.type === "identifier" && obj.text === "module") {
+                    const prop = firstChildOfType(node, "property_identifier");
+                    if (prop?.text === "exports")
+                        hasCjs = true;
+                }
+            }
+        });
+        const moduleType = hasEsm && !hasCjs
+            ? "esm"
+            : hasCjs && !hasEsm
+                ? "cjs"
+                : hasEsm || hasCjs
+                    ? "esm" // mixed — static imports present, treat as ESM
+                    : "unknown";
+        // --- build entries ---
+        const imports = [];
+        for (const node of importNodes) {
+            const entry = parseStaticImport(node, moduleType);
+            if (entry)
+                imports.push(entry);
+        }
+        let dynamicCount = 0;
+        for (const d of dynamicRaw) {
+            if (d.kind === "import") {
+                imports.push({
+                    source: d.source,
+                    names: [],
+                    isDynamic: true,
+                    moduleType,
+                });
+            }
+            else {
+                imports.push({ source: d.source, names: [], moduleType: "cjs" });
+            }
+            dynamicCount++;
         }
-        // Dynamic imports and require() calls
-        const dynamic = collectDynamicImports(sourceFile, moduleType);
-        imports.push(...dynamic);
         store.setFileFact(ctx.filePath, "file.imports", imports);
-        // Re-export edges (used by call graph for barrel-file traversal)
-        const reexports = collectReExports(sourceFile);
+        const reexports = [];
+        for (const node of reExportNodes) {
+            const r = parseReExport(node);
+            if (r)
+                reexports.push(r);
+        }
         store.setFileFact(ctx.filePath, "file.reexports", reexports);
         // Telemetry: log when a file has dynamic imports or re-exports so we can
         // measure coverage and validate the implementation across real projects.
-        const dynamicCount = dynamic.length;
-        const reexportCount = reexports.length;
-        if (dynamicCount > 0 || reexportCount > 0) {
+        if (dynamicCount > 0 || reexports.length > 0) {
             logLatency({
                 type: "call_graph_facts",
                 filePath: ctx.filePath,
@@ -154,7 +201,7 @@ export const importFactProvider = {
                     moduleType,
                     staticImports: imports.length - dynamicCount,
                     dynamicImports: dynamicCount,
-                    reexports: reexportCount,
+                    reexports: reexports.length,
                     starReexports: reexports.filter((r) => r.names.length === 0).length,
                 },
             });

package/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -0,0 +1,34 @@
+/**
+ * Fact-provider-specific tree-sitter helper (#402).
+ *
+ * The generic node-walk utilities (`walk`, `childrenOfType`, `firstChildOfType`,
+ * `parseTreeSitterRoot`, `TsNode`) live in `clients/tree-sitter-shared.ts` so both
+ * the fact extractors and the complexity client share them. This module re-exports
+ * them for the extractors and adds the FactProvider-specific `extractFactsFromTree`
+ * shell.
+ */
+import { childrenOfType, firstChildOfType, parseTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
+export { childrenOfType, firstChildOfType, walk, };
+/** Parse `content` for `filePath` into a root node (or null). Alias of the shared helper. */
+export const parseFactTree = parseTreeSitterRoot;
+/**
+ * Provider shell for tree-sitter-backed fact extractors: read `file.content`,
+ * parse via the shared client, and hand the root node to `extract`. On empty
+ * content / parse failure / wasm abort it writes the empty `defaults` and returns
+ * (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) => {
+        for (const key of Object.keys(defaults)) {
+            store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
+        }
+    };
+    const content = store.getFileFact(ctx.filePath, "file.content");
+    if (!content)
+        return writeAll(defaults);
+    const root = await parseFactTree(ctx.filePath, content);
+    if (!root)
+        return writeAll(defaults);
+    writeAll(extract(root, content));
+}

package/dist/clients/dispatch/facts/try-catch-facts.js

@@ -1,4 +1,4 @@
-import { ts } from "../../deps/typescript.js";
+import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 // --- Helpers ---
 function isOnlyWhitespaceOrComments(text) {
     let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
@@ -29,8 +29,10 @@ function detectBoundaryCategory(tryText) {
 function detectTryResolvesLocalValues(tryText) {
     // Heuristic: no await, no IO calls, no mutations via known side-effectful APIs
     const hasAwait = /\bawait\b/.test(tryText);
-    const hasIO = DB_PATTERN.test(tryText) || NETWORK_PATTERN.test(tryText) ||
-        FS_PATTERN.test(tryText) || PROCESS_PATTERN.test(tryText);
+    const hasIO = DB_PATTERN.test(tryText) ||
+        NETWORK_PATTERN.test(tryText) ||
+        FS_PATTERN.test(tryText) ||
+        PROCESS_PATTERN.test(tryText);
     return !hasAwait && !hasIO;
 }
 // --- Provider ---
@@ -41,72 +43,64 @@ export const tryCatchFactProvider = {
     appliesTo(ctx) {
         return /\.tsx?$/.test(ctx.filePath);
     },
-    run(ctx, store) {
-        const content = store.getFileFact(ctx.filePath, "file.content");
-        if (!content) {
-            store.setFileFact(ctx.filePath, "file.tryCatchSummaries", []);
-            return;
-        }
-        const sourceFile = ts.createSourceFile(ctx.filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-        const summaries = [];
-        function visit(node) {
-            if (ts.isTryStatement(node)) {
-                const tryText = node.tryBlock.getText(sourceFile);
+    async run(ctx, store) {
+        await extractFactsFromTree(ctx, store, { "file.tryCatchSummaries": [] }, (root) => {
+            const summaries = [];
+            walk(root, (node) => {
+                if (node.type !== "try_statement")
+                    return;
+                // The direct `statement_block` child is the try body; the catch/finally
+                // blocks are nested inside their own clauses (not direct children).
+                const tryBlock = firstChildOfType(node, "statement_block");
+                const catchClause = firstChildOfType(node, "catch_clause");
+                if (!tryBlock || !catchClause)
+                    return;
+                const tryText = tryBlock.text;
                 const tryResolvesLocalValues = detectTryResolvesLocalValues(tryText);
                 const boundaryCategory = detectBoundaryCategory(tryText);
-                if (node.catchClause) {
-                    const clause = node.catchClause;
-                    const pos = sourceFile.getLineAndCharacterOfPosition(clause.getStart(sourceFile));
-                    let catchParam = null;
-                    if (clause.variableDeclaration) {
-                        const name = clause.variableDeclaration.name;
-                        if (ts.isIdentifier(name)) {
-                            catchParam = name.text;
-                        }
-                    }
-                    const bodyText = clause.block
-                        .getText(sourceFile)
-                        .replace(/^\{/, "")
-                        .replace(/\}$/, "")
-                        .trim();
-                    const isEmpty = isOnlyWhitespaceOrComments(bodyText);
-                    const hasRethrow = /\bthrow\b/.test(bodyText);
-                    const hasLogging = /\bconsole\.(log|warn|error)\b/.test(bodyText) ||
-                        /\blogger\./.test(bodyText);
-                    // Derived enrichment fields
-                    const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
-                    const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
-                    const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
-                    const catchLogsOnly = hasLogging &&
-                        !hasRethrow &&
-                        !catchReturnsDefault &&
-                        !catchReturnsStructuredError &&
-                        !/\b(?:set|update|notify|emit|dispatch|resolve|reject)\b/.test(bodyText);
-                    // Filesystem existence probe: try reads a file/path, catch returns a default
-                    const isFilesystemExistenceProbe = boundaryCategory === "fs" &&
-                        FS_PROBE_PATTERN.test(tryText) &&
-                        catchReturnsDefault;
-                    summaries.push({
-                        line: pos.line + 1,
-                        column: pos.character + 1,
-                        catchParam,
-                        bodyText,
-                        isEmpty,
-                        hasRethrow,
-                        hasLogging,
-                        catchLogsOnly,
-                        catchReturnsDefault,
-                        catchReturnsStructuredError,
-                        isDocumentedLocalFallback,
-                        tryResolvesLocalValues,
-                        isFilesystemExistenceProbe,
-                        boundaryCategory,
-                    });
-                }
-            }
-            ts.forEachChild(node, visit);
-        }
-        visit(sourceFile);
-        store.setFileFact(ctx.filePath, "file.tryCatchSummaries", summaries);
+                // Catch binding: `catch (e)` → identifier param; `catch {}` or a destructuring
+                // pattern → null (matching the old `ts.isIdentifier` gate).
+                const paramNode = firstChildOfType(catchClause, "identifier");
+                const catchParam = paramNode ? paramNode.text : null;
+                const catchBody = firstChildOfType(catchClause, "statement_block");
+                const bodyText = catchBody
+                    ? catchBody.text.replace(/^\{/, "").replace(/\}$/, "").trim()
+                    : "";
+                const isEmpty = isOnlyWhitespaceOrComments(bodyText);
+                const hasRethrow = /\bthrow\b/.test(bodyText);
+                const hasLogging = /\bconsole\.(log|warn|error)\b/.test(bodyText) ||
+                    /\blogger\./.test(bodyText);
+                // Derived enrichment fields
+                const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
+                const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
+                const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
+                const catchLogsOnly = hasLogging &&
+                    !hasRethrow &&
+                    !catchReturnsDefault &&
+                    !catchReturnsStructuredError &&
+                    !/\b(?:set|update|notify|emit|dispatch|resolve|reject)\b/.test(bodyText);
+                // Filesystem existence probe: try reads a file/path, catch returns a default
+                const isFilesystemExistenceProbe = boundaryCategory === "fs" &&
+                    FS_PROBE_PATTERN.test(tryText) &&
+                    catchReturnsDefault;
+                summaries.push({
+                    line: catchClause.startPosition.row + 1,
+                    column: catchClause.startPosition.column + 1,
+                    catchParam,
+                    bodyText,
+                    isEmpty,
+                    hasRethrow,
+                    hasLogging,
+                    catchLogsOnly,
+                    catchReturnsDefault,
+                    catchReturnsStructuredError,
+                    isDocumentedLocalFallback,
+                    tryResolvesLocalValues,
+                    isFilesystemExistenceProbe,
+                    boundaryCategory,
+                });
+            });
+            return { "file.tryCatchSummaries": summaries };
+        });
     },
 };

package/dist/clients/dispatch/inline-suppressions.js

@@ -0,0 +1,61 @@
+/**
+ * Inline `pi-lens-ignore` suppression — shared between the per-edit dispatch
+ * pipeline (`lens_diagnostics mode=all`) and the project-wide `mode=full` sweep so
+ * BOTH honor the same comments (#442). Previously this lived privately in the
+ * dispatcher, so a site suppressed on the write path reappeared as blocking in the
+ * full scan, making `mode=full` unusable as a clean gate.
+ *
+ * Syntax: `// pi-lens-ignore: rule-id` (JS/TS) or `# pi-lens-ignore: rule-id`
+ * (Python/Ruby/…), comma-separated for multiple rules, on the same line as the
+ * diagnostic or the line immediately above it.
+ */
+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);
+ * a user's bare `<id>` must still suppress those, so we match the normalized form
+ * as well as the raw one.
+ */
+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
+ * suppressed when its rule id — raw OR normalized — is listed on its own line or
+ * the line immediately above. Returns the surviving diagnostics (same array if
+ * nothing is suppressed).
+ */
+export function applyInlineSuppressions(diagnostics, content) {
+    if (!content || !diagnostics.length)
+        return diagnostics;
+    // Build the set of (1-based line, rule-id) pairs that are suppressed.
+    const suppressed = new Set();
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const m = SUPPRESS_RE.exec(lines[i]);
+        if (!m)
+            continue;
+        const rules = m[1]
+            .split(",")
+            .map((r) => r.trim())
+            .filter(Boolean);
+        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}`);
+        }
+    }
+    if (suppressed.size === 0)
+        return diagnostics;
+    return diagnostics.filter((d) => {
+        const rawId = d.rule ?? d.id ?? "";
+        const line = d.line ?? 1;
+        if (suppressed.has(`${line}:${rawId}`))
+            return false;
+        const normId = normalizeSuppressRule(rawId);
+        return normId === rawId || !suppressed.has(`${line}:${normId}`);
+    });
+}