pi-lens 4.3.0 → 4.4.0

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

@@ -1,348 +0,0 @@
-import { isJstsFactFile } from "../../file-kinds.js";
-import { findOwnerName } from "../../symbol-containment.js";
-import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
-const BOUNDARY_PREFIXES = [
-    "fetch",
-    "fs.",
-    "db.",
-    "http",
-    "axios",
-    "got",
-    "req.",
-    "res.",
-];
-const FUNCTION_TYPES = new Set([
-    "function_declaration",
-    "method_definition",
-    "function_expression",
-    "arrow_function",
-]);
-// Decision points for McCabe complexity (matches the old ts.SyntaxKind set).
-const COMPLEXITY_TYPES = new Set([
-    "if_statement",
-    "for_statement",
-    "for_in_statement", // for…of and for…in both parse to for_in_statement
-    "while_statement",
-    "do_statement",
-    "switch_case", // `case` only — `default` (switch_default) is not counted
-    "catch_clause",
-    "ternary_expression",
-]);
-// Control structures that increase nesting depth (matches the old set).
-const NESTING_TYPES = new Set([
-    "if_statement",
-    "for_statement",
-    "for_in_statement",
-    "while_statement",
-    "do_statement",
-    "switch_statement",
-    "try_statement",
-]);
-const LOGICAL_OPERATORS = new Set(["&&", "||", "??"]);
-/** Named children excluding comments — i.e. the "real" statements/args/expressions. */
-function namedChildren(node) {
-    return (node.children ?? []).filter((c) => c && c.isNamed && c.type !== "comment");
-}
-/** First named, non-comment child (e.g. a return statement's returned expression). */
-function firstNamedChild(node) {
-    return namedChildren(node)[0];
-}
-function getBody(node) {
-    // Only block-bodied functions get a summary (expression-bodied arrows have no
-    // statement_block — matching the old `!ts.isBlock(body)` skip).
-    return firstChildOfType(node, "statement_block");
-}
-function getParameters(node) {
-    const fp = firstChildOfType(node, "formal_parameters");
-    if (!fp)
-        return [];
-    return (fp.children ?? []).filter((c) => c &&
-        (c.type === "identifier" ||
-            c.type === "required_parameter" ||
-            c.type === "optional_parameter" ||
-            c.type === "rest_pattern" ||
-            c.type === "assignment_pattern" ||
-            // Plain JavaScript's grammar places a top-level destructured
-            // parameter directly as an object_pattern/array_pattern child
-            // of formal_parameters — no required_parameter wrapper (the TS
-            // grammar always wraps every parameter, destructured or not,
-            // which is why the wrapper types above already covered TS).
-            // Without this, `function f({a, b})` counted 0 params in JS
-            // while the TS-annotated equivalent counted correctly (#1089 P3-4).
-            c.type === "object_pattern" ||
-            c.type === "array_pattern"));
-}
-function parameterName(param) {
-    // JavaScript's grammar keeps a leaf parameter as the identifier itself;
-    // there is no named child to unwrap. TypeScript parameter wrapper nodes still
-    // use their first named child (type annotation/default/rest target).
-    return param.type === "identifier"
-        ? param.text
-        : (firstNamedChild(param)?.text ?? "");
-}
-function getFunctionName(node) {
-    if (node.type === "function_declaration") {
-        return firstChildOfType(node, "identifier")?.text ?? "<anonymous>";
-    }
-    if (node.type === "method_definition") {
-        // The name is the child just before formal_parameters (property_identifier /
-        // private / computed / string / number); skip async/get/set modifiers.
-        const kids = node.children ?? [];
-        const paramsIdx = kids.findIndex((c) => c?.type === "formal_parameters");
-        for (let i = paramsIdx - 1; i >= 0; i -= 1) {
-            const t = kids[i]?.type;
-            if (t === "property_identifier" ||
-                t === "private_property_identifier" ||
-                t === "computed_property_name" ||
-                t === "string" ||
-                t === "number") {
-                return kids[i].text;
-            }
-        }
-        return "<anonymous>";
-    }
-    if (node.type === "arrow_function" || node.type === "function_expression") {
-        // Name comes from the binding site (like the old parent-based lookup):
-        // `const f = () => …` / `{ prop: () => … }`.
-        const parent = node.parent;
-        if (parent?.type === "variable_declarator") {
-            const id = firstChildOfType(parent, "identifier");
-            if (id)
-                return id.text;
-        }
-        else if (parent?.type === "pair") {
-            const key = (parent.children ?? [])[0];
-            if (key)
-                return key.text;
-        }
-        return "<anonymous>";
-    }
-    return "<unknown>";
-}
-function isCallPassThrough(stmt, paramNames) {
-    if (stmt.type !== "return_statement")
-        return { pass: false };
-    const expr = firstNamedChild(stmt);
-    if (!expr || expr.type !== "call_expression")
-        return { pass: false };
-    const argsNode = firstChildOfType(expr, "arguments");
-    const args = argsNode ? namedChildren(argsNode).map((a) => a.text) : [];
-    if (args.length !== paramNames.length)
-        return { pass: false };
-    for (let i = 0; i < args.length; i += 1) {
-        if (args[i] !== paramNames[i])
-            return { pass: false };
-    }
-    return { pass: true, target: (expr.children ?? [])[0]?.text };
-}
-export function calcCyclomaticComplexity(body) {
-    let cc = 1;
-    walk(body, (node) => {
-        if (COMPLEXITY_TYPES.has(node.type)) {
-            cc++;
-        }
-        else if (node.type === "binary_expression") {
-            if ((node.children ?? []).some((c) => LOGICAL_OPERATORS.has(c?.type))) {
-                cc++;
-            }
-        }
-    });
-    return cc;
-}
-function calcMaxNestingDepth(body) {
-    let maxDepth = 0;
-    const walkDepth = (node, depth) => {
-        if (depth > maxDepth)
-            maxDepth = depth;
-        const next = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
-        for (const child of node.children ?? []) {
-            if (child)
-                walkDepth(child, next);
-        }
-    };
-    // Start at the body's children at depth 0 (the body block itself isn't counted).
-    for (const child of body.children ?? []) {
-        if (child)
-            walkDepth(child, 0);
-    }
-    return maxDepth;
-}
-function collectOutgoingCalls(body) {
-    const calls = new Set();
-    walk(body, (node) => {
-        if (node.type === "call_expression") {
-            const callee = (node.children ?? [])[0]?.text ?? "";
-            if (callee.length < 80)
-                calls.add(callee);
-        }
-    });
-    return [...calls];
-}
-/**
- * `obj.method()` call sites with a simple-identifier receiver (refs #655
- * phase 2). Only the plain shape `identifier.identifier(...)` is captured —
- * chained (`a.b.c()`), computed (`a[x]()`), and `this.`-receiver calls are
- * left out of this list (they still show up in `outgoingCalls`'s flattened
- * text form as before); those richer shapes need real type inference to
- * resolve safely, which is out of scope for this bounded slice.
- */
-function collectMemberCallSites(body) {
-    const sites = [];
-    walk(body, (node) => {
-        if (node.type !== "call_expression")
-            return;
-        const callee = (node.children ?? [])[0];
-        if (!callee || callee.type !== "member_expression")
-            return;
-        const object = (callee.children ?? [])[0];
-        const property = (callee.children ?? []).find((c) => c?.type === "property_identifier");
-        if (!object || object.type !== "identifier" || !property)
-            return;
-        sites.push({ receiver: object.text, method: property.text });
-    });
-    return sites;
-}
-/**
- * Best-effort receiver -> class-name map for one function (refs #655 phase
- * 2). Two clear, common shapes only — see {@link FunctionSummary.receiverTypes}.
- */
-function collectReceiverTypes(body, params) {
-    const types = {};
-    for (const param of params) {
-        const id = firstNamedChild(param);
-        if (!id || id.type !== "identifier")
-            continue;
-        const typeAnnotation = (param.children ?? []).find((c) => c?.type === "type_annotation");
-        const typeId = typeAnnotation
-            ? firstChildOfType(typeAnnotation, "type_identifier")
-            : undefined;
-        if (typeId)
-            types[id.text] = typeId.text;
-    }
-    walk(body, (node) => {
-        if (node.type !== "variable_declarator")
-            return;
-        const id = firstChildOfType(node, "identifier");
-        if (!id)
-            return;
-        const value = (node.children ?? []).find((c) => c?.type === "new_expression");
-        if (!value)
-            return;
-        const ctor = firstNamedChild(value);
-        if (ctor?.type === "identifier")
-            types[id.text] = ctor.text;
-    });
-    return types;
-}
-/**
- * Does this function/method declaration have an explicit `: Promise<...>`
- * return type? The `type_annotation` for a return type is a DIRECT child of
- * the function node itself (after `formal_parameters`, before the body) —
- * distinct from a parameter's own `type_annotation`, which is nested inside
- * `formal_parameters` and therefore invisible to `firstChildOfType` here.
- */
-function hasExplicitPromiseReturnType(node) {
-    const returnType = firstChildOfType(node, "type_annotation");
-    if (!returnType)
-        return false;
-    return /:\s*Promise\b/.test(returnType.text);
-}
-function hasAwaitInNode(node) {
-    let found = false;
-    walk(node, (n) => {
-        if (n.type === "await_expression")
-            found = true;
-    });
-    return found;
-}
-function hasReturnAwaitCall(node) {
-    let found = false;
-    walk(node, (n) => {
-        if (n.type !== "return_statement")
-            return;
-        const ret = firstNamedChild(n);
-        if (ret?.type !== "await_expression")
-            return;
-        const awaited = firstNamedChild(ret);
-        if (awaited?.type === "call_expression")
-            found = true;
-    });
-    return found;
-}
-export const functionFactProvider = {
-    id: "fact.file.functions",
-    provides: ["file.functionSummaries", "file.functionFactsCoverage"],
-    requires: ["file.content"],
-    appliesTo(ctx) {
-        return isJstsFactFile(ctx.filePath);
-    },
-    async run(ctx, store) {
-        await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
-            const summaries = [];
-            // Class/interface declarations, collected in the SAME walk over the
-            // already-parsed tree (refs #655 phase 2) so owner/qualified-name
-            // computation for jsts needs no second parse — see
-            // `symbol-containment.ts`'s doc comment for why this can't literally
-            // share code with module-report.ts's tree-sitter-symbol-extractor path
-            // (different tree-sitter integration), only the same algorithm.
-            const containers = [];
-            const addSummary = (node) => {
-                const body = getBody(node);
-                if (!body)
-                    return;
-                const params = getParameters(node);
-                const paramNames = params.map(parameterName);
-                const statements = namedChildren(body);
-                const statementCount = statements.length;
-                const passThrough = statementCount === 1
-                    ? isCallPassThrough(statements[0], paramNames)
-                    : { pass: false };
-                const target = passThrough.target ?? "";
-                const lowerTarget = target.toLowerCase();
-                const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
-                summaries.push({
-                    name: getFunctionName(node),
-                    line: node.startPosition.row + 1,
-                    column: node.startPosition.column + 1,
-                    endLine: body.endPosition.row + 1,
-                    isAsync: Boolean(firstChildOfType(node, "async")),
-                    hasAwait: hasAwaitInNode(body),
-                    hasReturnAwaitCall: hasReturnAwaitCall(body),
-                    statementCount,
-                    parameterCount: params.length,
-                    isPassThroughWrapper: passThrough.pass,
-                    passThroughTarget: passThrough.target,
-                    isBoundaryWrapper,
-                    hasExplicitPromiseReturnType: hasExplicitPromiseReturnType(node),
-                    cyclomaticComplexity: calcCyclomaticComplexity(body),
-                    maxNestingDepth: calcMaxNestingDepth(body),
-                    outgoingCalls: collectOutgoingCalls(body),
-                    memberCallSites: collectMemberCallSites(body),
-                    receiverTypes: collectReceiverTypes(body, params),
-                });
-            };
-            walk(root, (node) => {
-                if (FUNCTION_TYPES.has(node.type))
-                    addSummary(node);
-                if (node.type === "class_declaration" ||
-                    node.type === "interface_declaration") {
-                    const nameNode = firstChildOfType(node, "type_identifier") ??
-                        firstChildOfType(node, "identifier");
-                    if (nameNode) {
-                        containers.push({
-                            name: nameNode.text,
-                            startLine: node.startPosition.row + 1,
-                            endLine: node.endPosition.row + 1,
-                        });
-                    }
-                }
-            });
-            for (const summary of summaries) {
-                const owner = findOwnerName(containers, summary.line, summary.endLine ?? summary.line);
-                if (owner)
-                    summary.owner = owner;
-            }
-            return { "file.functionSummaries": summaries };
-        }, "file.functionFactsCoverage");
-    },
-};

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

