@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.1

package/src/utils/image-resize.ts

@@ -1,11 +1,10 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { ImageFormat, PhotonImage, SamplingFilter } from "@oh-my-pi/pi-natives";
 
 export interface ImageResizeOptions {
-	maxWidth?: number; // Default: 1568
-	maxHeight?: number; // Default: 1568
-	maxBytes?: number; // Default: 500KB
-	jpegQuality?: number; // Default: 75
+	maxWidth?: number;
+	maxHeight?: number;
+	maxBytes?: number;
+	jpegQuality?: number;
 }
 
 export interface ResizedImage {
@@ -24,12 +23,12 @@ export interface ResizedImage {
 const DEFAULT_MAX_BYTES = 500 * 1024;
 
 const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
-	// 1568px — Anthropic downscales anything larger; OpenAI tiles at 768px;
-	// sending bigger pixels wastes bandwidth the model never sees.
+	// Anthropic's "internal recommended size" — Claude internally caps images at
+	// 1568px on the longest edge before vision processing.
 	maxWidth: 1568,
 	maxHeight: 1568,
 	maxBytes: DEFAULT_MAX_BYTES,
-	jpegQuality: 75,
+	jpegQuality: 80,
 };
 
 /** Pick the smallest of N encoded buffers. */
@@ -48,43 +47,34 @@ Buffer.prototype.toBase64 = function (this: Buffer) {
 /**
  * Resize and recompress an image to fit within the specified max dimensions and file size.
  *
- * Defaults target Anthropic's internal 1568px downscale threshold and produce small
- * lossy JPEG output suitable for tool-call payloads (~100–500KB typical).
- *
  * Strategy:
- * 1. Fast path — if input already fits dimensions AND is at <=25% of byte budget,
- *    return as-is. Avoids re-encoding tiny icons/diagrams.
- * 2. Resize to maxWidth/maxHeight, encode both PNG and JPEG at default quality,
- *    pick whichever is smaller. PNG wins for line art / few-color UI; JPEG wins
- *    for photographic content.
- * 3. If still too large, JPEG-only quality ladder (PNG quality is a no-op).
- * 4. If still too large, progressively reduce dimensions and retry the JPEG ladder.
- * 5. Last resort: ship the smallest variant produced.
+ *  1. Probe metadata. If already within all limits, return original.
+ *  2. Resize to fit max dimensions and encode at high quality across PNG/JPEG/WebP — return smallest.
+ *  3. If still too large, walk a lossy JPEG/WebP quality ladder.
+ *  4. If still too large, walk a dimension-scale ladder × quality ladder.
+ *  5. If still too large, return the smallest variant produced.
  *
- * On any decode failure, returns the original bytes unchanged with wasResized=false.
+ * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
+ * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
 export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const inputBuffer = Buffer.from(img.data, "base64");
 
 	try {
-		const image = await PhotonImage.parse(inputBuffer);
-
-		const originalWidth = image.width;
-		const originalHeight = image.height;
-		const format = img.mimeType?.split("/")[1] ?? "png";
+		const { width: originalWidth, height: originalHeight, format } = await new Bun.Image(inputBuffer).metadata();
+		const sourceMime = img.mimeType ?? `image/${format}`;
 
-		// Check if already within all limits (dimensions AND size)
-		const originalSize = inputBuffer.length;
-		// Fast path: skip if already within dimensions AND well under budget.
+		// Fast path: already within dimensions AND well under budget.
 		// Threshold is 1/4 of budget — if already that compact, don't re-encode.
 		// Avoids wasted work on tiny icons/diagrams while ensuring larger PNGs
 		// still get JPEG-compressed.
+		const originalSize = inputBuffer.length;
 		const comfortableSize = opts.maxBytes / 4;
 		if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= comfortableSize) {
 			return {
 				buffer: inputBuffer,
-				mimeType: img.mimeType ?? `image/${format}`,
+				mimeType: sourceMime,
 				originalWidth,
 				originalHeight,
 				width: originalWidth,
@@ -117,14 +107,11 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			height: number,
 			quality: number,
 		): Promise<{ buffer: Uint8Array; mimeType: string }> {
-			const resized = await image.resize(width, height, SamplingFilter.Lanczos3);
-
 			const [pngBuffer, jpegBuffer, webpBuffer] = await Promise.all([
-				resized.encode(ImageFormat.PNG, quality),
-				resized.encode(ImageFormat.JPEG, quality),
-				resized.encode(ImageFormat.WEBP, quality),
+				new Bun.Image(inputBuffer).resize(width, height).png().bytes(),
+				new Bun.Image(inputBuffer).resize(width, height).jpeg({ quality }).bytes(),
+				new Bun.Image(inputBuffer).resize(width, height).webp({ quality }).bytes(),
 			]);
-
 			return pickSmallest(
 				{ buffer: pngBuffer, mimeType: "image/png" },
 				{ buffer: jpegBuffer, mimeType: "image/jpeg" },
@@ -140,10 +127,9 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			height: number,
 			quality: number,
 		): Promise<{ buffer: Uint8Array; mimeType: string }> {
-			const resized = await image.resize(width, height, SamplingFilter.Lanczos3);
 			const [jpegBuffer, webpBuffer] = await Promise.all([
-				resized.encode(ImageFormat.JPEG, quality),
-				resized.encode(ImageFormat.WEBP, quality),
+				new Bun.Image(inputBuffer).resize(width, height).jpeg({ quality }).bytes(),
+				new Bun.Image(inputBuffer).resize(width, height).webp({ quality }).bytes(),
 			]);
 			return pickSmallest(
 				{ buffer: jpegBuffer, mimeType: "image/jpeg" },
@@ -159,7 +145,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		let finalWidth = targetWidth;
 		let finalHeight = targetHeight;
 
-		// First attempt: resize to target, try both PNG and JPEG, pick smaller
+		// First attempt: resize to target, try PNG/JPEG/WebP, pick smallest
 		best = await encodeSmallest(targetWidth, targetHeight, opts.jpegQuality);
 
 		if (best.buffer.length <= opts.maxBytes) {
@@ -264,9 +250,12 @@ export function formatDimensionNote(result: ResizedImage): string | undefined {
 	if (!result.wasResized) {
 		return undefined;
 	}
-
+	if (!result.originalWidth || !result.originalHeight || !result.width || !result.height) {
+		return undefined;
+	}
+	if (result.width === result.originalWidth && result.height === result.originalHeight) {
+		return undefined;
+	}
 	const scale = result.originalWidth / result.width;
-	return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${
-		result.height
-	}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+	return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
 }

package/src/vim/parser.ts

@@ -124,10 +124,6 @@ export function parseKeySequences(sequences: string[]): VimKeyToken[] {
 	return tokens;
 }
 
-export function tokensToReplay(tokens: readonly VimKeyToken[]): string[] {
-	return tokens.map(token => token.value);
-}
-
 export function replayTokens(values: readonly string[]): VimKeyToken[] {
 	return values.map((value, index) => ({
 		value,
@@ -136,16 +132,3 @@ export function replayTokens(values: readonly string[]): VimKeyToken[] {
 		offset: index,
 	}));
 }
-
-export function formatVimError(error: unknown): string {
-	if (!(error instanceof VimError)) {
-		return error instanceof Error ? error.message : String(error);
-	}
-
-	const base = error.message;
-	if (!error.location) {
-		return base;
-	}
-
-	return `${base} (sequence ${error.location.sequenceIndex + 1}, token ${error.location.offset + 1})`;
-}

package/src/vim/render.ts

@@ -13,7 +13,7 @@ import type {
 
 export const VIM_OPEN_VIEWPORT_LINES = 80;
 export const VIM_DEFAULT_VIEWPORT_LINES = 10;
-export const VIM_TAB_DISPLAY = "→";
+const VIM_TAB_DISPLAY = "→";
 const VIM_INLINE_CURSOR = "▏";
 
 const VIM_VIEWPORT_WIDTH = 140;

package/src/vim/types.ts

@@ -164,7 +164,7 @@ export function clonePosition(position: Position): Position {
 	return { line: position.line, col: position.col };
 }
 
-export function comparePositions(left: Position, right: Position): number {
+function comparePositions(left: Position, right: Position): number {
 	if (left.line !== right.line) {
 		return left.line - right.line;
 	}

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

@@ -5,15 +5,11 @@
  * Requires OAuth credentials stored in agent.db for provider "google-gemini-cli" or "google-antigravity".
  * Returns synthesized answers with citations and source metadata from grounding chunks.
  */
-import {
-	ANTIGRAVITY_SYSTEM_INSTRUCTION,
-	extractRetryDelay,
-	getAntigravityUserAgent,
-	getGeminiCliHeaders,
-} from "@oh-my-pi/pi-ai";
+import { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders } from "@oh-my-pi/pi-ai";
 import { refreshAntigravityToken } from "@oh-my-pi/pi-ai/utils/oauth/google-antigravity";
 import { refreshGoogleCloudToken } from "@oh-my-pi/pi-ai/utils/oauth/google-gemini-cli";
-import { getAgentDbPath } from "@oh-my-pi/pi-utils";
+import { fetchWithRetry, getAgentDbPath } from "@oh-my-pi/pi-utils";
+
 import { AgentStorage } from "../../../session/agent-storage";
 import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -303,98 +299,42 @@ async function callGeminiSearch(
 		}
 		(requestBody.request as Record<string, unknown>).generationConfig = generationConfig;
 	}
-	let response: Response | undefined;
-	let rateLimitTimeSpent = 0;
-	let lastError: Error | undefined;
-
-	for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex++) {
-		const url = `${endpoints[endpointIndex]}/v1internal:streamGenerateContent?alt=sse`;
-
-		for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-			try {
-				response = await fetch(url, {
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${auth.accessToken}`,
-						"Content-Type": "application/json",
-						Accept: "text/event-stream",
-						...headers,
-					},
-					body: JSON.stringify(requestBody),
-				});
-			} catch (error) {
-				if (attempt < MAX_RETRIES) {
-					await Bun.sleep(BASE_DELAY_MS * 2 ** attempt);
-					continue;
-				}
-
-				if (auth.isAntigravity && endpointIndex < endpoints.length - 1) {
-					break;
-				}
-
-				throw error;
-			}
-
-			if (response.ok) {
-				break;
-			}
-
-			const errorText = await response.text();
-			const canRefreshAuth =
-				response.status === 401 ||
-				response.status === 403 ||
-				(response.status === 400 &&
-					/api key not valid|invalid credentials|invalid authentication/i.test(errorText));
-			if (canRefreshAuth && attempt === 0 && (await refreshGeminiAuth(auth))) {
-				continue;
-			}
-			const isRetryableStatus =
-				response.status === 429 ||
-				response.status === 500 ||
-				response.status === 502 ||
-				response.status === 503 ||
-				response.status === 504;
-
-			if (isRetryableStatus && attempt < MAX_RETRIES) {
-				const serverDelay = extractRetryDelay(errorText, response);
-				if (response.status === 429) {
-					if (serverDelay && rateLimitTimeSpent + serverDelay <= RATE_LIMIT_BUDGET_MS) {
-						rateLimitTimeSpent += serverDelay;
-						await Bun.sleep(serverDelay);
-						continue;
-					}
-					if (!serverDelay) {
-						await Bun.sleep(BASE_DELAY_MS * 2 ** attempt);
-						continue;
-					}
-				} else {
-					await Bun.sleep(serverDelay ?? BASE_DELAY_MS * 2 ** attempt);
-					continue;
-				}
-			}
-
-			lastError = new SearchProviderError(
-				"gemini",
-				`Gemini Cloud Code API error (${response.status}): ${errorText}`,
-				response.status,
-			);
-
-			if (auth.isAntigravity && isRetryableStatus && endpointIndex < endpoints.length - 1) {
-				break;
-			}
-
-			throw lastError;
-		}
+	const buildInit = (): RequestInit => ({
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${auth.accessToken}`,
+			"Content-Type": "application/json",
+			Accept: "text/event-stream",
+			...headers,
+		},
+		body: JSON.stringify(requestBody),
+	});
+	const urlFor = (attempt: number) =>
+		`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`;
+
+	let response = await fetchWithRetry(urlFor, {
+		...buildInit(),
+		maxAttempts: MAX_RETRIES + 1,
+		defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
+		maxDelayMs: RATE_LIMIT_BUDGET_MS,
+	});
 
-		if (response?.ok) {
-			break;
+	if (!response.ok) {
+		const errorText = await response.clone().text();
+		const canRefreshAuth =
+			response.status === 401 ||
+			response.status === 403 ||
+			(response.status === 400 && /api key not valid|invalid credentials|invalid authentication/i.test(errorText));
+		if (canRefreshAuth && (await refreshGeminiAuth(auth))) {
+			response = await fetchWithRetry(urlFor, {
+				...buildInit(),
+				maxAttempts: MAX_RETRIES + 1,
+				defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
+				maxDelayMs: RATE_LIMIT_BUDGET_MS,
+			});
 		}
 	}
 
-	if (!response) {
-		throw new SearchProviderError("gemini", "Gemini API request failed", 500);
-	}
-
 	if (!response.ok) {
 		const errorText = await response.text();
 		throw new SearchProviderError(

package/src/prompts/tools/exit-plan-mode.md

@@ -1,6 +0,0 @@
-Submits a finalized implementation plan for user approval.
-
-Write the plan to `local://PLAN.md` first, then call this with `title` (e.g. `WP_MIGRATION_PLAN`); on approval the file is renamed to `local://<title>.md` and full tool access is restored.
-- Use only after planning implementation steps; not for pure research.
-- NEVER call before the plan file exists.
-- NEVER use `ask` to request plan approval — this tool does that.

package/src/tools/exit-plan-mode.ts

@@ -1,97 +0,0 @@
-import * as fs from "node:fs/promises";
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { isEnoent, prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
-import exitPlanModeDescription from "../prompts/tools/exit-plan-mode.md" with { type: "text" };
-import type { ToolSession } from ".";
-import { resolvePlanPath } from "./plan-mode-guard";
-import { ToolError } from "./tool-errors";
-
-const exitPlanModeSchema = Type.Object({
-	title: Type.String({ description: "final plan title", examples: ["WP_MIGRATION_PLAN"] }),
-});
-
-type ExitPlanModeParams = Static<typeof exitPlanModeSchema>;
-
-function normalizePlanTitle(title: string): { title: string; fileName: string } {
-	const trimmed = title.trim();
-	if (!trimmed) {
-		throw new ToolError("Title is required and must not be empty.");
-	}
-
-	if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("..")) {
-		throw new ToolError("Title must not contain path separators or '..'.");
-	}
-
-	const withExtension = trimmed.toLowerCase().endsWith(".md") ? trimmed : `${trimmed}.md`;
-	if (!/^[A-Za-z0-9_-]+\.md$/.test(withExtension)) {
-		throw new ToolError("Title may only contain letters, numbers, underscores, or hyphens.");
-	}
-
-	const normalizedTitle = withExtension.slice(0, -3);
-	return { title: normalizedTitle, fileName: withExtension };
-}
-
-export interface ExitPlanModeDetails {
-	planFilePath: string;
-	planExists: boolean;
-	title: string;
-	finalPlanFilePath: string;
-}
-
-export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, ExitPlanModeDetails> {
-	readonly name = "exit_plan_mode";
-	readonly label = "ExitPlanMode";
-	readonly description: string;
-	readonly parameters = exitPlanModeSchema;
-	readonly strict = true;
-	readonly concurrency = "exclusive";
-	readonly intent = (): string => "present plan";
-
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(exitPlanModeDescription);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: ExitPlanModeParams,
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<ExitPlanModeDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<ExitPlanModeDetails>> {
-		const state = this.session.getPlanModeState?.();
-		if (!state?.enabled) {
-			throw new ToolError("Plan mode is not active.");
-		}
-
-		const normalized = normalizePlanTitle(params.title);
-		const finalPlanFilePath = `local://${normalized.fileName}`;
-		const resolvedPlanPath = resolvePlanPath(this.session, state.planFilePath);
-		resolvePlanPath(this.session, finalPlanFilePath);
-		let planExists = false;
-		try {
-			const stat = await fs.stat(resolvedPlanPath);
-			planExists = stat.isFile();
-		} catch (error) {
-			if (!isEnoent(error)) {
-				throw error;
-			}
-		}
-
-		if (!planExists) {
-			throw new ToolError(
-				`Plan file not found at ${state.planFilePath}. Write the finalized plan to ${state.planFilePath} before calling exit_plan_mode.`,
-			);
-		}
-
-		return {
-			content: [{ type: "text", text: "Plan ready for approval." }],
-			details: {
-				planFilePath: state.planFilePath,
-				planExists,
-				title: normalized.title,
-				finalPlanFilePath,
-			},
-		};
-	}
-}

package/src/utils/fuzzy.ts

@@ -1,108 +0,0 @@
-// Fuzzy search. Matches if all query characters appear in order (not necessarily consecutive).
-// Lower score = better match.
-
-export interface FuzzyMatch {
-	matches: boolean;
-	score: number;
-}
-
-export function fuzzyMatch(query: string, text: string): FuzzyMatch {
-	const queryLower = query.toLowerCase();
-	const textLower = text.toLowerCase();
-
-	if (queryLower.length === 0) {
-		return { matches: true, score: 0 };
-	}
-
-	if (queryLower.length > textLower.length) {
-		return { matches: false, score: 0 };
-	}
-
-	let queryIndex = 0;
-	let score = 0;
-	let lastMatchIndex = -1;
-	let consecutiveMatches = 0;
-
-	for (let i = 0; i < textLower.length && queryIndex < queryLower.length; i++) {
-		if (textLower[i] === queryLower[queryIndex]) {
-			const isWordBoundary = i === 0 || /[\s\-_./]/.test(textLower[i - 1]!);
-
-			// Reward consecutive character matches (e.g., typing "foo" matches "foobar" better than "f_o_o")
-			if (lastMatchIndex === i - 1) {
-				consecutiveMatches++;
-				score -= consecutiveMatches * 5;
-			} else {
-				consecutiveMatches = 0;
-				// Penalize gaps between matched characters
-				if (lastMatchIndex >= 0) {
-					score += (i - lastMatchIndex - 1) * 2;
-				}
-			}
-
-			// Reward matches at word boundaries (start of words are more likely intentional targets)
-			if (isWordBoundary) {
-				score -= 10;
-			}
-
-			// Slight penalty for matches later in the string (prefer earlier matches)
-			score += i * 0.1;
-
-			lastMatchIndex = i;
-			queryIndex++;
-		}
-	}
-
-	// Not all query characters were found in order
-	if (queryIndex < queryLower.length) {
-		return { matches: false, score: 0 };
-	}
-
-	return { matches: true, score };
-}
-
-// Filter and sort items by fuzzy match quality (best matches first)
-// Supports space-separated tokens: all tokens must match, sorted by match count then score
-export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[] {
-	if (!query.trim()) {
-		return items;
-	}
-
-	// Split query into tokens
-	const tokens = query
-		.trim()
-		.split(/\s+/)
-		.filter(t => t.length > 0);
-
-	if (tokens.length === 0) {
-		return items;
-	}
-
-	const results: { item: T; totalScore: number }[] = [];
-
-	for (const item of items) {
-		const text = getText(item);
-		let totalScore = 0;
-		let allMatch = true;
-
-		// Check each token against the text - ALL must match
-		for (const token of tokens) {
-			const match = fuzzyMatch(token, text);
-			if (match.matches) {
-				totalScore += match.score;
-			} else {
-				allMatch = false;
-				break;
-			}
-		}
-
-		// Only include if all tokens match
-		if (allMatch) {
-			results.push({ item, totalScore });
-		}
-	}
-
-	// Sort by score (asc, lower is better)
-	results.sort((a, b) => a.totalScore - b.totalScore);
-
-	return results.map(r => r.item);
-}

package/src/utils/image-convert.ts

@@ -1,27 +0,0 @@
-import { ImageFormat, PhotonImage } from "@oh-my-pi/pi-natives";
-
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(
-	base64Data: string,
-	mimeType: string,
-): Promise<{ data: string; mimeType: string } | null> {
-	// Already PNG, no conversion needed
-	if (mimeType === "image/png") {
-		return { data: base64Data, mimeType };
-	}
-
-	try {
-		const image = await PhotonImage.parse(new Uint8Array(Buffer.from(base64Data, "base64")));
-		const pngBuffer = await image.encode(ImageFormat.PNG, 100);
-		return {
-			data: Buffer.from(pngBuffer).toBase64(),
-			mimeType: "image/png",
-		};
-	} catch {
-		// Conversion failed
-		return null;
-	}
-}