@danypops/pi-lector 0.4.0 → 0.6.0

package/extension/src/external-search-operations.ts

@@ -0,0 +1,26 @@
+import type { GithubRepoSearchResult, NpmPackageCandidate, SourcegraphCodeCandidate } from "@danypops/lector";
+import { lectorClient } from "./lector-client.ts";
+
+/** Thin wrapper over search.githubRepos/search.npmPackages/search.sourcegraphCode -- explicit-query discovery inputs shaped for repo_cache/package_source, never open-ended discovery/trending. */
+export interface ExternalSearchOperations {
+	githubRepos(query: string, maxResults: number): Promise<GithubRepoSearchResult>;
+	npmPackages(query: string, maxResults: number): Promise<{ candidates: readonly NpmPackageCandidate[] }>;
+	sourcegraphCode(query: string, maxResults: number): Promise<{ candidates: readonly SourcegraphCodeCandidate[] }>;
+}
+
+export function createExternalSearchOperations(): ExternalSearchOperations {
+	return {
+		async githubRepos(query, maxResults) {
+			const client = await lectorClient();
+			return client.call("search.githubRepos", { query, maxResults });
+		},
+		async npmPackages(query, maxResults) {
+			const client = await lectorClient();
+			return client.call("search.npmPackages", { query, maxResults });
+		},
+		async sourcegraphCode(query, maxResults) {
+			const client = await lectorClient();
+			return client.call("search.sourcegraphCode", { query, maxResults });
+		},
+	};
+}

package/extension/src/external-search-rendering.ts

@@ -0,0 +1,27 @@
+import type { GithubRepoSearchResult, NpmPackageCandidate, SourcegraphCodeCandidate } from "@danypops/lector";
+import type { LectorTheme } from "./lector-tui-theme.ts";
+
+type ExternalSearchAction = "github_repos" | "npm_packages" | "sourcegraph_code";
+
+export function formatExternalSearchCall(action: ExternalSearchAction, args: { query?: unknown }, theme: LectorTheme): string {
+	const label = theme.fg("toolTitle", theme.bold("external_search"));
+	const query = typeof args.query === "string" ? args.query : "";
+	return `${label} ${theme.fg("accent", action)} ${theme.fg("dim", query)}`;
+}
+
+export function formatGithubRepoSearchResult(result: GithubRepoSearchResult | undefined, theme: LectorTheme): string {
+	if (!result) return theme.fg("dim", "No result.");
+	const count = result.candidates.length;
+	const summary = count === 0 ? theme.fg("dim", "no repositories matched") : theme.fg("success", `${count} repositor${count === 1 ? "y" : "ies"}`);
+	return result.authenticated ? summary : `${summary} ${theme.fg("warning", "(unauthenticated -- lower rate limit)")}`;
+}
+
+export function formatNpmPackageSearchResult(result: { candidates: readonly NpmPackageCandidate[] } | undefined, theme: LectorTheme): string {
+	const count = result?.candidates.length ?? 0;
+	return count === 0 ? theme.fg("dim", "no packages matched") : theme.fg("success", `${count} package${count === 1 ? "" : "s"}`);
+}
+
+export function formatSourcegraphCodeSearchResult(result: { candidates: readonly SourcegraphCodeCandidate[] } | undefined, theme: LectorTheme): string {
+	const count = result?.candidates.length ?? 0;
+	return count === 0 ? theme.fg("dim", "no code matches") : theme.fg("success", `${count} match${count === 1 ? "" : "es"}`);
+}

package/extension/src/index.ts

