@oh-my-pi/pi-coding-agent 3.20.0 → 3.21.0

package/src/modes/interactive/interactive-mode.ts

@@ -6,8 +6,8 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import type { AssistantMessage, ImageContent, Message, OAuthProvider } from "@mariozechner/pi-ai";
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, ImageContent, Message, OAuthProvider } from "@oh-my-pi/pi-ai";
 import type { SlashCommand } from "@oh-my-pi/pi-tui";
 import {
 	CombinedAutocompleteProvider,
@@ -31,6 +31,7 @@ import { getRecentSessions, type SessionContext, SessionManager } from "../../co
 import { loadSlashCommands } from "../../core/slash-commands";
 import { detectNotificationProtocol, isNotificationSuppressed, sendNotification } from "../../core/terminal-notify";
 import { generateSessionTitle, setTerminalTitle } from "../../core/title-generator";
+import { setPreferredImageProvider, setPreferredWebSearchProvider } from "../../core/tools/index";
 import type { TruncationResult } from "../../core/tools/truncate";
 import { VoiceSupervisor } from "../../core/voice-supervisor";
 import { disableProvider, enableProvider } from "../../discovery";
@@ -1559,7 +1560,10 @@ export class InteractiveMode {
 			case "fileMention": {
 				// Render compact file mention display
 				for (const file of message.files) {
-					const text = `${theme.fg("dim", `${theme.tree.hook} `)}${theme.fg("muted", "Read")} ${theme.fg("accent", file.path)} ${theme.fg("dim", `(${file.lineCount} lines)`)}`;
+					const text = `${theme.fg("dim", `${theme.tree.hook} `)}${theme.fg("muted", "Read")} ${theme.fg(
+						"accent",
+						file.path,
+					)} ${theme.fg("dim", `(${file.lineCount} lines)`)}`;
 					this.chatContainer.addChild(new Text(text, 0, 0));
 				}
 				break;
@@ -2362,6 +2366,14 @@ export class InteractiveMode {
 				break;
 			}
 
+			// Provider settings - update runtime preferences
+			case "webSearchProvider":
+				setPreferredWebSearchProvider(value as "auto" | "exa" | "perplexity" | "anthropic");
+				break;
+			case "imageProvider":
+				setPreferredImageProvider(value as "auto" | "gemini" | "openrouter");
+				break;
+
 			// All other settings are handled by the definitions (get/set on SettingsManager)
 			// No additional side effects needed
 		}
@@ -2466,13 +2478,13 @@ export class InteractiveMode {
 						return;
 					}
 
-					// Ask about summarization
+					// Ask about summarization (or skip if disabled in settings)
 					done(); // Close selector first
 
-					const wantsSummary = await this.showHookConfirm(
-						"Summarize branch?",
-						"Create a summary of the branch you're leaving?",
-					);
+					const branchSummariesEnabled = this.settingsManager.getBranchSummaryEnabled();
+					const wantsSummary = branchSummariesEnabled
+						? await this.showHookConfirm("Summarize branch?", "Create a summary of the branch you're leaving?")
+						: false;
 
 					// Set up escape handler and loader if summarizing
 					let summaryLoader: Loader | undefined;

package/src/modes/print-mode.ts

@@ -6,7 +6,7 @@
  * - `omp --mode json "prompt"` - JSON event stream
  */
 
-import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent } from "@mariozechner/pi-ai";
 import type { AgentSession } from "../core/agent-session";
 
 /**

package/src/modes/rpc/rpc-client.ts

@@ -4,8 +4,8 @@
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
 
+import type { ImageContent } from "@mariozechner/pi-ai";
 import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { Subprocess } from "bun";
 import type { SessionStats } from "../../core/agent-session";
 import type { BashResult } from "../../core/bash-executor";

package/src/modes/rpc/rpc-types.ts

@@ -5,8 +5,8 @@
  * Responses and events are emitted as JSON lines on stdout.
  */
 
+import type { ImageContent, Model } from "@mariozechner/pi-ai";
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { SessionStats } from "../../core/agent-session";
 import type { BashResult } from "../../core/bash-executor";
 import type { CompactionResult } from "../../core/compaction/index";

package/src/prompts/system-prompt.md

@@ -15,6 +15,10 @@ Core behavior:
 - If a command fails due to sandboxing or needs elevated access, request approval and rerun.
 - Follow project validation/testing guidance; if checks are not run, suggest them in next steps.
 - Resolve blockers before yielding; do not guess.
+- Use tools to ground answers when external or deterministic info is needed; avoid speculation when a tool can verify.
+- Ask for missing or ambiguous tool parameters instead of guessing; confirm before actions.
+- Minimize tool calls and context usage by narrowing queries and summarizing only what is needed.
+- After each tool result, check relevance; iterate or clarify if results conflict or are insufficient.
 - Use concise, scannable responses; include file paths in backticks; use short bullets for multi-item lists; avoid dumping large files.
 
 Documentation:

package/src/prompts/tools/gemini-image.md

@@ -1,4 +1,8 @@
-Generate or edit images using Google Gemini image models ("Nano Banana").
+Generate or edit images using Gemini image models directly or via OpenRouter.
 
 Provide a text prompt and optional input images. Use response modalities to request image-only output,
 set aspect ratio or image size, and choose the model explicitly when needed.
+
+Prompt tips:
+- Describe subject, composition, style, and lighting in full sentences.
+- For edits, reference the input image and specify the exact changes.

package/src/prompts/tools/output.md

@@ -21,3 +21,7 @@ Do NOT use when:
   - `"raw"` (default): Full output with ANSI codes preserved
   - `"json"`: Structured object with metadata
   - `"stripped"`: Plain text with ANSI codes removed for parsing
+- `offset` (optional): Line number to start reading from (1-indexed)
+- `limit` (optional): Maximum number of lines to read
+
+Use offset/limit for line ranges to reduce context usage on large outputs.

package/src/prompts/tools/web-fetch.md

@@ -6,3 +6,4 @@ Use this tool when you need to:
 - Retrieve information from Stack Overflow, Wikipedia, Reddit, NPM, arXiv, or technical blogs
 - Access RSS/Atom feeds or JSON endpoints
 - Read PDF or DOCX files hosted at a URL
+- Use `raw: true` for untouched HTML or debugging

package/src/prompts/tools/web-search.md

@@ -3,6 +3,8 @@ Allows OMP to search the web and use the results to inform responses
 - Returns search result information formatted as search result blocks, including links as markdown hyperlinks
 - Use this tool for accessing information beyond Claude's knowledge cutoff
 - Searches are performed automatically within a single API call
+- Prefer primary sources (papers, official docs) and corroborate key claims with multiple sources
+- Include links for cited sources in the final response
 
 Common: system_prompt (guides response style)
 Anthropic-specific: max_tokens

package/src/utils/image-convert.ts

@@ -1,6 +1,9 @@
+import { convertToPngWithImageMagick } from "./image-magick.js";
+
 /**
  * Convert image to PNG format for terminal display.
  * Kitty graphics protocol requires PNG format (f=100).
+ * Uses sharp if available, falls back to ImageMagick (magick/convert).
  */
 export async function convertToPng(
 	base64Data: string,
@@ -11,6 +14,7 @@ export async function convertToPng(
 		return { data: base64Data, mimeType };
 	}
 
+	// Try sharp first
 	try {
 		const sharp = (await import("sharp")).default;
 		const buffer = Buffer.from(base64Data, "base64");
@@ -20,7 +24,9 @@ export async function convertToPng(
 			mimeType: "image/png",
 		};
 	} catch {
-		// Sharp not available or conversion failed
-		return null;
+		// Sharp not available, try ImageMagick fallback
 	}
+
+	// Fall back to ImageMagick
+	return convertToPngWithImageMagick(base64Data, mimeType);
 }

package/src/utils/image-magick.ts

@@ -0,0 +1,247 @@
+let imagemagickCommand: string | null | undefined;
+
+/**
+ * Detect available ImageMagick command.
+ * Returns "magick" (IM7) or "convert" (IM6) or null if unavailable.
+ */
+async function detectImageMagick(): Promise<string | null> {
+	if (imagemagickCommand !== undefined) {
+		return imagemagickCommand;
+	}
+
+	for (const cmd of ["magick", "convert"]) {
+		try {
+			const proc = Bun.spawn([cmd, "-version"], { stdout: "ignore", stderr: "ignore" });
+			const code = await proc.exited;
+			if (code === 0) {
+				imagemagickCommand = cmd;
+				return cmd;
+			}
+		} catch {}
+	}
+
+	imagemagickCommand = null;
+	return null;
+}
+
+/**
+ * Run ImageMagick command with buffer input/output.
+ */
+async function runImageMagick(cmd: string, args: string[], input: Buffer): Promise<Buffer> {
+	const proc = Bun.spawn([cmd, ...args], {
+		stdin: new Blob([input]),
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).arrayBuffer(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+
+	if (exitCode !== 0) {
+		throw new Error(`ImageMagick exited with code ${exitCode}: ${stderr}`);
+	}
+
+	return Buffer.from(stdout);
+}
+
+/**
+ * Convert image to PNG using ImageMagick.
+ * Returns null if ImageMagick is unavailable or conversion fails.
+ */
+export async function convertToPngWithImageMagick(
+	base64Data: string,
+	_mimeType: string,
+): Promise<{ data: string; mimeType: string } | null> {
+	const cmd = await detectImageMagick();
+	if (!cmd) {
+		return null;
+	}
+
+	try {
+		const input = Buffer.from(base64Data, "base64");
+		// "-" reads from stdin, "png:-" writes PNG to stdout
+		const output = await runImageMagick(cmd, ["-", "png:-"], input);
+		return {
+			data: output.toString("base64"),
+			mimeType: "image/png",
+		};
+	} catch {
+		return null;
+	}
+}
+
+export interface ImageMagickResizeResult {
+	data: string; // base64
+	mimeType: string;
+	width: number;
+	height: number;
+}
+
+/**
+ * Get image dimensions using ImageMagick identify.
+ */
+async function getImageDimensions(cmd: string, buffer: Buffer): Promise<{ width: number; height: number } | null> {
+	try {
+		// Use identify to get dimensions
+		const identifyCmd = cmd === "magick" ? "magick" : "identify";
+		const args = cmd === "magick" ? ["identify", "-format", "%w %h", "-"] : ["-format", "%w %h", "-"];
+
+		const output = await runImageMagick(identifyCmd, args, buffer);
+		const [w, h] = output.toString().trim().split(" ").map(Number);
+		if (Number.isFinite(w) && Number.isFinite(h)) {
+			return { width: w, height: h };
+		}
+	} catch {
+		// Fall through
+	}
+	return null;
+}
+
+/**
+ * Resize image using ImageMagick.
+ * Returns null if ImageMagick is unavailable or operation fails.
+ */
+export async function resizeWithImageMagick(
+	base64Data: string,
+	_mimeType: string,
+	maxWidth: number,
+	maxHeight: number,
+	maxBytes: number,
+	jpegQuality: number,
+): Promise<ImageMagickResizeResult | null> {
+	const cmd = await detectImageMagick();
+	if (!cmd) {
+		return null;
+	}
+
+	try {
+		const input = Buffer.from(base64Data, "base64");
+
+		// Get original dimensions
+		const dims = await getImageDimensions(cmd, input);
+		if (!dims) {
+			return null;
+		}
+
+		// Check if already within limits
+		if (dims.width <= maxWidth && dims.height <= maxHeight && input.length <= maxBytes) {
+			return null; // Signal caller to use original
+		}
+
+		// Calculate target dimensions maintaining aspect ratio
+		let targetWidth = dims.width;
+		let targetHeight = dims.height;
+
+		if (targetWidth > maxWidth) {
+			targetHeight = Math.round((targetHeight * maxWidth) / targetWidth);
+			targetWidth = maxWidth;
+		}
+		if (targetHeight > maxHeight) {
+			targetWidth = Math.round((targetWidth * maxHeight) / targetHeight);
+			targetHeight = maxHeight;
+		}
+
+		// Try PNG first, then JPEG with decreasing quality
+		const attempts: Array<{ args: string[]; mimeType: string }> = [
+			{ args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "png:-"], mimeType: "image/png" },
+			{
+				args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "-quality", String(jpegQuality), "jpeg:-"],
+				mimeType: "image/jpeg",
+			},
+		];
+
+		// Add lower quality JPEG attempts
+		for (const q of [70, 55, 40]) {
+			attempts.push({
+				args: ["-", "-resize", `${targetWidth}x${targetHeight}>`, "-quality", String(q), "jpeg:-"],
+				mimeType: "image/jpeg",
+			});
+		}
+
+		let best: { buffer: Buffer; mimeType: string } | null = null;
+
+		for (const attempt of attempts) {
+			try {
+				const output = await runImageMagick(cmd, attempt.args, input);
+				if (output.length <= maxBytes) {
+					return {
+						data: output.toString("base64"),
+						mimeType: attempt.mimeType,
+						width: targetWidth,
+						height: targetHeight,
+					};
+				}
+				if (!best || output.length < best.buffer.length) {
+					best = { buffer: output, mimeType: attempt.mimeType };
+				}
+			} catch {}
+		}
+
+		// Try progressively smaller dimensions
+		const scaleSteps = [0.75, 0.5, 0.35, 0.25];
+		for (const scale of scaleSteps) {
+			const scaledWidth = Math.round(targetWidth * scale);
+			const scaledHeight = Math.round(targetHeight * scale);
+
+			if (scaledWidth < 100 || scaledHeight < 100) break;
+
+			for (const q of [85, 70, 55, 40]) {
+				try {
+					const output = await runImageMagick(
+						cmd,
+						["-", "-resize", `${scaledWidth}x${scaledHeight}>`, "-quality", String(q), "jpeg:-"],
+						input,
+					);
+					if (output.length <= maxBytes) {
+						return {
+							data: output.toString("base64"),
+							mimeType: "image/jpeg",
+							width: scaledWidth,
+							height: scaledHeight,
+						};
+					}
+					if (!best || output.length < best.buffer.length) {
+						best = { buffer: output, mimeType: "image/jpeg" };
+					}
+				} catch {}
+			}
+		}
+
+		// Return best attempt even if over limit
+		if (best) {
+			return {
+				data: best.buffer.toString("base64"),
+				mimeType: best.mimeType,
+				width: targetWidth,
+				height: targetHeight,
+			};
+		}
+
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get image dimensions using ImageMagick.
+ * Returns null if ImageMagick is unavailable.
+ */
+export async function getImageDimensionsWithImageMagick(
+	base64Data: string,
+): Promise<{ width: number; height: number } | null> {
+	const cmd = await detectImageMagick();
+	if (!cmd) {
+		return null;
+	}
+
+	try {
+		const buffer = Buffer.from(base64Data, "base64");
+		return await getImageDimensions(cmd, buffer);
+	} catch {
+		return null;
+	}
+}

package/src/utils/image-resize.ts

@@ -1,4 +1,5 @@
-import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent } from "@mariozechner/pi-ai";
+import { getImageDimensionsWithImageMagick, resizeWithImageMagick } from "./image-magick.js";
 
 export interface ImageResizeOptions {
 	maxWidth?: number; // Default: 2000
@@ -27,6 +28,52 @@ const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
 	jpegQuality: 80,
 };
 
+/**
+ * Fallback resize using ImageMagick when sharp is unavailable.
+ */
+async function resizeImageWithImageMagick(
+	img: ImageContent,
+	opts: Required<ImageResizeOptions>,
+): Promise<ResizedImage> {
+	// Try to get dimensions first
+	const dims = await getImageDimensionsWithImageMagick(img.data);
+	const originalWidth = dims?.width ?? 0;
+	const originalHeight = dims?.height ?? 0;
+
+	// Try to resize
+	const result = await resizeWithImageMagick(
+		img.data,
+		img.mimeType,
+		opts.maxWidth,
+		opts.maxHeight,
+		opts.maxBytes,
+		opts.jpegQuality,
+	);
+
+	if (result) {
+		return {
+			data: result.data,
+			mimeType: result.mimeType,
+			originalWidth,
+			originalHeight,
+			width: result.width,
+			height: result.height,
+			wasResized: true,
+		};
+	}
+
+	// ImageMagick not available or resize not needed - return original
+	return {
+		data: img.data,
+		mimeType: img.mimeType,
+		originalWidth,
+		originalHeight,
+		width: originalWidth,
+		height: originalHeight,
+		wasResized: false,
+	};
+}
+
 /** Helper to pick the smaller of two buffers */
 function pickSmaller(
 	a: { buffer: Buffer; mimeType: string },
@@ -56,17 +103,8 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 	try {
 		sharp = (await import("sharp")).default;
 	} catch {
-		// Sharp not available - return original image
-		// We can't get dimensions without sharp, so return 0s
-		return {
-			data: img.data,
-			mimeType: img.mimeType,
-			originalWidth: 0,
-			originalHeight: 0,
-			width: 0,
-			height: 0,
-			wasResized: false,
-		};
+		// Sharp not available - try ImageMagick fallback
+		return resizeImageWithImageMagick(img, opts);
 	}
 
 	const sharpImg = sharp(buffer);
@@ -211,5 +249,7 @@ export function formatDimensionNote(result: ResizedImage): string | 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.]`;
 }