pi-lens 3.8.65 → 3.8.67

package/dist/clients/dead-code-logger.js

@@ -5,26 +5,20 @@
  * input to phasing decisions in the issue). Mirrors `ast-grep-tool-logger.ts`
  * for shape + size-based rotation.
  */
-import * as fs from "node:fs";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
 const LOG_DIR = getGlobalPiLensDir();
 const LOG_FILE = path.join(LOG_DIR, "dead-code.log");
 const LOG_BACKUP_FILE = path.join(LOG_DIR, "dead-code.log.1");
 const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DEAD_CODE_LOG_MAX_BYTES ?? "1048576", 10) ||
     1048576);
-function rotateIfNeeded() {
-    try {
-        const stat = fs.statSync(LOG_FILE);
-        if (stat.size >= MAX_LOG_BYTES) {
-            fs.renameSync(LOG_FILE, LOG_BACKUP_FILE);
-        }
-    }
-    catch {
-        // no file yet, or rename raced — nothing to rotate
-    }
-}
+const writer = createNdjsonLogger({
+    filePath: LOG_FILE,
+    maxBytes: MAX_LOG_BYTES,
+    backupPath: LOG_BACKUP_FILE,
+});
 /**
  * Append one scan event. Fire-and-forget: telemetry must never break a scan, so
  * every fs error is swallowed. Skipped under test mode to keep the suite from
@@ -33,14 +27,9 @@ function rotateIfNeeded() {
 export function logDeadCodeScan(event) {
     if (isTestMode())
         return;
-    try {
-        if (!fs.existsSync(LOG_DIR))
-            fs.mkdirSync(LOG_DIR, { recursive: true });
-        rotateIfNeeded();
-        const row = JSON.stringify({ ts: new Date().toISOString(), ...event });
-        fs.appendFileSync(LOG_FILE, row + "\n");
-    }
-    catch {
-        // telemetry is best-effort
-    }
+    writer.log({ ts: new Date().toISOString(), ...event });
+}
+/** Resolve once all enqueued dead-code writes are on disk (tests/shutdown). */
+export function flushDeadCodeLog() {
+    return writer.flush();
 }

package/dist/clients/dependency-checker.js