@@ -1,20 +1,24 @@
 import { resolve } from "node:path";
 import type {
+	CachedRepositoryPage,
 	ContentHash,
 	Diagnostic,
 	DocumentSymbolEntry,
 	EditOutcome,
 	FindFilesResult,
+	GithubRepoSearchResult,
 	Hover,
 	IntelligenceProvenance,
 	JobSnapshot,
 	LineEdit,
 	LineEditOutcome,
 	MutationHistoryEntry,
+	NpmPackageCandidate,
 	OperationOutputs,
 	PackageSourceOperationResult,
 	PopulateSymbolGraphResult,
 	RepoFetchResult,
+	SourcegraphCodeCandidate,
 	SymbolAnnotation,
 	SymbolNode,
 	SymbolSearchResult,
@@ -62,6 +66,13 @@ import {
 import { createLectorCrossWorkspaceSearchOperations } from "./cross-workspace-search-operations.ts";
 import { formatCrossWorkspaceCall, formatFindSymbolsAcrossProjectsResult, formatSearchTextAcrossProjectsResult } from "./cross-workspace-search-rendering.ts";
 import { createLectorEditOperations } from "./edit-operations.ts";
+import { createExternalSearchOperations } from "./external-search-operations.ts";
+import {
+	formatExternalSearchCall,
+	formatGithubRepoSearchResult,
+	formatNpmPackageSearchResult,
+	formatSourcegraphCodeSearchResult,
+} from "./external-search-rendering.ts";
 import { createLectorFindFilesOperations } from "./find-files-operations.ts";
 import { formatFindFilesCall, formatFindFilesResult } from "./find-files-rendering.ts";
 import { createLectorFindSymbolsOperations } from "./find-symbols-operations.ts";
@@ -78,9 +89,10 @@ import { formatPackageSourceCall, formatPackageSourceResult } from "./package-so
 import { createLectorReadOperations } from "./read-operations.ts";
 import { createReferenceBasedRenameOperations } from "./reference-based-rename-operations.ts";
 import { createRenameOperations } from "./rename-operations.ts";
+import { createRepoCacheEvictOperations } from "./repo-cache-evict-operations.ts";
 import { createRepoCacheListOperations } from "./repo-cache-list-operations.ts";
+import { formatRepoCacheCall, formatRepoCacheEvictResult, formatRepoCacheListResult, formatRepoFetchResult } from "./repo-cache-rendering.ts";
 import { createLectorRepoFetchOperations } from "./repo-fetch-operations.ts";
-import { formatRepoFetchCall, formatRepoFetchResult } from "./repo-fetch-rendering.ts";
 import { createLectorSearchOperations } from "./search-operations.ts";
 import { formatSearchCall, formatSearchResult } from "./search-rendering.ts";
 import { type AnnotationAnchorInput, createLectorSymbolAnnotationOperations } from "./symbol-annotation-operations.ts";
@@ -1445,88 +1457,131 @@ export default function (pi: ExtensionAPI) {
 			},
 		});
 
+		type RepoCacheToolDetails =
+			| { readonly action: "fetch"; readonly result: RepoFetchResult & { workspaceId: string } }
+			| { readonly action: "list"; readonly page: CachedRepositoryPage }
+			| { readonly action: "evict"; readonly result: { evicted: boolean } };
+
 		const repoFetchOperations = createLectorRepoFetchOperations();
 		const repoCacheListOperations = createRepoCacheListOperations();
