pi-readseek 0.7.6 → 0.7.8

package/src/hover.ts

@@ -1,140 +0,0 @@
-import { readFile } from "node:fs/promises";
-
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { Text } from "@earendil-works/pi-tui";
-
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { buildToolErrorResult } from "./readseek-value.js";
-import { resolveToCwd } from "./path-utils.js";
-import { formatFsError } from "./fs-error.js";
-import { classifyReadSeekFailure, readSeekIdentify } from "./readseek-client.js";
-import { filePathParam, registerReadSeekTool } from "./register-tool.js";
-
-import { clampLineToWidth, clampLinesToWidth, linkToolPath, renderErrorResult, renderPendingResult, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
-
-const HOVER_PROMPT_METADATA = defineToolPromptMetadata({
-	promptUrl: new URL("../prompts/hover.md", import.meta.url),
-	promptSnippet: "Identify the token and enclosing symbol at a cursor",
-});
-
-const hoverSchema = Type.Object({
-	path: filePathParam(),
-	line: Type.Integer({ minimum: 1, description: "One-based cursor line" }),
-	column: Type.Optional(Type.Integer({ minimum: 1, description: "One-based cursor byte column" })),
-});
-
-interface HoverParams {
-	path: string;
-	line: number;
-	column?: number;
-}
-
-export interface ExecuteHoverOptions {
-	params: unknown;
-	signal: AbortSignal | undefined;
-	cwd: string;
-}
-
-export async function executeHover(opts: ExecuteHoverOptions): Promise<any> {
-	const { params, signal, cwd } = opts;
-	const p = params as HoverParams;
-
-	if (!Number.isSafeInteger(p.line) || p.line < 1) {
-		return buildToolErrorResult("hover", "invalid-parameter", "hover parameter 'line' must be a positive integer");
-	}
-	if (p.column !== undefined && (!Number.isSafeInteger(p.column) || p.column < 1)) {
-		return buildToolErrorResult("hover", "invalid-parameter", "hover parameter 'column' must be a positive integer");
-	}
-
-	const filePath = resolveToCwd(p.path, cwd);
-
-	let content: string;
-	try {
-		content = await readFile(filePath, "utf-8");
-	} catch (err: any) {
-		const { code, message } = formatFsError(err, "hover-error");
-		return buildToolErrorResult("hover", code, message, { path: p.path });
-	}
-
-	try {
-		const output = await readSeekIdentify(filePath, content, {
-			line: p.line,
-			column: p.column,
-			signal,
-		});
-
-		const lines: string[] = [];
-		if (output.identifier) {
-			lines.push(`identifier: ${output.identifier.text}`);
-		}
-		if (output.symbol) {
-			lines.push(`symbol: ${output.symbol.name}`);
-			lines.push(`kind: ${output.symbol.kind}`);
-			lines.push(`qualified: ${output.symbol.qualified_name}`);
-		}
-		lines.push(`file: ${output.file}`);
-		lines.push(`language: ${output.language}`);
-		lines.push(`location: ${output.line}:${output.column}`);
-
-		return {
-			content: [{ type: "text", text: lines.join("\n") }],
-			details: {
-				readSeekValue: {
-					tool: "hover",
-					ok: true,
-					path: filePath,
-					output,
-				},
-			},
-		};
-	} catch (err: any) {
-		const failure = classifyReadSeekFailure(err);
-		return buildToolErrorResult("hover", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-	}
-}
-
-export function registerHoverTool(pi: ExtensionAPI) {
-	registerReadSeekTool(pi, {
-		name: "readSeek_hover",
-		label: "Hover",
-		description: HOVER_PROMPT_METADATA.description,
-		promptSnippet: HOVER_PROMPT_METADATA.promptSnippet,
-		promptGuidelines: HOVER_PROMPT_METADATA.promptGuidelines,
-		parameters: hoverSchema,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			return executeHover({ params, signal, cwd: ctx.cwd });
-		},
-		renderCall(args: any, theme: any, ...rest: any[]) {
-			const context = rest[0] ?? {};
-			const cwd = context.cwd ?? process.cwd();
-			const displayPath = typeof args?.path === "string" ? args.path : "?";
-			let text = theme.fg("toolTitle", theme.bold("hover"));
-			text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-			if (args?.line) text += theme.fg("dim", `:${args.line}`);
-			return new Text(clampLineToWidth(text, context.width), 0, 0);
-		},
-		renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-			const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
-
-			if (isPartial) return renderPendingResult("pending hover", width, theme);
-
-			const content = result.content?.[0];
-			const textContent = content?.type === "text" ? content.text : "";
-
-			if (isError || result.isError) {
-				return renderErrorResult(textContent, { expanded, width, fallback: "hover failed", theme });
-			}
-
-			const output = (result.details as any)?.readSeekValue?.output;
-			const label = output?.identifier?.text
-				? `identified ${output.identifier.text}`
-				: output?.symbol?.name
-					? `symbol ${output.symbol.name}`
-					: "identified cursor";
-			let text = summaryLine(label, { hidden: !!textContent && !expanded, theme, style: "success" });
-			if (expanded && textContent) text += `\n${textContent}`;
-			return new Text(clampLinesToWidth(text.split("\n"), width).join("\n"), 0, 0);
-		},
-	});
-}

