@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/review-graph/format.js

@@ -1,33 +0,0 @@
-import * as path from "node:path";
-const MAX_SYMBOLS = 5;
-function displayList(items, maxFiles, map) {
-    return items.slice(0, maxFiles).map((item) => (map ? map(item) : item));
-}
-export function formatImpactCascade(result, maxFiles = 4) {
-    if (result.changedSymbols.length === 0 &&
-        result.neighborFiles.length === 0 &&
-        result.riskFlags.length === 0) {
-        return undefined;
-    }
-    const lines = ["🕸️ Impact cascade from edited file:"];
-    if (result.changedSymbols.length > 0) {
-        const shown = result.changedSymbols.slice(0, MAX_SYMBOLS);
-        const suffix = result.changedSymbols.length > shown.length
-            ? ` (+${result.changedSymbols.length - shown.length} more)`
-            : "";
-        lines.push(`Changed symbols: ${shown.join(", ")}${suffix}`);
-    }
-    if (result.directImporters.length > 0) {
-        lines.push(`Direct importers: ${displayList(result.directImporters, maxFiles, (item) => path.basename(item)).join(", ")}`);
-    }
-    if (result.directCallers.length > 0) {
-        lines.push(`Direct callers: ${displayList(result.directCallers, maxFiles, (item) => path.basename(item)).join(", ")}`);
-    }
-    if (result.neighborFiles.length > 0) {
-        lines.push(`Check next: ${displayList(result.neighborFiles, maxFiles, (item) => path.basename(item)).join(", ")}`);
-    }
-    if (result.riskFlags.length > 0) {
-        lines.push(`Risk: ${result.riskFlags.join(", ")}`);
-    }
-    return lines.join("\n");
-}

package/node_modules/pi-lens/dist/clients/review-graph/git-identity.js