@@ -1,204 +0,0 @@
-import { logLatency } from "../../latency-logger.js";
-import { isJstsFactFile } from "../../file-kinds.js";
-import { childrenOfType, firstChildOfType, withFactTree, walk, } from "./tree-sitter-facts.js";
-/** Whether the import-facts provider applies to a source path. */
-export function importFactsApplyTo(filePath) {
-    return isJstsFactFile(filePath);
-}
-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 (child.type === "namespace_import") {
-            // `import * as fs from ...`
-            const id = firstChildOfType(child, "identifier");
-            if (id)
-                entry.namespace = id.text;
-        }
-        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);
-            }
-        }
-    }
-    return entry;
-}
-/** 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: [] };
-    }
-    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 { source, names };
-}
-export const importFactProvider = {
-    id: "fact.file.imports",
-    provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
-    requires: ["file.content"],
-    appliesTo(ctx) {
-        return importFactsApplyTo(ctx.filePath);
-    },
-    async run(ctx, store) {
-        const content = store.getFileFact(ctx.filePath, "file.content");
-        const setEmpty = (complete = false) => {
-            store.setFileFact(ctx.filePath, "file.imports", []);
-            store.setFileFact(ctx.filePath, "file.reexports", []);
-            store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
-        };
-        if (content == null) {
-            setEmpty();
-            return;
-        }
-        // Grammar unavailable / parse failed / wasm aborted — degrade to empty
-        // (there is no typescript-compiler fallback by design, #402).
-        const parsed = await withFactTree(ctx.filePath, content, (root) => {
-            // --- 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);
-                }
-                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);
-                }
-            }
-            // --- 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 if (callee?.type === "identifier" &&
-                        callee.text === "require") {
-                        dynamicRaw.push({ source, kind: "require" });
-                        hasCjs = true;
-                    }
-                }
-                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++;
-            }
-            store.setFileFact(ctx.filePath, "file.imports", imports);
-            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.
-            if (dynamicCount > 0 || reexports.length > 0) {
-                logLatency({
-                    type: "call_graph_facts",
-                    filePath: ctx.filePath,
-                    durationMs: 0,
-                    metadata: {
-                        moduleType,
-                        staticImports: imports.length - dynamicCount,
-                        dynamicImports: dynamicCount,
-                        reexports: reexports.length,
-                        starReexports: reexports.filter((r) => r.names.length === 0).length,
-                    },
-                });
-            }
-        });
-        if (!parsed.parsed)
-            setEmpty();
-        else
-            store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
-    },
-};

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

@@ -1,34 +0,0 @@
-/**
- * Fact-provider-specific tree-sitter helper (#402).
- *
- * The generic node-walk utilities (`walk`, `childrenOfType`, `firstChildOfType`,
- * `withTreeSitterRoot`, `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, withTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
-export { childrenOfType, firstChildOfType, walk };
-export const withFactTree = withTreeSitterRoot;
-/**
- * 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, 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 == null)
-        return writeAll(defaults, false);
-    const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
-    writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
-}