+		const repoCacheEvictOperations = createRepoCacheEvictOperations();
 		pi.registerTool({
-			name: "repo_fetch",
-			label: "Repo Fetch",
+			name: "repo_cache",
+			label: "Repo Cache",
 			description:
-				"Shallow-clones an external repository into a disk-bounded cache and registers it as a read-only project -- every other tool (search_code, find_symbols, go_to_definition, ...) then works on it unchanged. Explicit owner/repo[@ref] only, no discovery/search -- use web_fetch to find candidates first.",
-			promptSnippet: "Fetch an external open-source repo to search or analyze",
+				"Fetch, list/query, or evict entries in Lector's external-repo cache. action=fetch shallow-clones an external repository into a disk-bounded cache and registers it as a read-only project -- every other tool (search_code, find_symbols, go_to_definition, ...) then works on it unchanged; explicit owner/repo[@ref] only, no discovery/search (use web_fetch to find candidates first); forceRefresh reclones even when an unexpired cache entry already exists, for a caller that has already positively confirmed the remote moved. action=list queries the cache -- no network call, no mutation -- filtering by any combination of host/owner/repo/ref (exact match) and text (case-insensitive substring), bounded and paginated via cursor; each entry reports whether it's currently a registered workspace or just present on disk. action=evict removes one cache entry from disk by its exact host/owner/repo/ref identity; refuses with a clear error if it is still a currently-registered workspace.",
+			promptSnippet: "Fetch, list, or evict entries in the external-repo cache",
 			parameters: Type.Object({
-				owner: Type.String({ description: "Repository owner or organization" }),
-				repo: Type.String({ description: "Repository name" }),
-				ref: Type.Optional(Type.String({ description: "Branch, tag, or commit to fetch; defaults to the repository's default branch" })),
-				host: Type.Optional(Type.String({ description: "Git host; defaults to github.com" })),
+				action: Type.Union([Type.Literal("fetch"), Type.Literal("list"), Type.Literal("evict")]),
+				owner: Type.Optional(Type.String({ description: "Required for action=fetch/evict -- repository owner or organization" })),
+				repo: Type.Optional(Type.String({ description: "Required for action=fetch/evict -- repository name" })),
+				ref: Type.Optional(
+					Type.String({
+						description:
+							"fetch/evict: branch, tag, or commit; defaults to the repository's default branch. list: matches either the requested or the resolved ref",
+					}),
+				),
+				host: Type.Optional(Type.String({ description: "Git host; defaults to github.com for fetch/evict, unfiltered for list" })),
+				forceRefresh: Type.Optional(Type.Boolean({ description: "action=fetch only -- reclone even if an unexpired cache entry already exists" })),
+				text: Type.Optional(Type.String({ description: "action=list only -- case-insensitive substring match across host/owner/repo/refs" })),
+				maxResults: Type.Optional(Type.Number({ description: "Required for action=list -- maximum entries to return in this page" })),
+				cursor: Type.Optional(Type.String({ description: "action=list only -- opaque cursor from a prior call's nextCursor, to fetch the next page" })),
 			}),
-			async execute(_toolCallId, params) {
-				const result = await repoFetchOperations.fetch(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null);
-				return { content: [{ type: "text", text: JSON.stringify(result) }], details: { result } };
+			async execute(_toolCallId, params): Promise<AgentToolResult<RepoCacheToolDetails>> {
+				if (params.action === "fetch") {
+					if (!params.owner || !params.repo) throw new Error("repo_cache action=fetch requires owner and repo");
+					const result = await repoFetchOperations.fetch(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null, params.forceRefresh);
+					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "fetch", result } };
+				}
+				if (params.action === "evict") {
+					if (!params.owner || !params.repo) throw new Error("repo_cache action=evict requires owner and repo");
+					const result = await repoCacheEvictOperations.evict(params.host ?? "github.com", params.owner, params.repo, params.ref ?? null);
+					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "evict", result } };
+				}
+				if (params.maxResults === undefined) throw new Error("repo_cache action=list requires maxResults");
+				const page = await repoCacheListOperations.list(
+					{ text: params.text, host: params.host, owner: params.owner, repo: params.repo, ref: params.ref },
+					params.maxResults,
+					params.cursor,
+				);
+				return { content: [{ type: "text", text: JSON.stringify(page) }], details: { action: "list", page } };
 			},
 			renderCall(args, theme, context) {
+				const action = args.action === "list" || args.action === "evict" ? args.action : "fetch";
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-				text.setText(formatRepoFetchCall(args, theme));
+				text.setText(formatRepoCacheCall(action, args, theme));
 				return text;
 			},
 			renderResult(result, { isPartial }, theme, context) {
-				if (isPartial) return new Text(theme.fg("warning", "Fetching repository..."), 0, 0);
+				if (isPartial) return new Text(theme.fg("warning", "Working on repo cache..."), 0, 0);
 				if (context.isError) {
 					const errorText = result.content
 						.filter((block) => block.type === "text")
 						.map((block) => block.text)
 						.join("\n");
-					return new Text(theme.fg("error", errorText || "repo_fetch failed"), 0, 0);
+					return new Text(theme.fg("error", errorText || "repo_cache failed"), 0, 0);
 				}
-				const details = result.details as { result?: RepoFetchResult & { workspaceId: string } } | undefined;
+				const details = result.details as RepoCacheToolDetails | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-				text.setText(formatRepoFetchResult(details?.result, theme));
+				if (details?.action === "list") text.setText(formatRepoCacheListResult(details.page, theme));
+				else if (details?.action === "evict") text.setText(formatRepoCacheEvictResult(details.result, theme));
+				else text.setText(formatRepoFetchResult(details?.action === "fetch" ? details.result : undefined, theme));
 				return text;
 			},
 		});
 
