@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/scripts/lib/skills-predicate.mjs

@@ -1,129 +0,0 @@
-// The ONE structural replica of pi's own skill-loading walk (#2626 review
-// round 2, F1/F2).
-//
-// Two independent detectors used to answer "does this directory tree hold a
-// skill pi would load" with two DIFFERENT, hand-rolled heuristics that both
-// diverged from pi's real resolver:
-//   - `clients/skills-resolver.ts` (a `SKILL.md` one level down only, no
-//     recursion, no root `.md` acceptance, no symlink-follow, no dot/
-//     node_modules skip)
-//   - `scripts/install-selftest.mjs`'s `countSkillFiles` (recursed
-//     UNBOUNDED — would double-count a `SKILL.md` sitting inside another
-//     skill's own resource subdirectory — with no dot/node_modules skip, no
-//     root `.md` acceptance, no symlink handling)
-// Neither matched `loadSkillsFromDirInternal` in
-// `@earendil-works/pi-coding-agent` `dist/core/skills.js` (mirrored by
-// `collectSkillEntries` in `dist/core/package-manager.js`, byte-identical
-// walk, confirmed against the 0.85.1 tarball). This module is the fold: BOTH
-// consumers now derive from `collectSkillEntryPaths` below.
-//
-// Discovery rules, replicated from `loadSkillsFromDirInternal` (verified
-// against the extracted 0.85.1 `skills.js`):
-//   1. If `dir` directly contains a (non-symlink-broken) `SKILL.md`, `dir` IS
-//      one skill root — return immediately, do NOT look at `dir`'s other
-//      entries or recurse into its subdirectories (a `SKILL.md` inside a
-//      skill's own reference/ subfolder is the skill's OWN resource, not a
-//      second skill).
-//   2. Otherwise, skip dot-prefixed entries and `node_modules`; recurse into
-//      every remaining subdirectory (same two rules, one level down); at the
-//      OUTERMOST call only (`isRoot`), a loose `*.md` file directly in `dir`
-//      also counts (pi's `includeRootFiles`, true only for the top call).
-//   3. A symlink is followed via `statSync` (broken symlink = skip) for BOTH
-//      the `SKILL.md` check and the directory/file classification in step 2.
-//
-// Deliberately NOT replicated (out of #2626's scope — packaging/path
-// resolution, not skill-content validation):
-//   - `.gitignore`/`.ignore`/`.fdignore` matching inside the skills tree.
-//   - frontmatter parsing: pi additionally requires a non-empty `description`
-//     field before a discovered file becomes a loaded skill. A `SKILL.md`
-//     file that exists but fails THAT validation is a content-authoring
-//     defect a maintainer would see in normal use, not a silent zero.
-// Both gaps mean this predicate can be a bit more OPTIMISTIC than pi's true
-// count in a pathological case (an ignored or description-less file still
-// counts as "found" here); it is never more PESSIMISTIC — every real skill
-// pi loads is found by this walk too — which is the direction #2626 cares
-// about (never claim "no skills" when pi would load one).
-import * as fs from "node:fs";
-import * as path from "node:path";
-/**
- * Symlink-aware entry classification, mirroring `loadSkillsFromDirInternal`'s
- * own `entry.isSymbolicLink() ? statSync(fullPath) : entry`.
- * @param {string} fullPath
- * @param {import("node:fs").Dirent} entry
- * @returns {"file" | "dir" | "other"}
- */
-function resolvedEntryKind(fullPath, entry) {
-    if (entry.isSymbolicLink()) {
-        try {
-            const stats = fs.statSync(fullPath);
-            if (stats.isDirectory())
-                return "dir";
-            if (stats.isFile())
-                return "file";
-            return "other";
-        }
-        catch {
-            return "other"; // broken symlink
-        }
-    }
-    if (entry.isDirectory())
-        return "dir";
-    if (entry.isFile())
-        return "file";
-    return "other";
-}
-/**
- * The structural walk over an ALREADY-READ directory listing — split out
- * from `collectSkillEntryPaths` so a caller that already has `entries` (a
- * top-level ENOENT/EACCES distinction, say) is not forced into a second
- * `readdirSync`.
- * @param {string} dir
- * @param {import("node:fs").Dirent[]} entries
- * @param {boolean} isRoot
- * @returns {string[]} absolute paths of every `SKILL.md` (or, at the root,
- *   loose `.md`) file pi's own resolver would treat as a skill entry point.
- */
-export function scanEntriesForSkills(dir, entries, isRoot) {
-    for (const entry of entries) {
-        if (entry.name === "SKILL.md" &&
-            resolvedEntryKind(path.join(dir, entry.name), entry) === "file") {
-            return [path.join(dir, entry.name)];
-        }
-    }
-    const found = [];
-    for (const entry of entries) {
-        if (entry.name.startsWith(".") || entry.name === "node_modules") {
-            continue;
-        }
-        const fullPath = path.join(dir, entry.name);
-        const kind = resolvedEntryKind(fullPath, entry);
-        if (kind === "dir") {
-            found.push(...collectSkillEntryPaths(fullPath, false));
-            continue;
-        }
-        if (isRoot && kind === "file" && entry.name.endsWith(".md")) {
-            found.push(fullPath);
-        }
-    }
-    return found;
-}
-/**
- * Every skill entry point under `dir`, recursively, per pi's discovery
- * rules. Fail-closed: a `readdirSync` error at `dir` (absent, unreadable) or
- * any recursed-into subdirectory returns `[]` for that branch rather than
- * throwing — matching `loadSkillsFromDirInternal`'s own bare `try { … }
- * catch {}` per directory.
- * @param {string} dir
- * @param {boolean} [isRoot]
- * @returns {string[]}
- */
-export function collectSkillEntryPaths(dir, isRoot = true) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return scanEntriesForSkills(dir, entries, isRoot);
-}

