@oh-my-pi/pi-coding-agent 13.16.4 → 13.17.0

package/src/slash-commands/builtin-registry.ts

@@ -1,6 +1,20 @@
+import * as os from "node:os";
+import * as path from "node:path";
+
 import { getOAuthProviders } from "@oh-my-pi/pi-ai";
+import { getConfigDirName } from "@oh-my-pi/pi-utils";
+import { invalidate as invalidateFsCache } from "../capability/fs";
 import type { SettingPath, SettingValue } from "../config/settings";
 import { settings } from "../config/settings";
+import { clearClaudePluginRootsCache } from "../discovery/helpers.js";
+import { PluginManager } from "../extensibility/plugins";
+import {
+	getInstalledPluginsRegistryPath,
+	getMarketplacesCacheDir,
+	getMarketplacesRegistryPath,
+	getPluginsCacheDir,
+	MarketplaceManager,
+} from "../extensibility/plugins/marketplace";
 import type { InteractiveModeContext } from "../modes/types";
 
 function refreshStatusLine(ctx: InteractiveModeContext): void {
@@ -543,6 +557,265 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 		description: "Exit the application",
 		handle: shutdownHandler,
 	},
+	{
+		name: "marketplace",
+		description: "Manage marketplace plugin sources and installed plugins",
+		subcommands: [
+			{ name: "add", description: "Add a marketplace source", usage: "<source>" },
+			{ name: "remove", description: "Remove a marketplace source", usage: "<name>" },
+			{ name: "update", description: "Update marketplace catalog(s)", usage: "[name]" },
+			{ name: "list", description: "List configured marketplaces" },
+			{ name: "discover", description: "Browse available plugins", usage: "[marketplace]" },
+			{
+				name: "install",
+				description: "Install a plugin (interactive browser if no args)",
+				usage: "[--force] [name@marketplace]",
+			},
+			{ name: "uninstall", description: "Uninstall a plugin (selector if no args)", usage: "[name@marketplace]" },
+			{ name: "installed", description: "List installed marketplace plugins" },
+			{ name: "upgrade", description: "Upgrade outdated plugins", usage: "[name@marketplace]" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			const args = command.args.trim().split(/\s+/);
+			const sub = args[0] || "install";
+			const rest = args.slice(1).join(" ").trim();
+
+			// /marketplace (no args) or /marketplace install (no args) → interactive browser
+			if ((sub === "install" && !rest) || (!args[0] && !command.args.trim())) {
+				try {
+					runtime.ctx.showPluginSelector("install");
+				} catch (err) {
+					runtime.ctx.showStatus(`Marketplace error: ${err}`);
+				}
+				return;
+			}
+
+			const mgr = new MarketplaceManager({
+				marketplacesRegistryPath: getMarketplacesRegistryPath(),
+				installedRegistryPath: getInstalledPluginsRegistryPath(),
+				marketplacesCacheDir: getMarketplacesCacheDir(),
+				pluginsCacheDir: getPluginsCacheDir(),
+				clearPluginRootsCache: () => {
+					const home = os.homedir();
+					invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+					invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+					clearClaudePluginRootsCache();
+				},
+			});
+
+			try {
+				switch (sub) {
+					case "add": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /marketplace add <source>");
+							return;
+						}
+						const entry = await mgr.addMarketplace(rest);
+						runtime.ctx.showStatus(`Added marketplace: ${entry.name}`);
+						break;
+					}
+					case "remove":
+					case "rm": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /marketplace remove <name>");
+							return;
+						}
+						await mgr.removeMarketplace(rest);
+						runtime.ctx.showStatus(`Removed marketplace: ${rest}`);
+						break;
+					}
+					case "update": {
+						if (rest) {
+							await mgr.updateMarketplace(rest);
+							runtime.ctx.showStatus(`Updated marketplace: ${rest}`);
+						} else {
+							const results = await mgr.updateAllMarketplaces();
+							runtime.ctx.showStatus(`Updated ${results.length} marketplace(s)`);
+						}
+						break;
+					}
+					case "discover": {
+						const plugins = await mgr.listAvailablePlugins(rest || undefined);
+						if (plugins.length === 0) {
+							runtime.ctx.showStatus("No plugins available");
+						} else {
+							const lines = plugins.map(
+								p =>
+									`  ${p.name}${p.version ? `@${p.version}` : ""}${p.description ? ` - ${p.description}` : ""}`,
+							);
+							runtime.ctx.showStatus(`Available plugins:\n${lines.join("\n")}`);
+						}
+						break;
+					}
+					case "install": {
+						// Parse: /marketplace install [--force] name@marketplace
+						const force = rest.startsWith("--force ");
+						const installSpec = force ? rest.slice("--force ".length).trim() : rest;
+						if (!installSpec?.includes("@")) {
+							runtime.ctx.showStatus("Usage: /marketplace install [--force] <name@marketplace>");
+							return;
+						}
+						const atIdx = installSpec.lastIndexOf("@");
+						const name = installSpec.slice(0, atIdx);
+						const marketplace = installSpec.slice(atIdx + 1);
+						await mgr.installPlugin(name, marketplace, { force });
+						runtime.ctx.showStatus(`Installed ${name} from ${marketplace}`);
+						break;
+					}
+					case "uninstall": {
+						if (!rest) {
+							// No args → open interactive uninstall selector
+							runtime.ctx.showPluginSelector("uninstall");
+							return;
+						}
+						await mgr.uninstallPlugin(rest);
+						runtime.ctx.showStatus(`Uninstalled ${rest}`);
+						break;
+					}
+					case "installed": {
+						const installed = await mgr.listInstalledPlugins();
+						if (installed.length === 0) {
+							runtime.ctx.showStatus("No marketplace plugins installed");
+						} else {
+							const lines = installed.map(p => `  ${p.id} (${p.entries.length} entry)`);
+							runtime.ctx.showStatus(`Installed plugins:\n${lines.join("\n")}`);
+						}
+						break;
+					}
+					case "upgrade": {
+						if (rest) {
+							const result = await mgr.upgradePlugin(rest);
+							runtime.ctx.showStatus(`Upgraded ${rest} to ${result.version}`);
+						} else {
+							const results = await mgr.upgradeAllPlugins();
+							if (results.length === 0) {
+								runtime.ctx.showStatus("All marketplace plugins are up to date");
+							} else {
+								const lines = results.map(r => `  ${r.pluginId}: ${r.from} -> ${r.to}`);
+								runtime.ctx.showStatus(`Upgraded ${results.length} plugin(s):\n${lines.join("\n")}`);
+							}
+						}
+						break;
+					}
+					default: {
+						// Default to list marketplaces
+						const marketplaces = await mgr.listMarketplaces();
+						if (marketplaces.length === 0) {
+							runtime.ctx.showStatus("No marketplaces configured. Use /marketplace add <source>");
+						} else {
+							const lines = marketplaces.map(m => `  ${m.name}  ${m.sourceUri}`);
+							runtime.ctx.showStatus(`Marketplaces:\n${lines.join("\n")}`);
+						}
+						break;
+					}
+				}
+			} catch (err) {
+				runtime.ctx.showStatus(`Marketplace error: ${err}`);
+			}
+		},
+	},
+	{
+		name: "plugins",
+		description: "View and manage installed plugins",
+		subcommands: [
+			{ name: "list", description: "List all installed plugins (npm + marketplace)" },
+			{ name: "enable", description: "Enable a marketplace plugin", usage: "<name@marketplace>" },
+			{ name: "disable", description: "Disable a marketplace plugin", usage: "<name@marketplace>" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			const args = command.args.trim().split(/\s+/);
+			const sub = args[0] || "list";
+			const rest = args.slice(1).join(" ").trim();
+
+			try {
+				const mgr = new MarketplaceManager({
+					marketplacesRegistryPath: getMarketplacesRegistryPath(),
+					installedRegistryPath: getInstalledPluginsRegistryPath(),
+					marketplacesCacheDir: getMarketplacesCacheDir(),
+					pluginsCacheDir: getPluginsCacheDir(),
+					clearPluginRootsCache: () => {
+						const home = os.homedir();
+						invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+						invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+						clearClaudePluginRootsCache();
+					},
+				});
+
+				switch (sub) {
+					case "enable": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /plugins enable <name@marketplace>");
+							return;
+						}
+						await mgr.setPluginEnabled(rest, true);
+						runtime.ctx.showStatus(`Enabled ${rest}`);
+						break;
+					}
+					case "disable": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /plugins disable <name@marketplace>");
+							return;
+						}
+						await mgr.setPluginEnabled(rest, false);
+						runtime.ctx.showStatus(`Disabled ${rest}`);
+						break;
+					}
+					default: {
+						const lines: string[] = [];
+
+						const npm = new PluginManager();
+						const npmPlugins = await npm.list();
+						if (npmPlugins.length > 0) {
+							lines.push("npm plugins:");
+							for (const p of npmPlugins) {
+								const status = p.enabled === false ? " (disabled)" : "";
+								lines.push(`  ${p.name}@${p.version}${status}`);
+							}
+						}
+
+						const mktPlugins = await mgr.listInstalledPlugins();
+						if (mktPlugins.length > 0) {
+							if (lines.length > 0) lines.push("");
+							lines.push("marketplace plugins:");
+							for (const p of mktPlugins) {
+								const entry = p.entries[0];
+								const status = entry?.enabled === false ? " (disabled)" : "";
+								lines.push(`  ${p.id} v${entry?.version ?? "?"}${status}`);
+							}
+						}
+
+						if (lines.length === 0) {
+							runtime.ctx.showStatus("No plugins installed");
+						} else {
+							runtime.ctx.showStatus(lines.join("\n"));
+						}
+						break;
+					}
+				}
+			} catch (err) {
+				runtime.ctx.showStatus(`Plugin error: ${err}`);
+			}
+		},
+	},
+	{
+		name: "reload-plugins",
+		description: "Reload all plugins (skills, commands, hooks, tools, agents, MCP)",
+		handle: async (_command, runtime) => {
+			// Invalidate the fs content cache for both registry files so
+			// listClaudePluginRoots re-reads from disk on next access.
+			const home = os.homedir();
+			invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+			invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+			clearClaudePluginRootsCache();
+			await runtime.ctx.refreshSlashCommandState();
+			runtime.ctx.showStatus("Plugins reloaded.");
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "quit",
 		description: "Quit the application",

package/src/tools/bash-skill-urls.ts

@@ -40,19 +40,29 @@ export function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): st
 		throw new ToolError(`Invalid skill:// URL: ${url}`);
 	}
 
