pi-readseek 0.7.6 → 0.7.8

package/src/readseek-params.ts

@@ -1,39 +0,0 @@
-import { Type } from "@sinclair/typebox";
-
-import { buildToolErrorResult, type ToolErrorResult } from "./readseek-value.js";
-
-/** Optional search path shared by the readseek search tools. */
-export function searchPathParam() {
-  return Type.Optional(Type.String({ description: "File or directory to search" }));
-}
-
-/** Optional language hint shared by the readseek search tools. */
-export function langParam() {
-  return Type.Optional(Type.String({ description: "Language override when auto-detection is ambiguous" }));
-}
-
-/**
- * TypeBox fragment for the Git-scope parameters shared by every readseek
- * search tool. Returns fresh schema instances so each tool spreads its own.
- */
-export function readSeekGitSearchParams() {
-  return {
-    cached: Type.Optional(Type.Boolean({ description: "In a Git repository, search tracked/indexed files" })),
-    others: Type.Optional(Type.Boolean({ description: "In a Git repository, search untracked files" })),
-    ignored: Type.Optional(Type.Boolean({ description: "With others=true, include ignored untracked files" })),
-  };
-}
-
-/**
- * Enforce that `ignored` is only meaningful alongside `others`. Returns an
- * error envelope tagged with {@link tool} when the rule is violated, else null.
- */
-export function validateIgnoredRequiresOthers(
-  tool: string,
-  params: { others?: boolean; ignored?: boolean },
-): ToolErrorResult | null {
-  if (params.ignored && !params.others) {
-    return buildToolErrorResult(tool, "invalid-parameter", `${tool} parameter 'ignored' requires 'others'`);
-  }
-  return null;
-}

package/src/readseek-settings.ts

