@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

package/node_modules/pi-lens/dist/clients/middle-man-analysis.js

@@ -1,263 +0,0 @@
-/**
- * Middle-man / delegate-only class detection (#325, split from #305).
- *
- * ast-grep can match *existence* ("this class has a delegate method") but not
- * *universal quantification* ("EVERY method of this class is a pure forward to
- * one held field") — that whole-class judgment is a structural pass over the
- * already-extracted outline, not a pattern rule (see #325 for the full
- * rationale). This module computes, per class, a "delegation ratio" — the
- * share of real methods whose ENTIRE body is a single pure-forwarding call to
- * one held field — and flags the class only when that ratio is near 100% AND
- * the class isn't a named facade/adapter/proxy/wrapper/decorator, and doesn't
- * structurally implement an interface (a legitimate reason for near-total
- * forwarding).
- *
- * Deliberately precision-first: every ambiguous case (destructured params,
- * multi-statement bodies, mixed delegate fields, too few methods to judge)
- * resolves to "not flagged" rather than guessing. False negatives are cheap;
- * flooding legitimate forwarding layers (the risk #325 repeatedly calls out)
- * is not.
- *
- * Scope (v1): languages with a simple, deterministic "self" token and a `.`
- * (or PHP's `->`) member-access operator — typescript/tsx/javascript, java,
- * kotlin, csharp, swift, dart, python, ruby, rust, php. Go/C++ are skipped —
- * Go has no `this`-equivalent token in the method text (the receiver name is
- * arbitrary) and C++ mixes `.`/`->` depending on whether the held field is a
- * pointer, both of which need real AST access to resolve soundly; a future
- * slice can add them once middle-man analysis has an AST-node entry point
- * rather than this text-based one.
- */
-import { escapeRegExp } from "./string-utils.js";
-/** Self-reference token + member-access separator, per languageId. Both the
- * self→field and field→method hops use the SAME separator in every language
- * covered here (true even for PHP's `$this->field->method()`). */
-const SELF_TOKEN = {
-    typescript: { token: "this", sep: "." },
-    tsx: { token: "this", sep: "." },
-    javascript: { token: "this", sep: "." },
-    java: { token: "this", sep: "." },
-    kotlin: { token: "this", sep: "." },
-    csharp: { token: "this", sep: "." },
-    swift: { token: "this", sep: "." },
-    dart: { token: "this", sep: "." },
-    rust: { token: "self", sep: "." },
-    python: { token: "self", sep: "." },
-    ruby: { token: "self", sep: "." },
-    php: { token: "$this", sep: "->" },
-};
-/** Guard: a class named after an intentional forwarding pattern is never the
- * Fowler "Middle Man" smell — that's its whole job. Substring match, so
- * `LegacyApiAdapter`/`ConfigFacade`/`LoggingProxy`/`HttpWrapper` all guard out. */
-const INTENTIONAL_FORWARDER_NAME = /adapter|facade|proxy|wrapper|decorator/i;
-/** Names that are constructors/destructors (never delegation candidates) in at
- * least one covered language. */
-const CONSTRUCTOR_NAMES = new Set([
-    "constructor",
-    "__init__",
-    "__new__",
-    "initialize",
-]);
-/** Below this many real (non-accessor, non-constructor) methods, a delegation
- * ratio isn't a meaningful judgment — a one-method utility class forwarding
- * that one call is not "the class only ever delegates", it's just a small
- * class (#325 FP concern: don't flood on tiny legitimate wrappers). */
-const MIN_CANDIDATE_METHODS = 2;
-/** How close to "every method forwards" counts as the smell. Near-100%, not
- * "mostly" — a class with a couple of forwarding convenience methods among
- * real logic must NOT flag (the exact distinction #325 asks for). */
-const DELEGATION_RATIO_THRESHOLD = 0.9;
-function buildForwardRegex(token, sep) {
-    const t = escapeRegExp(token);
-    const s = escapeRegExp(sep);
-    // `(?:return\s+)?(?:await\s+)?` — value-returning and void forwards both
-    // count (issue explicitly includes the no-`return` void-method form).
-    return new RegExp(`^(?:return\\s+)?(?:await\\s+)?${t}${s}(\\w+)${s}(\\w+)\\(([^()]*)\\)\\s*;?$`);
-}
-/** Splits a parameter/argument list on top-level commas only (naive but
- * sufficient — a nested paren pair would already have failed the outer
- * `[^()]*` capture in `buildForwardRegex`, so args here never contain `(`). */
-function splitArgs(s) {
-    const trimmed = s.trim();
-    if (!trimmed)
-        return [];
-    return trimmed.split(",").map((a) => a.trim());
-}
-/** Parameter names from a method's captured `(a: T, b = 1)`-shaped signature
- * text. Returns `undefined` (ineligible — don't guess) for destructured
- * params, since arg-identity comparison can't be done textually for those. */
-function paramNamesFromSignature(signature, languageId) {
-    const inner = (signature ?? "").trim().replace(/^\(/, "").replace(/\)$/, "");
-    if (inner.trim() === "")
-        return [];
-    if (inner.includes("{") || inner.includes("["))
-        return undefined;
-    const names = splitArgs(inner)
-        .filter((p) => p.length > 0)
-        .map((raw) => {
-        let name = raw;
-        // Rest/spread params forward as themselves textually (`...args`).
-        const isRest = name.startsWith("...");
-        name = name.replace(/^\.\.\./, "");
-        name = name.split("=")[0].trim(); // strip default value
-        name = name.split(":")[0].trim(); // strip type annotation
-        name = name.replace(/\?$/, ""); // strip optional marker
-        return isRest ? `...${name}` : name;
-    });
-    if (languageId === "python" && names[0] === "self")
-        return names.slice(1);
-    if (languageId === "python" && names[0] === "cls")
-        return names.slice(1);
-    return names;
-}
-/** Extracts the statement(s) inside a method body as a list of non-blank,
- * comment-stripped, trimmed lines. Brace languages: content between the
- * FIRST `{` and LAST `}` in the member's source range (sound as long as the
- * body itself contains no nested `{…}` — true by construction for the
- * single-statement forward pattern we're checking for; anything with nested
- * braces has >1 meaningful line anyway and correctly fails the single-
- * statement check below). Python: everything after the `def …:` line,
- * dedented is unnecessary since we only care about non-blank line count. */
-function bodyStatementLines(lines, entry, isPython) {
-    const raw = lines.slice(entry.startLine - 1, entry.endLine).join("\n");
-    let body;
-    if (isPython) {
-        const nlIdx = raw.indexOf("\n");
-        if (nlIdx === -1)
-            return [];
-        body = raw.slice(nlIdx + 1);
-    }
-    else {
-        const braceIdx = raw.indexOf("{");
-        const lastBrace = raw.lastIndexOf("}");
-        if (braceIdx === -1 || lastBrace === -1 || lastBrace <= braceIdx)
-            return [];
-        body = raw.slice(braceIdx + 1, lastBrace);
-    }
-    return (body
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .split("\n")
-        .map((l) => l.replace(/\/\/.*$/, ""))
-        .map((l) => (isPython ? l.replace(/#.*$/, "") : l))
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0)
-        // A lone triple-quoted docstring line in python isn't executable, but
-        // distinguishing it textually is unreliable — treat any leading `"""`/`'''`
-        // line as noise so a documented one-liner forward still qualifies.
-        .filter((l) => !/^("""|''')/.test(l)));
-}
-/** Detects an accessor (getter/setter) declaration from its raw source line —
- * accessors are a DIFFERENT smell (anemic class) and excluded from both the
- * numerator and denominator here so property-heavy adapters/DTOs don't skew
- * the ratio either way. */
-function isAccessorLine(rawLine) {
-    return /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|override\s+|readonly\s+)*(?:get|set)\s+\w+\s*[/(]/.test(rawLine);
-}
-/**
- * Computes the middle-man signal for a single class entry, or `undefined`
- * when there isn't enough signal to judge (too few candidate methods, no
- * language support, mixed delegate fields, etc). Pure function over already-
- * extracted data — no re-parsing, no file I/O beyond the lines already read
- * by the caller.
- */
-function analyzeMiddleMan(classEntry, lines, languageId) {
-    if (!languageId)
-        return undefined;
-    const selfSpec = SELF_TOKEN[languageId];
-    if (!selfSpec)
-        return undefined;
-    if (!classEntry.members || classEntry.members.length === 0)
-        return undefined;
-    const isPython = languageId === "python";
-    const forwardRe = buildForwardRegex(selfSpec.token, selfSpec.sep);
-    const className = classEntry.name;
-    const candidates = classEntry.members.filter((m) => {
-        if (m.kind !== "method")
-            return false;
-        if (CONSTRUCTOR_NAMES.has(m.name))
-            return false;
-        if (m.name === className || m.name === `~${className}`)
-            return false; // C++/C# ctor/dtor-by-name
-        const rawLine = lines[m.startLine - 1] ?? "";
-        if (isAccessorLine(rawLine))
-            return false;
-        return true;
-    });
-    if (candidates.length < MIN_CANDIDATE_METHODS)
-        return undefined;
-    let forwardingCount = 0;
-    const fieldCounts = new Map();
-    for (const member of candidates) {
-        const bodyLines = bodyStatementLines(lines, member, isPython);
-        if (bodyLines.length !== 1)
-            continue;
-        const match = forwardRe.exec(bodyLines[0]);
-        if (!match)
-            continue;
-        const [, field, calledMethod, argsText] = match;
-        const paramNames = paramNamesFromSignature(member.signature, languageId);
-        if (paramNames === undefined)
-            continue; // destructured params — ineligible
-        const args = splitArgs(argsText);
-        if (args.length !== paramNames.length)
-            continue;
-        if (!args.every((a, i) => a === paramNames[i]))
-            continue;
-        void calledMethod;
-        forwardingCount += 1;
-        fieldCounts.set(field, (fieldCounts.get(field) ?? 0) + 1);
-    }
-    if (forwardingCount === 0)
-        return undefined;
-    // "One held field" (#325) — require every forward to target the SAME
-    // field. Two-or-more distinct delegate fields is a different shape
-    // (multi-target wrapper) and out of scope for this flag; be conservative.
-    if (fieldCounts.size !== 1)
-        return undefined;
-    const [delegateField] = [...fieldCounts.keys()];
-    return {
-        delegationRatio: forwardingCount / candidates.length,
-        candidateCount: candidates.length,
-        forwardingCount,
-        delegateField,
-    };
-}
-/** True when the class structurally looks like an intentional interface-
- * forwarding shape — `implements X` on the declaration line(s), which is
- * a legitimate, common reason for a class to be "all delegation" (a typed
- * adapter satisfying an interface). Scans the declaration line plus one
- * continuation line to tolerate simple wraps. */
-function implementsInterface(lines, classEntry) {
-    const declText = lines
-        .slice(classEntry.startLine - 1, Math.min(classEntry.startLine + 1, lines.length))
-        .join(" ");
-    return /\bimplements\b/.test(declText);
-}
-/**
- * Mutates `entries` in place (same convention as the rest of module-report's
- * flag computation): every class-kind entry that clears the delegation-ratio
- * threshold, isn't a named facade/adapter/proxy/wrapper/decorator, and isn't
- * a structural interface-forwarder gets `flags: [..., "middle man"]` and a
- * `delegationRatio` field. Operates on the FLAT entries list (post-nesting,
- * so `members` is populated) — nested/inner classes are analyzed the same as
- * top-level ones.
- */
-export function annotateMiddleMan(entries, content, languageId) {
-    if (!languageId || !SELF_TOKEN[languageId])
-        return;
-    const lines = content.split(/\r?\n/);
-    for (const entry of entries) {
-        if (entry.kind !== "class")
-            continue;
-        if (INTENTIONAL_FORWARDER_NAME.test(entry.name))
-            continue;
-        if (implementsInterface(lines, entry))
-            continue;
-        const signal = analyzeMiddleMan(entry, lines, languageId);
-        if (!signal)
-            continue;
-        if (signal.delegationRatio < DELEGATION_RATIO_THRESHOLD)
-            continue;
-        entry.delegationRatio = signal.delegationRatio;
-        entry.flags = entry.flags ? [...entry.flags, "middle man"] : ["middle man"];
-    }
-}

package/node_modules/pi-lens/dist/clients/model-provider.js

@@ -1,53 +0,0 @@
-/**
- * Provider derivation for worklog/disposition attribution (#1448).
- *
- * The host reports `provider` and `model` as separate fields on its telemetry
- * events (see `updateRuntimeIdentityFromEvent` in index.ts and the
- * `tool_result` handler in clients/runtime-tool-result.ts) MOST of the time —
- * so the common case needs no parsing at all. This parser exists only for the
- * fallback: a model id supplied without an explicit provider.
- *
- * Derivation rule (conservative — returns "" rather than guess):
- *   1. A single `/` or `:` separator splits the id into `<provider>/<rest>`
- *      or `<provider>:<rest>` — e.g. "anthropic/claude-sonnet-4-5",
- *      "openai:gpt-5". The left segment is lowercased and returned AS-IS
- *      (no allowlist check) since an explicit separator is deliberate host
- *      structure, not a guess.
- *   2. No separator: match a known model-id PREFIX against a small table of
- *      vendor naming conventions (claude- -> anthropic; gpt-, o1-, o3- ->
- *      openai; gemini- -> google; llama- -> meta; mistral-, mixtral- ->
- *      mistral; command- -> cohere). First match wins.
- *   3. Anything else (unrecognized prefix, multiple separators, empty
- *      string) is ambiguous -> "".
- */
-const KNOWN_PREFIXES = [
-    ["claude-", "anthropic"],
-    ["gpt-", "openai"],
-    ["o1-", "openai"],
-    ["o3-", "openai"],
-    ["gemini-", "google"],
-    ["llama-", "meta"],
-    ["mistral-", "mistral"],
-    ["mixtral-", "mistral"],
-    ["command-", "cohere"],
-];
-export function deriveProviderFromModelId(modelId) {
-    const id = modelId?.trim().toLowerCase();
-    if (!id)
-        return "";
-    const separators = [...id].filter((c) => c === "/" || c === ":").length;
-    if (separators === 1) {
-        const sep = id.includes("/") ? "/" : ":";
-        const [providerPart, ...rest] = id.split(sep);
-        if (providerPart && rest.join(sep).length > 0)
-            return providerPart;
-        return "";
-    }
-    if (separators > 1)
-        return "";
-    for (const [prefix, provider] of KNOWN_PREFIXES) {
-        if (id.startsWith(prefix))
-            return provider;
-    }
-    return "";
-}

package/node_modules/pi-lens/dist/clients/module-report-lsp.js

@@ -1,189 +0,0 @@
-/**
- * On-demand, file-scoped live-LSP enrichment for module_report (#256).
- *
- * Split out from clients/module-report.ts because LSP is the risky/optional tier:
- * it can touch heavyweight language-server state while the base report must stay a
- * predictable tree-sitter + review-graph read substitute. Invariants that keep
- * the #256 OOM impossible:
- *   - SCOPED: only ever query `references`/`implementation` on the REQUESTED file's
- *     own symbols. Reference *targets* are recorded as locations, never re-queried,
- *     so the blast radius is one server + this file (a sweep amortizes to one
- *     spawn per project root — clients are keyed by root and reused).
- *   - BOUNDED: a process-local queue serializes module_report LSP sweeps, then a
- *     worker pool caps per-sweep concurrency (2) and a symbol cap (20) so parallel
- *     report fan-out cannot flood the server; each probe is clipped to the
- *     remaining wall-clock budget.
- *   - OPT-IN: disabled by default (budget 0) until validated in a real pi session;
- *     enable with PI_LENS_MODULE_REPORT_LSP_BUDGET_MS.
- *
- * PARKED BY DECISION (#1090, 2026-08-12): zero live importers by design —
- * efe3d2a5 unwired module_report's LSP path (#256) and re-homed live
- * enrichment to #236 (LSP-confirmed graph edges). Kept for that future
- * implementation; do not re-flag in dead-code sweeps while #236 is open.
- */
-import { withinRemaining } from "./deadline-utils.js";
-import { uriToPath } from "./path-utils.js";
-let _lspBudgetMs;
-let lspEnrichmentTail = Promise.resolve();
-/** Test seam: clear memoized config/queue state so env overrides take effect. */
-export function _resetModuleReportConfigForTests() {
-    _lspBudgetMs = undefined;
-    lspEnrichmentTail = Promise.resolve();
-}
-function getLspBudgetMs() {
-    if (_lspBudgetMs === undefined) {
-        const raw = Number(process.env.PI_LENS_MODULE_REPORT_LSP_BUDGET_MS);
-        // Default OFF (0) after the #256 OOM: the live-LSP tier is opt-in until the
-        // bounded/file-scoped path is validated in a real pi session. A finite >=0
-        // value is honored verbatim (set 3000 to enable); anything else → 0.
-        _lspBudgetMs = Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 0;
-    }
-    return _lspBudgetMs;
-}
-// Keep defaults conservative: module_report is a read substitute, not a bulk
-// references tool. These caps bound concurrent/in-flight language-server work
-// inside the wall-clock budget. The process-level queue prevents N parallel
-// reports from multiplying this per-report worker pool into a reference storm.
-const MAX_LSP_SYMBOLS = 20;
-const LSP_SYMBOL_CONCURRENCY = 2;
-// Kinds whose implementers are worth an LSP `implementation` probe.
-const INTERFACE_LIKE_KINDS = new Set(["interface", "class", "type"]);
-const NO_LSP = {
-    source: "none",
-    references: false,
-    implementations: false,
-    byName: new Map(),
-};
-/**
- * LSP positions are 0-based and must land on the symbol's *identifier*. The
- * extractor records `column` at the declaration start (e.g. `export`/`function`),
- * so search the start line for the name from there to find the identifier column.
- */
-function lspPosition(sym, lines) {
-    const lineIdx = Math.max(0, sym.line - 1);
-    const text = lines[lineIdx] ?? "";
-    const fromCol = Math.max(0, (sym.column ?? 1) - 1);
-    let character = text.indexOf(sym.name, fromCol);
-    if (character < 0)
-        character = text.indexOf(sym.name);
-    if (character < 0)
-        character = fromCol;
-    return { line: lineIdx, character };
-}
-function lspLocationsToUsedBy(locs, cap) {
-    const out = [];
-    const seen = new Set();
-    for (const loc of locs) {
-        const file = loc.uri ? uriToPath(loc.uri) : "";
-        if (!file)
-            continue;
-        const line = (loc.range?.start?.line ?? 0) + 1;
-        const key = `${file}:${line}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        out.push({
-            file,
-            symbol: "",
-            line,
-            relation: "references",
-            provenance: "lsp",
-        });
-        if (out.length >= cap)
-            break;
-    }
-    return out;
-}
-async function runWithExclusiveLspSweep(work) {
-    const previous = lspEnrichmentTail.catch(() => undefined);
-    let release;
-    lspEnrichmentTail = previous.then(() => new Promise((resolve) => {
-        release = resolve;
-    }));
-    await previous;
-    try {
-        return await work();
-    }
-    finally {
-        release();
-    }
-}
-/**
- * Best-effort live-LSP enrichment for the requested file's exported symbols.
- * On-demand: the first `references` call spawns/reuses the language server for
- * this file's root (clients are keyed by root, so repeated calls amortize to one
- * server). All queries target `absPath` only — never the reference targets — so
- * the work is bounded to this one file. Returns the base report's data untouched
- * if the tier is disabled, no server is configured, or nothing resolves in budget.
- */
-export async function enrichModuleReportWithLsp(absPath, lines, targets, maxRefs, budgetMs = getLspBudgetMs()) {
-    if (targets.length === 0 || budgetMs <= 0)
-        return NO_LSP;
-    return runWithExclusiveLspSweep(() => enrichModuleReportWithLspNow(absPath, lines, targets, maxRefs, budgetMs));
-}
-async function enrichModuleReportWithLspNow(absPath, lines, targets, maxRefs, budgetMs) {
-    let getServersForFileWithConfig;
-    let getLSPService;
-    try {
-        ({ getServersForFileWithConfig } = await import("./lsp/config.js"));
-        ({ getLSPService } = await import("./lsp/index.js"));
-    }
-    catch {
-        return NO_LSP;
-    }
-    // Gate: no configured server for THIS file's language → never spawn anything.
-    try {
-        if (getServersForFileWithConfig(absPath).length === 0)
-            return NO_LSP;
-    }
-    catch {
-        return NO_LSP;
-    }
-    const lsp = getLSPService();
-    const deadlineAt = Date.now() + budgetMs;
-    const byName = new Map();
-    let sawReferences = false;
-    let sawImpl = false;
-    let next = 0;
-    const cappedTargets = targets.slice(0, MAX_LSP_SYMBOLS);
-    async function enrichOne(sym) {
-        if (Date.now() >= deadlineAt)
-            return;
-        const { line, character } = lspPosition(sym, lines);
-        const refsPromise = withinRemaining(lsp.references(absPath, line, character, false), deadlineAt).then((locs) => {
-            if (!locs || Date.now() > deadlineAt)
-                return;
-            const usedBy = lspLocationsToUsedBy(locs, maxRefs);
-            if (usedBy.length === 0)
-                return;
-            byName.set(sym.name, { ...byName.get(sym.name), usedBy });
-            sawReferences = true;
-        });
-        const implPromise = INTERFACE_LIKE_KINDS.has(sym.kind)
-            ? withinRemaining(lsp.implementation(absPath, line, character), deadlineAt).then((locs) => {
-                if (!locs || locs.length === 0 || Date.now() > deadlineAt)
-                    return;
-                byName.set(sym.name, { ...byName.get(sym.name), hasImpl: true });
-                sawImpl = true;
-            })
-            : Promise.resolve();
-        await Promise.allSettled([refsPromise, implPromise]);
-    }
-    async function worker() {
-        while (Date.now() < deadlineAt) {
-            const index = next++;
-            const sym = cappedTargets[index];
-            if (!sym)
-                return;
-            await enrichOne(sym);
-        }
-    }
-    const workers = Array.from({ length: Math.min(LSP_SYMBOL_CONCURRENCY, cappedTargets.length) }, () => worker());
-    await Promise.allSettled(workers);
-    return {
-        source: sawReferences || sawImpl ? "live-lsp" : "none",
-        references: sawReferences,
-        implementations: sawImpl,
-        byName,
-    };
-}