@shanepadgett/tau-agent 0.26.0 → 0.28.0

package/extensions/explore/limits.ts

@@ -1,22 +0,0 @@
-export function normalizeNonNegativeInteger(value: number | undefined, fallback: number): number {
-	if (value === undefined) return fallback;
-	if (!Number.isFinite(value)) return fallback;
-	return Math.max(0, Math.floor(value));
-}
-
-export function normalizeCountLimit(value: number | undefined, fallback: number): number {
-	if (value === undefined) return fallback;
-	if (!Number.isFinite(value)) return fallback;
-	return Math.max(1, Math.floor(value));
-}
-
-export function divideBudget(limit: number, count: number): number[] {
-	if (count <= 0) return [];
-	const base = Math.max(1, Math.floor(limit / count));
-	let remainder = Math.max(0, limit - base * count);
-	return Array.from({ length: count }, () => {
-		const extra = remainder > 0 ? 1 : 0;
-		if (remainder > 0) remainder -= 1;
-		return base + extra;
-	});
-}

package/extensions/explore/ls.ts

@@ -1,113 +0,0 @@
-import { defineTool, formatSize } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { type Static, Type } from "typebox";
-import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
-import { divideBudget, normalizeCountLimit, normalizeNonNegativeInteger } from "./limits.ts";
-import { formatPathForDisplay, pathResolutionError, resolveExplorePath, stripLeadingAt } from "./path-display.ts";
-import { type PathTreeEntry, renderPathTree } from "./path-tree.ts";
-import { createExploreTextResult, type ExploreTextDetails, expandedExploreText } from "./result.ts";
-import { collectPaths, type TraversalEntry } from "./traverse.ts";
-
-const lsParams = Type.Object(
-	{
-		paths: Type.Optional(Type.Array(Type.String())),
-		depth: Type.Optional(Type.Number()),
-		limit: Type.Optional(Type.Number()),
-		all: Type.Optional(Type.Boolean()),
-		long: Type.Optional(Type.Boolean()),
-	},
-	{ additionalProperties: false },
-);
-
-type LsParams = Static<typeof lsParams>;
-
-function formatTime(date: Date): string {
-	return date.toISOString().slice(0, 10);
-}
-
-function entryMetadata(entry: TraversalEntry, long: boolean): string | undefined {
-	if (!long) return undefined;
-	const size = entry.type === "dir" ? "dir" : formatSize(entry.stats.size);
-	return `${size} ${formatTime(entry.stats.mtime)}`;
-}
-
-function pathTreeEntry(entry: TraversalEntry, long: boolean): PathTreeEntry {
-	return {
-		displayPath: entry.displayPath,
-		type: entry.type,
-		metadata: entryMetadata(entry, long),
-		empty: entry.empty,
-	};
-}
-
-function renderCallSummary(args: LsParams | undefined): string {
-	const paths = args?.paths && args.paths.length > 0 ? args.paths.map(stripLeadingAt).join(" ") : ".";
-	const depth = normalizeNonNegativeInteger(args?.depth, 1);
-	const limit = normalizeCountLimit(args?.limit, 100);
-	const flags = [args?.all ? "all" : "", args?.long ? "long" : ""].filter(Boolean).join(" ");
-	return `paths=${paths} depth=${depth} limit=${limit}${flags ? ` ${flags}` : ""}`;
-}
-
-export function createLsTool(rowState: ToolRowStateStore) {
-	return defineTool<typeof lsParams, ExploreTextDetails | undefined>({
-		name: "ls",
-		label: "ls",
-		description: "List files and directories with compact path output.",
-		promptSnippet: "List files and directories",
-		parameters: lsParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			const requestedPaths = params.paths && params.paths.length > 0 ? params.paths : ["."];
-			const depth = normalizeNonNegativeInteger(params.depth, 1);
-			const limit = normalizeCountLimit(params.limit, 100);
-			const budgets = divideBudget(limit, requestedPaths.length);
-			const all = params.all === true;
-			const humanParts: string[] = [];
-			const agentParts: string[] = [];
-
-			for (let i = 0; i < requestedPaths.length; i += 1) {
-				const input = requestedPaths[i] ?? ".";
-				const root = resolveExplorePath(ctx.cwd, input);
-				const entries = await collectPaths({
-					cwd: ctx.cwd,
-					root,
-					maxDepth: depth,
-					includeRoot: true,
-					includeHidden: all,
-					includeIgnored: all,
-					includeNoise: all,
-				}).catch((error: unknown) => {
-					throw pathResolutionError(error, input);
-				});
-
-				const budget = budgets[i] ?? limit;
-				const shown = entries.slice(0, budget);
-				const omitted = entries.length - shown.length;
-				const notice = omitted > 0 ? `… omitted ${omitted} entries (limit ${budget})` : undefined;
-				const rootPath = formatPathForDisplay(root, ctx.cwd);
-				const tree = renderPathTree(
-					shown.map((entry) => pathTreeEntry(entry, params.long === true)),
-					{
-						rootPath,
-						omissionNotice: notice,
-					},
-				);
-				humanParts.push(tree.humanText);
-				agentParts.push(tree.agentText);
-			}
-
-			return createExploreTextResult(agentParts.join("\n\n"), humanParts.join("\n\n"));
-		},
-		renderCall(args, theme, context) {
-			rowState.watch(context.toolCallId, context.invalidate);
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			const title = formatToolRowTitle(rowState, context.toolCallId, "ls", theme);
-			text.setText(`${title} ${theme.fg("muted", renderCallSummary(args))}`);
-			return text;
-		},
-		renderResult(result, _options, _theme, context) {
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			text.setText(context.expanded ? expandedExploreText(result) : "");
-			return text;
-		},
-	});
-}