@@ -10,6 +10,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { findNodeToolBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 /**
  * Build madge's argv for a circular-dependency scan.
@@ -77,6 +78,16 @@ export class DependencyChecker {
             ? (msg) => console.error(`[deps] ${msg}`)
             : () => { };
     }
+    /**
+     * Resolve how to invoke madge for `cwd`: a local/global-installed binary
+     * (npm/pnpm/yarn/bun) if found, else `npx madge` (#375). `prefix` is prepended
+     * to the madge args (empty for a resolved binary, `["madge"]` for the npx
+     * fallback).
+     */
+    async resolveMadge(cwd) {
+        const bin = await findNodeToolBinary("madge", cwd);
+        return bin ? { cmd: bin, prefix: [] } : { cmd: "npx", prefix: ["madge"] };
+    }
     /**
      * Check if madge is available, auto-install if not
      */
@@ -250,7 +261,8 @@ export class DependencyChecker {
         this.log(`Imports changed for ${path.basename(normalized)}, checking dependencies...`);
         // Run madge on the specific file (fast)
         try {
-            const result = await safeSpawnAsync("npx", ["madge", ...buildMadgeArgs(normalized, projectRoot)], {
+            const { cmd, prefix } = await this.resolveMadge(projectRoot);
+            const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(normalized, projectRoot)], {
                 timeout: 15000,
                 cwd: projectRoot,
             });
@@ -344,7 +356,8 @@ export class DependencyChecker {
     }
     async runScanProject(projectRoot) {
         try {
-            const result = await safeSpawnAsync("npx", ["madge", ...buildMadgeArgs(projectRoot, projectRoot)], {
+            const { cmd, prefix } = await this.resolveMadge(projectRoot);
+            const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(projectRoot, projectRoot)], {
                 timeout: 30000,
                 cwd: projectRoot,
             });

package/dist/clients/deps/vscode-jsonrpc.js

@@ -1 +1 @@
-export { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/node";
+export { CancellationTokenSource, createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/node";

package/dist/clients/diagnostic-logger.js

@@ -3,17 +3,12 @@
  *
  * Log file: ~/.pi-lens/logs/{date}.jsonl
  */
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
 function getLogDir() {
-    const home = os.homedir();
-    const logDir = path.join(home, ".pi-lens", "logs");
-    if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
-    }
-    return logDir;
+    return path.join(os.homedir(), ".pi-lens", "logs");
 }
 function getLogFile() {
     const date = new Date().toISOString().split("T")[0];
@@ -28,30 +23,15 @@ export function getDiagnosticLogger() {
     return _logger;
 }
 export function createDiagnosticLogger() {
-    const pending = [];
-    let writing = false;
-    const writePending = async () => {
-        if (writing || pending.length === 0)
-            return;
-        writing = true;
-        const toWrite = pending.splice(0, pending.length);
-        const lines = toWrite.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        try {
-            await fs.promises.appendFile(getLogFile(), lines);
-        }
-        catch (err) {
-            // pi-lens-ignore: missing-error-propagation — fire-and-forget log write, must not throw
-            console.error("Failed to write diagnostic log:", err);
-        }
-        writing = false;
-    };
+    // Lazy filePath: the log file is keyed on the current date, resolved per
+    // drain so a long-lived logger rolls over at midnight.
+    const writer = createNdjsonLogger({ filePath: () => getLogFile() });
     return {
         log(entry) {
             if (isTestMode()) {
                 return;
             }
-            pending.push(entry);
-            writePending(); // async, non-blocking
+            writer.log(entry); // async, non-blocking
         },
         logCaught(d, context, shownInline = false) {
             this.log({
@@ -77,11 +57,7 @@ export function createDiagnosticLogger() {
             });
         },
         async flush() {
-            // Drain any buffered entries, then wait for the write to finish.
-            await writePending();
-            while (writing) {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
+            await writer.flush();
         },
     };
 }

package/dist/clients/dispatch/auxiliary-lsp.js

@@ -20,6 +20,42 @@ import { findLocalOpengrepConfig } from "../opengrep-config.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { findLocalZizmorConfig } from "../zizmor-config.js";
 import { classifyDefect } from "./diagnostic-taxonomy.js";
+/**
+ * Semgrep/opengrep `# nosemgrep` / `# nosemgrep: <rule-id>[,<rule-id>]` inline
+ * suppression (#441). A bare `# nosemgrep` drops every finding on its line; the
+ * `: <ids>` form drops only the listed rule ids. `d.code` is the semgrep rule id.
+ * Also accepts the `//` comment form.
+ *
+ * Matches Semgrep placement: honored on the finding's OWN line (inline or not),
+ * and on the line ABOVE only when that line is a STANDALONE comment (no code before
+ * it) — so `a()  # nosemgrep` suppresses a finding on `a()` but not the next line.
+ */
+const NOSEMGREP_RE = /(?:#|\/\/)\s*nosemgrep(?::\s*(.+))?/i;
+const NOSEMGREP_STANDALONE_RE = /^\s*(?:#|\/\/)\s*nosemgrep(?::\s*(.+))?\s*$/i;
+export function isNosemgrepSuppressed(d, content) {
+    const startLine = d.range?.start?.line; // 0-based
+    if (startLine == null)
+        return false;
+    const lines = content.split("\n");
+    const ruleId = String(d.code ?? "");
+    const checkLine = (text, standaloneOnly) => {
+        if (!text)
+            return false;
+        const m = (standaloneOnly ? NOSEMGREP_STANDALONE_RE : NOSEMGREP_RE).exec(text);
+        if (!m)
+            return false;
+        if (m[1] === undefined)
+            return true; // bare nosemgrep → suppress the line
+        return m[1]
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .includes(ruleId);
+    };
+    // The finding's own line (inline OK), then the line above (standalone comment only).
+    return (checkLine(lines[startLine], false) ||
+        checkLine(lines[startLine - 1], true));
+}
 export const AUXILIARY_LSP_PROFILES = [
     {
         serverId: "opengrep",
@@ -37,6 +73,8 @@ export const AUXILIARY_LSP_PROFILES = [
         allowBlocking: (cwd) => Boolean(findLocalOpengrepConfig(cwd)),
         semantic: (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning",
         defectClass: (d) => classifyDefect(String(d.code ?? ""), "opengrep", d.message ?? ""),
+        // Honor the canonical Semgrep suppression the user already knows (#441).
+        isSuppressed: isNosemgrepSuppressed,
     },
     {
         serverId: "ast-grep",

package/dist/clients/dispatch/dispatcher.js

@@ -27,6 +27,7 @@ import { loadPiLensProjectConfig } from "../project-lens-config.js";
 import { RUNTIME_CONFIG, getRunnerTimeoutFloorMs } from "../runtime-config.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 import { classifyDiagnostic } from "./diagnostic-taxonomy.js";
+import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
 import { getToolProfile } from "./tool-profile.js";
@@ -187,42 +188,6 @@ function dedupeOverlappingDiagnostics(diagnostics) {
     }
     return [...byKey.values()];
 }
-/**
- * Apply inline suppression comments.
- * Syntax: `// pi-lens-ignore: rule-id` (JS/TS) or `# pi-lens-ignore: rule-id` (Python/Ruby/etc.)
- * Place on the same line as the diagnostic or the line immediately above it.
- */
-function applyInlineSuppressions(diagnostics, content) {
-    if (!content || !diagnostics.length)
-        return diagnostics;
-    // Build a set of (line, ruleId) pairs that are suppressed.
-    // Line numbers are 1-based to match diagnostic line numbers.
-    const suppressed = new Set();
-    const lines = content.split("\n");
-    const SUPPRESS_RE = /(?:\/\/|#)\s*pi-lens-ignore:\s*(.+)/;
-    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 ruleId = d.rule ?? d.id ?? "";
-        const line = d.line ?? 1;
-        return !suppressed.has(`${line}:${ruleId}`);
-    });
-}
 function suppressLintOverlapsWithLsp(diagnostics) {
     const lspBySpanClass = new Set();
     const lspByLine = new Set();
@@ -230,7 +195,7 @@ function suppressLintOverlapsWithLsp(diagnostics) {
         return getToolProfile(tool).lintLike;
     };
     for (const d of diagnostics) {
-        if (d.tool !== "lsp" && d.tool !== "ts-lsp")
+        if (d.tool !== "lsp")
             continue;
         const line = d.line ?? 1;
         const defectClass = d.defectClass ?? classifyDiagnostic(d);
@@ -240,7 +205,7 @@ function suppressLintOverlapsWithLsp(diagnostics) {
     if (lspByLine.size === 0)
         return diagnostics;
     return diagnostics.filter((d) => {
-        if (d.tool === "lsp" || d.tool === "ts-lsp")
+        if (d.tool === "lsp")
             return true;
         if (!isLintTool(d.tool))
             return true;
@@ -628,7 +593,7 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     const inlineFixed = fixedItems;
     const coverageNotice = buildCoverageNotice(ctx, runnerLatencies);
     // Format output — only blocking issues shown inline
-    // Warnings tracked but not shown (noise) — surfaced via /lens-booboo
+    // Warnings tracked but not shown (noise) — surfaced via lens_diagnostics
     const blockerOutput = formatDiagnostics(inlineBlockers, "blocking");
     let output = blockerOutput;
     output += formatDiagnostics(inlineFixed, "fixed");

package/dist/clients/dispatch/fact-runner.js

@@ -1,4 +1,3 @@
-import { registerRule } from "./fact-rule-runner.js";
 import { scheduleProviders } from "./fact-scheduler.js";
 const providers = [];
 export function registerProvider(p) {
@@ -8,64 +7,17 @@ export function clearProviders() {
     providers.length = 0;
 }
 /**
- * The TypeScript-compiler-backed fact providers + rules are registered LAZILY,
- * the first time any dispatch actually runs — NOT at module import. This keeps
- * the 24 MB `typescript` dependency out of pi-lens's eager entry graph, so a
- * failure to resolve it (#285/#335: a package-manager layout the runtime can't
- * traverse) degrades to "no TS-based structural analysis" instead of crashing
- * the whole extension at load. `runProviders` is the single seam every dispatch
- * path funnels through, so registering here covers them all (integration's three
- * entries + the project scanner) with no per-caller wiring.
+ * Run the registered fact providers for `ctx`, in dependency order.
+ *
+ * Providers + fact rules are registered eagerly at `integration.ts` import (the
+ * dispatch entry) — including the tree-sitter-backed providers. That's safe for
+ * pi-lens's eager graph because the parsing stack loads `web-tree-sitter` (an
+ * optional dep) via a dynamic `import()` inside `client.init()`, not at module
+ * import, so an unavailable grammar/runtime degrades there rather than crashing
+ * the extension at load. As of #402 nothing here uses the `typescript` compiler,
+ * so the old lazy-import-with-degrade indirection (#285/#335) is gone.
  */
-let tsUnitsEnsured = null;
-export function ensureTypeScriptDispatchUnits() {
-    tsUnitsEnsured ??= (async () => {
-        try {
-            const [tryCatch, fn, comment, imp, quality, sonar] = await Promise.all([
-                import("./facts/try-catch-facts.js"),
-                import("./facts/function-facts.js"),
-                import("./facts/comment-facts.js"),
-                import("./facts/import-facts.js"),
-                import("./rules/quality-rules.js"),
-                import("./rules/sonar-rules.js"),
-            ]);
-            registerProvider(tryCatch.tryCatchFactProvider);
-            registerProvider(fn.functionFactProvider);
-            registerProvider(comment.commentFactProvider);
-            registerProvider(imp.importFactProvider);
-            registerRule(quality.highImportCouplingRule);
-            registerRule(quality.noBooleanParamsRule);
-            registerRule(quality.noComplexConditionalsRule);
-            registerRule(sonar.commentedCredentialsRule);
-            registerRule(sonar.commentedOutCodeRule);
-            registerRule(sonar.corsWildcardRule);
-            registerRule(sonar.duplicateStringLiteralRule);
-            registerRule(sonar.dynamicRegexpRule);
-            registerRule(sonar.functionInLoopRule);
-            registerRule(sonar.maxSwitchCasesRule);
-        }
-        catch (err) {
-            // Degrade, don't crash: name the failure + emit the install fingerprint
-            // so a reporter has the full picture. tsUnitsEnsured stays resolved, so we
-            // don't re-attempt (and re-log) on every subsequent dispatch.
-            try {
-                const { collectInstallDiagnostics, formatInstallDiagnostics } = await import("../install-diagnostics.js");
-                console.error(`[pi-lens] TypeScript-based dispatch analysis disabled (degraded mode): ${err?.message ?? String(err)}`);
-                console.error(formatInstallDiagnostics(collectInstallDiagnostics(), err));
-            }
-            catch {
-                console.error(`[pi-lens] TypeScript-based dispatch analysis disabled: ${err?.message ?? String(err)}`);
-            }
-        }
-    })();
-    return tsUnitsEnsured;
-}
-/** Test-only: drop the memoized lazy-registration so it can be re-exercised. */
-export function _resetTypeScriptDispatchUnitsForTests() {
-    tsUnitsEnsured = null;
-}
 export async function runProviders(ctx) {
-    await ensureTypeScriptDispatchUnits();
     const applicable = providers.filter((p) => p.appliesTo(ctx));
     const ordered = scheduleProviders(applicable);
     for (const provider of ordered) {

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

@@ -1,4 +1,4 @@
-import { ts } from "../../deps/typescript.js";
+import { extractFactsFromTree, walk } from "./tree-sitter-facts.js";
 export const commentFactProvider = {
     id: "fact.file.comments",
     provides: ["file.comments"],
@@ -6,30 +6,17 @@ export const commentFactProvider = {
     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.comments", []);
-            return;
-        }
-        const sourceFile = ts.createSourceFile(ctx.filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-        const comments = [];
-        const pushComment = (pos, end) => {
-            const lc = sourceFile.getLineAndCharacterOfPosition(pos);
-            comments.push({
-                line: lc.line + 1,
-                text: content.slice(pos, end),
+    async run(ctx, store) {
+        await extractFactsFromTree(ctx, store, { "file.comments": [] }, (root) => {
+            // Tree-sitter attaches comments as `comment` nodes wherever they occur; a
+            // pre-order walk yields them in source order (matching the old scanner pass).
+            const comments = [];
+            walk(root, (node) => {
+                if (node.type === "comment") {
+                    comments.push({ line: node.startPosition.row + 1, text: node.text });
+                }
             });
-        };
-        const scan = ts.createScanner(sourceFile.languageVersion, false, sourceFile.languageVariant, content);
-        let token = scan.scan();
-        while (token !== ts.SyntaxKind.EndOfFileToken) {
-            if (token === ts.SyntaxKind.SingleLineCommentTrivia ||
-                token === ts.SyntaxKind.MultiLineCommentTrivia) {
-                pushComment(scan.getTokenPos(), scan.getTextPos());
-            }
-            token = scan.scan();
-        }
-        store.setFileFact(ctx.filePath, "file.comments", comments);
+            return { "file.comments": comments };
+        });
     },
 };