package/src/path-utils.ts

@@ -1,24 +0,0 @@
-import { homedir } from "node:os";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-
-function normalizeUnicodeSpaces(str: string): string {
-	return str.replace(UNICODE_SPACES, " ");
-}
-
-function normalizeAtPrefix(filePath: string): string {
-	return filePath.startsWith("@") ? filePath.slice(1) : filePath;
-}
-
-function expandPath(filePath: string): string {
-	const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-	if (normalized === "~") return homedir();
-	if (normalized.startsWith("~/")) return homedir() + normalized.slice(1);
-	return normalized;
-}
-
-export function resolveToCwd(filePath: string, cwd: string): string {
-	const expanded = expandPath(filePath);
-	return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
-}

package/src/pending-diff-preview.ts

@@ -1,269 +0,0 @@
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import { generateDiffString, normalizeToLF, replaceText } from "./edit-diff.js";
-import { applyHashlineEdits, type HashlineEditItem } from "./hashline.js";
-import { replaceSymbol } from "./replace-symbol.js";
-
-const PENDING_DIFF_MAX_BYTES = 1024 * 1024;
-
-interface PendingDiffPreviewData {
-	filePath: string;
-	previousContent: string;
-	nextContent: string;
-	fileExistedBeforeWrite: boolean;
-	headerLabel: "pending edit" | "pending overwrite" | "pending create";
-	diff: string;
-}
-
-export type PendingDiffPreviewResult =
-	| { type: "ok"; data: PendingDiffPreviewData }
-	| { type: "skip"; reason: string };
-
-function skip(reason: string): PendingDiffPreviewResult {
-	return { type: "skip", reason };
-}
-
-function isInsidePath(parent: string, child: string): boolean {
-	const rel = relative(parent, child);
-	return rel === "" || (rel !== "" && !rel.startsWith("..") && !rel.startsWith(sep) && !resolve(rel).startsWith(".." + sep));
-}
-
-function resolveWorkspacePreviewPath(rawPath: unknown, cwd: string, allowMissing: boolean): { type: "ok"; path: string; existed: boolean } | { type: "skip"; reason: string } {
-	if (typeof rawPath !== "string" || rawPath.trim() === "") return { type: "skip", reason: "missing path" };
-	const workspace = realpathSync(cwd);
-	const normalizedPath = rawPath.replace(/^@/, "");
-	const explicitAbsolute = isAbsolute(normalizedPath);
-	const requested = resolve(workspace, normalizedPath);
-	if (existsSync(requested)) {
-		const realTarget = realpathSync(requested);
-		if (!explicitAbsolute && !isInsidePath(workspace, realTarget)) return { type: "skip", reason: "path outside workspace" };
-		return { type: "ok", path: realTarget, existed: true };
-	}
-
-	if (!explicitAbsolute && !isInsidePath(workspace, requested)) return { type: "skip", reason: "path outside workspace" };
-
-	if (!allowMissing) return { type: "skip", reason: "file not found" };
-	const parent = dirname(requested);
-	if (!existsSync(parent)) return { type: "skip", reason: "parent directory not found" };
-	return { type: "ok", path: requested, existed: false };
-}
-
-function readUtf8File(filePath: string): { type: "ok"; content: string } | { type: "skip"; reason: string } {
-	const stat = statSync(filePath);
-	if (!stat.isFile()) return { type: "skip", reason: "not a file" };
-	if (stat.size > PENDING_DIFF_MAX_BYTES) return { type: "skip", reason: "file too large" };
-	const content = readFileSync(filePath, "utf-8");
-	if (content.includes("\0")) return { type: "skip", reason: "binary file" };
-	return { type: "ok", content };
-}
-
-function buildData(
-	filePath: string,
-	previousContent: string,
-	nextContent: string,
-	existed: boolean,
-	headerLabel: PendingDiffPreviewData["headerLabel"],
-): PendingDiffPreviewResult {
-	const diff = generateDiffString(normalizeToLF(previousContent), normalizeToLF(nextContent)).diff;
-	return {
-		type: "ok",
-		data: {
-			filePath,
-			previousContent,
-			nextContent,
-			fileExistedBeforeWrite: existed,
-			headerLabel,
-			diff,
-		},
-	};
-}
-
-type ReplaceEdit = { replace: { old_text: string; new_text: string; all?: boolean; fuzzy?: boolean } };
-type PendingEditInput = { path?: unknown; edits?: unknown[] };
-
-function getEdits(input: PendingEditInput): unknown[] {
-	return Array.isArray(input.edits) ? input.edits : [];
-}
-
-function isReplaceEdit(edit: unknown): edit is ReplaceEdit {
-	if (!edit || typeof edit !== "object" || !("replace" in edit)) return false;
-	const replace = (edit as { replace?: { old_text?: unknown; new_text?: unknown } }).replace;
-	return typeof replace?.old_text === "string" && typeof replace?.new_text === "string";
-}
-
-type AnchorEdit =
-	| { set_line: { anchor: string; new_text: string } }
-	| { replace_lines: { start_anchor: string; end_anchor: string; new_text: string } }
-	| { insert_after: { anchor: string; new_text: string } };
-
-function isAnchorEdit(edit: unknown): edit is AnchorEdit {
-	return !!edit && typeof edit === "object" && ("set_line" in edit || "replace_lines" in edit || "insert_after" in edit);
-}
-
-function applyAnchoredPreview(content: string, edits: AnchorEdit[]): { type: "ok"; content: string } | { type: "skip"; reason: string } {
-	try {
-		return { type: "ok", content: applyHashlineEdits(content, edits as HashlineEditItem[]).content };
-	} catch (err: any) {
-		return { type: "skip", reason: `anchor projection failed: ${err?.message ?? String(err)}` };
-	}
-}
-
-type ReplaceSymbolEdit = { replace_symbol: { symbol: string; new_body: string } };
-
-function isReplaceSymbolEdit(edit: unknown): edit is ReplaceSymbolEdit {
-	if (!edit || typeof edit !== "object" || !("replace_symbol" in edit)) return false;
-	const replaceSymbol = (edit as { replace_symbol?: { symbol?: unknown; new_body?: unknown } }).replace_symbol;
-	return typeof replaceSymbol?.symbol === "string" && typeof replaceSymbol?.new_body === "string";
-}
-
-async function applyReplaceSymbolPreview(filePath: string, content: string, edit: ReplaceSymbolEdit): Promise<{ type: "ok"; content: string } | { type: "skip"; reason: string }> {
-	try {
-		if (!edit.replace_symbol.new_body.trim()) return { type: "skip", reason: "replace_symbol new_body is empty" };
-		const probe = await replaceSymbol({
-			filePath,
-			content,
-			symbol: edit.replace_symbol.symbol,
-			newBody: edit.replace_symbol.new_body,
-		});
-		if (probe.type !== "ok") return { type: "skip", reason: `symbol projection failed: ${probe.message}` };
-		return { type: "ok", content: probe.content };
-	} catch (err: any) {
-		return { type: "skip", reason: `symbol projection failed: ${err?.message ?? String(err)}` };
-	}
-}
-
-
-function applyReplacePreview(content: string, edit: ReplaceEdit): { type: "ok"; content: string } | { type: "skip"; reason: string } {
-	const { old_text, new_text } = edit.replace;
-	if (!old_text.length) return { type: "skip", reason: "replace old_text is empty" };
-	const replacement = replaceText(content, old_text, new_text, {
-		all: edit.replace.all ?? false,
-		fuzzy: edit.replace.fuzzy ?? false,
-	});
-	if (!replacement.count) return { type: "skip", reason: "replace old_text was not found" };
-	return { type: "ok", content: replacement.content };
-}
-
-export function buildPendingWritePreviewData(input: { path?: unknown; content?: unknown }, cwd: string): PendingDiffPreviewResult {
-	if (typeof input.content !== "string") return skip("missing content");
-	if (Buffer.byteLength(input.content, "utf8") > PENDING_DIFF_MAX_BYTES) return skip("content too large");
-	const resolved = resolveWorkspacePreviewPath(input.path, cwd, true);
-	if (resolved.type === "skip") return resolved;
-	const previous = resolved.existed ? readUtf8File(resolved.path) : { type: "ok" as const, content: "" };
-	if (previous.type === "skip") return previous;
-	return buildData(resolved.path, previous.content, input.content, resolved.existed, resolved.existed ? "pending overwrite" : "pending create");
-}
-
-export async function buildPendingEditPreviewData(input: PendingEditInput, cwd: string): Promise<PendingDiffPreviewResult> {
-	const edits = getEdits(input);
-	if (edits.length === 0) return skip("missing edits");
-	const resolved = resolveWorkspacePreviewPath(input.path, cwd, false);
-	if (resolved.type === "skip") return resolved;
-	const previous = readUtf8File(resolved.path);
-	if (previous.type === "skip") return previous;
-	let next = normalizeToLF(previous.content);
-	const anchorBatch: AnchorEdit[] = [];
-
-	for (const edit of edits) {
-		if (isReplaceEdit(edit)) {
-			if (anchorBatch.length > 0) {
-				const anchored = applyAnchoredPreview(next, anchorBatch);
-				if (anchored.type === "skip") return anchored;
-				next = anchored.content;
-				anchorBatch.length = 0;
-			}
-			const projected = applyReplacePreview(next, edit);
-			if (projected.type === "skip") return projected;
-			next = projected.content;
-			continue;
-		}
-		if (isAnchorEdit(edit)) {
-			anchorBatch.push(edit);
-			continue;
-		}
-		if (isReplaceSymbolEdit(edit)) {
-			if (anchorBatch.length > 0) {
-				const anchored = applyAnchoredPreview(next, anchorBatch);
-				if (anchored.type === "skip") return anchored;
-				next = anchored.content;
-				anchorBatch.length = 0;
-			}
-			const projected = await applyReplaceSymbolPreview(resolved.path, next, edit);
-			if (projected.type === "skip") return projected;
-			next = projected.content;
-			continue;
-		}
-		return skip("unsupported edit variant");
-	}
-
-	if (anchorBatch.length > 0) {
-		const anchored = applyAnchoredPreview(next, anchorBatch);
-		if (anchored.type === "skip") return anchored;
-		next = anchored.content;
-	}
-	return buildData(resolved.path, previous.content, next, true, "pending edit");
-}
-
-interface PendingDiffPreviewCacheSlot<T = PendingDiffPreviewResult> {
-	key?: string;
-	data?: T;
-	pending?: boolean;
-}
-
-export function buildEditPreviewKey(input: PendingEditInput): string | undefined {
-	if (typeof input.path !== "string") return undefined;
-	const edits = getEdits(input);
-	if (edits.length === 0) return undefined;
-	return JSON.stringify({ path: input.path, edits });
-}
-
-export function buildWritePreviewKey(input: { path?: unknown; content?: unknown }): string | undefined {
-	if (typeof input.path !== "string" || typeof input.content !== "string") return undefined;
-	return JSON.stringify({ path: input.path, content: input.content });
-}
-
-export function resolvePendingDiffPreview<T extends PendingDiffPreviewResult>(
-	context: { state?: Record<string, PendingDiffPreviewCacheSlot<T>>; invalidate?: () => void } | undefined,
-	stateKey: string,
-	previewKey: string | undefined,
-	compute: () => T | Promise<T>,
-): T | undefined {
-	if (!previewKey) return undefined;
-	const root = context?.state;
-	if (!root) return undefined;
-	const slot = (root[stateKey] ??= {} as PendingDiffPreviewCacheSlot<T>);
-	if (slot.key !== previewKey) {
-		slot.key = previewKey;
-		slot.data = undefined;
-		slot.pending = false;
-	}
-	if (slot.data !== undefined) return slot.data;
-	if (slot.pending) return undefined;
-
-	let value: T | Promise<T>;
-	try {
-		value = compute();
-	} catch (err: any) {
-		const skipped = { type: "skip", reason: `projection failed: ${err?.message ?? String(err)}` } as T;
-		slot.data = skipped;
-		return skipped;
-	}
-	if (value && typeof (value as any).then === "function") {
-		slot.pending = true;
-		void (value as Promise<T>).then((resolved) => {
-			if (slot.key !== previewKey) return;
-			slot.data = resolved;
-			slot.pending = false;
-			context?.invalidate?.();
-		}).catch((err: any) => {
-			if (slot.key !== previewKey) return;
-			slot.data = { type: "skip", reason: `projection failed: ${err?.message ?? String(err)}` } as T;
-			slot.pending = false;
-			context?.invalidate?.();
-		});
-		return undefined;
-	}
-
-	slot.data = value as T;
-	return slot.data;
-}