@@ -1,263 +0,0 @@
-import { readFileSync, statSync, type Stats } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export type ReadSeekImageAnalysisMode = "on" | "off" | "auto";
-export type ReadSeekSyntaxValidationMode = "warn" | "block" | "off";
-interface ReadSeekGrepSettings {
-  maxLines?: number;
-  maxBytes?: number;
-}
-
-const READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_read",
-  edit: "readSeek_edit",
-  grep: "readSeek_grep",
-  write: "readSeek_write",
-} as const;
-
-type ReadSeekReplacementTool = keyof typeof READSEEK_TOOL_REPLACEMENTS;
-
-interface ReadSeekJsonSettings {
-  replacedTools?: ReadSeekReplacementTool[];
-  imageMode?: ReadSeekImageAnalysisMode;
-  syntaxValidation?: ReadSeekSyntaxValidationMode;
-  timeoutMs?: number;
-  grep?: ReadSeekGrepSettings;
-}
-
-export interface ReadSeekSettingsWarning {
-  source: string;
-  message: string;
-  path?: string;
-}
-
-export interface ReadSeekSettingsResult {
-  settings: ReadSeekJsonSettings;
-  warnings: ReadSeekSettingsWarning[];
-}
-
-const READSEEK_KEYS = ["replacedTools", "imageMode", "syntaxValidation", "timeoutMs", "grep"];
-const READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
-
-function globalSettingsPath(): string {
-  return join(homedir(), ".pi/agent/settings.json");
-}
-
-function projectSettingsPath(): string {
-  return join(process.cwd(), ".pi/settings.json");
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function invalid(source: string, path: string): ReadSeekSettingsWarning {
-  return { source, path, message: `Invalid readseek setting at ${path}` };
-}
-
-function warnUnknownKeys(
-  raw: Record<string, unknown>,
-  known: string[],
-  prefix: string,
-  source: string,
-  warnings: ReadSeekSettingsWarning[],
-): void {
-  for (const key of Object.keys(raw)) {
-    if (known.includes(key)) continue;
-    const path = `${prefix}.${key}`;
-    warnings.push({ source, path, message: `Unknown readseek setting at ${path}` });
-  }
-}
-
-function readPositive(
-  raw: Record<string, unknown>,
-  key: string,
-  path: string,
-  source: string,
-  warnings: ReadSeekSettingsWarning[],
-): number | undefined {
-  if (!(key in raw)) return undefined;
-  const val = raw[key];
-  if (typeof val === "number" && Number.isSafeInteger(val) && val > 0) return val;
-  warnings.push(invalid(source, path));
-  return undefined;
-}
-
-function readEnum<T extends string>(
-  raw: Record<string, unknown>,
-  key: string,
-  values: readonly T[],
-  path: string,
-  source: string,
-  warnings: ReadSeekSettingsWarning[],
-): T | undefined {
-  if (!(key in raw)) return undefined;
-  const val = raw[key];
-  if (typeof val === "string" && (values as readonly string[]).includes(val)) return val as T;
-  warnings.push(invalid(source, path));
-  return undefined;
-}
-
-function readImageMode(
-  raw: Record<string, unknown>,
-  source: string,
-  warnings: ReadSeekSettingsWarning[],
-): ReadSeekImageAnalysisMode | undefined {
-  if (!("imageMode" in raw)) return undefined;
-  const val = raw.imageMode;
-  if (val === "on" || val === "off" || val === "auto") return val;
-  warnings.push(invalid(source, "readseek.imageMode"));
-  return undefined;
-}
-
-function readReplacedTools(
-  raw: Record<string, unknown>,
-  source: string,
-  warnings: ReadSeekSettingsWarning[],
-): ReadSeekReplacementTool[] | undefined {
-  if (!("replacedTools" in raw)) return undefined;
-  const value = raw.replacedTools;
-  if (!Array.isArray(value)) {
-    warnings.push(invalid(source, "readseek.replacedTools"));
-    return undefined;
-  }
-
-  const tools: ReadSeekReplacementTool[] = [];
-  value.forEach((tool, index) => {
-    if (typeof tool === "string" && Object.hasOwn(READSEEK_TOOL_REPLACEMENTS, tool)) {
-      tools.push(tool as ReadSeekReplacementTool);
-    } else {
-      warnings.push(invalid(source, `readseek.replacedTools[${index}]`));
-    }
-  });
-  return tools;
-}
-
-function validateSettings(raw: unknown, source: string): ReadSeekSettingsResult {
-  const settings: ReadSeekJsonSettings = {};
-  const warnings: ReadSeekSettingsWarning[] = [];
-  if (!isRecord(raw)) {
-    warnings.push({ source, message: "Invalid readseek settings: expected a JSON object" });
-    return { settings, warnings };
-  }
-  if (!("readseek" in raw)) {
-    const misplaced = READSEEK_KEYS.filter((key) => key in raw);
-    if (misplaced.length > 0) {
-      warnings.push({
-        source,
-        path: misplaced[0],
-        message: `Readseek setting at top level: move ${misplaced.join(", ")} under "readseek"`,
-      });
-    }
-    return { settings, warnings };
-  }
-  if (!isRecord(raw.readseek)) {
-    warnings.push(invalid(source, "readseek"));
-    return { settings, warnings };
-  }
-
-  const section = raw.readseek;
-  warnUnknownKeys(section, READSEEK_KEYS, "readseek", source, warnings);
-
-  const replacedTools = readReplacedTools(section, source, warnings);
-  if (replacedTools !== undefined) settings.replacedTools = replacedTools;
-
-  const imageMode = readImageMode(section, source, warnings);
-  if (imageMode !== undefined) settings.imageMode = imageMode;
-
-  const syntaxValidation = readEnum(
-    section,
-    "syntaxValidation",
-    ["warn", "block", "off"] as const,
-    "readseek.syntaxValidation",
-    source,
-    warnings,
-  );
-  if (syntaxValidation !== undefined) settings.syntaxValidation = syntaxValidation;
-
-  const timeoutMs = readPositive(section, "timeoutMs", "readseek.timeoutMs", source, warnings);
-  if (timeoutMs !== undefined) settings.timeoutMs = timeoutMs;
-
-  if ("grep" in section) {
-    if (isRecord(section.grep)) {
-      warnUnknownKeys(section.grep, READSEEK_GREP_KEYS, "readseek.grep", source, warnings);
-      const grep: ReadSeekGrepSettings = {};
-      const maxLines = readPositive(section.grep, "maxLines", "readseek.grep.maxLines", source, warnings);
-      if (maxLines !== undefined) grep.maxLines = maxLines;
-      const maxBytes = readPositive(section.grep, "maxBytes", "readseek.grep.maxBytes", source, warnings);
-      if (maxBytes !== undefined) grep.maxBytes = maxBytes;
-      if (Object.keys(grep).length > 0) settings.grep = grep;
-    } else {
-      warnings.push(invalid(source, "readseek.grep"));
-    }
-  }
-
-  return { settings, warnings };
-}
-
-interface SettingsFileCacheEntry {
-  mtimeMs: number;
-  size: number;
-  result: ReadSeekSettingsResult;
-}
-
-const settingsFileCache = new Map<string, SettingsFileCacheEntry>();
-
-function statFileOrNull(path: string): Stats | null {
-  try {
-    return statSync(path);
-  } catch {
-    return null;
-  }
-}
-
-function readSettingsFile(path: string): ReadSeekSettingsResult {
-  const stats = statFileOrNull(path);
-  if (!stats) {
-    settingsFileCache.delete(path);
-    return { settings: {}, warnings: [] };
-  }
-
-  const cached = settingsFileCache.get(path);
-  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) return cached.result;
-
-  let result: ReadSeekSettingsResult;
-  try {
-    const text = readFileSync(path, "utf8");
-    result = validateSettings(JSON.parse(text) as unknown, path);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    result = { settings: {}, warnings: [{ source: path, message: `Invalid JSON: ${message}` }] };
-  }
-  settingsFileCache.set(path, { mtimeMs: stats.mtimeMs, size: stats.size, result });
-  return result;
-}
-
-function mergeSettings(base: ReadSeekJsonSettings, override: ReadSeekJsonSettings): ReadSeekJsonSettings {
-  const settings: ReadSeekJsonSettings = { ...base, ...override };
-  const grep = { ...(base.grep ?? {}), ...(override.grep ?? {}) };
-  if (Object.keys(grep).length > 0) settings.grep = grep;
-  return settings;
-}
-
-export function resolveReadSeekJsonSettings(): ReadSeekSettingsResult {
-  const globalResult = readSettingsFile(globalSettingsPath());
-  const projectResult = readSettingsFile(projectSettingsPath());
-  return {
-    settings: mergeSettings(globalResult.settings, projectResult.settings),
-    warnings: [...globalResult.warnings, ...projectResult.warnings],
-  };
-}
-
-export function resolveReadSeekImageMode(): ReadSeekImageAnalysisMode {
-  return resolveReadSeekJsonSettings().settings.imageMode ?? "auto";
-}
-
-export function resolveReadSeekSyntaxValidation(): ReadSeekSyntaxValidationMode | undefined {
-  return resolveReadSeekJsonSettings().settings.syntaxValidation;
-}
-
-export function resolveReadSeekTimeoutMs(): number | undefined {
-  return resolveReadSeekJsonSettings().settings.timeoutMs;
-}