-	const skillName = parsed[1];
-	if (!skillName) {
+	let rawSkillSegment = parsed[1];
+	if (!rawSkillSegment) {
 		throw new ToolError(`skill:// URL requires a skill name: ${url}`);
 	}
+	// Decode percent-encoded colons (%3A) used for namespaced skill names
+	try {
+		rawSkillSegment = decodeURIComponent(rawSkillSegment);
+	} catch {
+		// Leave as-is if decoding fails
+	}
 
-	const rawPath = parsed[2] ?? "";
-	const skill = skills.find(s => s.name === skillName);
+	// Resolve skill name by longest-prefix match against registered skills.
+	// This handles namespaced skills ("plugin:skill") where the URI may also
+	// carry a colon-delimited suffix (e.g., ":1-5" line range).
+	const { skill, suffix } = matchSkillName(rawSkillSegment, skills);
 	if (!skill) {
 		const available = skills.map(s => s.name);
 		const availableStr = available.length > 0 ? available.join(", ") : "none";
-		throw new ToolError(`Unknown skill: ${skillName}. Available: ${availableStr}`);
+		throw new ToolError(`Unknown skill: ${rawSkillSegment}. Available: ${availableStr}`);
 	}
 
+	// Combine any colon suffix (line range like ":1-5") with the path segment
+	const rawPath = (parsed[2] ?? "") + (suffix ? `/${suffix}` : "");
 	const hasRelativePath = rawPath !== "" && rawPath !== "/";
 
 	if (!hasRelativePath) {
@@ -82,6 +92,39 @@ export function resolveSkillUrlToPath(url: string, skills: readonly Skill[]): st
 	return resolvedPath;
 }
 
+/**
+ * Match a raw skill segment against registered skills using longest-prefix match.
+ * Handles colons in both skill names (namespacing) and suffixes (line ranges).
+ *
+ * For "superpowers:brainstorming:1-5" with skill "superpowers:brainstorming":
+ *   -> skill = superpowers:brainstorming, suffix = "1-5"
+ * For "brainstorming" with skill "brainstorming":
+ *   -> skill = brainstorming, suffix = undefined
+ */
+function matchSkillName(
+	rawSegment: string,
+	skills: readonly Skill[],
+): { skill: Skill | undefined; suffix: string | undefined } {
+	// Exact match first (most common case)
+	const exact = skills.find(s => s.name === rawSegment);
+	if (exact) return { skill: exact, suffix: undefined };
+
+	// Try stripping colon-delimited suffixes from the right
+	let candidate = rawSegment;
+	while (true) {
+		const lastColon = candidate.lastIndexOf(":");
+		if (lastColon <= 0) break;
+		candidate = candidate.slice(0, lastColon);
+		const match = skills.find(s => s.name === candidate);
+		if (match) {
+			const suffix = rawSegment.slice(lastColon + 1);
+			return { skill: match, suffix };
+		}
+	}
+
+	return { skill: undefined, suffix: undefined };
+}
+
 function extractScheme(url: string): SupportedInternalScheme | undefined {
 	const match = /^([a-z][a-z0-9+.-]*):\/\//i.exec(url);
 	if (!match) return undefined;

package/src/tools/bash.ts

@@ -222,6 +222,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			asyncEnabled: this.#asyncEnabled,
 			hasAstGrep: this.session.settings.get("astGrep.enabled"),
 			hasAstEdit: this.session.settings.get("astEdit.enabled"),
+			hasGrep: this.session.settings.get("grep.enabled"),
+			hasFind: this.session.settings.get("find.enabled"),
 		});
 	}
 