package/src/read-local-bundle.ts

@@ -1,75 +0,0 @@
-import { SymbolKind } from "./readseek/enums.js";
-import type { SymbolMatch } from "./readseek/symbol-lookup.js";
-import type { FileMap, FileSymbol } from "./readseek/types.js";
-import { traverseSymbolTree } from "./readseek/symbol-tree.js";
-
-export interface LocalBundleSupport {
-  symbol: SymbolMatch;
-  lines: string[];
-}
-
-export interface LocalBundlePlan {
-  requested: SymbolMatch;
-  support: LocalBundleSupport[];
-}
-
-interface FlatSymbol {
-  symbol: FileSymbol;
-  parentName?: string;
-}
-
-const CONTAINER_KINDS = new Set<SymbolKind>([
-  SymbolKind.Class,
-  SymbolKind.Module,
-  SymbolKind.Namespace,
-]);
-
-export function buildLocalBundle(
-  fileMap: FileMap,
-  requested: SymbolMatch,
-  allLines: string[],
-): LocalBundlePlan | null {
-  const requestedText = allLines.slice(requested.startLine - 1, requested.endLine).join("\n");
-  const identifiers = new Set(requestedText.match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []);
-
-  const candidates = traverseSymbolTree(fileMap.symbols, (symbol, parentName): FlatSymbol => ({ symbol, parentName })).filter(({ symbol }) => {
-    if (CONTAINER_KINDS.has(symbol.kind as SymbolKind)) return false;
-    return !(symbol.name === requested.name && symbol.startLine === requested.startLine && symbol.endLine === requested.endLine);
-  });
-
-  const symbolsByName = new Map<string, FlatSymbol[]>();
-  for (const candidate of candidates) {
-    const bucket = symbolsByName.get(candidate.symbol.name) ?? [];
-    bucket.push(candidate);
-    symbolsByName.set(candidate.symbol.name, bucket);
-  }
-
-  const support: LocalBundleSupport[] = [];
-  for (const identifier of identifiers) {
-    const matches = symbolsByName.get(identifier) ?? [];
-    if (matches.length === 0) continue;
-    if (matches.length > 1) return null;
-
-    const match = matches[0];
-    support.push({
-      symbol: {
-        name: match.symbol.name,
-        kind: match.symbol.kind,
-        startLine: match.symbol.startLine,
-        endLine: match.symbol.endLine,
-        ...(match.parentName ? { parentName: match.parentName } : {}),
-      },
-      lines: allLines.slice(match.symbol.startLine - 1, match.symbol.endLine),
-    });
-  }
-
-  support.sort((a, b) => {
-    if (a.symbol.startLine !== b.symbol.startLine) return a.symbol.startLine - b.symbol.startLine;
-    return a.symbol.name.localeCompare(b.symbol.name);
-  });
-
-  return {
-    requested,
-    support,
-  };
-}