+		type ExternalSearchToolDetails =
+			| { readonly action: "github_repos"; readonly result: GithubRepoSearchResult }
+			| { readonly action: "npm_packages"; readonly result: { candidates: readonly NpmPackageCandidate[] } }
+			| { readonly action: "sourcegraph_code"; readonly result: { candidates: readonly SourcegraphCodeCandidate[] } };
+
+		const externalSearchOperations = createExternalSearchOperations();
 		pi.registerTool({
-			name: "repo_cache_list",
-			label: "Repo Cache List",
+			name: "external_search",
+			label: "External Search",
 			description:
-				"Lists and queries repo_fetch's own on-disk cache -- no network call, no cache mutation. Filter by any combination of host/owner/repo/ref (exact match) and text (case-insensitive substring across host/owner/repo/refs). Each entry reports whether it's currently a registered workspace (usable directly by other tools) or just present on disk. Bounded and paginated via cursor.",
-			promptSnippet: "List or search previously-fetched external repositories",
+				"Finds real prior art before writing new code -- explicit-query search only, never open-ended discovery/trending. action=github_repos searches GitHub repositories by name/description/topic (GitHub's own relevance ranking); candidates are shaped as direct repo_cache(action=fetch) inputs (host/owner/repo). Unauthenticated is rate-limited to 10 req/min; configure GITHUB_TOKEN on the daemon host for 30/min. action=npm_packages searches the public npm registry; candidates are shaped as direct package_source inputs (name, plus the version already returned). action=sourcegraph_code searches code content across public GitHub via sourcegraph.com -- \"which repos actually contain code matching X\", a genuinely different mode than the other two (which search names/metadata, not file contents); each candidate's repository field feeds repo_cache(action=fetch) once split on '/'. Every source is cached for a short TTL -- an identical query moments apart is served from cache, not re-fetched.",
+			promptSnippet: "Search GitHub repos, npm packages, or code content for prior art",
 			parameters: Type.Object({
-				text: Type.Optional(Type.String({ description: "Case-insensitive substring match across host/owner/repo/refs" })),
-				host: Type.Optional(Type.String({ description: "Exact host match, e.g. github.com" })),
-				owner: Type.Optional(Type.String()),
-				repo: Type.Optional(Type.String()),
-				ref: Type.Optional(Type.String({ description: "Matches either the requested or the resolved ref" })),
-				maxResults: Type.Number({ description: "Maximum entries to return in this page" }),
-				cursor: Type.Optional(Type.String({ description: "Opaque cursor from a prior call's nextCursor, to fetch the next page" })),
+				action: Type.Union([Type.Literal("github_repos"), Type.Literal("npm_packages"), Type.Literal("sourcegraph_code")]),
+				query: Type.String({
+					description: "The search query -- repo/package name or description keywords for github_repos/npm_packages, code content for sourcegraph_code",
+				}),
+				maxResults: Type.Optional(Type.Number({ description: "Maximum candidates to return (default 20)" })),
 			}),
-			async execute(_toolCallId, params) {
-				const page = await repoCacheListOperations.list(
-					{ text: params.text, host: params.host, owner: params.owner, repo: params.repo, ref: params.ref },
-					params.maxResults,
-					params.cursor,
-				);
-				return { content: [{ type: "text", text: JSON.stringify(page) }], details: { page } };
+			async execute(_toolCallId, params): Promise<AgentToolResult<ExternalSearchToolDetails>> {
+				const maxResults = params.maxResults ?? 20;
+				if (params.action === "github_repos") {
+					const result = await externalSearchOperations.githubRepos(params.query, maxResults);
+					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "github_repos", result } };
+				}
+				if (params.action === "npm_packages") {
+					const result = await externalSearchOperations.npmPackages(params.query, maxResults);
+					return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "npm_packages", result } };
+				}
+				const result = await externalSearchOperations.sourcegraphCode(params.query, maxResults);
+				return { content: [{ type: "text", text: JSON.stringify(result) }], details: { action: "sourcegraph_code", result } };
 			},