@@ -1,163 +0,0 @@
-/**
- * Pure-filesystem git identity resolution for the review-graph snapshot
- * (#300). Resolves the current HEAD commit and worktree top-level path
- * WITHOUT spawning `git` — this runs on the persist path, which includes the
- * synchronous process-exit flush in builder.ts. Spawning a child process
- * during teardown crashes libuv on Windows (uv_async on a closing handle —
- * the #234 `pi update` crash), so every read here is a plain `fs` call
- * wrapped so any failure degrades to "not a git repo" (no stamp, no check —
- * identical to today's behavior).
- *
- * Handles both a normal repo (`.git` is a directory) and a linked worktree
- * (`.git` is a FILE containing `gitdir: <path>`, where HEAD lives in that
- * worktree-private gitdir but branch refs live in the shared `commondir`).
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeFilePath, walkUpDirs } from "../path-utils.js";
-/** A build-local memo: it is discarded when the build settles. */
-export function createGitIdentityResolver() {
-    const memo = new Map();
-    return (cwd) => {
-        if (memo.has(cwd))
-            return memo.get(cwd);
-        const identity = resolveGitIdentity(cwd);
-        memo.set(cwd, identity);
-        return identity;
-    };
-}
-// Kept as a compatibility no-op for tests that reset the former memo. Git
-// repository creation/removal is a process-lifecycle change, so the lookup
-// below must walk the filesystem on every call rather than cache presence or
-// absence by cwd.
-export function _resetGitIdentityCacheForTests() {
-    return;
-}
-function readCommonDir(gitDir) {
-    try {
-        const raw = fs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
-        if (!raw)
-            return gitDir;
-        return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
-    }
-    catch {
-        return gitDir;
-    }
-}
-/**
- * Walk up from `cwd` looking for a `.git` entry. Returns null when none is
- * found (not a git repo) or the entry is malformed in a way we can't resolve.
- */
-function resolveGitDir(cwd) {
-    for (const dir of walkUpDirs(cwd)) {
-        const gitPath = path.join(dir, ".git");
-        let stat;
-        try {
-            stat = fs.statSync(gitPath);
-        }
-        catch {
-            continue;
-        }
-        if (stat.isDirectory()) {
-            return {
-                gitDir: gitPath,
-                commonDir: readCommonDir(gitPath),
-                worktreeRoot: dir,
-            };
-        }
-        if (stat.isFile()) {
-            // Linked worktree: ".git" is a file with a single "gitdir: <path>" line.
-            try {
-                const contents = fs.readFileSync(gitPath, "utf-8").trim();
-                const match = contents.match(/^gitdir:\s*(.+)$/);
-                if (!match)
-                    return null;
-                const linkedGitDir = path.isAbsolute(match[1])
-                    ? match[1]
-                    : path.resolve(dir, match[1]);
-                if (!fs.statSync(linkedGitDir).isDirectory())
-                    return null;
-                return {
-                    gitDir: linkedGitDir,
-                    commonDir: readCommonDir(linkedGitDir),
-                    worktreeRoot: dir,
-                };
-            }
-            catch {
-                return null;
-            }
-        }
-        // Neither a dir nor a file at `.git` — treat as not-a-repo rather than
-        // keep walking past what looks like a repo root.
-        return null;
-    }
-    return null;
-}
-function getResolvedGitDir(cwd) {
-    let resolved;
-    try {
-        resolved = resolveGitDir(cwd);
-    }
-    catch {
-        resolved = null;
-    }
-    return resolved;
-}
-function resolveRefToSha(commonDir, ref) {
-    // Loose ref file first (refs/heads/x), then packed-refs as fallback.
-    try {
-        const loose = fs.readFileSync(path.join(commonDir, ref), "utf-8").trim();
-        if (loose)
-            return loose;
-    }
-    catch {
-        /* fall through to packed-refs */
-    }
-    try {
-        const packed = fs.readFileSync(path.join(commonDir, "packed-refs"), "utf-8");
-        for (const line of packed.split("\n")) {
-            if (line.startsWith("#") || line.startsWith("^") || !line.trim())
-                continue;
-            const [sha, packedRef] = line.trim().split(/\s+/, 2);
-            if (packedRef === ref)
-                return sha;
-        }
-    }
-    catch {
-        /* no packed-refs — ref is simply unresolved */
-    }
-    return null;
-}
-/**
- * Resolve the current git HEAD commit + worktree root purely by reading
- * files — no `git` subprocess. Returns undefined for anything that isn't (or
- * can't be confidently resolved as) a git repo; callers treat that exactly
- * like "not a git repo" — no stamp, no check, today's behavior.
- */
-export function resolveGitIdentity(cwd) {
-    try {
-        const resolved = getResolvedGitDir(cwd);
-        if (!resolved)
-            return undefined;
-        const headRaw = fs
-            .readFileSync(path.join(resolved.gitDir, "HEAD"), "utf-8")
-            .trim();
-        const refMatch = headRaw.match(/^ref:\s*(.+)$/);
-        let headCommit;
-        if (refMatch) {
-            headCommit = resolveRefToSha(resolved.commonDir, refMatch[1].trim());
-        }
-        else {
-            headCommit = /^[0-9a-f]{7,40}$/i.test(headRaw) ? headRaw : null;
-        }
-        if (!headCommit)
-            return undefined;
-        return {
-            headCommit,
-            worktreeRoot: normalizeFilePath(resolved.worktreeRoot),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}

package/node_modules/pi-lens/dist/clients/review-graph/import-resolvers.js

@@ -1,481 +0,0 @@
-/**
- * Internal-import resolution-to-file for tree-sitter languages (#249 follow-up).
- *
- * The review graph extracts import SOURCES per language (IMPORT_QUERIES), but a
- * raw source string ("os.path", "./foo", "github.com/me/p/pkg") isn't a graph
- * edge until it's resolved to an in-project FILE. jsts (localImportToFile) and
- * cxx (#include) already do this; these resolvers extend it to the tree-sitter
- * languages where an import maps cleanly to a file:
- *
- *   - relative file paths   : ruby (require_relative), zig (@import), bash
- *                             (source/.), dart (relative `import`)
- *   - package/module roots  : python (dotted → package file), java (package →
- *                             source-root file), go (import path → package DIR's
- *                             .go files)
- *
- * Languages whose imports are NOT a 1:1 file concept (rust mod-system,
- * c#/swift namespaces, kotlin/elixir multi-symbol files) are intentionally not
- * resolved — they stay honest `external:` nodes rather than misleading edges.
- *
- * Every resolver is pure + existence-checked + confined to `cwd`: an
- * unresolvable source returns `[]` and the caller keeps the unresolved node, so
- * a wrong guess can never fabricate an edge to a file that isn't there.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeMapKey } from "../path-utils.js";
-import { aliasedImportTargets, referencedProjectImportTarget, } from "./tsconfig-paths.js";
-import { buildModuleGraph } from "./workspace-modules.js";
-/** True when `p` is inside (or equal to) `cwd` — blocks resolution escaping the workspace. */
-function isWithin(cwd, p) {
-    const root = path.resolve(cwd);
-    const rp = path.resolve(p);
-    return rp === root || rp.startsWith(root + path.sep);
-}
-function isFile(p) {
-    try {
-        return fs.statSync(p).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function isDir(p) {
-    try {
-        return fs.statSync(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/** First candidate that exists as a file within cwd, normalized — or []. */
-function firstExistingFile(cwd, candidates) {
-    for (const c of candidates) {
-        if (isWithin(cwd, c) && isFile(c))
-            return [normalizeMapKey(c)];
-    }
-    return [];
-}
-/** All `ext` files directly in `dir` (non-recursive), normalized — or []. */
-function sourceFilesIn(cwd, dir, ext) {
-    if (!isWithin(cwd, dir) || !isDir(dir))
-        return [];
-    try {
-        return fs
-            .readdirSync(dir)
-            .filter((n) => n.endsWith(ext))
-            .map((n) => normalizeMapKey(path.join(dir, n)))
-            .sort();
-    }
-    catch {
-        return [];
-    }
-}
-/** Resolve a path-ish source relative to the importing file's directory. */
-function resolveRelative(cwd, filePath, source, exts) {
-    const base = path.resolve(path.dirname(filePath), source);
-    return firstExistingFile(cwd, [base, ...exts.map((e) => base + e)]);
-}
-function resolveDart(cwd, filePath, source) {
-    // package: / dart: imports are SDK/pub deps, not project files.
-    if (source.startsWith("package:") || source.startsWith("dart:"))
-        return [];
-    return resolveRelative(cwd, filePath, source, [".dart"]);
-}
-// --- JS/TS -------------------------------------------------------------------
-// TS-as-ESM sources commonly write `import { x } from "./service.js"` while
-// the real file on disk is `service.ts` (Node's ESM resolver requires the
-// RUNTIME extension in the specifier, which is `.js` even for a `.ts` source —
-// this repo's own `clients/**/*.ts` does this throughout). Stripping a known
-// JS/TS extension from the specifier before re-appending candidate extensions
-// lets that universal pattern resolve to the real source file. Exported so
-// builder.ts's warm `localImportToFile` shares the exact same regex (#694).
-const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
-/**
- * Ordered candidate list for resolving a relative JS/TS import specifier
- * (already resolved to an absolute base path) to an on-disk file, with
- * SOURCE-TWIN PREFERENCE (#694): on a repo that compiles in place, `./foo.js`
- * commonly has BOTH the written `foo.js` (compiled artifact) and a `foo.ts`
- * source sitting next to it. Trying the `.ts`/`.tsx` (or `.mts`/`.cts` for an
- * `.mjs`/`.cjs` specifier) twin BEFORE the literal/compiled extension means
- * the edge lands on the file developers actually edit; the compiled artifact
- * is only used when no source twin exists on disk (pure-JS projects, vendored
- * `.js`, or a genuinely JS-only import). Every candidate is still
- * existence-checked by the caller — a wrong guess can never fabricate an edge
- * to a file that isn't there, it just tries the next candidate.
- *
- * Shared between the cold module_report path ({@link resolveJsTs} below) and
- * the warm review-graph builder's `localImportToFile` (builder.ts) so the two
- * resolution paths can never diverge on which twin wins (#694 — a divergent
- * second mapping was exactly the kind of thing to avoid).
- */
-/**
- * Shared tail of {@link jsTsCandidatePaths} and the workspace-package subpath
- * resolver below (#775) — both need "given a base path (already stripped of
- * any known JS/TS extension) and the original extension (if any), produce the
- * source-twin-preferring candidate list." Only how `base`/`strippedBase` are
- * computed differs (relative-to-importing-file vs. relative-to-package-root).
- */
-function jsTsExtensionCandidates(base, strippedBase, ext) {
-    const candidates = [];
-    if (ext === ".mjs")
-        candidates.push(`${strippedBase}.mts`);
-    if (ext === ".cjs")
-        candidates.push(`${strippedBase}.cts`);
-    if (ext === ".mts")
-        candidates.push(`${strippedBase}.mts`);
-    if (ext === ".cts")
-        candidates.push(`${strippedBase}.cts`);
-    candidates.push(`${strippedBase}.ts`, `${strippedBase}.tsx`, `${strippedBase}.mts`, `${strippedBase}.cts`);
-    // The literal specifier path (covers both "no extension in the specifier"
-    // — base === strippedBase — and the compiled/as-written extension itself).
-    candidates.push(base, `${strippedBase}.js`, `${strippedBase}.jsx`, `${strippedBase}.mjs`, `${strippedBase}.cjs`);
-    for (const index of [
-        "index.ts",
-        "index.tsx",
-        "index.mts",
-        "index.cts",
-        "index.js",
-        "index.jsx",
-        "index.mjs",
-        "index.cjs",
-    ]) {
-        candidates.push(path.join(base, index));
-    }
-    return [...new Set(candidates)];
-}
-export function jsTsCandidatePaths(filePath, source) {
-    const base = path.resolve(path.dirname(filePath), source);
-    const strippedSource = source.replace(JS_TS_EXT_RE, "");
-    const strippedBase = strippedSource === source
-        ? base
-        : path.resolve(path.dirname(filePath), strippedSource);
-    const ext = path.extname(source).toLowerCase();
-    return jsTsExtensionCandidates(base, strippedBase, ext);
-}
-/**
- * Longest-name match of a bare specifier against known workspace package
- * names, handling `@scope/pkg/subpath` imports (subpath is everything after
- * the matched name + "/"). "Longest" only matters for the theoretical case of
- * two workspace packages whose names are string-prefixes of one another
- * (`@scope/pkg` vs `@scope/pkg-two`) — the required "/" boundary already
- * makes that case unambiguous, but longest-match is kept as a defensive tie
- * breaker rather than relying on Map iteration order.
- */
-function findWorkspaceModuleForSpecifier(modules, source) {
-    let best;
-    for (const mod of modules) {
-        let subpath;
-        if (source === mod.name)
-            subpath = "";
-        else if (source.startsWith(`${mod.name}/`))
-            subpath = source.slice(mod.name.length + 1);
-        if (subpath === undefined)
-            continue;
-        if (!best || mod.name.length > best.mod.name.length)
-            best = { mod, subpath };
-    }
-    return best;
-}
-/** First string found among `exports`'s "." condition (or the field itself if
- * it's a bare string) — covers the common `"exports": "./index.js"` and
- * `"exports": {".": {"import": "./index.js", ...}}` shapes. Anything more
- * exotic (subpath patterns, condition arrays) falls through to the
- * index.ts/js fallback below rather than guessing. */
-function pickExportsMain(exportsField) {
-    if (typeof exportsField === "string")
-        return exportsField;
-    if (!exportsField || typeof exportsField !== "object")
-        return undefined;
-    const obj = exportsField;
-    const dot = obj["."] ?? obj;
-    if (typeof dot === "string")
-        return dot;
-    if (dot && typeof dot === "object") {
-        for (const key of ["import", "require", "default"]) {
-            const v = dot[key];
-            if (typeof v === "string")
-                return v;
-        }
-    }
-    return undefined;
-}
-/** Candidate entry-file paths for a workspace package root: package.json's
- * `main`/`module`/`exports`-main first, then the conventional index files. */
-function workspaceEntryCandidates(pkgRoot) {
-    let main;
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf-8"));
-        main = pickExportsMain(pkg.exports) ?? pkg.module ?? pkg.main;
-    }
-    catch {
-        // missing/unreadable package.json — fall through to index candidates
-    }
-    const candidates = [];
-    if (main) {
-        const mainPath = path.resolve(pkgRoot, main);
-        const ext = path.extname(mainPath).toLowerCase();
-        const stripped = mainPath.replace(JS_TS_EXT_RE, "");
-        candidates.push(...jsTsExtensionCandidates(mainPath, stripped, ext));
-    }
-    for (const base of [pkgRoot, path.join(pkgRoot, "src")]) {
-        candidates.push(path.join(base, "index.ts"), path.join(base, "index.tsx"), path.join(base, "index.mts"), path.join(base, "index.cts"), path.join(base, "index.js"), path.join(base, "index.jsx"), path.join(base, "index.mjs"), path.join(base, "index.cjs"));
-    }
-    return [...new Set(candidates)];
-}
-/** Candidate paths for a workspace-package SUBPATH import (`@scope/pkg/foo`)
- * — same source-twin-preferring extension probe as a relative import, rooted
- * at the package dir instead of the importing file's dir. */
-function workspaceSubpathCandidates(pkgRoot, subpath) {
-    const base = path.join(pkgRoot, subpath);
-    const strippedSubpath = subpath.replace(JS_TS_EXT_RE, "");
-    const strippedBase = strippedSubpath === subpath ? base : path.join(pkgRoot, strippedSubpath);
-    const ext = path.extname(subpath).toLowerCase();
-    return jsTsExtensionCandidates(base, strippedBase, ext);
-}
-/** Resolve tsconfig paths aliases before workspace-package matching. */
-export function resolveAliasedImport(cwd, specifier, importerDir) {
-    for (const target of aliasedImportTargets(specifier, importerDir)) {
-        const ext = path.extname(target).toLowerCase();
-        const stripped = target.replace(JS_TS_EXT_RE, "");
-        const found = firstExistingFile(cwd, jsTsExtensionCandidates(target, stripped, ext));
-        if (found.length)
-            return found;
-    }
-    return [];
-}
-/** Resolve an exact package name declared by a tsconfig project reference. */
-export function resolveProjectReferenceImport(cwd, specifier, importerDir) {
-    const target = referencedProjectImportTarget(specifier, importerDir);
-    return target ? firstExistingFile(cwd, [target]) : [];
-}
-/**
- * Resolve a bare specifier that names a sibling workspace package (npm/pnpm
- * workspaces, cargo, go.work — detected by `workspace-modules.ts`) to that
- * package's entry file, or a file within it for a subpath import (#775). A
- * specifier that doesn't match any known workspace package name returns []
- * — an ordinary third-party dependency stays `external:`, unchanged.
- *
- * `buildModuleGraph` memoizes the workspace scan per cwd, so this costs a
- * real filesystem scan only once per graph build (first bare specifier hit),
- * not once per import edge.
- */
-export function resolveWorkspacePackageImport(cwd, source) {
-    if (source.startsWith("."))
-        return [];
-    const graph = buildModuleGraph(cwd);
-    if (!graph)
-        return [];
-    const match = findWorkspaceModuleForSpecifier(graph.modules.values(), source);
-    if (!match)
-        return [];
-    const candidates = match.subpath
-        ? workspaceSubpathCandidates(match.mod.root, match.subpath)
-        : workspaceEntryCandidates(match.mod.root);
-    return firstExistingFile(cwd, candidates);
-}
-/**
- * Resolve a relative ESM import (`./x`, `../y`) to an in-project file — see
- * {@link jsTsCandidatePaths} for the source-twin-preferring candidate order.
- * A bare specifier (`react`, `@scope/pkg`) is resolved against known
- * workspace package names (#775 — see {@link resolveWorkspacePackageImport});
- * anything that isn't a recognized workspace package stays an external dep,
- * returning []. Used only on the COLD module_report path: the warm jsts
- * builder resolves imports via `localImportToFile` (builder.ts), which shares
- * both candidate lists.
- */
-function resolveJsTs(cwd, filePath, source) {
-    if (!source.startsWith(".")) {
-        const aliased = resolveAliasedImport(cwd, source, path.dirname(filePath));
-        if (aliased.length)
-            return aliased;
-        const referenced = resolveProjectReferenceImport(cwd, source, path.dirname(filePath));
-        return referenced.length
-            ? referenced
-            : resolveWorkspacePackageImport(cwd, source);
-    }
-    return firstExistingFile(cwd, jsTsCandidatePaths(filePath, source));
-}
-// --- C / C++ -----------------------------------------------------------------
-/**
- * Resolve a C/C++ `#include` to an in-project header (#302). A system header
- * (`<stdio.h>`, captured with its angle brackets) is a toolchain/library dep →
- * external, so it returns []. A quoted local include (`#include "foo.h"` →
- * `foo.h` after quote-strip) resolves against the same candidate roots the warm
- * graph's `resolveCxxInclude` uses (the including file's dir, then cwd / include /
- * src), so cold and warm agree on which file a local include points to.
- */
-function resolveCxx(cwd, filePath, source) {
-    if (source.startsWith("<"))
-        return [];
-    const dir = path.dirname(path.resolve(filePath));
-    return firstExistingFile(cwd, [
-        path.resolve(dir, source),
-        path.resolve(cwd, source),
-        path.resolve(cwd, "include", source),
-        path.resolve(cwd, "src", source),
-    ]);
-}
-// --- Python -----------------------------------------------------------------
-/** Candidate source roots for an absolute dotted import. */
-function pythonRoots(cwd, fileDir) {
-    // The package root is the first ancestor of the importing file that is NOT
-    // itself a package (no __init__.py) — that's where a top-level `import a.b`
-    // is anchored. Add cwd and cwd/src as conventional fallbacks.
-    let p = fileDir;
-    const root = path.resolve(cwd);
-    while (isWithin(cwd, p) && isFile(path.join(p, "__init__.py"))) {
-        const parent = path.dirname(p);
-        if (parent === p)
-            break;
-        p = parent;
-    }
-    const roots = new Set([p, root, path.join(root, "src")]);
-    return [...roots].filter((r) => isDir(r));
-}
-function resolvePython(cwd, filePath, source) {
-    const fileDir = path.dirname(path.resolve(filePath));
-    if (source.startsWith(".")) {
-        // Relative import: leading dots = how far up, remainder = dotted subpath.
-        const m = source.match(/^(\.+)(.*)$/);
-        if (!m)
-            return [];
-        const dots = m[1].length;
-        let baseDir = fileDir;
-        for (let i = 1; i < dots; i++)
-            baseDir = path.dirname(baseDir);
-        const rest = m[2] ? m[2].split(".") : [];
-        const target = path.join(baseDir, ...rest);
-        return firstExistingFile(cwd, [
-            `${target}.py`,
-            path.join(target, "__init__.py"),
-        ]);
-    }
-    const parts = source.split(".");
-    for (const root of pythonRoots(cwd, fileDir)) {
-        const target = path.join(root, ...parts);
-        const found = firstExistingFile(cwd, [
-            `${target}.py`,
-            path.join(target, "__init__.py"),
-        ]);
-        if (found.length)
-            return found;
-    }
-    return [];
-}
-// --- Go ---------------------------------------------------------------------
-/** Walk up from the importing file to a go.mod and read its `module` path. */
-function findGoModule(cwd, filePath) {
-    let dir = path.dirname(path.resolve(filePath));
-    const root = path.resolve(cwd);
-    while (true) {
-        try {
-            const content = fs.readFileSync(path.join(dir, "go.mod"), "utf-8");
-            const m = content.match(/^\s*module\s+(\S+)/m);
-            if (m)
-                return { moduleDir: dir, modulePath: m[1] };
-        }
-        catch {
-            // no go.mod here — keep climbing
-        }
-        if (dir === root)
-            break;
-        const parent = path.dirname(dir);
-        if (parent === dir || !isWithin(cwd, parent))
-            break;
-        dir = parent;
-    }
-    return null;
-}
-function resolveGo(cwd, filePath, source) {
-    const mod = findGoModule(cwd, filePath);
-    if (!mod)
-        return [];
-    // Only same-module import paths map to a local package directory; stdlib and
-    // third-party paths (no module prefix) stay external.
-    if (source !== mod.modulePath && !source.startsWith(`${mod.modulePath}/`)) {
-        return [];
-    }
-    const rel = source === mod.modulePath ? "" : source.slice(mod.modulePath.length + 1);
-    // A Go package is a directory; edge to every .go file in it (who-imports
-    // works at file granularity). Exclude nothing — _test.go files import too.
-    return sourceFilesIn(cwd, path.join(mod.moduleDir, rel), ".go");
-}
-// --- Java -------------------------------------------------------------------
-function javaSourceRoots(cwd, filePath) {
-    const root = path.resolve(cwd);
-    const roots = new Set();
-    for (const c of ["src/main/java", "src/test/java", "src", ""]) {
-        roots.add(path.join(root, c));
-    }
-    // The importing file's own source root is one of its ancestors, so a
-    // same-project import resolves even on a non-conventional layout.
-    let p = path.dirname(path.resolve(filePath));
-    while (true) {
-        roots.add(p);
-        if (p === root)
-            break;
-        const parent = path.dirname(p);
-        if (parent === p || !isWithin(cwd, parent))
-            break;
-        p = parent;
-    }
-    return [...roots].filter((r) => isDir(r));
-}
-function resolveJava(cwd, filePath, source) {
-    const parts = source.split(".");
-    for (const root of javaSourceRoots(cwd, filePath)) {
-        // import a.b.Foo  → a/b/Foo.java
-        const asFile = firstExistingFile(cwd, [
-            `${path.join(root, ...parts)}.java`,
-        ]);
-        if (asFile.length)
-            return asFile;
-        // import a.b.*  (captured as a.b) → every .java in the package dir
-        const asPkg = sourceFilesIn(cwd, path.join(root, ...parts), ".java");
-        if (asPkg.length)
-            return asPkg;
-        // static import a.b.Foo.bar → drop the member, resolve the class file
-        if (parts.length > 1) {
-            const dropLast = firstExistingFile(cwd, [
-                `${path.join(root, ...parts.slice(0, -1))}.java`,
-            ]);
-            if (dropLast.length)
-                return dropLast;
-        }
-    }
-    return [];
-}
-/**
- * Resolve a single tree-sitter import source to in-project file(s). Returns
- * normalized paths (possibly several — a Go/Java package is a directory) or `[]`
- * when the source isn't a resolvable in-project file (keep it as external).
- */
-export function resolveImportToFiles(cwd, filePath, languageId, source) {
-    switch (languageId) {
-        case "typescript":
-        case "tsx":
-        case "javascript":
-        case "jsts":
-            return resolveJsTs(cwd, filePath, source);
-        case "c":
-        case "cpp":
-            return resolveCxx(cwd, filePath, source);
-        case "ruby":
-            return resolveRelative(cwd, filePath, source, [".rb"]);
-        case "zig":
-            return resolveRelative(cwd, filePath, source, [".zig"]);
-        case "bash":
-            return resolveRelative(cwd, filePath, source, [".sh", ".bash"]);
-        case "dart":
-            return resolveDart(cwd, filePath, source);
-        case "python":
-            return resolvePython(cwd, filePath, source);
-        case "go":
-            return resolveGo(cwd, filePath, source);
-        case "java":
-            return resolveJava(cwd, filePath, source);
-        default:
-            return [];
-    }
-}

package/node_modules/pi-lens/dist/clients/review-graph/persist-worker.js

@@ -1,10 +0,0 @@
-import { serveGzipStageWorker, } from "../gzip-stage-write.js";
-// Streamed gzip stage write runs off the main thread via the shared core (see
-// clients/gzip-stage-write.ts); this worker only echoes its routing fields.
-serveGzipStageWorker((request) => ({
-    id: request.id,
-    cwd: request.cwd,
-    generation: request.generation,
-    stagePath: request.stagePath,
-    elements: request.elements,
-}));