package/src/readseek-value.ts

@@ -1,184 +0,0 @@
-import { computeLineHash, escapeControlCharsForDisplay } from "./hashline.js";
-import type { DiffData } from "./diff-data.js";
-
-export interface ReadSeekLine {
-  line: number;
-  hash: string;
-  anchor: string;
-  raw: string;
-  display: string;
-}
-
-export interface ReadSeekWarningSymbol {
-  name: string;
-  kind: string;
-  startLine: number;
-  endLine: number;
-  parentName?: string;
-}
-export interface ReadSeekWarning {
-  code: string;
-  message: string;
-  tier?: "camelCase" | "substring";
-  symbol?: ReadSeekWarningSymbol;
-  otherCandidates?: ReadSeekWarningSymbol[];
-}
-
-export interface ReadSeekError {
-  code: string;
-  message: string;
-  hint?: string;
-  details?: unknown;
-}
-
-export interface ReadSeekRange {
-  startLine: number;
-  endLine: number;
-  totalLines?: number;
-}
-
-export interface SemanticSummary {
-  classification: "no-op" | "whitespace-only" | "semantic" | "mixed";
-}
-export interface ReadSeekEditResult {
-  tool: "edit";
-  ok: boolean;
-  path: string;
-  summary: string;
-  diff: string;
-  diffData?: DiffData;
-  firstChangedLine: number | undefined;
-  warnings: string[];
-  noopEdits: unknown[];
-  semanticSummary?: SemanticSummary;
-}
-
-/**
- * Build a {@link ReadSeekLine} from an already-known hash. Use this when the
- * hash is supplied by readseek (search, refs) rather than computed from `raw`;
- * {@link buildReadSeekLine} delegates here after hashing.
- */
-export function buildReadSeekLineWithHash(line: number, hash: string, raw: string): ReadSeekLine {
-  return {
-    line,
-    hash,
-    anchor: `${line}:${hash}`,
-    raw,
-    display: escapeControlCharsForDisplay(raw),
-  };
-}
-
-export function buildReadSeekLine(line: number, raw: string): ReadSeekLine {
-  return buildReadSeekLineWithHash(line, computeLineHash(raw), raw);
-}
-
-export function buildReadSeekLines(startLine: number, rawLines: string[]): ReadSeekLine[] {
-  return rawLines.map((raw, index) => buildReadSeekLine(startLine + index, raw));
-}
-
-export function renderReadSeekLines(lines: ReadSeekLine[]): string {
-  return lines.map((line) => `${line.anchor}|${line.display}`).join("\n");
-}
-
-/**
- * Render the anchored-file block format shared by the `search` and `refs`
- * tools: a `--- <displayPath> ---` header per file followed by one
- * `>><anchor>|<display>` line per match. {@link lineSuffix} appends tool
- * specific trailers (e.g. refs' enclosing-symbol annotation).
- */
-export function formatAnchoredFileBlocks<T extends ReadSeekLine>(
-  files: Array<{ displayPath: string; lines: T[] }>,
-  lineSuffix?: (line: T) => string,
-): string {
-  const blocks: string[] = [];
-  for (const file of files) {
-    blocks.push(`--- ${file.displayPath} ---`);
-    for (const line of file.lines) {
-      blocks.push(`>>${line.anchor}|${line.display}${lineSuffix?.(line) ?? ""}`);
-    }
-  }
-  return blocks.join("\n");
-}
-
-export function buildReadSeekWarning(
-  code: string,
-  message: string,
-  metadata: Omit<ReadSeekWarning, "code" | "message"> = {},
-): ReadSeekWarning {
-  return { code, message, ...metadata };
-}
-
-export function buildReadSeekError(
-  code: string,
-  message: string,
-  hint?: string,
-  details?: unknown,
-): ReadSeekError {
-  return {
-    code,
-    message,
-    ...(hint !== undefined ? { hint } : {}),
-    ...(details !== undefined ? { details } : {}),
-  };
-}
-
-export interface ToolErrorResult {
-  content: [{ type: "text"; text: string }];
-  isError: true;
-  details: { readSeekValue: Record<string, unknown> };
-}
-
-/**
- * Build the standard failure envelope shared by every read-family tool: a text
- * content block plus a `readSeekValue` carrying `ok: false` and a
- * {@link buildReadSeekError} payload.
- *
- * `path` is included only when provided, and `extra` is merged into
- * `readSeekValue` so callers can attach tool-specific fields (e.g. write's
- * `lines`/`warnings`).
- */
-export function buildToolErrorResult(
-  tool: string,
-  code: string,
-  message: string,
-  opts: { path?: string; hint?: string; details?: unknown; extra?: Record<string, unknown> } = {},
-): ToolErrorResult {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true,
-    details: {
-      readSeekValue: {
-        tool,
-        ...(opts.extra ?? {}),
-        ok: false,
-        ...(opts.path !== undefined ? { path: opts.path } : {}),
-        error: buildReadSeekError(code, message, opts.hint, opts.details),
-      },
-    },
-  };
-}
-
-export function buildReadSeekEditResult(input: {
-  ok?: boolean;
-  path: string;
-  summary: string;
-  diff: string;
-  diffData?: DiffData;
-  firstChangedLine: number | undefined;
-  warnings: string[];
-  noopEdits: unknown[];
-  semanticSummary?: SemanticSummary;
-}): ReadSeekEditResult {
-  return {
-    tool: "edit",
-    ok: input.ok ?? true,
-    path: input.path,
-    summary: input.summary,
-    diff: input.diff,
-    ...(input.diffData ? { diffData: input.diffData } : {}),
-    firstChangedLine: input.firstChangedLine,
-    warnings: [...input.warnings],
-    noopEdits: [...input.noopEdits],
-    ...(input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}),
-  };
-}