package/extensions/explore/path-display.ts

@@ -1,41 +0,0 @@
-import { isAbsolute, relative, resolve } from "node:path";
-
-export function stripLeadingAt(value: string): string {
-	return value.startsWith("@") ? value.slice(1) : value;
-}
-
-export function toSlashPath(value: string): string {
-	return value.replace(/\\/g, "/");
-}
-
-export function resolveExplorePath(cwd: string, input: string): string {
-	const path = stripLeadingAt(input);
-	if (path.length === 0) return resolve(cwd);
-	return isAbsolute(path) ? resolve(path) : resolve(cwd, path);
-}
-
-export function pathResolutionError(error: unknown, input: string): Error {
-	if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-		return new Error(`Path not found: ${stripLeadingAt(input)}`);
-	}
-	return error instanceof Error ? error : new Error(String(error));
-}
-
-export function isWithinPath(parent: string, child: string): boolean {
-	const rel = relative(resolve(parent), resolve(child));
-	return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-}
-
-export function formatPathForDisplay(absolutePath: string, cwd: string): string {
-	const resolvedCwd = resolve(cwd);
-	const resolvedPath = resolve(absolutePath);
-	const rel = relative(resolvedCwd, resolvedPath);
-	if (rel === "") return ".";
-	if (!rel.startsWith("..") && !isAbsolute(rel)) return toSlashPath(rel);
-	return toSlashPath(resolvedPath);
-}
-
-export function relativeSlash(from: string, to: string): string {
-	const rel = relative(resolve(from), resolve(to));
-	return rel === "" ? "." : toSlashPath(rel);
-}

package/extensions/explore/path-tree.ts