-			renderCall(_args, theme, context) {
+			renderCall(args, theme, context) {
+				const action = args.action === "npm_packages" || args.action === "sourcegraph_code" ? args.action : "github_repos";
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-				text.setText(`${theme.fg("toolTitle", theme.bold("repo_cache_list"))}`);
+				text.setText(formatExternalSearchCall(action, args, theme));
 				return text;
 			},
 			renderResult(result, { isPartial }, theme, context) {
-				if (isPartial) return new Text(theme.fg("warning", "Listing cached repositories..."), 0, 0);
+				if (isPartial) return new Text(theme.fg("warning", "Searching..."), 0, 0);
 				if (context.isError) {
 					const errorText = result.content
 						.filter((block) => block.type === "text")
 						.map((block) => block.text)
 						.join("\n");
-					return new Text(theme.fg("error", errorText || "repo_cache_list failed"), 0, 0);
+					return new Text(theme.fg("error", errorText || "external_search failed"), 0, 0);
 				}
-				const details = result.details as
-					| { page?: { entries: readonly { host: string; owner: string; repo: string }[]; nextCursor: string | null } }
-					| undefined;
+				const details = result.details as ExternalSearchToolDetails | undefined;
 				const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-				const count = details?.page?.entries.length ?? 0;
-				text.setText(count === 0 ? theme.fg("dim", "no cached repositories") : theme.fg("success", `${count} cached repositor${count === 1 ? "y" : "ies"}`));
+				if (details?.action === "npm_packages") text.setText(formatNpmPackageSearchResult(details.result, theme));
+				else if (details?.action === "sourcegraph_code") text.setText(formatSourcegraphCodeSearchResult(details.result, theme));
+				else text.setText(formatGithubRepoSearchResult(details?.action === "github_repos" ? details.result : undefined, theme));
 				return text;
 			},
 		});

package/extension/src/repo-cache-evict-operations.ts

@@ -0,0 +1,19 @@
+import { lectorClient } from "./lector-client.ts";
+
+/**
+ * Thin wrapper over repo.evictCache -- no `directory`/workspaceForDirectory resolution (matching
+ * repo-fetch-operations.ts and repo-cache-list-operations.ts: this targets the daemon-wide fetch
+ * cache, not a workspace-scoped concept).
+ */
+export interface RepoCacheEvictOperations {
+	evict(host: string, owner: string, repo: string, ref: string | null): Promise<{ evicted: boolean }>;
+}
+
+export function createRepoCacheEvictOperations(): RepoCacheEvictOperations {
+	return {
+		async evict(host, owner, repo, ref) {
+			const client = await lectorClient();
+			return client.call("repo.evictCache", { host, owner, repo, ref });
+		},
+	};
+}

package/extension/src/repo-cache-rendering.ts

@@ -0,0 +1,42 @@
+import type { CachedRepositoryPage, RepoFetchResult } from "@danypops/lector";
+import type { LectorTheme } from "./lector-tui-theme.ts";
+
+type RepoCacheAction = "fetch" | "list" | "evict";
+
+export function formatRepoCacheCall(
+	action: RepoCacheAction,
+	args: { owner?: unknown; repo?: unknown; ref?: unknown; host?: unknown; text?: unknown },
+	theme: LectorTheme,
+): string {
+	const label = theme.fg("toolTitle", theme.bold("repo_cache"));
+	if (action === "list") {
+		const filter = typeof args.text === "string" && args.text.length > 0 ? args.text : typeof args.repo === "string" ? args.repo : "";
+		return `${label} ${theme.fg("accent", "list")}${filter ? ` ${theme.fg("dim", filter)}` : ""}`;
+	}
+	const host = typeof args.host === "string" && args.host.length > 0 ? args.host : "github.com";
+	const owner = typeof args.owner === "string" ? args.owner : "";
+	const repo = typeof args.repo === "string" ? args.repo : "";
+	const ref = typeof args.ref === "string" ? `@${args.ref}` : "";
+	return `${label} ${theme.fg("accent", action)} ${theme.fg("dim", `${host}/${owner}/${repo}${ref}`)}`;
+}
+
+export function formatRepoFetchResult(result: (RepoFetchResult & { workspaceId: string }) | undefined, theme: LectorTheme): string {
+	if (!result) return theme.fg("dim", "No result.");
+	const lines = [
+		`${theme.fg("accent", result.workspaceId)} ${result.fromCache ? theme.fg("dim", "(from cache)") : theme.fg("toolTitle", "(fetched)")} -- ${result.path}`,
+	];
+	if (result.refFallbackOccurred) {
+		lines.push(theme.fg("warning", `requested ref not found; fell back to the default branch (resolved: ${result.resolvedRef})`));
+	}
+	return lines.join("\n");
+}
+
+export function formatRepoCacheListResult(page: CachedRepositoryPage | undefined, theme: LectorTheme): string {
+	const count = page?.entries.length ?? 0;
+	return count === 0 ? theme.fg("dim", "no cached repositories") : theme.fg("success", `${count} cached repositor${count === 1 ? "y" : "ies"}`);
+}
+
+export function formatRepoCacheEvictResult(result: { evicted: boolean } | undefined, theme: LectorTheme): string {
+	if (!result) return theme.fg("dim", "No result.");
+	return result.evicted ? theme.fg("success", "evicted") : theme.fg("dim", "nothing cached for that reference");
+}

