@oh-my-pi/pi-coding-agent 13.2.1 → 13.3.0

package/src/utils/commit-message-generator.ts

@@ -0,0 +1,132 @@
+/**
+ * Generate commit messages from diffs using a smol, fast model.
+ * Follows the same pattern as title-generator.ts.
+ */
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { parseModelString } from "../config/model-resolver";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import MODEL_PRIO from "../priority.json" with { type: "json" };
+import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
+
+const COMMIT_SYSTEM_PROMPT = renderPromptTemplate(commitSystemPrompt);
+const MAX_DIFF_CHARS = 4000;
+
+/** File patterns that should be excluded from commit message generation diffs. */
+const NOISE_SUFFIXES = [".lock", ".lockb", "-lock.json", "-lock.yaml"];
+
+/** Strip diff hunks for noisy files that drown out real changes. */
+function filterDiffNoise(diff: string): string {
+	const lines = diff.split("\n");
+	const filtered: string[] = [];
+	let skip = false;
+	for (const line of lines) {
+		if (line.startsWith("diff --git ")) {
+			const bPath = line.split(" b/")[1];
+			skip = bPath != null && NOISE_SUFFIXES.some(s => bPath.endsWith(s));
+		}
+		if (!skip) filtered.push(line);
+	}
+	return filtered.join("\n");
+}
+
+function getSmolModelCandidates(registry: ModelRegistry, savedSmolModel?: string): Model<Api>[] {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return [];
+
+	const candidates: Model<Api>[] = [];
+	const addCandidate = (model?: Model<Api>): void => {
+		if (!model) return;
+		if (candidates.some(c => c.provider === model.provider && c.id === model.id)) return;
+		candidates.push(model);
+	};
+
+	if (savedSmolModel) {
+		const parsed = parseModelString(savedSmolModel);
+		if (parsed) {
+			const match = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+			addCandidate(match);
+		}
+	}
+
+	for (const pattern of MODEL_PRIO.smol) {
+		const needle = pattern.toLowerCase();
+		addCandidate(availableModels.find(m => m.id.toLowerCase() === needle));
+		addCandidate(availableModels.find(m => m.id.toLowerCase().includes(needle)));
+	}
+
+	for (const model of availableModels) {
+		addCandidate(model);
+	}
+
+	return candidates;
+}
+
+/**
+ * Generate a commit message from a unified diff.
+ * Returns null if generation fails (caller should fall back to generic message).
+ */
+export async function generateCommitMessage(
+	diff: string,
+	registry: ModelRegistry,
+	savedSmolModel?: string,
+	sessionId?: string,
+): Promise<string | null> {
+	const candidates = getSmolModelCandidates(registry, savedSmolModel);
+	if (candidates.length === 0) {
+		logger.debug("commit-msg-generator: no smol model found");
+		return null;
+	}
+
+	const cleanDiff = filterDiffNoise(diff);
+	const truncatedDiff =
+		cleanDiff.length > MAX_DIFF_CHARS ? `${cleanDiff.slice(0, MAX_DIFF_CHARS)}\n… (truncated)` : cleanDiff;
+	if (!truncatedDiff.trim()) {
+		logger.debug("commit-msg-generator: diff is empty after noise filtering");
+		return null;
+	}
+	const userMessage = `<diff>\n${truncatedDiff}\n</diff>`;
+
+	for (const model of candidates) {
+		const apiKey = await registry.getApiKey(model, sessionId);
+		if (!apiKey) continue;
+
+		try {
+			const response = await completeSimple(
+				model,
+				{
+					systemPrompt: COMMIT_SYSTEM_PROMPT,
+					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
+				},
+				{ apiKey, maxTokens: 60 },
+			);
+
+			if (response.stopReason === "error") {
+				logger.debug("commit-msg-generator: error", { model: model.id, error: response.errorMessage });
+				continue;
+			}
+
+			let msg = "";
+			for (const content of response.content) {
+				if (content.type === "text") msg += content.text;
+			}
+			msg = msg.trim();
+			if (!msg) continue;
+
+			// Clean up: remove wrapping quotes, backticks, trailing period
+			msg = msg.replace(/^[`"']|[`"']$/g, "").replace(/\.$/, "");
+
+			logger.debug("commit-msg-generator: generated", { model: model.id, msg });
+			return msg;
+		} catch (err) {
+			logger.debug("commit-msg-generator: error", {
+				model: model.id,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
+	}
+
+	return null;
+}

package/src/web/search/providers/exa.ts

@@ -3,6 +3,8 @@
  *
  * High-quality neural search via Exa Search API.
  * Returns structured search results with optional content extraction.
+ * Requests per-result summaries via `contents.summary` and synthesizes
+ * them into a combined `answer` string on the SearchResponse.
  */
 import { getEnvApiKey } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
@@ -34,6 +36,7 @@ interface ExaSearchResult {
 	publishedDate?: string | null;
 	text?: string | null;
 	highlights?: string[] | null;
+	summary?: string | null;
 }
 
 interface ExaSearchResponse {
@@ -44,18 +47,41 @@ interface ExaSearchResponse {
 	searchTime?: number;
 }
 
-function normalizeSearchType(type: ExaSearchParamType | undefined): ExaSearchType {
+export function normalizeSearchType(type: ExaSearchParamType | undefined): ExaSearchType {
 	if (!type) return "auto";
 	if (type === "keyword") return "fast";
 	return type;
 }
 
-/** Call Exa Search API */
-async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<ExaSearchResponse> {
+/** Maximum number of per-result summaries to include in the synthesized answer. */
+const MAX_ANSWER_SUMMARIES = 3;
+
+/**
+ * Synthesize an answer string from per-result summaries returned by Exa.
+ * Returns `undefined` when no non-empty summaries are available so callers
+ * can leave `SearchResponse.answer` unset (matching other providers).
+ */
+export function synthesizeAnswer(results: ExaSearchResult[]): string | undefined {
+	const parts: string[] = [];
+	for (const r of results) {
+		if (parts.length >= MAX_ANSWER_SUMMARIES) break;
+		const summary = r.summary?.trim();
+		if (!summary) continue;
+		const title = r.title?.trim() || r.url || "Untitled";
+		parts.push(`**${title}**: ${summary}`);
+	}
+	return parts.length > 0 ? parts.join("\n\n") : undefined;
+}
+
+/** Build the request body for `callExaSearch`. Exported for testing. */
+export function buildExaRequestBody(params: ExaSearchParams): Record<string, unknown> {
 	const body: Record<string, unknown> = {
 		query: params.query,
 		numResults: params.num_results ?? 10,
 		type: normalizeSearchType(params.type),
+		contents: {
+			summary: { query: params.query },
+		},
 	};
 
 	if (params.include_domains?.length) {
@@ -71,6 +97,13 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 		body.endPublishedDate = params.end_published_date;
 	}
 
+	return body;
+}
+
+/** Call Exa Search API */
+async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<ExaSearchResponse> {
+	const body = buildExaRequestBody(params);
+
 	const response = await fetch(EXA_API_URL, {
 		method: "POST",
 		headers: {
@@ -106,7 +139,7 @@ export async function searchExa(params: ExaSearchParams): Promise<SearchResponse
 			sources.push({
 				title: result.title ?? result.url,
 				url: result.url,
-				snippet: result.text ?? result.highlights?.join(" ") ?? undefined,
+				snippet: result.summary || result.text || result.highlights?.join(" ") || undefined,
 				publishedDate: result.publishedDate ?? undefined,
 				ageSeconds: dateToAgeSeconds(result.publishedDate ?? undefined),
 				author: result.author ?? undefined,
@@ -117,8 +150,12 @@ export async function searchExa(params: ExaSearchParams): Promise<SearchResponse
 	// Apply num_results limit if specified
 	const limitedSources = params.num_results ? sources.slice(0, params.num_results) : sources;
 
+	// Synthesize answer only from results that have a URL (same guard as sources loop)
+	const answer = response.results ? synthesizeAnswer(response.results.filter(r => !!r.url)) : undefined;
+
 	return {
 		provider: "exa",
+		answer,
 		sources: limitedSources,
 		requestId: response.requestId,
 	};

package/src/web/search/providers/perplexity.ts

@@ -1,13 +1,14 @@
 /**
  * Perplexity Web Search Provider
  *
- * Supports two auth modes:
- * - API key (`PERPLEXITY_API_KEY`) via `api.perplexity.ai/chat/completions`
+ * Supports three auth modes:
+ * - Cookies (`PERPLEXITY_COOKIES`) via `www.perplexity.ai/rest/sse/perplexity_ask`
  * - OAuth JWT (stored in `agent.db`) via `www.perplexity.ai/rest/sse/perplexity_ask`
+ * - API key (`PERPLEXITY_API_KEY`) via `api.perplexity.ai/chat/completions`
  */
 
 import { getEnvApiKey } from "@oh-my-pi/pi-ai";
-import { getAgentDbPath, readSseJson } from "@oh-my-pi/pi-utils";
+import { $env, getAgentDbPath, readSseJson } from "@oh-my-pi/pi-utils";
 import { AgentStorage } from "../../../session/agent-storage";
 import type {
 	PerplexityMessageOutput,
@@ -46,6 +47,10 @@ type PerplexityAuth =
 	| {
 			type: "oauth";
 			token: string;
+	  }
+	| {
+			type: "cookies";
+			cookies: string;
 	  };
 
 interface PerplexityOAuthStreamMarkdownBlock {
@@ -188,10 +193,17 @@ async function findOAuthToken(): Promise<string | null> {
 }
 
 async function findPerplexityAuth(): Promise<PerplexityAuth | null> {
+	// 1. PERPLEXITY_COOKIES env var
+	const cookies = $env.PERPLEXITY_COOKIES?.trim();
+	if (cookies) {
+		return { type: "cookies", cookies };
+	}
+	// 2. OAuth token from agent.db
 	const oauthToken = await findOAuthToken();
 	if (oauthToken) {
 		return { type: "oauth", token: oauthToken };
 	}
+	// 3. PERPLEXITY_API_KEY env var
 	const apiKey = findApiKey();
 	if (apiKey) {
 		return { type: "api_key", token: apiKey };
@@ -289,7 +301,7 @@ function buildOAuthAnswer(event: PerplexityOAuthStreamEvent): string {
 }
 
 async function callPerplexityOAuth(
-	oauthToken: string,
+	auth: { type: "oauth"; token: string } | { type: "cookies"; cookies: string },
 	params: PerplexitySearchParams,
 ): Promise<{ answer: string; sources: SearchSource[]; model?: string; requestId?: string }> {
 	const requestId = crypto.randomUUID();
@@ -298,7 +310,7 @@ async function callPerplexityOAuth(
 	const response = await fetch(PERPLEXITY_OAUTH_ASK_URL, {
 		method: "POST",
 		headers: {
-			Authorization: `Bearer ${oauthToken}`,
+			...(auth.type === "cookies" ? { Cookie: auth.cookies } : { Authorization: `Bearer ${auth.token}` }),
 			"Content-Type": "application/json",
 			Accept: "text/event-stream",
 			Origin: "https://www.perplexity.ai",
@@ -455,11 +467,11 @@ function applySourceLimit(result: SearchResponse, limit?: number): SearchRespons
 export async function searchPerplexity(params: PerplexitySearchParams): Promise<SearchResponse> {
 	const auth = await findPerplexityAuth();
 	if (!auth) {
-		throw new Error("Perplexity auth not found. Set PERPLEXITY_API_KEY or login via OAuth.");
+		throw new Error("Perplexity auth not found. Set PERPLEXITY_COOKIES, PERPLEXITY_API_KEY, or login via OAuth.");
 	}
 
-	if (auth.type === "oauth") {
-		const oauthResult = await callPerplexityOAuth(auth.token, params);
+	if (auth.type === "oauth" || auth.type === "cookies") {
+		const oauthResult = await callPerplexityOAuth(auth, params);
 		return applySourceLimit(
 			{
 				provider: "perplexity",