@@ -1,150 +0,0 @@
-export type PathTreeEntryType = "file" | "dir";
-
-export interface PathTreeEntry {
-	displayPath: string;
-	type: PathTreeEntryType;
-	metadata?: string;
-	empty?: boolean;
-}
-
-export interface PathTreeRenderOptions {
-	rootPath?: string;
-	omissionNotice?: string;
-}
-
-export interface PathTreeRender {
-	humanText: string;
-	agentText: string;
-}
-
-interface TreeNode {
-	name: string;
-	type: PathTreeEntryType;
-	metadata?: string;
-	empty?: boolean;
-	children: Map<string, TreeNode>;
-}
-
-function splitDisplayPath(displayPath: string): string[] {
-	if (displayPath === ".") return [];
-	if (displayPath === "/") return ["/"];
-	if (displayPath.startsWith("/")) return ["/", ...displayPath.slice(1).split("/").filter(Boolean)];
-	return displayPath.split("/").filter(Boolean);
-}
-
-function isUnderRoot(rootPath: string, displayPath: string): boolean {
-	if (rootPath === "/") return displayPath.startsWith("/");
-	if (rootPath === ".") return !displayPath.startsWith("/");
-	return displayPath === rootPath || displayPath.startsWith(`${rootPath}/`);
-}
-
-function relativeToRoot(rootPath: string, displayPath: string): string {
-	if (rootPath === "/") return displayPath === "/" ? "" : displayPath.slice(1);
-	if (rootPath === ".") return displayPath === "." ? "" : displayPath;
-	if (displayPath === rootPath) return "";
-	return displayPath.slice(rootPath.length + 1);
-}
-
-function entryLabel(node: TreeNode): string {
-	const name = node.name === "/" ? "/" : node.type === "dir" ? `${node.name}/` : node.name;
-	return node.metadata ? `${name} ${node.metadata}` : name;
-}
-
-function sortChildren(node: TreeNode): TreeNode[] {
-	return [...node.children.values()].sort((a, b) => {
-		if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
-		return a.name.localeCompare(b.name);
-	});
-}
-
-function createNode(name: string, type: PathTreeEntryType): TreeNode {
-	return { name, type, children: new Map() };
-}
-
-function insert(root: TreeNode, relativePath: string, entry: PathTreeEntry): void {
-	const parts = splitDisplayPath(relativePath);
-	if (parts.length === 0) {
-		root.type = entry.type;
-		root.metadata = entry.metadata;
-		root.empty = entry.empty;
-		return;
-	}
-
-	let current = root;
-	for (let i = 0; i < parts.length; i += 1) {
-		const part = parts[i];
-		if (!part) continue;
-		const isLeaf = i === parts.length - 1;
-		const type = isLeaf ? entry.type : "dir";
-		let child = current.children.get(part);
-		if (!child) {
-			child = createNode(part, type);
-			current.children.set(part, child);
-		}
-		if (isLeaf) {
-			child.type = entry.type;
-			child.metadata = entry.metadata;
-			child.empty = entry.empty;
-		}
-		current = child;
-	}
-}
-
-function renderHumanNode(node: TreeNode, depth: number, lines: string[]): void {
-	lines.push(`${"  ".repeat(depth)}${entryLabel(node)}`);
-	if (node.empty && node.children.size === 0) lines.push(`${"  ".repeat(depth + 1)}[empty]`);
-	for (const child of sortChildren(node)) renderHumanNode(child, depth + 1, lines);
-}
-
-function renderAgentNode(node: TreeNode, depth: number, lines: string[]): void {
-	if (node.type === "file") {
-		lines.push(`${"  ".repeat(depth)}${entryLabel(node)}`);
-		return;
-	}
-
-	const children = sortChildren(node);
-	const files = children.filter((child) => child.type === "file").map(entryLabel);
-	let line = `${"  ".repeat(depth)}${entryLabel(node)}`;
-	if (files.length > 0) line += `: ${files.join(", ")}`;
-	else if (node.empty && children.length === 0) line += " [empty]";
-	lines.push(line);
-
-	for (const child of children) {
-		if (child.type === "dir") renderAgentNode(child, depth + 1, lines);
-	}
-}
-
-function buildTree(entries: readonly PathTreeEntry[], rootPath: string | undefined): TreeNode {
-	const rootName = rootPath === undefined ? "" : rootPath === "." ? "." : rootPath;
-	const root = createNode(rootName, "dir");
-	for (const entry of entries) {
-		if (rootPath !== undefined && isUnderRoot(rootPath, entry.displayPath)) {
-			insert(root, relativeToRoot(rootPath, entry.displayPath), entry);
-		} else {
-			insert(root, entry.displayPath, entry);
-		}
-	}
-	return root;
-}
-
-function appendNotice(lines: string[], notice: string | undefined): void {
-	if (notice) lines.push(notice);
-}
-
-export function renderPathTree(entries: readonly PathTreeEntry[], options: PathTreeRenderOptions = {}): PathTreeRender {
-	const root = buildTree(entries, options.rootPath);
-	const humanLines: string[] = [];
-	const agentLines: string[] = [];
-
-	if (options.rootPath === undefined) {
-		for (const child of sortChildren(root)) renderHumanNode(child, 0, humanLines);
-		for (const child of sortChildren(root)) renderAgentNode(child, 0, agentLines);
-	} else {
-		renderHumanNode(root, 0, humanLines);
-		renderAgentNode(root, 0, agentLines);
-	}
-
-	appendNotice(humanLines, options.omissionNotice);
-	appendNotice(agentLines, options.omissionNotice);
-	return { humanText: humanLines.join("\n"), agentText: agentLines.join("\n") };
-}

package/extensions/explore/read-cache.ts

