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

package/src/utils/image-resize.ts

@@ -0,0 +1,215 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+
+export interface ImageResizeOptions {
+	maxWidth?: number; // Default: 2000
+	maxHeight?: number; // Default: 2000
+	maxBytes?: number; // Default: 4.5MB (below Anthropic's 5MB limit)
+	jpegQuality?: number; // Default: 80
+}
+
+export interface ResizedImage {
+	data: string; // base64
+	mimeType: string;
+	originalWidth: number;
+	originalHeight: number;
+	width: number;
+	height: number;
+	wasResized: boolean;
+}
+
+// 4.5MB - provides headroom below Anthropic's 5MB limit
+const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+
+const DEFAULT_OPTIONS: Required<ImageResizeOptions> = {
+	maxWidth: 2000,
+	maxHeight: 2000,
+	maxBytes: DEFAULT_MAX_BYTES,
+	jpegQuality: 80,
+};
+
+/** Helper to pick the smaller of two buffers */
+function pickSmaller(
+	a: { buffer: Buffer; mimeType: string },
+	b: { buffer: Buffer; mimeType: string },
+): { buffer: Buffer; mimeType: string } {
+	return a.buffer.length <= b.buffer.length ? a : b;
+}
+
+/**
+ * Resize an image to fit within the specified max dimensions and file size.
+ * Returns the original image if it already fits within the limits.
+ *
+ * Uses sharp for image processing. If sharp is not available (e.g., in some
+ * environments), returns the original image unchanged.
+ *
+ * Strategy for staying under maxBytes:
+ * 1. First resize to maxWidth/maxHeight
+ * 2. Try both PNG and JPEG formats, pick the smaller one
+ * 3. If still too large, try JPEG with decreasing quality
+ * 4. If still too large, progressively reduce dimensions
+ */
+export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+	const opts = { ...DEFAULT_OPTIONS, ...options };
+	const buffer = Buffer.from(img.data, "base64");
+
+	let sharp: typeof import("sharp") | undefined;
+	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,
+		};
+	}
+
+	const sharpImg = sharp(buffer);
+	const metadata = await sharpImg.metadata();
+
+	const originalWidth = metadata.width ?? 0;
+	const originalHeight = metadata.height ?? 0;
+	const format = metadata.format ?? img.mimeType?.split("/")[1] ?? "png";
+
+	// Check if already within all limits (dimensions AND size)
+	const originalSize = buffer.length;
+	if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= opts.maxBytes) {
+		return {
+			data: img.data,
+			mimeType: img.mimeType ?? `image/${format}`,
+			originalWidth,
+			originalHeight,
+			width: originalWidth,
+			height: originalHeight,
+			wasResized: false,
+		};
+	}
+
+	// Calculate initial dimensions respecting max limits
+	let targetWidth = originalWidth;
+	let targetHeight = originalHeight;
+
+	if (targetWidth > opts.maxWidth) {
+		targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
+		targetWidth = opts.maxWidth;
+	}
+	if (targetHeight > opts.maxHeight) {
+		targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
+		targetHeight = opts.maxHeight;
+	}
+
+	// Helper to resize and encode in both formats, returning the smaller one
+	async function tryBothFormats(
+		width: number,
+		height: number,
+		jpegQuality: number,
+	): Promise<{ buffer: Buffer; mimeType: string }> {
+		const resized = await sharp!(buffer)
+			.resize(width, height, { fit: "inside", withoutEnlargement: true })
+			.toBuffer();
+
+		const [pngBuffer, jpegBuffer] = await Promise.all([
+			sharp!(resized).png({ compressionLevel: 9 }).toBuffer(),
+			sharp!(resized).jpeg({ quality: jpegQuality }).toBuffer(),
+		]);
+
+		return pickSmaller({ buffer: pngBuffer, mimeType: "image/png" }, { buffer: jpegBuffer, mimeType: "image/jpeg" });
+	}
+
+	// Try to produce an image under maxBytes
+	const qualitySteps = [85, 70, 55, 40];
+	const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
+
+	let best: { buffer: Buffer; mimeType: string };
+	let finalWidth = targetWidth;
+	let finalHeight = targetHeight;
+
+	// First attempt: resize to target dimensions, try both formats
+	best = await tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+
+	if (best.buffer.length <= opts.maxBytes) {
+		return {
+			data: best.buffer.toString("base64"),
+			mimeType: best.mimeType,
+			originalWidth,
+			originalHeight,
+			width: finalWidth,
+			height: finalHeight,
+			wasResized: true,
+		};
+	}
+
+	// Still too large - try JPEG with decreasing quality (and compare to PNG each time)
+	for (const quality of qualitySteps) {
+		best = await tryBothFormats(targetWidth, targetHeight, quality);
+
+		if (best.buffer.length <= opts.maxBytes) {
+			return {
+				data: best.buffer.toString("base64"),
+				mimeType: best.mimeType,
+				originalWidth,
+				originalHeight,
+				width: finalWidth,
+				height: finalHeight,
+				wasResized: true,
+			};
+		}
+	}
+
+	// Still too large - reduce dimensions progressively
+	for (const scale of scaleSteps) {
+		finalWidth = Math.round(targetWidth * scale);
+		finalHeight = Math.round(targetHeight * scale);
+
+		// Skip if dimensions are too small
+		if (finalWidth < 100 || finalHeight < 100) {
+			break;
+		}
+
+		for (const quality of qualitySteps) {
+			best = await tryBothFormats(finalWidth, finalHeight, quality);
+
+			if (best.buffer.length <= opts.maxBytes) {
+				return {
+					data: best.buffer.toString("base64"),
+					mimeType: best.mimeType,
+					originalWidth,
+					originalHeight,
+					width: finalWidth,
+					height: finalHeight,
+					wasResized: true,
+				};
+			}
+		}
+	}
+
+	// Last resort: return smallest version we produced even if over limit
+	// (the API will reject it, but at least we tried everything)
+	return {
+		data: best.buffer.toString("base64"),
+		mimeType: best.mimeType,
+		originalWidth,
+		originalHeight,
+		width: finalWidth,
+		height: finalHeight,
+		wasResized: true,
+	};
+}
+
+/**
+ * Format a dimension note for resized images.
+ * This helps the model understand the coordinate mapping.
+ */
+export function formatDimensionNote(result: ResizedImage): string | undefined {
+	if (!result.wasResized) {
+		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.]`;
+}

package/src/utils/shell-snapshot.ts

@@ -6,7 +6,6 @@
  * shell experience.
  */
 
-import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -28,9 +27,11 @@ function getShellConfigFile(shell: string): string {
  * This script sources the user's rc file and extracts functions, aliases, and options.
  * Matches Claude Code's snapshot generation logic.
  */
-function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): string {
-	const hasRcFile = existsSync(rcFile);
+async function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): Promise<string> {
+	const hasRcFile = await Bun.file(rcFile).exists();
 	const isZsh = shell.includes("zsh");
+	const commonToolsRegex =
+		"^(ls|dir|vdir|cat|head|tail|less|more|grep|egrep|fgrep|rg|find|fd|locate|sed|awk|perl|cp|mv|rm|mkdir|rmdir|touch|chmod|chown|ln|pwd|readlink|stat|cut|sort|uniq|xargs|tee|tr|basename|dirname)$";
 
 	// Escape the snapshot path for shell
 	const escapedPath = snapshotPath.replace(/'/g, "'\\''");
@@ -42,7 +43,7 @@ echo "# Functions" >> "$SNAPSHOT_FILE"
 # Force autoload all functions first
 typeset -f > /dev/null 2>&1
 # Get user function names - filter system/private ones
-typeset +f 2>/dev/null | grep -vE '^(_|__)' | while read func; do
+typeset +f 2>/dev/null | grep -vE '^(_|__)' | grep -vE '${commonToolsRegex}' | while read func; do
    typeset -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
 done
 `
@@ -51,7 +52,7 @@ echo "# Functions" >> "$SNAPSHOT_FILE"
 # Force autoload all functions first
 declare -f > /dev/null 2>&1
 # Get user function names - filter system/private ones, use base64 for special chars
-declare -F 2>/dev/null | cut -d' ' -f3 | grep -vE '^(_|__)' | while read func; do
+declare -F 2>/dev/null | cut -d' ' -f3 | grep -vE '^(_|__)' | grep -vE '${commonToolsRegex}' | while read func; do
    encoded_func=$(declare -f "$func" | base64)
    echo "eval \\"\\$(echo '$encoded_func' | base64 -d)\\" > /dev/null 2>&1" >> "$SNAPSHOT_FILE"
 done
@@ -90,9 +91,9 @@ ${optionsScript}
 echo "# Aliases" >> "$SNAPSHOT_FILE"
 # Filter out winpty aliases on Windows to avoid "stdin is not a tty" errors
 if [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]]; then
