@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,100 +0,0 @@
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensLogDir } from "./probe-home-state.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-import { normalizeLoggedPath } from "./path-utils.js";
-const TREE_SITTER_LOG_DIR = getGlobalPiLensLogDir();
-const TREE_SITTER_LOG_FILE = path.join(TREE_SITTER_LOG_DIR, "tree-sitter.log");
-const writer = createNdjsonLogger({
-    filePath: TREE_SITTER_LOG_FILE,
-    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
-});
-const CACHE_COUNTER_KEYS = [
-    "lookups",
-    "hits",
-    "misses",
-    "coldMisses",
-    "capacityMisses",
-    "contentChangedMisses",
-    "mtimeMisses",
-    "statFailedMisses",
-    "sets",
-    "replacements",
-    "evictions",
-    "clears",
-    "ghostHistoryDrops",
-    "parserInvocations",
-    "parserDurationMs",
-    "parserFailures",
-];
-/**
- * #2219 (the #2141 class): `filePath` mixes raw `path.resolve()`/`cwd`
- * values (`project-diagnostics/scanner.ts`, `review-graph/builder.ts`,
- * `tree-sitter-shared.ts`) with already-normalized `ctx.filePath` (the
- * `dispatch/runners/tree-sitter.ts` call sites) and the `"<tree-sitter>"`
- * sentinel `logTreeSitterDiagnostic` falls back to below. This is the single
- * seam every one of those paths funnels through (`logTreeSitterCacheStats`
- * and `logTreeSitterDiagnostic` both call this function), so normalize once
- * here — guarded via `normalizeLoggedPath` so the sentinel passes through
- * unchanged instead of being resolved against the process cwd.
- */
-export function logTreeSitter(entry) {
-    if (isTestMode()) {
-        return;
-    }
-    writer.log({
-        ts: new Date().toISOString(),
-        ...entry,
-        filePath: normalizeLoggedPath(entry.filePath),
-    });
-}
-export function logTreeSitterCacheStats(options) {
-    const delta = Object.fromEntries(CACHE_COUNTER_KEYS.map((key) => [key, options.stats[key]]));
-    logTreeSitter({
-        phase: "cache_stats",
-        filePath: options.filePath,
-        durationMs: options.durationMs,
-        metadata: {
-            scope: options.scope,
-            fileCount: options.fileCount,
-            hitRate: delta.lookups > 0 ? delta.hits / delta.lookups : null,
-            delta,
-            resident: {
-                size: options.stats.size,
-                maxSize: options.stats.maxSize,
-                totalBytes: options.stats.totalBytes,
-                totalLines: options.stats.totalLines,
-            },
-            astGrep: options.astGrep,
-        },
-    });
-}
-/**
- * The tree-sitter stack's terminal-safe diagnostic sink (#1333).
- *
- * pi owns the terminal, so nothing under `clients/` may `console.error`. The
- * tree-sitter subsystem already owns `tree-sitter.log`, so its diagnostics stay
- * there rather than moving to the generic `extension.log` — one log per
- * subsystem, per the AGENTS.md logger invariant.
- *
- * `filePath` is optional because several of these fire process-wide (WASM
- * abort, grammar fetch, rule compile) with no file in hand.
- */
-export function logTreeSitterDiagnostic(entry) {
-    logTreeSitter({
-        phase: "diagnostic",
-        filePath: entry.filePath ?? "<tree-sitter>",
-        ...(entry.languageId ? { languageId: entry.languageId } : {}),
-        status: entry.level ?? "error",
-        reason: entry.message,
-        metadata: { subsystem: entry.subsystem, ...entry.metadata },
-    });
-}
-export function getTreeSitterLogPath() {
-    return TREE_SITTER_LOG_FILE;
-}
-/** Resolve once all enqueued tree-sitter writes are on disk (tests/shutdown). */
-export function flushTreeSitterLog() {
-    return writer.flush();
-}

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