@@ -1,273 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolve } from "node:path";
-import { replayContextPruningState } from "../../shared/context-pruning-state.ts";
-import { applyCompleteFileDiff, COMPLETE_FILE_SCOPE, decodeCompleteFileSource } from "./full-file-knowledge.ts";
-
-export type ReadCacheMode = "baseline" | "recovery" | "unchanged" | "diff";
-export type ReadCachePresentation = "plain" | "line-numbered";
-
-export interface ReadCacheMetaV1 {
-	v: 1;
-	pathKey: string;
-	scopeKey: string;
-	presentation: ReadCachePresentation;
-	servedHash: string;
-	baseHash?: string;
-	mode: ReadCacheMode;
-	baselineTokens: number;
-	returnedTokens: number;
-	totalLines: number;
-	summary: string;
-}
-
-export interface ReadCacheScopeTrust {
-	hash: string;
-	text?: string;
-	rowIds: readonly string[];
-}
-
-export interface AcceptedReadCacheRow {
-	rowId: string;
-	pathKey: string;
-	scopeKey: string;
-	meta: ReadCacheMetaV1;
-	dependencyRowIds: readonly string[];
-}
-
-export interface CompleteFileDependencyChain {
-	pathKey: string;
-	servedHash: string;
-	rowIds: readonly string[];
-	sourceText: string;
-}
-
-export interface ReadCacheReplayResult {
-	scopeTrust: ReadonlyMap<string, ReadonlyMap<string, ReadCacheScopeTrust>>;
-	acceptedRows: readonly AcceptedReadCacheRow[];
-	completeFileChains: ReadonlyMap<string, CompleteFileDependencyChain>;
-	failedPatchRecoveryPaths: ReadonlySet<string>;
-}
-
-export interface ReadCacheDecision {
-	baseHash?: string;
-	baselineText?: string;
-	recovery: boolean;
-}
-
-export interface ReadCacheStore {
-	decision(ctx: ExtensionContext, pathKey: string, scopeKey: string): ReadCacheDecision;
-}
-
-export function createReadCacheStore(): ReadCacheStore {
-	return {
-		decision(ctx, pathKey, scopeKey) {
-			const manager = ctx.sessionManager;
-			if (!manager) {
-				return { baseHash: undefined, baselineText: undefined, recovery: false };
-			}
-			const pruning = replayContextPruningState(manager.getBranch());
-			const ignoredRowIds = new Set([...pruning.prunedToolCallIds, ...pruning.prunedAutoreadRowIds]);
-			for (const id of pruning.retainedToolCallIds) ignoredRowIds.delete(id);
-			const state = replayReadCache(manager.buildContextEntries(), ctx.cwd, ignoredRowIds);
-			const trust = state.scopeTrust.get(pathKey)?.get(scopeKey);
-			return {
-				baseHash: trust?.hash,
-				baselineText: trust?.text,
-				recovery: state.failedPatchRecoveryPaths.has(pathKey),
-			};
-		},
-	};
-}
-
-function parseReadCacheMeta(value: unknown): ReadCacheMetaV1 | undefined {
-	if (!isRecord(value) || value.v !== 1) return undefined;
-	if (typeof value.pathKey !== "string" || typeof value.scopeKey !== "string") return undefined;
-	if (value.presentation !== "plain" && value.presentation !== "line-numbered") return undefined;
-	if (typeof value.servedHash !== "string" || value.servedHash.length === 0) return undefined;
-	if (!isReadCacheMode(value.mode)) return undefined;
-	if (!isNonNegativeFinite(value.baselineTokens) || !isNonNegativeFinite(value.returnedTokens)) return undefined;
-	if (!isNonNegativeFinite(value.totalLines) || typeof value.summary !== "string") return undefined;
-	if (value.baseHash !== undefined && typeof value.baseHash !== "string") return undefined;
-	if ((value.mode === "unchanged" || value.mode === "diff") && !value.baseHash) return undefined;
-	return {
-		v: 1,
-		pathKey: value.pathKey,
-		scopeKey: value.scopeKey,
-		presentation: value.presentation,
-		servedHash: value.servedHash,
-		baseHash: value.baseHash,
-		mode: value.mode,
-		baselineTokens: value.baselineTokens,
-		returnedTokens: value.returnedTokens,
-		totalLines: value.totalLines,
-		summary: value.summary,
-	};
-}
-
-export function readMetaFromMessage(message: unknown): ReadCacheMetaV1 | undefined {
-	if (!isRecord(message)) return undefined;
-	const isReadResult = message.role === "toolResult" && message.toolName === "read";
-	const isAutoread = message.customType === "tau.autoread";
-	if (!isReadResult && !isAutoread) return undefined;
-	if (!isRecord(message.details)) return undefined;
-	if (isAutoread && message.details.status !== "read") return undefined;
-	return parseReadCacheMeta(message.details.readCache);
-}
-
-export function replayReadCache(
-	entries: readonly unknown[],
-	cwd: string,
-	ignoredRowIds: ReadonlySet<string> = new Set(),
-): ReadCacheReplayResult {
-	const trust = new Map<string, Map<string, ReadCacheScopeTrust>>();
-	const acceptedRows: AcceptedReadCacheRow[] = [];
-	const failedPatchRecoveryPaths = new Set<string>();
-	for (const entry of entries) {
-		if (!isRecord(entry)) continue;
-		let message: unknown;
-		if (entry.type === "message" && "message" in entry) message = entry.message;
-		else if (entry.type === "custom_message") message = entry;
-		else continue;
-		const parsedMeta = readMetaFromMessage(message);
-		if (parsedMeta) {
-			const rowId = readRowId(message);
-			if (!rowId || ignoredRowIds.has(rowId)) continue;
-			const pathKey = resolve(cwd, parsedMeta.pathKey);
-			const meta = pathKey === parsedMeta.pathKey ? parsedMeta : { ...parsedMeta, pathKey };
-			if (applyReadMeta(trust, failedPatchRecoveryPaths, message, meta, rowId)) {
-				const acceptedTrust = trust.get(meta.pathKey)?.get(meta.scopeKey);
-				if (acceptedTrust)
-					acceptedRows.push({
-						rowId,
-						pathKey: meta.pathKey,
-						scopeKey: meta.scopeKey,
-						meta,
-						dependencyRowIds: [...acceptedTrust.rowIds],
-					});
-			}
-			continue;
-		}
-		for (const path of failedPatchPaths(message, cwd)) failedPatchRecoveryPaths.add(path);
-	}
-	const completeFileChains = new Map<string, CompleteFileDependencyChain>();
-	for (const [pathKey, scopes] of trust) {
-		const complete = scopes.get(COMPLETE_FILE_SCOPE);
-		if (!complete || complete.text === undefined) continue;
-		completeFileChains.set(pathKey, {
-			pathKey,
-			servedHash: complete.hash,
-			rowIds: [...complete.rowIds],
-			sourceText: complete.text,
-		});
-	}
-	return { scopeTrust: trust, acceptedRows, completeFileChains, failedPatchRecoveryPaths };
-}
-
-function applyReadMeta(
-	trust: Map<string, Map<string, ReadCacheScopeTrust>>,
-	failedPatchRecoveryPaths: Set<string>,
-	message: unknown,
-	meta: ReadCacheMetaV1,
-	rowId: string,
-): boolean {
-	const existing = trust.get(meta.pathKey)?.get(meta.scopeKey);
-	if (meta.mode === "baseline" || meta.mode === "recovery") {
-		let text: string | undefined;
-		if (meta.scopeKey === COMPLETE_FILE_SCOPE) {
-			if (!isRecord(message)) return false;
-			let pathHeader: string | undefined;
-			if (message.customType === "tau.autoread") {
-				if (!isRecord(message.details)) return false;
-				if (typeof message.details.path !== "string" || typeof message.details.cwd !== "string") return false;
-				if (resolve(message.details.cwd, message.details.path) !== meta.pathKey) return false;
-				pathHeader = message.details.path;
-			}
-			const decoded = decodeCompleteFileSource({
-				content: message.content,
-				autoread: message.customType === "tau.autoread",
-				...(pathHeader === undefined ? {} : { pathHeader }),
-				presentation: meta.presentation,
-				servedHash: meta.servedHash,
-			});
-			if (!decoded.valid || decoded.text === undefined) return false;
-			text = decoded.text;
-		}
-		setTrust(trust, meta.pathKey, meta.scopeKey, { hash: meta.servedHash, text, rowIds: [rowId] });
-		failedPatchRecoveryPaths.delete(meta.pathKey);
-		return true;
-	}
-	if (!meta.baseHash || existing?.hash !== meta.baseHash) return false;
-	if (meta.mode === "unchanged" && meta.servedHash !== meta.baseHash) return false;
-	let text = meta.mode === "unchanged" ? existing.text : undefined;
-	if (meta.scopeKey === COMPLETE_FILE_SCOPE && meta.mode === "diff") {
-		if (existing.text === undefined) return false;
-		const decoded = applyCompleteFileDiff({
-			content: isRecord(message) ? message.content : undefined,
-			baseText: existing.text,
-			baseHash: meta.baseHash,
-			servedHash: meta.servedHash,
-		});
-		if (!decoded.valid || decoded.text === undefined) return false;
-		text = decoded.text;
-	}
-	setTrust(trust, meta.pathKey, meta.scopeKey, {
-		hash: meta.servedHash,
-		text,
-		rowIds: [...existing.rowIds, rowId],
-	});
-	return true;
-}
-
-function readRowId(message: unknown): string | undefined {
-	if (!isRecord(message)) return undefined;
-	if (message.role === "toolResult" && message.toolName === "read") {
-		return typeof message.toolCallId === "string" && message.toolCallId.length > 0 ? message.toolCallId : undefined;
-	}
-	if (message.customType !== "tau.autoread" || !isRecord(message.details)) return undefined;
-	return typeof message.details.rowId === "string" && message.details.rowId.length > 0
-		? message.details.rowId
-		: undefined;
-}
-
-function failedPatchPaths(message: unknown, cwd: string): string[] {
-	if (!isRecord(message) || message.role !== "toolResult" || message.toolName !== "patch") return [];
-	if (
-		!isRecord(message.details) ||
-		message.details.status === "completed" ||
-		!Array.isArray(message.details.failures)
-	) {
-		return [];
-	}
-	const paths: string[] = [];
-	for (const failure of message.details.failures) {
-		if (!isRecord(failure) || typeof failure.path !== "string" || failure.path.trim().length === 0) continue;
-		paths.push(resolve(cwd, failure.path));
-	}
-	return paths;
-}
-
-function setTrust(
-	trust: Map<string, Map<string, ReadCacheScopeTrust>>,
-	pathKey: string,
-	scopeKey: string,
-	value: ReadCacheScopeTrust,
-): void {
-	let scopes = trust.get(pathKey);
-	if (!scopes) {
-		scopes = new Map();
-		trust.set(pathKey, scopes);
-	}
-	scopes.set(scopeKey, value);
-}
-
-function isReadCacheMode(value: unknown): value is ReadCacheMode {
-	return value === "baseline" || value === "recovery" || value === "unchanged" || value === "diff";
-}
-
-function isNonNegativeFinite(value: unknown): value is number {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}