package/src/read-output.ts

@@ -1,186 +0,0 @@
-import {
-  DEFAULT_MAX_BYTES,
-  DEFAULT_MAX_LINES,
-  formatSize,
-  truncateHead,
-} from "@earendil-works/pi-coding-agent";
-import { buildReadSeekLines, renderReadSeekLines, type ReadSeekLine, type ReadSeekWarning } from "./readseek-value.js";
-
-
-interface ReadSymbolMetadata {
-  query: string;
-  name: string;
-  kind: string;
-  parentName?: string;
-  startLine: number;
-  endLine: number;
-}
-
-interface ReadTruncationMetadata {
-  outputLines: number;
-  totalLines: number;
-  outputBytes: number;
-  totalBytes: number;
-}
-
-interface ReadMapMetadata {
-  requested: boolean;
-  appended: boolean;
-  text?: string | null;
-}
-
-interface ReadContinuationMetadata {
-  nextOffset: number;
-}
-
-interface ReadBundleSupportItem {
-  symbol: ReadSymbolMetadata;
-  lines: string[];
-}
-
-interface ReadBundleMetadata {
-  mode: "local";
-  applied: boolean;
-  localSupport: ReadBundleSupportItem[];
-  warnings?: ReadSeekWarning[];
-}
-
-interface ReadOutputInput {
-  path: string;
-  startLine: number;
-  endLine: number;
-  totalLines: number;
-  selectedLines?: string[];
-  lines?: ReadSeekLine[];
-  warnings?: ReadSeekWarning[];
-  truncation?: ReadTruncationMetadata | null;
-  continuation?: ReadContinuationMetadata | null;
-  symbol?: ReadSymbolMetadata | null;
-  map?: ReadMapMetadata;
-  bundle?: ReadBundleMetadata | null;
-}
-
-interface ReadOutputResult {
-  text: string;
-  lines: ReadSeekLine[];
-  readSeekValue: {
-    tool: "read";
-    path: string;
-    range: {
-      startLine: number;
-      endLine: number;
-      totalLines: number;
-    };
-    warnings: ReadSeekWarning[];
-    truncation: ReadTruncationMetadata | null;
-    symbol: ReadSymbolMetadata | null;
-    map: {
-      requested: boolean;
-      appended: boolean;
-    };
-    lines: ReadSeekLine[];
-    bundle?: {
-      mode: "local";
-      applied: boolean;
-      localSupport: Array<{
-        name: string;
-        kind: string;
-        parentName?: string;
-        startLine: number;
-        endLine: number;
-        lineAnchors: string[];
-      }>;
-      warnings: ReadSeekWarning[];
-    };
-  };
-}
-
-export function buildReadOutput(input: ReadOutputInput): ReadOutputResult {
-  const selectedLines = input.selectedLines ?? input.lines?.map((line) => line.raw) ?? [];
-  const lines = input.lines ?? buildReadSeekLines(input.startLine, selectedLines);
-  const warnings = input.warnings ?? [];
-  const renderedLines = renderReadSeekLines(lines);
-  const truncated = truncateHead(renderedLines, {
-    maxLines: DEFAULT_MAX_LINES,
-    maxBytes: DEFAULT_MAX_BYTES,
-  });
-
-  let text = input.truncation ? truncated.content : renderedLines;
-
-  if (input.truncation) {
-    text += `\n\n[Output truncated: showing ${input.truncation.outputLines} of ${input.totalLines} lines (${formatSize(input.truncation.outputBytes)} of ${formatSize(input.truncation.totalBytes)}). Use offset=${input.startLine + input.truncation.outputLines} to continue.]`;
-  } else if (input.continuation) {
-    text += `\n\n[Showing lines ${input.startLine}-${input.endLine} of ${input.totalLines}. Use offset=${input.continuation.nextOffset} to continue.]`;
-  }
-
-  if (input.bundle?.applied) {
-    const supportBlocks = input.bundle.localSupport.map((item) => {
-      const supportLines = buildReadSeekLines(item.symbol.startLine, item.lines);
-      return renderReadSeekLines(supportLines);
-    });
-
-    text = [
-      "## Requested symbol",
-      text,
-      "",
-      "## Local support",
-      ...supportBlocks,
-    ].join("\n");
-  }
-
-  if (input.map?.appended && input.map.text) {
-    text += `\n\n${input.map.text}`;
-  }
-
-  if (input.symbol) {
-    const parentInfo = input.symbol.parentName ? ` in ${input.symbol.parentName}` : "";
-    text = `[Symbol: ${input.symbol.name} (${input.symbol.kind})${parentInfo}, lines ${input.symbol.startLine}-${input.symbol.endLine} of ${input.totalLines}]\n\n${text}`;
-  }
-
-  if (warnings.length) {
-    text = `${warnings.map((warning) => warning.message).join("\n\n")}\n\n${text}`;
-  }
-
-  const readSeekValue: ReadOutputResult["readSeekValue"] = {
-    tool: "read",
-    path: input.path,
-    range: {
-      startLine: input.startLine,
-      endLine: input.endLine,
-      totalLines: input.totalLines,
-    },
-    warnings,
-    truncation: input.truncation ?? null,
-    symbol: input.symbol ?? null,
-    map: {
-      requested: input.map?.requested ?? false,
-      appended: input.map?.appended ?? false,
-    },
-    lines,
-  };
-
-  if (input.bundle) {
-    readSeekValue.bundle = {
-      mode: input.bundle.mode,
-      applied: input.bundle.applied,
-      localSupport: input.bundle.localSupport.map((item) => {
-        const supportLines = buildReadSeekLines(item.symbol.startLine, item.lines);
-        return {
-          name: item.symbol.name,
-          kind: item.symbol.kind,
-          parentName: item.symbol.parentName,
-          startLine: item.symbol.startLine,
-          endLine: item.symbol.endLine,
-          lineAnchors: supportLines.map((line) => line.anchor),
-        };
-      }),
-      warnings: input.bundle.warnings ?? [],
-    };
-  }
-
-  return {
-    text,
-    lines,
-    readSeekValue,
-  };
-}