package/src/refs-output.ts

@@ -1,47 +0,0 @@
-import { formatAnchoredFileBlocks, type ReadSeekLine } from "./readseek-value.js";
-
-export interface RefsOutputLine extends ReadSeekLine {
-  enclosingSymbol?: string;
-}
-
-export interface RefsOutputFile {
-  displayPath: string;
-  path: string;
-  lines: RefsOutputLine[];
-}
-
-interface BuildRefsOutputInput {
-  name: string;
-  files: RefsOutputFile[];
-}
-
-interface RefsOutputResult {
-  text: string;
-  readSeekValue: {
-    tool: "refs";
-    files: Array<{
-      path: string;
-      lines: RefsOutputLine[];
-    }>;
-  };
-}
-
-export function buildRefsOutput(input: BuildRefsOutputInput): RefsOutputResult {
-  if (input.files.length === 0) {
-    return {
-      text: `No references found for: ${input.name}`,
-      readSeekValue: { tool: "refs", files: [] },
-    };
-  }
-
-  return {
-    text: formatAnchoredFileBlocks(input.files, (line) => (line.enclosingSymbol ? ` (in ${line.enclosingSymbol})` : "")),
-    readSeekValue: {
-      tool: "refs",
-      files: input.files.map((file) => ({
-        path: file.path,
-        lines: file.lines.map((line) => ({ ...line })),
-      })),
-    },
-  };
-}