package/src/tools/read.ts

@@ -9,6 +9,8 @@ import { getRemoteDir, ptree, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { parseInternalUrl } from "../internal-urls/parse";
+import type { InternalUrl } from "../internal-urls/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import { computeLineHash } from "../patch/hashline";
 import readDescription from "../prompts/tools/read.md" with { type: "text" };
@@ -686,18 +688,22 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
 		const internalRouter = this.session.internalRouter!;
 
-		// Check if URL has query extraction (agent:// only)
-		let parsed: URL;
+		// Check if URL has query extraction (agent:// only).
+		// Use parseInternalUrl which handles colons in host (namespaced skills).
+		let parsed: InternalUrl;
 		try {
-			parsed = new URL(url);
-		} catch {
-			throw new ToolError(`Invalid URL: ${url}`);
+			parsed = parseInternalUrl(url);
+		} catch (e) {
+			throw new ToolError(e instanceof Error ? e.message : String(e));
 		}
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
-		const hasPathExtraction = parsed.pathname && parsed.pathname !== "/" && parsed.pathname !== "";
-		const queryParam = parsed.searchParams.get("q");
-		const hasQueryExtraction = scheme === "agent" && queryParam !== null && queryParam !== "";
-		const hasExtraction = scheme === "agent" && (hasPathExtraction || hasQueryExtraction);
+		let hasExtraction = false;
+		if (scheme === "agent") {
+			const hasPathExtraction = parsed.pathname && parsed.pathname !== "/" && parsed.pathname !== "";
+			const queryParam = parsed.searchParams.get("q");
+			const hasQueryExtraction = queryParam !== null && queryParam !== "";
+			hasExtraction = hasPathExtraction || hasQueryExtraction;
+		}
 
 		// Reject offset/limit with query extraction
 		if (hasExtraction && (offset !== undefined || limit !== undefined)) {

package/src/web/search/code-search.ts

@@ -11,7 +11,6 @@ import {
 	replaceTabs,
 	truncateToWidth,
 } from "../../tools/render-utils";
-import { decodeHtmlEntities } from "../scrapers/types";
 import type { CodeSearchProviderId } from "./types";
 
 export interface CodeSearchToolParams {
@@ -42,25 +41,6 @@ export interface CodeSearchRenderDetails {
 	provider: CodeSearchProviderId;
 }
 
-interface GrepApiHit {
-	repo: string;
-	branch: string;
-	path: string;
-	contentSnippet?: string;
-	totalMatches?: string;
-}
-
-interface GrepApiResponse {
-	totalResults?: number;
-	hits: GrepApiHit[];
-}
-
-let preferredCodeSearchProvider: CodeSearchProviderId = "grep";
-
-export function setPreferredCodeSearchProvider(provider: CodeSearchProviderId): void {
-	preferredCodeSearchProvider = provider;
-}
-
 function stringifyExaCodeResponse(payload: unknown): string {
 	if (typeof payload === "string") return payload;
 	if (typeof payload === "number" || typeof payload === "boolean") return String(payload);
@@ -91,161 +71,6 @@ function normalizeExaCodeSearchResponse(
 	};
 }
 
-function getStringProperty(value: object, key: string): string | undefined {
-	const candidate = Reflect.get(value, key);
-	return typeof candidate === "string" ? candidate : undefined;
-}
-
-function getNumberProperty(value: object, key: string): number | undefined {
-	const candidate = Reflect.get(value, key);
-	return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : undefined;
-}
-
-function getObjectProperty(value: object, key: string): object | undefined {
-	const candidate = Reflect.get(value, key);
-	return typeof candidate === "object" && candidate !== null ? candidate : undefined;
-}
-
-function getArrayProperty(value: object, key: string): unknown[] | undefined {
-	const candidate = Reflect.get(value, key);
-	return Array.isArray(candidate) ? candidate : undefined;
-}
-
-function stripHtmlTags(value: string): string {
-	return value
-		.replace(/<br\s*\/?>/gi, "")
-		.replace(/<\/?mark>/gi, "")
-		.replace(/<span[^>]*>/gi, "")
-		.replace(/<\/span>/gi, "")
-		.replace(/<[^>]+>/g, "");
-}
-
-function formatGrepSnippet(snippetHtml: string | undefined): string | undefined {
-	if (!snippetHtml) return undefined;
-
-	const rowPattern = /<tr[^>]*data-line="(\d+)"[^>]*>[\s\S]*?<pre>([\s\S]*?)<\/pre>[\s\S]*?<\/tr>/gi;
-	const lines: string[] = [];
-
-	for (const match of snippetHtml.matchAll(rowPattern)) {
-		const lineNumber = match[1];
-		const rawCode = match[2] ?? "";
-		const text = decodeHtmlEntities(stripHtmlTags(rawCode)).trimEnd();
-		if (text.length === 0) continue;
-		lines.push(`${lineNumber}: ${text}`);
-	}
-
-	if (lines.length > 0) {
-		return lines.join("\n");
-	}
-
-	const plainText = decodeHtmlEntities(stripHtmlTags(snippetHtml)).replace(/\s+\n/g, "\n").trim();
-	return plainText.length > 0 ? plainText : undefined;
-}
-
-function parseGrepApiResponse(payload: unknown): GrepApiResponse | null {
-	if (typeof payload !== "object" || payload === null) return null;
-
-	const hitsObject = getObjectProperty(payload, "hits");
-	if (!hitsObject) return null;
-
-	const hitValues = getArrayProperty(hitsObject, "hits") ?? [];
-	const hits: GrepApiHit[] = [];
-	for (const item of hitValues) {
-		if (typeof item !== "object" || item === null) continue;
-		const repo = getStringProperty(item, "repo");
-		const branch = getStringProperty(item, "branch");
-		const path = getStringProperty(item, "path");
-		if (!repo || !branch || !path) continue;
-
-		const content = getObjectProperty(item, "content");
-		hits.push({
-			repo,
-			branch,
-			path,
-			contentSnippet: content ? getStringProperty(content, "snippet") : undefined,
-			totalMatches: getStringProperty(item, "total_matches"),
-		});
-	}
-	if (hitValues.length > 0 && hits.length === 0) return null;
-
-	return {
-		totalResults: getNumberProperty(hitsObject, "total"),
-		hits,
-	};
-}
-
-function buildGrepQuery(params: CodeSearchToolParams): string {
-	return params.query.trim();
-}
-
-function tokenizeCodeContext(codeContext: string | undefined): string[] {
-	if (!codeContext) return [];
-	return codeContext
-		.toLowerCase()
-		.split(/[^a-z0-9_./:-]+/i)
-		.filter(token => token.length >= 2);
-}
-
-function scoreGrepHit(hit: GrepApiHit, contextTokens: string[]): number {
-	if (contextTokens.length === 0) return 0;
-	const snippet = formatGrepSnippet(hit.contentSnippet)?.toLowerCase() ?? "";
-	const repo = hit.repo.toLowerCase();
-	const path = hit.path.toLowerCase();
-
-	let score = 0;
-	for (const token of contextTokens) {
-		if (repo.includes(token)) score += 4;
-		if (path.includes(token)) score += 3;
-		if (snippet.includes(token)) score += 2;
-	}
-
-	return score;
-}
-
-export async function searchCodeWithGrep(params: CodeSearchToolParams): Promise<CodeSearchResponse> {
-	const query = buildGrepQuery(params);
-	const url = new URL("https://grep.app/api/search");
-	url.searchParams.set("q", query);
-
-	const response = await fetch(url, {
-		headers: {
-			Accept: "application/json",
-			Referer: `https://grep.app/search?q=${encodeURIComponent(query)}`,
-		},
-	});
-
-	if (!response.ok) {
-		const message = await response.text();
-		throw new Error(`grep.app API error (${response.status}): ${message}`);
-	}
-
-	const payload: unknown = await response.json();
-	const parsed = parseGrepApiResponse(payload);
-	if (!parsed) {
-		throw new Error("grep.app returned an unexpected response shape.");
-	}
-
-	const contextTokens = tokenizeCodeContext(params.code_context);
-	const rankedHits = [...parsed.hits].sort(
-		(left, right) => scoreGrepHit(right, contextTokens) - scoreGrepHit(left, contextTokens),
-	);
-
-	return {
-		provider: "grep",
-		query,
-		totalResults: parsed.totalResults,
-		sources: rankedHits.map(hit => ({
-			title: `${hit.repo}/${hit.path}`,
-			url: `https://github.com/${hit.repo}/blob/${hit.branch}/${hit.path}`,
-			repository: hit.repo,
-			path: hit.path,
-			branch: hit.branch,
-			snippet: formatGrepSnippet(hit.contentSnippet),
-			totalMatches: hit.totalMatches,
-		})),
-	};
-}
-
 async function searchCodeWithExa(params: CodeSearchToolParams): Promise<CodeSearchResponse> {
 	const exaParams = params.code_context
 		? { query: params.query, code_context: params.code_context }
@@ -290,8 +115,7 @@ export async function executeCodeSearch(
 	params: CodeSearchToolParams,
 ): Promise<CustomToolResult<CodeSearchRenderDetails>> {
 	try {
-		const response =
-			preferredCodeSearchProvider === "grep" ? await searchCodeWithGrep(params) : await searchCodeWithExa(params);
+		const response = await searchCodeWithExa(params);
 
 		return {
 			content: [{ type: "text", text: formatCodeSearchForLlm(response) }],
@@ -301,7 +125,7 @@ export async function executeCodeSearch(
 		const message = error instanceof Error ? error.message : String(error);
 		return {
 			content: [{ type: "text", text: `Error: ${message}` }],
-			details: { provider: preferredCodeSearchProvider, error: message },
+			details: { provider: "exa", error: message },
 		};
 	}
 }
@@ -312,7 +136,6 @@ export function renderCodeSearchCall(
 	theme: Theme,
 ): Component {
 	let text = `${theme.fg("toolTitle", "Code Search")} ${theme.fg("accent", truncateToWidth(args.query, 80))}`;
-	text += ` ${theme.fg("muted", `provider:${preferredCodeSearchProvider}`)}`;
 	if (args.code_context) {
 		text += ` ${theme.fg("dim", truncateToWidth(args.code_context, 40))}`;
 	}

package/src/web/search/index.ts

@@ -4,7 +4,7 @@
  * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  *
- * Code search is also supported via the code_search tool, supports Exa and grep.app.
+ * Code search is also supported via the code_search tool.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
@@ -292,7 +292,6 @@ export function getSearchTools(): CustomTool<any, any>[] {
 	return [webSearchCustomTool, codeSearchTool];
 }
 
-export { setPreferredCodeSearchProvider } from "./code-search";
 export { getSearchProvider, setPreferredSearchProvider } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
-export { isCodeSearchProviderId, isSearchProviderPreference } from "./types";
+export { isSearchProviderPreference } from "./types";

package/src/web/search/types.ts

@@ -20,7 +20,7 @@ export type SearchProviderId =
 	| "kagi"
 	| "synthetic";
 
-export type CodeSearchProviderId = "grep" | "exa";
+export type CodeSearchProviderId = "exa";
 
 export function isSearchProviderId(value: string): value is SearchProviderId {
 	return [
@@ -44,10 +44,6 @@ export function isSearchProviderPreference(value: string): value is SearchProvid
 	return value === "auto" || isSearchProviderId(value);
 }
 
-export function isCodeSearchProviderId(value: string): value is CodeSearchProviderId {
-	return value === "grep" || value === "exa";
-}
-
 /** Source returned by search (all providers) */
 export interface SearchSource {
 	title: string;