@@ -1,269 +0,0 @@
-/**
- * Tree-sitter AST Navigator
- *
- * Provides tree traversal utilities for context-aware analysis:
- * - Parent/sibling navigation
- * - Scope detection (test vs production)
- * - Variable shadowing detection
- * - Context-aware filtering
- */
-export class TreeSitterNavigator {
-    /**
-     * Find parent node of a specific type
-     */
-    findParent(node, type) {
-        let current = node.parent;
-        const types = Array.isArray(type) ? type : [type];
-        while (current) {
-            if (types.includes(current.type)) {
-                return current;
-            }
-            current = current.parent;
-        }
-        return null;
-    }
-    /**
-     * Check if node is inside a specific type of parent
-     */
-    isInside(node, type) {
-        return this.findParent(node, type) !== null;
-    }
-    /**
-     * Get all ancestors of a node
-     */
-    getAncestors(node) {
-        const ancestors = [];
-        let current = node.parent;
-        while (current) {
-            ancestors.push(current);
-            current = current.parent;
-        }
-        return ancestors;
-    }
-    /**
-     * Detect if we're in a test block (it, describe, test, etc.)
-     */
-    isInTestBlock(node) {
-        const testPatterns = [
-            "call_expression", // it(), describe(), test()
-        ];
-        let current = node.parent;
-        while (current) {
-            if (testPatterns.includes(current.type)) {
-                // Check if the call is a test function
-                const callName = this.getCallName(current);
-                if (callName &&
-                    /^\b(it|describe|test|before|after|beforeEach|afterEach)\b/.test(callName)) {
-                    return true;
-                }
-            }
-            current = current.parent;
-        }
-        return false;
-    }
-    /**
-     * Get the name of a call expression (e.g., "it" from it("test", ...))
-     */
-    getCallName(node) {
-        if (node.type !== "call_expression")
-            return null;
-        const func = node.children[0];
-        if (!func)
-            return null;
-        if (func.type === "identifier") {
-            return func.text;
-        }
-        if (func.type === "member_expression") {
-            // Handle cases like describe.skip, it.only, etc.
-            const parts = [];
-            for (const child of func.children) {
-                if (child.type === "identifier" ||
-                    child.type === "property_identifier") {
-                    parts.push(child.text);
-                }
-            }
-            return parts.join(".");
-        }
-        return null;
-    }
-    /**
-     * Detect if we're inside a try/catch block
-     * Use as post_filter: not_in_try_catch to enforce "must be wrapped"
-     */
-    isInTryCatch(node) {
-        // try_statement: TypeScript, JavaScript, Python
-        // begin:         Ruby (begin/rescue/ensure)
-        // rescue:        Ruby inline rescue modifier
-        return this.isInside(node, ["try_statement", "begin", "rescue"]);
-    }
-    /**
-     * Detect if we're inside a loop (for, while, forEach)
-     */
-    isInLoop(node) {
-        return this.isInside(node, [
-            "for_statement",
-            "while_statement",
-            "do_statement",
-            "for_in_statement",
-            "for_of_statement",
-        ]);
-    }
-    /**
-     * Detect if we're in an async context (async function or contains await)
-     */
-    isInAsyncContext(node) {
-        // Check parent function for async keyword
-        const functionTypes = [
-            "function_declaration",
-            "function_expression",
-            "arrow_function",
-            "method_definition",
-        ];
-        let current = node.parent;
-        while (current) {
-            if (functionTypes.includes(current.type)) {
-                // Check for async keyword
-                if (current.children?.some((c) => c.text === "async")) {
-                    return true;
-                }
-            }
-            current = current.parent;
-        }
-        return false;
-    }
-    /**
-     * Get scope chain (list of function/block scopes enclosing this node)
-     */
-    getScopeChain(node) {
-        const chain = [];
-        let current = node.parent;
-        while (current) {
-            if ([
-                "function_declaration",
-                "function_expression",
-                "arrow_function",
-                "method_definition",
-                "block",
-                "statement_block",
-            ].includes(current.type)) {
-                const name = this.getNodeName(current);
-                if (name) {
-                    chain.push(name);
-                }
-                else {
-                    chain.push(`<${current.type}>`);
-                }
-            }
-            current = current.parent;
-        }
-        return chain;
-    }
-    /**
-     * Get name of a function/class node
-     */
-    getNodeName(node) {
-        // Try to find name identifier
-        for (const child of node.children || []) {
-            if (child.type === "identifier" && child.isNamed) {
-                return child.text;
-            }
-        }
-        // For member definitions, check name field
-        if (node.type === "method_definition") {
-            const nameNode = node.children?.find((c) => c.type === "property_identifier");
-            return nameNode?.text || null;
-        }
-        return null;
-    }
-    /**
-     * Check if a variable is shadowed in current scope
-     */
-    isShadowed(node, varName) {
-        // Navigate up to find if this variable name is redeclared
-        let current = node.parent;
-        while (current) {
-            // Check for variable declarations
-            if (["variable_declaration", "lexical_declaration"].includes(current.type)) {
-                // Check if this declaration shadows our variable
-                const declarator = current.children?.find((c) => c.type === "variable_declarator");
-                if (declarator) {
-                    const idNode = declarator.children?.find((c) => c.type === "identifier");
-                    if (idNode?.text === varName) {
-                        return true;
-                    }
-                }
-            }
-            // Check function parameters
-            if ([
-                "function_declaration",
-                "function_expression",
-                "arrow_function",
-                "method_definition",
-            ].includes(current.type)) {
-                const params = current.children?.find((c) => c.type === "formal_parameters");
-                if (params) {
-                    for (const param of params.children || []) {
-                        if (param.type === "identifier" && param.text === varName) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            current = current.parent;
-        }
-        return false;
-    }
-    /**
-     * Get comprehensive scope context for a node
-     */
-    getScopeContext(node) {
-        const ancestors = this.getAncestors(node);
-        const functionDepth = ancestors.filter((a) => [
-            "function_declaration",
-            "function_expression",
-            "arrow_function",
-            "method_definition",
-        ].includes(a.type)).length;
-        return {
-            isTestBlock: this.isInTestBlock(node),
-            isLoop: this.isInLoop(node),
-            isAsync: this.isInAsyncContext(node),
-            functionDepth,
-            scopeChain: this.getScopeChain(node),
-        };
-    }
-    /**
-     * Find sibling nodes (nodes at the same level)
-     */
-    getSiblings(node) {
-        if (!node.parent)
-            return [];
-        return node.parent.children?.filter((c) => c !== node) || [];
-    }
-    /**
-     * Get previous sibling
-     */
-    getPreviousSibling(node) {
-        if (!node.parent)
-            return null;
-        const siblings = node.parent.children || [];
-        const index = siblings.indexOf(node);
-        if (index > 0) {
-            return siblings[index - 1];
-        }
-        return null;
-    }
-    /**
-     * Get next sibling
-     */
-    getNextSibling(node) {
-        if (!node.parent)
-            return null;
-        const siblings = node.parent.children || [];
-        const index = siblings.indexOf(node);
-        if (index >= 0 && index < siblings.length - 1) {
-            return siblings[index + 1];
-        }
-        return null;
-    }
-}