package/src/refs.ts

@@ -1,161 +0,0 @@
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import path from "node:path";
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { statSearchPathOrError } from "./stat-search-path.js";
-import { buildReadSeekLineWithHash, buildToolErrorResult } from "./readseek-value.js";
-import { resolveToCwd } from "./path-utils.js";
-import { classifyReadSeekFailure, readSeekRefs, type ReadSeekReference } from "./readseek-client.js";
-import { buildRefsOutput, type RefsOutputFile, type RefsOutputLine } from "./refs-output.js";
-import type { FileAnchoredCallback } from "./tool-types.js";
-import { langParam, readSeekGitSearchParams, searchPathParam, validateIgnoredRequiresOthers } from "./readseek-params.js";
-import { registerReadSeekTool } from "./register-tool.js";
-
-import { renderAnchoredFilesResult, renderReadSeekSearchCall } from "./tui-render-utils.js";
-
-type RefsParams = {
-  name: string;
-  path?: string;
-  lang?: string;
-  scope?: boolean;
-  line?: number;
-  column?: number;
-  cached?: boolean;
-  others?: boolean;
-  ignored?: boolean;
-};
-
-const REFS_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/refs.md", import.meta.url),
-  promptSnippet: "Find usages of an identifier or cursor binding",
-});
-
-interface RefsToolOptions {
-  onFileAnchored?: FileAnchoredCallback;
-}
-
-/**
- * Inputs for executing the references tool without registering it.
- */
-export interface ExecuteRefsOptions {
-  params: unknown;
-  signal: AbortSignal | undefined;
-  cwd: string;
-  onFileAnchored?: FileAnchoredCallback;
-}
-
-function refsLine(reference: ReadSeekReference): RefsOutputLine {
-  return {
-    ...buildReadSeekLineWithHash(reference.line, reference.line_hash, reference.text),
-    enclosingSymbol: reference.enclosingSymbol,
-  };
-}
-
-function groupReferences(references: ReadSeekReference[], cwd: string): RefsOutputFile[] {
-  const files = new Map<string, RefsOutputFile>();
-  const seen = new Set<string>();
-  for (const reference of references) {
-    const abs = path.isAbsolute(reference.file) ? reference.file : path.resolve(cwd, reference.file);
-    const dedupeKey = `${abs}:${reference.line}:${reference.column}`;
-    if (seen.has(dedupeKey)) continue;
-    seen.add(dedupeKey);
-    let file = files.get(abs);
-    if (!file) {
-      file = { displayPath: path.relative(cwd, abs) || abs, path: abs, lines: [] };
-      files.set(abs, file);
-    }
-    file.lines.push(refsLine(reference));
-  }
-  return [...files.values()];
-}
-
-function isReadSeekCursorValidationFailure(message: string): boolean {
-  return (
-    /line and column must be greater than zero/i.test(message) ||
-    /line \d+ not found/i.test(message) ||
-    /column \d+ exceeds maximum column \d+ for line \d+/i.test(message)
-  );
-}
-
-/**
- * Executes identifier reference lookup and returns readseek-anchored matches.
- */
-export async function executeRefs(opts: ExecuteRefsOptions): Promise<any> {
-  const { params, signal, cwd, onFileAnchored } = opts;
-  const p = params as RefsParams;
-  const ignoredError = validateIgnoredRequiresOthers("refs", p);
-  if (ignoredError) return ignoredError;
-  if (p.scope && p.line === undefined) {
-    return buildToolErrorResult("refs", "invalid-parameter", "refs parameter 'scope' requires 'line'");
-  }
-  const searchPath = resolveToCwd(p.path ?? ".", cwd);
-
-  const statResult = await statSearchPathOrError("refs", p.path, searchPath);
-  if (!statResult.ok) return statResult.error;
-
-  try {
-    const references = await readSeekRefs(searchPath, p.name, {
-      scope: p.scope,
-      line: p.line,
-      column: p.column,
-      language: p.lang,
-      cached: p.cached,
-      others: p.others,
-      ignored: p.ignored,
-      signal,
-    });
-    const files = groupReferences(references, cwd);
-    const builtOutput = buildRefsOutput({ name: p.name, files });
-    for (const file of files) {
-      onFileAnchored?.(file.path);
-    }
-    return {
-      content: [{ type: "text", text: builtOutput.text }],
-      details: { readSeekValue: builtOutput.readSeekValue },
-    };
-  } catch (err: any) {
-    const failure = classifyReadSeekFailure(err);
-    if (p.scope && isReadSeekCursorValidationFailure(failure.message)) {
-      return buildToolErrorResult("refs", "invalid-parameter", failure.message);
-    }
-    return buildToolErrorResult("refs", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-  }
-}
-
-export function registerRefsTool(pi: ExtensionAPI, options: RefsToolOptions = {}) {
-  const tool = registerReadSeekTool(pi, {
-    name: "readSeek_refs",
-    label: "References",
-    description: REFS_PROMPT_METADATA.description,
-    promptSnippet: REFS_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: REFS_PROMPT_METADATA.promptGuidelines,
-    parameters: Type.Object({
-      name: Type.String({ description: "Identifier to find references for" }),
-      path: searchPathParam(),
-      lang: langParam(),
-      scope: Type.Optional(Type.Boolean({ description: "Restrict results to the binding at the cursor" })),
-      line: Type.Optional(Type.Number({ description: "Cursor line (1-indexed), required with scope" })),
-      column: Type.Optional(Type.Number({ description: "Cursor byte column (1-indexed) for disambiguation" })),
-      ...readSeekGitSearchParams(),
-    }),
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeRefs({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
-    },
-    renderCall(args: any, theme: any, ...rest: any[]) {
-      return renderReadSeekSearchCall(args, theme, rest, {
-        label: "refs",
-        accent: args.name,
-        flags: [args.scope && "scope", args.cached && "cached", args.others && "others", args.ignored && "ignored"],
-      });
-    },
-    renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-      return renderAnchoredFilesResult(result, options, theme, rest, {
-        pendingLabel: "pending refs",
-        emptyLabel: "no references",
-        unitSingular: "reference",
-        unitPlural: "references",
-      });
-    },
-  });
-  return tool;
-}