package/node_modules/pi-lens/dist/scripts/lib/web-tree-sitter-dir.mjs

@@ -1,123 +0,0 @@
-/**
- * Where web-tree-sitter is installed — ONE ladder, for every caller that needs
- * the answer (#3409).
- *
- * Callers: `clients/tree-sitter-client.ts` (the grammar read path and the
- * lazy-fetch write target), `clients/install-diagnostics.ts` (the pasted
- * environment fingerprint) and `scripts/install-selftest.mjs` (the installed
- * host's own diagnostic). Each used to spell its own rungs, and the two that led
- * with a BARE specifier were unconditionally broken on the host pi ships: inside
- * a `bun build --compile` binary `require.resolve("web-tree-sitter")` throws
- * MODULE_NOT_FOUND while `require.resolve("web-tree-sitter/tree-sitter.wasm")` —
- * an explicit file subpath — still resolves.
- *
- * It lives in `scripts/lib/` rather than `clients/` because the installed
- * selftest is packaged (`files[]`) without `clients/`, and this is the house
- * pattern for logic a packaged .mjs script and the TypeScript runtime share
- * (`scripts/lib/skills-predicate.mjs`, `scripts/lib/process-scan.mjs`). It
- * imports nothing but `node:fs` and `node:path`, so it loads even on the hosts
- * whose broken dependency graph the selftest exists to report.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-/** The package this module is about. Also the name its manifest must carry. */
-const WEB_TREE_SITTER = "web-tree-sitter";
-/**
- * The wasm the runtime loads, at the package root — where 0.25.10's `exports`
- * map puts it (`"./tree-sitter.wasm": "./tree-sitter.wasm"`). If a later release
- * moves it (#381's 0.26 migration), the two FALLBACK rungs below stop matching
- * and the resolver rungs, which ask Node for that same subpath, keep working;
- * this constant is then the one line to update.
- */
-const RUNTIME_WASM = "tree-sitter.wasm";
-/**
- * True when `dir` IS an installed web-tree-sitter package: its own manifest
- * names it, and the wasm the runtime loads is in it.
- *
- * Round 1 review of #3409 (R3418-1): the constructed rungs used to accept any
- * directory that merely EXISTED at `<base>/node_modules/web-tree-sitter`, so an
- * empty or foreign directory of that name became the runtime fetch's write
- * target and a downloaded grammar would land in an unrelated tree. Existence is
- * not identity. The manifest name is the identity; the wasm is what makes the
- * directory the right place to put grammars, since a grammar is only loadable by
- * the web-tree-sitter runtime sitting next to it (the ABI drift #1564 is about).
- */
-export function isWebTreeSitterPackageDir(dir) {
-    try {
-        if (!fs.existsSync(path.join(dir, RUNTIME_WASM)))
-            return false;
-        const manifest = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
-        return manifest?.name === WEB_TREE_SITTER;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * The package directory owning `resolvedFile`: walk up until a directory passes
- * the identity check, or the filesystem root is reached. The walk exists because
- * an `exports` map may point into a subdirectory, so the file's own parent is
- * not necessarily the package; the identity check is what stops the walk, so a
- * resolver that answers outside any web-tree-sitter package yields nothing
- * rather than an unrelated ancestor.
- */
-function packageDirOf(resolvedFile) {
-    let dir = path.dirname(resolvedFile);
-    for (;;) {
-        if (isWebTreeSitterPackageDir(dir))
-            return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
-    }
-}
-/**
- * web-tree-sitter's installed package directory, or undefined.
- *
- * Rung order, most authoritative first:
- *  1. the `tree-sitter.wasm` SUBPATH, which resolves on a compiled host as well
- *     as a plain one. This is the rung that makes the non-core grammars
- *     fetchable there at all.
- *  2. the BARE specifier, for a future web-tree-sitter whose exports map no
- *     longer carries `./tree-sitter.wasm`.
- *  3. pi-lens's own package root, for the temp-dir compile layout (#20) where
- *     the resolver's context is a temp directory but the package root still has
- *     the right `node_modules`.
- *  4. the working directory, the pre-#3409 last resort.
- *
- * Rungs 1-2 are the resolver's answer and outrank the constructed guesses: the
- * grammars must come from the SAME package whose wasm the runtime loaded. Every
- * rung's candidate passes `isWebTreeSitterPackageDir` before it is returned.
- *
- * `resolve`, `packageRoot` and `cwd` are injected, never defaulted: the caller's
- * resolver context and package root are what differ on a compiled host, so they
- * must not be silently replaced by this module's — and a rung nothing can vary
- * is a rung no test can drive.
- */
-export function resolveWebTreeSitterPackageDir(deps) {
-    for (const specifier of [
-        `${WEB_TREE_SITTER}/${RUNTIME_WASM}`,
-        WEB_TREE_SITTER,
-    ]) {
-        try {
-            const dir = packageDirOf(deps.resolve(specifier));
-            if (dir)
-                return dir;
-        }
-        catch {
-            /* next rung */
-        }
-    }
-    for (const base of [deps.packageRoot, deps.cwd]) {
-        try {
-            const candidate = path.join(base(), "node_modules", WEB_TREE_SITTER);
-            if (isWebTreeSitterPackageDir(candidate))
-                return candidate;
-        }
-        catch {
-            /* next rung */
-        }
-    }
-    return undefined;
-}

package/node_modules/pi-lens/dist/tools/activate-tools.js

@@ -1,87 +0,0 @@
-/**
- * pi_lens_activate_tools — the loader tool that bootstraps pi's dynamic
- * tooling (registered-but-inactive tools activated via `pi.setActiveTools`).
- *
- * A handful of pi-lens tools are situational (structural ast-grep
- * search/replace/outline/dump, LSP go-to-definition/references/rename) —
- * useful on many turns, but not every turn. On hosts that support it, pi
- * lets an extension register such tools inactive and expose a small
- * always-active loader the model calls to activate a subset by name
- * (docs: https://github.com/earendil-works/pi, packages/coding-agent/docs/
- * extensions.md, "Dynamic Tool Loading"). Newly activated tools appear
- * starting the NEXT turn — no reload needed.
- *
- * This tool stays always-active (it has to, to bootstrap activation). It is
- * a no-op catalog lookup on hosts where the caller never wired
- * `setActiveTools`/`getActiveTools` (see the feature-detected gating in
- * index.ts) — the situational tools are registered statically active there
- * instead, so calling this tool is harmless, just unnecessary.
- */
-import { Type } from "../clients/deps/typebox.js";
-export function createActivateToolsTool(pi, lazyTools, options = {}) {
-    const lazyNames = lazyTools.map((t) => t.name);
-    const lazyNameSet = new Set(lazyNames);
-    return {
-        name: "pi_lens_activate_tools",
-        label: "Activate pi-lens Tools",
-        description: 'Activate registered situational tools for the next turn. Example: `{tools: ["lsp_navigation"]}`.',
-        promptSnippet: "Activate a situational tool",
-        parameters: Type.Object({
-            tools: Type.Array(Type.String({ enum: lazyNames }), {
-                minItems: 1,
-                description: "Names of situational tools to activate, e.g. `lsp_navigation`.",
-            }),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const requested = Array.isArray(params.tools)
-                ? params.tools.filter((t) => typeof t === "string" && lazyNameSet.has(t))
-                : [];
-            if (Array.isArray(params.tools)) {
-                for (const name of params.tools) {
-                    if (typeof name === "string" && !lazyNameSet.has(name))
-                        options.onRejected?.(name);
-                }
-            }
-            if (requested.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No valid tool names given. Available: ${lazyNames.join(", ")}`,
-                        },
-                    ],
-                    isError: true,
-                    details: { matches: [], added: [] },
-                };
-            }
-            // Additive only, per the docs' contract: never drop currently active
-            // tools in the same call.
-            // Remember every requested tool, not just the newly-added ones: a
-            // tool that is already active still has to survive the next
-            // fork/reload/resume restore.
-            options.onActivated?.(requested, ctx);
-            const active = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
-            const activeSet = new Set(active);
-            const added = requested.filter((name) => !activeSet.has(name));
-            const merged = [...new Set([...active, ...added])];
-            if (added.length > 0 && typeof pi.setActiveTools === "function") {
-                pi.setActiveTools(merged);
-                options.onMutation?.({
-                    addedCount: added.length,
-                    removedCount: 0,
-                    reason: "lazy_activation",
-                    deferralApplies: options.deferredToolSupport?.(ctx) ?? false,
-                });
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Activated: ${requested.join(", ")}. Available starting next turn.`,
-                    },
-                ],
-                details: { matches: requested, added },
-            };
-        },
-    };
-}

package/node_modules/pi-lens/dist/tools/ast-grep-outline.js

@@ -1,137 +0,0 @@
-import * as path from "node:path";
-import { Type } from "../clients/deps/typebox.js";
-import { compactRenderResult } from "./render-compact.js";
-import { LANGUAGES } from "./shared.js";
-// Cap the wire payload so an outline over a large directory can't flood context.
-const MAX_FILES = 50;
-const MAX_ITEMS_PER_FILE = 200;
-/** Attach ready `read` args (1-based) to each item/member from its 0-based range. */
-function withReadHandles(filePath, item) {
-    const { members, ...rest } = item;
-    const offset = item.range.start.line + 1;
-    const limit = Math.max(1, item.range.end.line - item.range.start.line + 1);
-    return {
-        ...rest,
-        read: { path: filePath, offset, limit },
-        ...(members
-            ? { members: members.map((m) => withReadHandles(filePath, m)) }
-            : {}),
-    };
-}
-function errorResult(text) {
-    return {
-        content: [{ type: "text", text }],
-        isError: true,
-        details: {},
-    };
-}
-export function createAstGrepOutlineTool(astGrepClient) {
-    return {
-        name: "ast_grep_outline",
-        label: "AST-Grep Outline",
-        description: "Return syntax-only symbols, imports, exports, and members with ast-grep. An outline shows structure, not a symbol body, and does not satisfy read-before-edit; use read_symbol or read_enclosing for body coverage. Example: outline `src/` before choosing a symbol to read.",
-        promptSnippet: "Inspect syntax without index or LSP",
-        renderResult: compactRenderResult(({ details, isError, text }) => {
-            if (isError) {
-                return `ast_grep_outline — ${text.split("\n")[0] ?? "error"}`;
-            }
-            const files = details?.files ?? 0;
-            const items = details?.items ?? 0;
-            const trunc = details?.truncatedFiles ? " (truncated)" : "";
-            return `ast_grep_outline — ${items} symbols across ${files} file${files === 1 ? "" : "s"}${trunc}`;
-        }),
-        parameters: Type.Object({
-            paths: Type.Array(Type.String(), {
-                minItems: 1,
-                maxItems: 100,
-                description: "Files or directories to outline (workspace-relative or absolute).",
-            }),
-            lang: Type.Optional(Type.String({
-                enum: [...LANGUAGES],
-                description: "Restrict to one language. Required for stdin; for paths, ast-grep infers per file when omitted.",
-            })),
-            items: Type.Optional(Type.String({
-                enum: ["auto", "structure", "exports", "imports", "all"],
-                description: "Which top-level items to include. auto = `structure` for a file, `exports` for a directory (default).",
-            })),
-            view: Type.Optional(Type.String({
-                enum: ["auto", "names", "signatures", "digest", "expanded"],
-                description: "Text presentation level for the underlying outline; `expanded` shows members.",
-            })),
-            type: Type.Optional(Type.Array(Type.String(), {
-                description: 'Keep only these symbol types, e.g. ["class","function"].',
-            })),
-            match: Type.Optional(Type.String({
-                description: "Keep only top-level items whose name matches this regex.",
-            })),
-            pubMembers: Type.Optional(Type.Boolean({
-                description: "Show only public members in member views.",
-            })),
-            globs: Type.Optional(Type.Array(Type.String(), {
-                description: 'Include/exclude file globs for directory input, e.g. ["*.ts","!**/dist/**"].',
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const cwd = ctx.cwd || ".";
-            const rawPaths = (params.paths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
-            if (rawPaths.length === 0)
-                return errorResult("paths is required");
-            // Resolve relative paths against the workspace; pass absolute paths to the
-            // CLI (execFile-style args — no shell interpolation).
-            const absPaths = rawPaths.map((p) => path.isAbsolute(p) ? p : path.resolve(cwd, p));
-            if (!(await astGrepClient.ensureAvailable())) {
-                return errorResult("ast-grep CLI not found. Install: npm i -D @ast-grep/cli");
-            }
-            let result;
-            try {
-                result = await astGrepClient.outline(absPaths, {
-                    lang: params.lang,
-                    items: params.items,
-                    view: params.view,
-                    types: params.type,
-                    match: params.match,
-                    pubMembers: params.pubMembers,
-                    globs: params.globs,
-                });
-            }
-            catch (err) {
-                return errorResult(`Error: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            if (result.error)
-                return errorResult(`Error: ${result.error}`);
-            const files = (result.output ?? []).slice(0, MAX_FILES);
-            const truncatedFiles = (result.output?.length ?? 0) > MAX_FILES;
-            const outline = files.map((file) => ({
-                path: file.path,
-                language: file.language,
-                items: file.items
-                    .slice(0, MAX_ITEMS_PER_FILE)
-                    .map((item) => withReadHandles(file.path, item)),
-                ...(file.items.length > MAX_ITEMS_PER_FILE
-                    ? { truncatedItems: file.items.length - MAX_ITEMS_PER_FILE }
-                    : {}),
-            }));
-            const totalItems = files.reduce((n, f) => n + f.items.length, 0);
-            if (outline.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No outline items found (syntax-only — try module_report, or check lang/paths).",
-                        },
-                    ],
-                    details: { files: 0, items: 0 },
-                };
-            }
-            return {
-                content: [{ type: "text", text: JSON.stringify({ outline }) }],
-                details: {
-                    files: outline.length,
-                    items: totalItems,
-                    syntaxOnly: true,
-                    ...(truncatedFiles ? { truncatedFiles: true } : {}),
-                },
-            };
-        },
-    };
-}