@oh-my-pi/pi-coding-agent 13.11.0 → 13.12.0

package/src/utils/title-generator.ts

@@ -9,7 +9,6 @@ import type { ModelRegistry } from "../config/model-registry";
 import { resolveModelRoleValue } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
@@ -17,45 +16,28 @@ const TITLE_SYSTEM_PROMPT = renderPromptTemplate(titleSystemPrompt);
 
 const MAX_INPUT_CHARS = 2000;
 
-function getTitleModelCandidates(
+function getTitleModel(
 	registry: ModelRegistry,
 	settings: Settings,
-): Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> {
+	currentModel?: Model<Api>,
+): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
 	const availableModels = registry.getAvailable();
-	if (availableModels.length === 0) return [];
-
-	const candidates: Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> = [];
-	const addCandidate = (model?: Model<Api>, thinkingLevel?: ThinkingLevel): void => {
-		if (!model) return;
-		const exists = candidates.some(
-			candidate => candidate.model.provider === model.provider && candidate.model.id === model.id,
-		);
-		if (!exists) {
-			candidates.push({ model, thinkingLevel });
-		}
-	};
+	if (availableModels.length === 0) return undefined;
 
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
 	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
 		settings,
 		matchPreferences,
 	});
-	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
-
-	for (const pattern of MODEL_PRIO.smol) {
-		const needle = pattern.toLowerCase();
-		const exactMatch = availableModels.find(model => model.id.toLowerCase() === needle);
-		addCandidate(exactMatch);
-
-		const fuzzyMatch = availableModels.find(model => model.id.toLowerCase().includes(needle));
-		addCandidate(fuzzyMatch);
+	if (configuredSmol.model) {
+		return { model: configuredSmol.model, thinkingLevel: configuredSmol.thinkingLevel };
 	}
 
-	for (const model of availableModels) {
-		addCandidate(model);
+	if (currentModel) {
+		return { model: currentModel };
 	}
 
-	return candidates;
+	return undefined;
 }
 
 /**
@@ -71,10 +53,11 @@ export async function generateSessionTitle(
 	registry: ModelRegistry,
 	settings: Settings,
 	sessionId?: string,
+	currentModel?: Model<Api>,
 ): Promise<string | null> {
-	const candidates = getTitleModelCandidates(registry, settings);
-	if (candidates.length === 0) {
-		logger.debug("title-generator: no smol model found");
+	const candidate = getTitleModel(registry, settings, currentModel);
+	if (!candidate) {
+		logger.debug("title-generator: no title model found");
 		return null;
 	}
 
@@ -85,78 +68,73 @@ export async function generateSessionTitle(
 ${truncatedMessage}
 </user-message>`;
 
-	for (const candidate of candidates) {
-		const apiKey = await registry.getApiKey(candidate.model, sessionId);
-		if (!apiKey) {
-			logger.debug("title-generator: no API key for model", {
-				provider: candidate.model.provider,
-				id: candidate.model.id,
-			});
-			continue;
-		}
-
-		const request = {
-			model: `${candidate.model.provider}/${candidate.model.id}`,
-			systemPrompt: TITLE_SYSTEM_PROMPT,
-			userMessage,
-			maxTokens: 30,
-		};
-		logger.debug("title-generator: request", request);
-
-		try {
-			const response = await completeSimple(
-				candidate.model,
-				{
-					systemPrompt: request.systemPrompt,
-					messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
-				},
-				{
-					apiKey,
-					maxTokens: 30,
-					reasoning: toReasoningEffort(candidate.thinkingLevel),
-				},
-			);
-
-			if (response.stopReason === "error") {
-				logger.debug("title-generator: response error", {
-					model: request.model,
-					stopReason: response.stopReason,
-					errorMessage: response.errorMessage,
-				});
-				continue;
-			}
+	const apiKey = await registry.getApiKey(candidate.model, sessionId);
+	if (!apiKey) {
+		logger.debug("title-generator: no API key for smol model", {
+			provider: candidate.model.provider,
+			id: candidate.model.id,
+		});
+		return null;
+	}
 
-			// Extract title from response text content
-			let title = "";
-			for (const content of response.content) {
-				if (content.type === "text") {
-					title += content.text;
-				}
-			}
-			title = title.trim();
+	const request = {
+		model: `${candidate.model.provider}/${candidate.model.id}`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		userMessage,
+		maxTokens: 30,
+	};
+	logger.debug("title-generator: request", request);
+
+	try {
+		const response = await completeSimple(
+			candidate.model,
+			{
+				systemPrompt: request.systemPrompt,
+				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens: 30,
+				reasoning: toReasoningEffort(candidate.thinkingLevel),
+			},
+		);
 
-			logger.debug("title-generator: response", {
+		if (response.stopReason === "error") {
+			logger.debug("title-generator: response error", {
 				model: request.model,
-				title,
-				usage: response.usage,
 				stopReason: response.stopReason,
+				errorMessage: response.errorMessage,
 			});
+			return null;
+		}
 
-			if (!title) {
-				continue;
+		let title = "";
+		for (const content of response.content) {
+			if (content.type === "text") {
+				title += content.text;
 			}
+		}
+		title = title.trim();
 
-			// Clean up: remove quotes, trailing punctuation
-			return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
-		} catch (err) {
-			logger.debug("title-generator: error", {
-				model: request.model,
-				error: err instanceof Error ? err.message : String(err),
-			});
+		logger.debug("title-generator: response", {
+			model: request.model,
+			title,
+			usage: response.usage,
+			stopReason: response.stopReason,
+		});
+
+		if (!title) {
+			return null;
 		}
-	}
 
-	return null;
+		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+	} catch (err) {
+		logger.debug("title-generator: error", {
+			model: request.model,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
 }
 
 /**

package/src/utils/tools-manager.ts

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
 
 const TOOLS_DIR = getToolsDir();
-const TOOL_DOWNLOAD_TIMEOUT_MS = 15000;
+const TOOL_DOWNLOAD_TIMEOUT_MS = 120_000;
 const TOOL_METADATA_TIMEOUT_MS = 5000;
 
 interface ToolConfig {

package/src/web/scrapers/index.ts

@@ -85,17 +85,16 @@ export type { RenderResult, SpecialHandler } from "./types";
 export {
 	fetchGitHubApi,
 	handleArtifactHub,
-	handleDocsRs,
 	handleArxiv,
 	handleAur,
 	handleBiorxiv,
 	handleBluesky,
 	handleBrew,
 	handleCheatSh,
-	handleCisaKev,
 	handleChocolatey,
-	handleClojars,
 	handleChooseALicense,
+	handleCisaKev,
+	handleClojars,
 	handleCoinGecko,
 	handleCratesIo,
 	handleCrossref,
@@ -103,9 +102,10 @@ export {
 	handleDiscogs,
 	handleDiscourse,
 	handleDockerHub,
+	handleDocsRs,
 	handleFdroid,
-	handleFlathub,
 	handleFirefoxAddons,
+	handleFlathub,
 	handleGitHub,
 	handleGitHubGist,
 	handleGitLab,
@@ -129,8 +129,8 @@ export {
 	handleOllama,
 	handleOpenCorporates,
 	handleOpenLibrary,
-	handleOrcid,
 	handleOpenVsx,
+	handleOrcid,
 	handleOsv,
 	handlePackagist,
 	handlePubDev,
@@ -142,13 +142,13 @@ export {
 	handleRepology,
 	handleRfc,
 	handleRubyGems,
-	handleSecEdgar,
 	handleSearchcode,
+	handleSecEdgar,
 	handleSemanticScholar,
 	handleSnapcraft,
 	handleSourcegraph,
-	handleSpotify,
 	handleSpdx,
+	handleSpotify,
 	handleStackOverflow,
 	handleTerraform,
 	handleTldr,

package/src/web/scrapers/utils.ts

@@ -1,4 +1,5 @@
 import { isRecord, ptree, TempDir } from "@oh-my-pi/pi-utils";
+
 export { isRecord };
 
 import { ToolAbortError } from "../../tools/tool-errors";

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

@@ -0,0 +1,385 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { callExaTool, findApiKey as findExaKey, formatSearchResults, isSearchResponse } from "../../exa/mcp-client";
+import type { CustomToolResult, RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import {
+	formatCount,
+	formatExpandHint,
+	formatMoreItems,
+	formatStatusIcon,
+	replaceTabs,
+	truncateToWidth,
+} from "../../tools/render-utils";
+import { decodeHtmlEntities } from "../scrapers/types";
+import type { CodeSearchProviderId } from "./types";
+
+export interface CodeSearchToolParams {
+	query: string;
+	code_context?: string;
+}
+
+export interface CodeSearchSource {
+	title: string;
+	url: string;
+	repository: string;
+	path: string;
+	branch: string;
+	snippet?: string;
+	totalMatches?: string;
+}
+
+export interface CodeSearchResponse {
+	provider: CodeSearchProviderId;
+	query: string;
+	totalResults?: number;
+	sources: CodeSearchSource[];
+}
+
+export interface CodeSearchRenderDetails {
+	response?: CodeSearchResponse;
+	error?: string;
+	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);
+	if (payload === null || payload === undefined) return "";
+	const serialized = JSON.stringify(payload, null, 2);
+	return typeof serialized === "string" ? serialized : "";
+}
+
+function normalizeExaCodeSearchResponse(
+	params: CodeSearchToolParams,
+	payload: unknown,
+	formattedSearchResponse?: string,
+): CodeSearchResponse {
+	const snippet = formattedSearchResponse ?? stringifyExaCodeResponse(payload);
+	return {
+		provider: "exa",
+		query: params.query,
+		sources: [
+			{
+				title: params.query,
+				url: "https://exa.ai/",
+				repository: "exa",
+				path: "code-search",
+				branch: "public-mcp",
+				snippet: snippet.length > 0 ? snippet : undefined,
+			},
+		],
+	};
+}
+
+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 }
+		: { query: params.query };
+	const response = await callExaTool("get_code_context_exa", exaParams, findExaKey());
+	if (isSearchResponse(response)) {
+		return normalizeExaCodeSearchResponse(params, response, formatSearchResults(response));
+	}
+
+	return normalizeExaCodeSearchResponse(params, response);
+}
+
+export function formatCodeSearchForLlm(response: CodeSearchResponse): string {
+	const parts: string[] = [];
+	const summaryParts: string[] = [response.provider];
+	if (response.totalResults !== undefined) {
+		summaryParts.push(`${response.totalResults.toLocaleString()} total matches`);
+	}
+	parts.push(`Code search via ${summaryParts.join(" · ")}`);
+
+	if (response.sources.length === 0) {
+		parts.push("No results found.");
+		return parts.join("\n");
+	}
+
+	for (const [index, source] of response.sources.entries()) {
+		const metadata: string[] = [source.repository, source.path];
+		if (source.totalMatches) metadata.push(`${source.totalMatches} matches`);
+		parts.push(`[${index + 1}] ${metadata.join(" · ")}`);
+		parts.push(`    ${source.url}`);
+		if (source.snippet) {
+			for (const line of source.snippet.split("\n").slice(0, 8)) {
+				parts.push(`    ${line}`);
+			}
+		}
+	}
+
+	return parts.join("\n");
+}
+
+export async function executeCodeSearch(
+	params: CodeSearchToolParams,
+): Promise<CustomToolResult<CodeSearchRenderDetails>> {
+	try {
+		const response =
+			preferredCodeSearchProvider === "grep" ? await searchCodeWithGrep(params) : await searchCodeWithExa(params);
+
+		return {
+			content: [{ type: "text", text: formatCodeSearchForLlm(response) }],
+			details: { provider: response.provider, response },
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			content: [{ type: "text", text: `Error: ${message}` }],
+			details: { provider: preferredCodeSearchProvider, error: message },
+		};
+	}
+}
+
+export function renderCodeSearchCall(
+	args: CodeSearchToolParams,
+	_options: RenderResultOptions,
+	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))}`;
+	}
+	return new Text(text, 0, 0);
+}
+
+export function renderCodeSearchResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: CodeSearchRenderDetails },
+	options: RenderResultOptions,
+	uiTheme: Theme,
+): Component {
+	const details = result.details;
+	if (details?.error) {
+		return new Text(
+			`${formatStatusIcon("error", uiTheme)} ${uiTheme.fg("error", `Error: ${replaceTabs(details.error)}`)}`,
+			0,
+			0,
+		);
+	}
+
+	const response = details?.response;
+	if (!response) {
+		return new Text(`${formatStatusIcon("warning", uiTheme)} ${uiTheme.fg("muted", "No code search results")}`, 0, 0);
+	}
+
+	const resultCount = response.sources.length;
+	const meta: string[] = [formatCount("result", resultCount), `provider:${response.provider}`];
+	if (response.totalResults !== undefined) {
+		meta.push(`${response.totalResults.toLocaleString()} total`);
+	}
+	const expandHint = formatExpandHint(uiTheme, options.expanded, resultCount > 1);
+	let text = `${formatStatusIcon(resultCount > 0 ? "success" : "warning", uiTheme)} ${uiTheme.fg("dim", meta.join(uiTheme.sep.dot))}${expandHint}`;
+
+	if (resultCount === 0) {
+		text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", "No results")}`;
+		return new Text(text, 0, 0);
+	}
+
+	const visibleSources = options.expanded ? response.sources : response.sources.slice(0, 1);
+	for (const [index, source] of visibleSources.entries()) {
+		const isLast = index === visibleSources.length - 1;
+		const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+		const cont = isLast ? " " : uiTheme.tree.vertical;
+		text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", truncateToWidth(replaceTabs(source.title), 100))}`;
+		text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("mdLinkUrl", source.url)}`;
+
+		if (source.totalMatches) {
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `Matches: ${source.totalMatches}`)}`;
+		}
+
+		if (source.snippet) {
+			const snippetLines = source.snippet.split("\n").slice(0, options.expanded ? 6 : 3);
+			for (const line of snippetLines) {
+				text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
+					"toolOutput",
+					truncateToWidth(replaceTabs(line), 100),
+				)}`;
+			}
+		}
+	}
+
+	if (!options.expanded && response.sources.length > visibleSources.length) {
+		text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+			"muted",
+			formatMoreItems(response.sources.length - visibleSources.length, "result"),
+		)}`;
+	}
+
+	return new Text(text, 0, 0);
+}