@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.1

package/dist/types/tools/vim.d.ts

@@ -1,58 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { type Theme } from "../modes/theme/theme";
-import type { VimToolDetails } from "../vim/types";
-import type { ToolSession } from ".";
-declare const vimSchema: z.ZodObject<{
-    file: z.ZodString;
-    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        kbd: z.ZodArray<z.ZodString>;
-        insert: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    pause: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type VimParams = z.infer<typeof vimSchema>;
-interface VimRenderStep {
-    kbd?: string[];
-    insert?: string;
-}
-export interface VimRenderArgs {
-    file?: string;
-    steps?: VimRenderStep[];
-    pause?: boolean;
-    __partialJson?: string;
-}
-export declare class VimTool implements AgentTool<typeof vimSchema, VimToolDetails> {
-    #private;
-    private readonly session;
-    readonly name = "vim";
-    readonly label = "Vim";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        file: z.ZodString;
-        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            kbd: z.ZodArray<z.ZodString>;
-            insert: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        pause: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
-    readonly concurrency = "exclusive";
-    constructor(session: ToolSession);
-    execute(_toolCallId: string, params: VimParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<VimToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<VimToolDetails>>;
-}
-export declare function resetVimRendererStateForTest(): void;
-export declare const vimToolRenderer: {
-    renderCall(args: VimRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: VimToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme): Component;
-    mergeCallAndResult: boolean;
-};
-export { vimSchema };

package/dist/types/vim/buffer.d.ts

@@ -1,41 +0,0 @@
-import { type Position, type VimBufferSnapshot, type VimFingerprint, type VimLoadedFile } from "./types";
-export declare function snapshotEqual(left: VimBufferSnapshot, right: VimBufferSnapshot): boolean;
-export declare class VimBuffer {
-    displayPath: string;
-    filePath: string;
-    lines: string[];
-    cursor: Position;
-    modified: boolean;
-    trailingNewline: boolean;
-    baseFingerprint: VimFingerprint | null;
-    editabilityChecked: boolean;
-    constructor(input: VimLoadedFile);
-    clone(): VimBuffer;
-    createSnapshot(): VimBufferSnapshot;
-    restore(snapshot: VimBufferSnapshot): void;
-    replaceLoadedFile(input: VimLoadedFile): void;
-    markSaved(input: VimLoadedFile): void;
-    lineCount(): number;
-    lastLineIndex(): number;
-    getLine(line: number): string;
-    clampLine(line: number): number;
-    clampCol(line: number, col: number): number;
-    setCursor(position: Position): void;
-    clampCursor(): void;
-    firstNonBlank(line: number): number;
-    getText(): string;
-    setText(text: string, trailingNewline?: boolean): void;
-    currentOffset(): number;
-    positionToOffset(position: Position): number;
-    offsetToPosition(offset: number): Position;
-    setCursorFromOffset(offset: number): void;
-    replaceOffsets(start: number, end: number, replacement: string, cursorOffset?: number): void;
-    deleteOffsets(start: number, end: number): string;
-    deleteLines(startLine: number, endLine: number): string[];
-    insertLines(index: number, newLines: string[]): void;
-    replaceLine(line: number, content: string): void;
-    joinLines(startLine: number, count: number): void;
-    indentLines(startLine: number, endLine: number, indentUnit: string, direction: 1 | -1): void;
-    getCharacterAtOffset(offset: number): string;
-    getCharacter(position: Position): string;
-}

package/dist/types/vim/commands.d.ts

@@ -1,6 +0,0 @@
-import type { VimExCommand } from "./types";
-export interface VimExParseContext {
-    currentLine: number;
-    lastLine: number;
-}
-export declare function parseExCommand(input: string, context?: VimExParseContext): VimExCommand;

package/dist/types/vim/engine.d.ts

@@ -1,47 +0,0 @@
-import type { FileDiagnosticsResult } from "../lsp";
-import { type VimBuffer } from "./buffer";
-import type { Position, VimInputMode, VimKeyToken, VimLoadedFile, VimPendingInput, VimRegister, VimSearchState, VimSelection } from "./types";
-export interface VimSaveResult {
-    loaded: VimLoadedFile;
-    diagnostics?: FileDiagnosticsResult;
-}
-export interface VimEngineCallbacks {
-    beforeMutate: (buffer: VimBuffer) => Promise<void>;
-    loadBuffer: (path: string) => Promise<VimLoadedFile>;
-    saveBuffer: (buffer: VimBuffer, options?: {
-        force?: boolean;
-    }) => Promise<VimSaveResult>;
-}
-export declare class VimEngine {
-    #private;
-    buffer: VimBuffer;
-    inputMode: VimInputMode;
-    selectionAnchor: Position | null;
-    register: VimRegister;
-    lastSearch: VimSearchState | null;
-    lastCharFind: {
-        char: string;
-        mode: "f" | "F" | "t" | "T";
-    } | null;
-    lastVisual: {
-        anchor: Position;
-        cursor: Position;
-        mode: VimInputMode;
-    } | null;
-    lastCommand?: string;
-    statusMessage?: string;
-    diagnostics?: FileDiagnosticsResult;
-    viewportStart: number;
-    closed: boolean;
-    constructor(buffer: VimBuffer, callbacks: VimEngineCallbacks);
-    clone(callbacks?: Partial<VimEngineCallbacks>): VimEngine;
-    getPublicMode(): import("./types").VimMode;
-    getSelection(): VimSelection | undefined;
-    getPendingInput(): VimPendingInput | undefined;
-    rollbackPendingInsert(): void;
-    setCursor(line: number, col: number): void;
-    executeTokens(tokens: readonly VimKeyToken[], lastCommand?: string, onStep?: () => Promise<void>): Promise<void>;
-    close(force: boolean): Promise<void>;
-    centerViewportOnCursor(size?: number): void;
-    applyLiteralInsert(text: string, exitInsertMode: boolean): Promise<void>;
-}

package/dist/types/vim/parser.d.ts

@@ -1,3 +0,0 @@
-import { type VimKeyToken } from "./types";
-export declare function parseKeySequences(sequences: string[]): VimKeyToken[];
-export declare function replayTokens(values: readonly string[]): VimKeyToken[];

package/dist/types/vim/render.d.ts

@@ -1,25 +0,0 @@
-import type { VimErrorLocation, VimMode, VimPendingInput, VimSelection, VimToolDetails, VimViewport } from "./types";
-export declare const VIM_OPEN_VIEWPORT_LINES = 80;
-export declare const VIM_DEFAULT_VIEWPORT_LINES = 10;
-interface ViewportRenderInput {
-    file: string;
-    mode: VimMode;
-    cursor: {
-        line: number;
-        col: number;
-    };
-    totalLines: number;
-    modified: boolean;
-    lines: string[];
-    viewport: VimViewport;
-    selection?: VimSelection;
-    statusMessage?: string;
-    lastCommand?: string;
-    pendingInput?: VimPendingInput;
-    errorLocation?: VimErrorLocation;
-    closed?: boolean;
-}
-export declare function computeViewport(cursorLine: number, totalLines: number, size: number, preferredStart?: number): VimViewport;
-export declare function renderVimDetails(details: VimToolDetails): string;
-export declare function buildDetails(input: ViewportRenderInput): VimToolDetails;
-export {};

package/dist/types/vim/types.d.ts

@@ -1,182 +0,0 @@
-import type { FileDiagnosticsResult } from "../lsp";
-import type { OutputMeta } from "../tools/output-meta";
-export type VimMode = "NORMAL" | "INSERT" | "VISUAL" | "VISUAL-LINE" | "COMMAND";
-export type VimInputMode = "normal" | "insert" | "visual" | "visual-line" | "command" | "search-forward" | "search-backward";
-export interface Position {
-    line: number;
-    col: number;
-}
-export interface VimViewport {
-    start: number;
-    end: number;
-}
-export interface VimSelection {
-    kind: "char" | "line";
-    start: Position;
-    end: Position;
-}
-export interface VimFocusLine {
-    line: number;
-    text: string;
-    windowStartCol: number;
-    windowEndCol: number;
-    caretCol: number;
-}
-export interface VimViewportLine {
-    line: number;
-    text: string;
-    isCursor: boolean;
-    isSelected: boolean;
-    cursorCol?: number;
-}
-export interface VimPendingInput {
-    kind: "insert" | "command" | "search-forward" | "search-backward";
-    text: string;
-}
-export interface VimErrorLocation {
-    sequenceIndex: number;
-    offset: number;
-}
-export interface VimToolDetails {
-    file: string;
-    mode: VimMode;
-    cursor: {
-        line: number;
-        col: number;
-    };
-    totalLines: number;
-    modified: boolean;
-    viewport: VimViewport;
-    focus?: VimFocusLine;
-    viewportLines?: VimViewportLine[];
-    selection?: VimSelection;
-    pendingInput?: VimPendingInput;
-    errorLocation?: VimErrorLocation;
-    closed?: boolean;
-    meta?: OutputMeta;
-    lastCommand?: string;
-    statusMessage?: string;
-    diagnostics?: FileDiagnosticsResult;
-}
-export interface VimFingerprint {
-    exists: boolean;
-    size: number;
-    mtimeMs: number;
-    hash: string;
-}
-export interface VimLoadedFile {
-    absolutePath: string;
-    displayPath: string;
-    lines: string[];
-    trailingNewline: boolean;
-    fingerprint: VimFingerprint | null;
-}
-export interface VimKeyToken {
-    value: string;
-    display: string;
-    sequenceIndex: number;
-    offset: number;
-}
-export interface VimRegister {
-    kind: "char" | "line";
-    text: string;
-}
-export interface VimSearchState {
-    pattern: string;
-    direction: 1 | -1;
-}
-export interface VimBufferSnapshot {
-    displayPath: string;
-    filePath: string;
-    lines: string[];
-    cursor: Position;
-    modified: boolean;
-    trailingNewline: boolean;
-    baseFingerprint: VimFingerprint | null;
-    editabilityChecked: boolean;
-}
-export interface VimUndoEntry {
-    before: VimBufferSnapshot;
-    after: VimBufferSnapshot;
-}
-export interface VimLineRange {
-    start: number;
-    end: number;
-}
-export type VimExCommand = {
-    kind: "write";
-    force: boolean;
-} | {
-    kind: "update";
-    force: boolean;
-} | {
-    kind: "quit";
-    force: boolean;
-} | {
-    kind: "write-quit";
-    force: boolean;
-} | {
-    kind: "edit";
-    force: boolean;
-    path?: string;
-} | {
-    kind: "goto-line";
-    line: number;
-} | {
-    kind: "substitute";
-    range?: VimLineRange | "all";
-    pattern: string;
-    replacement: string;
-    flags: string;
-} | {
-    kind: "delete";
-    range?: VimLineRange | "all";
-} | {
-    kind: "yank";
-    range?: VimLineRange | "all";
-} | {
-    kind: "put";
-    range?: VimLineRange | "all";
-    before: boolean;
-} | {
-    kind: "copy";
-    range?: VimLineRange | "all";
-    destination: number;
-} | {
-    kind: "move";
-    range?: VimLineRange | "all";
-    destination: number;
-} | {
-    kind: "sort";
-    range?: VimLineRange | "all";
-    flags: string;
-} | {
-    kind: "join";
-    range?: VimLineRange | "all";
-    trimWhitespace: boolean;
-} | {
-    kind: "global";
-    range?: VimLineRange | "all";
-    pattern: string;
-    command: string;
-    invert: boolean;
-} | {
-    kind: "append";
-    range?: VimLineRange;
-    text: string;
-} | {
-    kind: "insert-before";
-    range?: VimLineRange;
-    text: string;
-};
-export declare class VimInputError extends Error {
-    location?: {
-        sequenceIndex: number;
-        offset: number;
-    };
-    constructor(message: string, token?: VimKeyToken);
-}
-export declare function clonePosition(position: Position): Position;
-export declare function minPosition(left: Position, right: Position): Position;
-export declare function maxPosition(left: Position, right: Position): Position;
-export declare function toPublicMode(mode: VimInputMode): VimMode;

package/src/hashline/parser.ts

@@ -1,246 +0,0 @@
-import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANGE_INTERIOR_HASH } from "./constants";
-import {
-	computeLineHash,
-	describeAnchorExamples,
-	HL_BODY_SEP_RE_RAW,
-	HL_FILE_PREFIX,
-	HL_HASH_CAPTURE_RE_RAW,
-	HL_OP_CHARS,
-	HL_OP_INSERT_AFTER,
-	HL_OP_INSERT_BEFORE,
-	HL_OP_REPLACE,
-} from "./hash";
-import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
-
-// Leniently accept anchors copied from read/search output:
-//   - optional leading line-marker decoration (`*`, `>`, `+`, `-`)
-//   - the required `LINE+HASH`
-//   - an optional trailing `|TEXT` body (or anything after the hash) so users
-//     can paste a full `LINE+HASH|TEXT` line verbatim.
-const LID_CAPTURE_RE = new RegExp(`^\\s*[>+\\-*]*\\s*${HL_HASH_CAPTURE_RE_RAW}(?:\\|.*)?\\s*$`);
-const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-function parseLid(raw: string, lineNum: number): Anchor {
-	const match = LID_CAPTURE_RE.exec(raw);
-	if (!match) {
-		throw new Error(
-			`line ${lineNum}: expected a full anchor such as ${describeAnchorExamples("119")}; ` +
-				`got ${JSON.stringify(raw)}.`,
-		);
-	}
-	return { line: Number.parseInt(match[1], 10), hash: match[2] };
-}
-
-interface ParsedRange {
-	start: Anchor;
-	end: Anchor;
-}
-
-function parseRange(raw: string, lineNum: number): ParsedRange {
-	if (!raw.includes("..")) {
-		const start = parseLid(raw, lineNum);
-		return { start, end: { ...start } };
-	}
-	const [startRaw, endRaw, extra] = raw.split("..");
-	if (extra !== undefined || !startRaw || !endRaw) {
-		throw new Error(
-			`line ${lineNum}: range must include exactly two full anchors separated by "..". ` +
-				`For a one-line edit, repeat the same anchor on both sides.`,
-		);
-	}
-	const start = parseLid(startRaw, lineNum);
-	const end = parseLid(endRaw, lineNum);
-	if (end.line < start.line) {
-		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} ends before it starts.`);
-	}
-	if (end.line === start.line && end.hash !== start.hash) {
-		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} uses two different hashes for the same line.`);
-	}
-	return { start, end };
-}
-
-function expandRange(range: ParsedRange): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (let line = range.start.line; line <= range.end.line; line++) {
-		const hash =
-			line === range.start.line ? range.start.hash : line === range.end.line ? range.end.hash : RANGE_INTERIOR_HASH;
-		anchors.push({ line, hash });
-	}
-	return anchors;
-}
-
-function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after"): HashlineCursor {
-	if (raw === "BOF") return { kind: "bof" };
-	if (raw === "EOF") return { kind: "eof" };
-	const cursorKind = kind === "before" ? "before_anchor" : "after_anchor";
-	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
-}
-
-/**
- * Decide how to interpret the optional `|TEXT` body captured on an insert
- * op line:
- *   - For BOF/EOF cursors the body is always treated as an inline payload
- *     line (there's no anchor hash to compare against).
- *   - For anchored cursors, compute the hash of TEXT at the anchor's line
- *     number. If it matches the anchor's hash, the body is just a verbatim
- *     copy of the anchored line — discard it, payload must come from the
- *     following lines as usual.
- *   - Otherwise the body is the first (or only) payload line for this op.
- */
-function resolveInlineInsertBody(cursor: HashlineCursor, body: string | undefined): string | undefined {
-	if (body === undefined) return undefined;
-	if (cursor.kind !== "before_anchor" && cursor.kind !== "after_anchor") return body;
-	const { line, hash } = cursor.anchor;
-	if (computeLineHash(line, body) === hash) return undefined;
-	return body;
-}
-
-// Insert ops leniently accept a trailing `|TEXT` body on the op line itself
-// (e.g. `»502zk|\tconst foo = ...`). The anchor token excludes `|` so the body
-// is captured separately; resolveInlineInsertBody decides whether to treat the
-// captured text as a verbatim anchor decoration (when its hash matches the
-// anchor's) or as an inline payload line.
-const INSERT_BEFORE_OP_RE = new RegExp(
-	`^${regexEscape(HL_OP_INSERT_BEFORE)}\\s*([^|\\s]+)(?:${HL_BODY_SEP_RE_RAW}(.*))?\\s*$`,
-);
-const INSERT_AFTER_OP_RE = new RegExp(
-	`^${regexEscape(HL_OP_INSERT_AFTER)}\\s*([^|\\s]+)(?:${HL_BODY_SEP_RE_RAW}(.*))?\\s*$`,
-);
-const REPLACE_OP_RE = new RegExp(`^${regexEscape(HL_OP_REPLACE)}\\s*([^\\s+<\\-=]\\S*)\\s*$`);
-
-function isEnvelopeOrAbortMarkerLine(line: string): boolean {
-	const trimmed = line.trimEnd();
-	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER || trimmed === ABORT_MARKER;
-}
-
-function isPayloadTerminatorLine(line: string): boolean {
-	const first = line[0];
-	return (
-		first === HL_FILE_PREFIX ||
-		(first !== undefined && HL_OP_CHARS.includes(first)) ||
-		isEnvelopeOrAbortMarkerLine(line)
-	);
-}
-
-export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
-	if (cursor.kind === "before_anchor") return { kind: "before_anchor", anchor: { ...cursor.anchor } };
-	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
-	return cursor;
-}
-
-function collectPayload(
-	lines: string[],
-	startIndex: number,
-	opLineNum: number,
-	requirePayload: boolean,
-): { payload: string[]; nextIndex: number } {
-	const payload: string[] = [];
-	let index = startIndex;
-	while (index < lines.length) {
-		const line = lines[index];
-		if (isPayloadTerminatorLine(line)) break;
-		payload.push(line);
-		index++;
-	}
-	if (payload.length === 0 && requirePayload) {
-		throw new Error(
-			`line ${opLineNum}: ${HL_OP_INSERT_BEFORE} and ${HL_OP_INSERT_AFTER} operations require at least one verbatim payload line.`,
-		);
-	}
-	return { payload, nextIndex: index };
-}
-
-export function parseHashline(diff: string): HashlineEdit[] {
-	return parseHashlineWithWarnings(diff).edits;
-}
-
-export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
-	const edits: HashlineEdit[] = [];
-	const warnings: string[] = [];
-	const lines = diff.split(/\r?\n/);
-	if (diff.endsWith("\n") && lines.at(-1) === "") lines.pop();
-	let editIndex = 0;
-
-	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
-		edits.push({ kind: "insert", cursor: cloneCursor(cursor), text, lineNum, index: editIndex++ });
-	};
-
-	for (let i = 0; i < lines.length; ) {
-		const lineNum = i + 1;
-		const line = lines[i];
-
-		if (line.trim().length === 0) {
-			i++;
-			continue;
-		}
-		if (line === END_PATCH_MARKER) {
-			break;
-		}
-		if (line === ABORT_MARKER) {
-			warnings.push(ABORT_WARNING);
-			break;
-		}
-		if (line === BEGIN_PATCH_MARKER) {
-			i++;
-			continue;
-		}
-
-		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
-		if (insertBeforeMatch) {
-			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const inlineBody = resolveInlineInsertBody(cursor, insertBeforeMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
-			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
-			for (const text of payload) pushInsert(cursor, text, lineNum);
-			i = nextIndex;
-			continue;
-		}
-
-		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
-		if (insertAfterMatch) {
-			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const inlineBody = resolveInlineInsertBody(cursor, insertAfterMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
-			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
-			for (const text of payload) pushInsert(cursor, text, lineNum);
-			i = nextIndex;
-			continue;
-		}
-
-		const replaceMatch = REPLACE_OP_RE.exec(line);
-		if (replaceMatch) {
-			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
-			if (payload.length > 0) {
-				for (const text of payload) {
-					edits.push({
-						kind: "insert",
-						cursor: { kind: "before_anchor", anchor: { ...range.start } },
-						text,
-						lineNum,
-						index: editIndex++,
-					});
-				}
-			}
-			for (const anchor of expandRange(range)) {
-				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
-			}
-			i = nextIndex;
-			continue;
-		}
-
-		if (isPayloadTerminatorLine(line) || /^[-@\u00B6]/u.test(line)) {
-			throw new Error(
-				`line ${lineNum}: unrecognized op. Use ${HL_OP_INSERT_BEFORE}ANCHOR (insert before), ${HL_OP_INSERT_AFTER}ANCHOR (insert after), or ${HL_OP_REPLACE}A..B (replace/delete). ` +
-					`Got ${JSON.stringify(line)}.`,
-			);
-		}
-
-		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, or ${HL_OP_REPLACE} operation. ` +
-				`Got ${JSON.stringify(line)}.`,
-		);
-	}
-
-	return { edits, warnings };
-}

package/src/mcp/discoverable-tool-metadata.ts

@@ -1,24 +0,0 @@
-/**
- * Back-compat re-export layer.
- * All types and functions have moved to src/tool-discovery/tool-index.ts.
- * This file exists solely so existing imports continue to compile without changes.
- */
-export type {
-	DiscoverableMCPSearchDocument,
-	DiscoverableMCPSearchIndex,
-	DiscoverableMCPSearchResult,
-	DiscoverableMCPTool,
-	DiscoverableMCPToolServerSummary,
-	DiscoverableMCPToolSummary,
-} from "../tool-discovery/tool-index";
-
-export {
-	buildDiscoverableMCPSearchIndex,
-	collectDiscoverableMCPTools,
-	formatDiscoverableMCPToolServerSummary,
-	getDiscoverableMCPTool,
-	isMCPToolName,
-	searchDiscoverableMCPTools,
-	selectDiscoverableMCPToolNamesByServer,
-	summarizeDiscoverableMCPTools,
-} from "../tool-discovery/tool-index";