@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

package/node_modules/pi-lens/dist/tools/symbol-search.js

@@ -1,155 +0,0 @@
-/**
- * symbol_search pi tool (#348) — the entry point of the discovery funnel:
- * symbol_search finds ranked candidate files by identifier, module_report
- * explains one, read_symbol reads the exact body. Thin wrapper over the
- * existing symbolSearch() engine seam (clients/lens-engine.ts), mirroring the
- * MCP pilens_symbol_search tool with the same #517-slimmed payload.
- */
-import * as path from "node:path";
-import { Type } from "../clients/deps/typebox.js";
-import { symbolSearch, } from "../clients/lens-engine.js";
-import { compactRenderResult } from "./render-compact.js";
-/**
- * Machine-actionable follow-up hint (#771) — mirrors ast-grep-search.ts's
- * `suggestedDump` pattern. Cheap enough to attach per hit rather than only the
- * top one: it's a pure derivation of `relPath`, no extra computation. Points
- * the discovery funnel's next step (module_report explains the file; from
- * there read_symbol reads a body).
- */
-function suggestedNext(relPath) {
-    return { tool: "module_report", path: relPath };
-}
-export function createSymbolSearchTool(getProjectRoot) {
-    return {
-        name: "symbol_search",
-        label: "Symbol Search",
-        description: "Find relevant files by ranked identifier search. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: search `authenticate user` before module_report.",
-        promptSnippet: "Find files by identifier",
-        renderResult: compactRenderResult(({ details, isError }) => {
-            if (isError || details?.available === false) {
-                return `symbol_search "${details?.query ?? ""}" — unavailable${details?.hint ? `: ${details.hint}` : ""}`;
-            }
-            return `symbol_search "${details?.query ?? ""}"  ${details?.count ?? 0} file(s)`;
-        }),
-        parameters: Type.Object({
-            query: Type.String({
-                description: "Identifier-ish query, e.g. 'authenticate user'. Mix in composable prefix filters: lang:<kind> (e.g. lang:jsts, lang:python — kinds from file-kinds.ts), file:<substr> (path substring), ext:<ext> (e.g. ext:ts or ext:.ts), each optionally negated with a leading '-' (-file:test). Filters apply before ranking; e.g. 'lang:jsts file:clients/ -file:test rank'. Unknown prefixes/kinds error with the supported list.",
-            }),
-            limit: Type.Optional(Type.Number({
-                description: "Max files to return (default 20).",
-            })),
-            paths: Type.Optional(Type.Array(Type.String(), {
-                description: "Glob array scoping hits to matching files — same shape/semantics as ast_grep_search's `paths` (a bare directory/file entry scopes its whole subtree). Filters before ranking, so scores within the scoped set are unaffected.",
-            })),
-            lang: Type.Optional(Type.String({
-                description: "Restrict hits to one language, using the same identifiers as ast_grep_search's `lang` param (e.g. 'typescript', 'python', 'go').",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const cwd = getProjectRoot() || ctx.cwd || ".";
-            let result;
-            try {
-                result = await symbolSearch(params.query, cwd, params.limit, {
-                    paths: params.paths,
-                    lang: params.lang,
-                });
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Symbol search failed for "${params.query}": ${message}`,
-                        },
-                    ],
-                    isError: true,
-                    details: { available: false, query: params.query },
-                };
-            }
-            if (!result.available) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: result.hint ??
-                                "No word index for this workspace yet — retry shortly.",
-                        },
-                    ],
-                    isError: true,
-                    details: {
-                        available: false,
-                        query: result.query,
-                        hint: result.hint,
-                        unavailableReason: result.unavailableReason,
-                    },
-                };
-            }
-            if (result.results.length === 0) {
-                const coverageLine = result.coverage
-                    ? `Index covers ${result.coverage.files} files${result.coverage.truncated ? " (capped — results may be incomplete)" : ""}.`
-                    : "";
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No files matched "${params.query}".${coverageLine ? `\n${coverageLine}` : ""}`,
-                        },
-                    ],
-                    details: {
-                        available: true,
-                        query: result.query,
-                        count: 0,
-                        coverage: result.coverage,
-                    },
-                };
-            }
-            const lines = [
-                `Top ${result.results.length} file(s) for "${result.query}":`,
-                ...result.results.map((hit, i) => `  ${i + 1}. ${path.relative(cwd, hit.file)} ` +
-                    `(score ${hit.score.toFixed(2)}, ${hit.hits} hit(s), line ${hit.startLine})`),
-                ...(result.coverage
-                    ? [
-                        `Index covers ${result.coverage.files} files${result.coverage.truncated ? " (capped — results may be incomplete)" : ""}.`,
-                    ]
-                    : []),
-            ];
-            // Compact (unindented) JSON payload, matching module_report/read_symbol
-            // (#517): path relative-to-cwd once per hit, no per-hit `read` block —
-            // startLine/endLine already derive offset/limit for a one-line peek.
-            const payload = {
-                available: true,
-                query: result.query,
-                coverage: result.coverage,
-                results: result.results.map((hit) => {
-                    const relFile = path.relative(cwd, hit.file);
-                    return {
-                        file: relFile,
-                        score: hit.score,
-                        hits: hit.hits,
-                        startLine: hit.startLine,
-                        endLine: hit.endLine,
-                        ...(hit.annotations ? { annotations: hit.annotations } : {}),
-                        suggestedNext: suggestedNext(relFile),
-                    };
-                }),
-            };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `${lines.join("\n")}\n\n${JSON.stringify(payload)}`,
-                    },
-                ],
-                details: {
-                    available: true,
-                    query: result.query,
-                    count: result.results.length,
-                    coverage: result.coverage,
-                },
-            };
-        },
-    };
-}
-// Re-exported so tests importing from this module can reach baseName without
-// a second import path.