package/extensions/explore/read-snapshots.ts

@@ -1,57 +0,0 @@
-import { MAX_COMPLETE_FILE_SNAPSHOT_BYTES } from "./full-file-knowledge.ts";
-
-const MAX_TOTAL_BYTES = 16 * 1024 * 1024;
-
-interface Snapshot {
-	text: string;
-	bytes: number;
-}
-
-export interface ReadSnapshotStore {
-	get(hash: string): string | undefined;
-	epoch(): number;
-	isCurrent(epoch: number): boolean;
-	set(hash: string, text: string, bytes: number, epoch: number): boolean;
-	clear(): void;
-}
-
-export function createReadSnapshotStore(): ReadSnapshotStore {
-	const snapshots = new Map<string, Snapshot>();
-	let totalBytes = 0;
-	let epoch = 0;
-
-	return {
-		get(hash) {
-			const snapshot = snapshots.get(hash);
-			if (!snapshot) return undefined;
-			snapshots.delete(hash);
-			snapshots.set(hash, snapshot);
-			return snapshot.text;
-		},
-		epoch() {
-			return epoch;
-		},
-		isCurrent(candidate) {
-			return candidate === epoch;
-		},
-		set(hash, text, bytes, candidateEpoch) {
-			if (candidateEpoch !== epoch || bytes > MAX_COMPLETE_FILE_SNAPSHOT_BYTES) return false;
-			if (snapshots.has(hash)) return true;
-			snapshots.set(hash, { text, bytes });
-			totalBytes += bytes;
-			while (totalBytes > MAX_TOTAL_BYTES) {
-				const oldestHash = snapshots.keys().next().value as string | undefined;
-				if (oldestHash === undefined) break;
-				const oldest = snapshots.get(oldestHash);
-				snapshots.delete(oldestHash);
-				totalBytes -= oldest?.bytes ?? 0;
-			}
-			return true;
-		},
-		clear() {
-			snapshots.clear();
-			totalBytes = 0;
-			epoch += 1;
-		},
-	};
-}