package/extension/src/repo-fetch-operations.ts

@@ -7,14 +7,14 @@ import { lectorClient } from "./lector-client.ts";
  * creates a new registered workspace from a fetched external repo.
  */
 export interface RepoFetchOperations {
-	fetch(host: string, owner: string, repo: string, ref: string | null): Promise<RepoFetchResult & { workspaceId: string }>;
+	fetch(host: string, owner: string, repo: string, ref: string | null, forceRefresh?: boolean): Promise<RepoFetchResult & { workspaceId: string }>;
 }
 
 export function createLectorRepoFetchOperations(): RepoFetchOperations {
 	return {
-		async fetch(host, owner, repo, ref) {
+		async fetch(host, owner, repo, ref, forceRefresh) {
 			const client = await lectorClient();
-			return client.call("repo.fetch", { host, owner, repo, ref });
+			return client.call("repo.fetch", { host, owner, repo, ref, forceRefresh });
 		},
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/pi-lector",
-	"version": "0.4.0",
+	"version": "0.6.0",
 	"description": "Pi host adapter for Lector: overrides read/write/edit with a daemon-backed, hash-guarded filesystem",
 	"license": "MIT",
 	"type": "module",
@@ -19,7 +19,7 @@
 	},
 	"dependencies": {
 		"@danypops/daemon-kit": "^0.22.1",
-		"@danypops/lector": "^0.5.0"
+		"@danypops/lector": "^0.7.0"
 	},
 	"devDependencies": {
 		"@earendil-works/pi-ai": "^0.81.1",

package/extension/src/repo-fetch-rendering.ts

@@ -1,21 +0,0 @@
-import type { RepoFetchResult } from "@danypops/lector";
-import type { LectorTheme } from "./lector-tui-theme.ts";
-
-export function formatRepoFetchCall(args: { owner?: unknown; repo?: unknown; ref?: unknown; host?: unknown }, theme: LectorTheme): string {
-	const host = typeof args.host === "string" && args.host.length > 0 ? args.host : "github.com";
-	const owner = typeof args.owner === "string" ? args.owner : "";
-	const repo = typeof args.repo === "string" ? args.repo : "";
-	const ref = typeof args.ref === "string" ? `@${args.ref}` : "";
-	return `${theme.fg("toolTitle", theme.bold("repo_fetch"))} ${theme.fg("accent", `${host}/${owner}/${repo}${ref}`)}`;
-}
-
-export function formatRepoFetchResult(result: (RepoFetchResult & { workspaceId: string }) | undefined, theme: LectorTheme): string {
-	if (!result) return theme.fg("dim", "No result.");
-	const lines = [
-		`${theme.fg("accent", result.workspaceId)} ${result.fromCache ? theme.fg("dim", "(from cache)") : theme.fg("toolTitle", "(fetched)")} -- ${result.path}`,
-	];
-	if (result.refFallbackOccurred) {
-		lines.push(theme.fg("warning", `requested ref not found; fell back to the default branch (resolved: ${result.resolvedRef})`));
-	}
-	return lines.join("\n");
-}