-   alias 2>/dev/null | grep -v "='winpty " | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+   alias 2>/dev/null | grep -v "='winpty " | grep -vE '^alias (${commonToolsRegex})=' | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
 else
-   alias 2>/dev/null | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+   alias 2>/dev/null | grep -vE '^alias (${commonToolsRegex})=' | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
 fi
 
 # Export PATH
@@ -115,7 +116,7 @@ export async function getOrCreateSnapshot(
 	env: Record<string, string | undefined>,
 ): Promise<string | null> {
 	// Return cached snapshot if valid
-	if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+	if (cachedSnapshotPath && (await Bun.file(cachedSnapshotPath).exists())) {
 		return cachedSnapshotPath;
 	}
 
@@ -128,9 +129,8 @@ export async function getOrCreateSnapshot(
 
 	// Create snapshot directory
 	const snapshotDir = join(tmpdir(), "omp-shell-snapshots");
-	try {
-		mkdirSync(snapshotDir, { recursive: true });
-	} catch {
+	const mkdirProc = Bun.spawnSync(["mkdir", "-p", snapshotDir]);
+	if (mkdirProc.exitCode !== 0) {
 		return null;
 	}
 
@@ -141,7 +141,7 @@ export async function getOrCreateSnapshot(
 	const snapshotPath = join(snapshotDir, `snapshot-${shellName}-${timestamp}-${random}.sh`);
 
 	// Generate and execute snapshot script
-	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
+	const script = await generateSnapshotScript(shell, snapshotPath, rcFile);
 
 	try {
 		const result = Bun.spawnSync([shell, "-l", "-c", script], {
@@ -152,7 +152,7 @@ export async function getOrCreateSnapshot(
 			timeout: 10000, // 10 second timeout
 		});
 
-		if (result.exitCode === 0 && existsSync(snapshotPath)) {
+		if (result.exitCode === 0 && (await Bun.file(snapshotPath).exists())) {
 			cachedSnapshotPath = snapshotPath;
 			registerCleanup();
 			return snapshotPath;
@@ -182,17 +182,19 @@ function registerCleanup(): void {
 	if (cleanupRegistered) return;
 	cleanupRegistered = true;
 
-	const cleanup = () => {
-		if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+	const cleanup = async () => {
+		if (cachedSnapshotPath && (await Bun.file(cachedSnapshotPath).exists())) {
 			try {
-				unlinkSync(cachedSnapshotPath);
+				Bun.spawnSync(["rm", cachedSnapshotPath]);
 			} catch {
 				// Ignore cleanup errors
 			}
 		}
 	};
 
-	process.on("exit", cleanup);
+	process.on("exit", () => {
+		cleanup();
+	});
 	process.on("SIGINT", () => {
 		cleanup();
 		process.exit(130);
@@ -206,10 +208,10 @@ function registerCleanup(): void {
 /**
  * Clear the cached snapshot (for testing or forced refresh).
  */
-export function clearSnapshotCache(): void {
-	if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+export async function clearSnapshotCache(): Promise<void> {
+	if (cachedSnapshotPath && (await Bun.file(cachedSnapshotPath).exists())) {
 		try {
-			unlinkSync(cachedSnapshotPath);
+			Bun.spawnSync(["rm", cachedSnapshotPath]);
 		} catch {
 			// Ignore
 		}