@tuan_son.dinh/gsd 2.6.3 → 2.7.0

package/packages/pi-coding-agent/src/utils/git.ts

@@ -0,0 +1,192 @@
+import hostedGitInfo from "hosted-git-info";
+
+/**
+ * Parsed git URL information.
+ */
+export type GitSource = {
+	/** Always "git" for git sources */
+	type: "git";
+	/** Clone URL (always valid for git clone, without ref suffix) */
+	repo: string;
+	/** Git host domain (e.g., "github.com") */
+	host: string;
+	/** Repository path (e.g., "user/repo") */
+	path: string;
+	/** Git ref (branch, tag, commit) if specified */
+	ref?: string;
+	/** True if ref was specified (package won't be auto-updated) */
+	pinned: boolean;
+};
+
+function splitRef(url: string): { repo: string; ref?: string } {
+	const scpLikeMatch = url.match(/^git@([^:]+):(.+)$/);
+	if (scpLikeMatch) {
+		const pathWithMaybeRef = scpLikeMatch[2] ?? "";
+		const refSeparator = pathWithMaybeRef.indexOf("@");
+		if (refSeparator < 0) return { repo: url };
+		const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+		const ref = pathWithMaybeRef.slice(refSeparator + 1);
+		if (!repoPath || !ref) return { repo: url };
+		return {
+			repo: `git@${scpLikeMatch[1] ?? ""}:${repoPath}`,
+			ref,
+		};
+	}
+
+	if (url.includes("://")) {
+		try {
+			const parsed = new URL(url);
+			const pathWithMaybeRef = parsed.pathname.replace(/^\/+/, "");
+			const refSeparator = pathWithMaybeRef.indexOf("@");
+			if (refSeparator < 0) return { repo: url };
+			const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+			const ref = pathWithMaybeRef.slice(refSeparator + 1);
+			if (!repoPath || !ref) return { repo: url };
+			parsed.pathname = `/${repoPath}`;
+			return {
+				repo: parsed.toString().replace(/\/$/, ""),
+				ref,
+			};
+		} catch {
+			return { repo: url };
+		}
+	}
+
+	const slashIndex = url.indexOf("/");
+	if (slashIndex < 0) {
+		return { repo: url };
+	}
+	const host = url.slice(0, slashIndex);
+	const pathWithMaybeRef = url.slice(slashIndex + 1);
+	const refSeparator = pathWithMaybeRef.indexOf("@");
+	if (refSeparator < 0) {
+		return { repo: url };
+	}
+	const repoPath = pathWithMaybeRef.slice(0, refSeparator);
+	const ref = pathWithMaybeRef.slice(refSeparator + 1);
+	if (!repoPath || !ref) {
+		return { repo: url };
+	}
+	return {
+		repo: `${host}/${repoPath}`,
+		ref,
+	};
+}
+
+function parseGenericGitUrl(url: string): GitSource | null {
+	const { repo: repoWithoutRef, ref } = splitRef(url);
+	let repo = repoWithoutRef;
+	let host = "";
+	let path = "";
+
+	const scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
+	if (scpLikeMatch) {
+		host = scpLikeMatch[1] ?? "";
+		path = scpLikeMatch[2] ?? "";
+	} else if (
+		repoWithoutRef.startsWith("https://") ||
+		repoWithoutRef.startsWith("http://") ||
+		repoWithoutRef.startsWith("ssh://") ||
+		repoWithoutRef.startsWith("git://")
+	) {
+		try {
+			const parsed = new URL(repoWithoutRef);
+			host = parsed.hostname;
+			path = parsed.pathname.replace(/^\/+/, "");
+		} catch {
+			return null;
+		}
+	} else {
+		const slashIndex = repoWithoutRef.indexOf("/");
+		if (slashIndex < 0) {
+			return null;
+		}
+		host = repoWithoutRef.slice(0, slashIndex);
+		path = repoWithoutRef.slice(slashIndex + 1);
+		if (!host.includes(".") && host !== "localhost") {
+			return null;
+		}
+		repo = `https://${repoWithoutRef}`;
+	}
+
+	const normalizedPath = path.replace(/\.git$/, "").replace(/^\/+/, "");
+	if (!host || !normalizedPath || normalizedPath.split("/").length < 2) {
+		return null;
+	}
+
+	return {
+		type: "git",
+		repo,
+		host,
+		path: normalizedPath,
+		ref,
+		pinned: Boolean(ref),
+	};
+}
+
+/**
+ * Parse git source into a GitSource.
+ *
+ * Rules:
+ * - With git: prefix, accept all historical shorthand forms.
+ * - Without git: prefix, only accept explicit protocol URLs.
+ */
+export function parseGitUrl(source: string): GitSource | null {
+	const trimmed = source.trim();
+	const hasGitPrefix = trimmed.startsWith("git:");
+	const url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
+
+	if (!hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(url)) {
+		return null;
+	}
+
+	const split = splitRef(url);
+
+	const hostedCandidates = [split.ref ? `${split.repo}#${split.ref}` : undefined, url].filter(
+		(value): value is string => Boolean(value),
+	);
+	for (const candidate of hostedCandidates) {
+		const info = hostedGitInfo.fromUrl(candidate);
+		if (info) {
+			if (split.ref && info.project?.includes("@")) {
+				continue;
+			}
+			const useHttpsPrefix =
+				!split.repo.startsWith("http://") &&
+				!split.repo.startsWith("https://") &&
+				!split.repo.startsWith("ssh://") &&
+				!split.repo.startsWith("git://") &&
+				!split.repo.startsWith("git@");
+			return {
+				type: "git",
+				repo: useHttpsPrefix ? `https://${split.repo}` : split.repo,
+				host: info.domain || "",
+				path: `${info.user}/${info.project}`.replace(/\.git$/, ""),
+				ref: info.committish || split.ref || undefined,
+				pinned: Boolean(info.committish || split.ref),
+			};
+		}
+	}
+
+	const httpsCandidates = [split.ref ? `https://${split.repo}#${split.ref}` : undefined, `https://${url}`].filter(
+		(value): value is string => Boolean(value),
+	);
+	for (const candidate of httpsCandidates) {
+		const info = hostedGitInfo.fromUrl(candidate);
+		if (info) {
+			if (split.ref && info.project?.includes("@")) {
+				continue;
+			}
+			return {
+				type: "git",
+				repo: `https://${split.repo}`,
+				host: info.domain || "",
+				path: `${info.user}/${info.project}`.replace(/\.git$/, ""),
+				ref: info.committish || split.ref || undefined,
+				pinned: Boolean(info.committish || split.ref),
+			};
+		}
+	}
+
+	return parseGenericGitUrl(url);
+}

package/packages/pi-coding-agent/src/utils/image-convert.ts

@@ -0,0 +1,38 @@
+import { loadPhoton } from "./photon.js";
+
+/**
+ * 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 };
+	}
+
+	const photon = await loadPhoton();
+	if (!photon) {
+		// Photon not available, can't convert
+		return null;
+	}
+
+	try {
+		const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
+		const image = photon.PhotonImage.new_from_byteslice(bytes);
+		try {
+			const pngBuffer = image.get_bytes();
+			return {
+				data: Buffer.from(pngBuffer).toString("base64"),
+				mimeType: "image/png",
+			};
+		} finally {
+			image.free();
+		}
+	} catch {
+		// Conversion failed
+		return null;
+	}
+}

package/packages/pi-coding-agent/src/utils/image-resize.ts

@@ -0,0 +1,231 @@
+import type { ImageContent } from "@gsd/pi-ai";
+import { loadPhoton } from "./photon.js";
+
+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: Uint8Array; mimeType: string },
+	b: { buffer: Uint8Array; mimeType: string },
+): { buffer: Uint8Array; 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 Photon (Rust/WASM) for image processing. If Photon is not available,
+ * 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 inputBuffer = Buffer.from(img.data, "base64");
+
+	const photon = await loadPhoton();
+	if (!photon) {
+		// Photon not available, return original image
+		return {
+			data: img.data,
+			mimeType: img.mimeType,
+			originalWidth: 0,
+			originalHeight: 0,
+			width: 0,
+			height: 0,
+			wasResized: false,
+		};
+	}
+
+	let image: ReturnType<typeof photon.PhotonImage.new_from_byteslice> | undefined;
+	try {
+		image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
+
+		const originalWidth = image.get_width();
+		const originalHeight = image.get_height();
+		const format = img.mimeType?.split("/")[1] ?? "png";
+
+		// Check if already within all limits (dimensions AND size)
+		const originalSize = inputBuffer.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
+		function tryBothFormats(
+			width: number,
+			height: number,
+			jpegQuality: number,
+		): { buffer: Uint8Array; mimeType: string } {
+			const resized = photon!.resize(image!, width, height, photon!.SamplingFilter.Lanczos3);
+
+			try {
+				const pngBuffer = resized.get_bytes();
+				const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
+
+				return pickSmaller(
+					{ buffer: pngBuffer, mimeType: "image/png" },
+					{ buffer: jpegBuffer, mimeType: "image/jpeg" },
+				);
+			} finally {
+				resized.free();
+			}
+		}
+
+		// 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: Uint8Array; mimeType: string };
+		let finalWidth = targetWidth;
+		let finalHeight = targetHeight;
+
+		// First attempt: resize to target dimensions, try both formats
+		best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+
+		if (best.buffer.length <= opts.maxBytes) {
+			return {
+				data: Buffer.from(best.buffer).toString("base64"),
+				mimeType: best.mimeType,
+				originalWidth,
+				originalHeight,
+				width: finalWidth,
+				height: finalHeight,
+				wasResized: true,
+			};
+		}
+
+		// Still too large - try JPEG with decreasing quality
+		for (const quality of qualitySteps) {
+			best = tryBothFormats(targetWidth, targetHeight, quality);
+
+			if (best.buffer.length <= opts.maxBytes) {
+				return {
+					data: Buffer.from(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);
+
+			if (finalWidth < 100 || finalHeight < 100) {
+				break;
+			}
+
+			for (const quality of qualitySteps) {
+				best = tryBothFormats(finalWidth, finalHeight, quality);
+
+				if (best.buffer.length <= opts.maxBytes) {
+					return {
+						data: Buffer.from(best.buffer).toString("base64"),
+						mimeType: best.mimeType,
+						originalWidth,
+						originalHeight,
+						width: finalWidth,
+						height: finalHeight,
+						wasResized: true,
+					};
+				}
+			}
+		}
+
+		// Last resort: return smallest version we produced
+		return {
+			data: Buffer.from(best.buffer).toString("base64"),
+			mimeType: best.mimeType,
+			originalWidth,
+			originalHeight,
+			width: finalWidth,
+			height: finalHeight,
+			wasResized: true,
+		};
+	} catch {
+		// Failed to load image
+		return {
+			data: img.data,
+			mimeType: img.mimeType,
+			originalWidth: 0,
+			originalHeight: 0,
+			width: 0,
+			height: 0,
+			wasResized: false,
+		};
+	} finally {
+		if (image) {
+			image.free();
+		}
+	}
+}
+
+/**
+ * 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/packages/pi-coding-agent/src/utils/mime.ts

@@ -0,0 +1,30 @@
+import { open } from "node:fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+
+const IMAGE_MIME_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+
+const FILE_TYPE_SNIFF_BYTES = 4100;
+
+export async function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null> {
+	const fileHandle = await open(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+		const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
+		if (bytesRead === 0) {
+			return null;
+		}
+
+		const fileType = await fileTypeFromBuffer(buffer.subarray(0, bytesRead));
+		if (!fileType) {
+			return null;
+		}
+
+		if (!IMAGE_MIME_TYPES.has(fileType.mime)) {
+			return null;
+		}
+
+		return fileType.mime;
+	} finally {
+		await fileHandle.close();
+	}
+}

package/packages/pi-coding-agent/src/utils/photon.ts

@@ -0,0 +1,139 @@
+/**
+ * Photon image processing wrapper.
+ *
+ * This module provides a unified interface to @silvia-odwyer/photon-node that works in:
+ * 1. Node.js (development, npm run build)
+ * 2. Bun compiled binaries (standalone distribution)
+ *
+ * The challenge: photon-node's CJS entry uses fs.readFileSync(__dirname + '/photon_rs_bg.wasm')
+ * which bakes the build machine's absolute path into Bun compiled binaries.
+ *
+ * Solution:
+ * 1. Patch fs.readFileSync to redirect missing photon_rs_bg.wasm reads
+ * 2. Copy photon_rs_bg.wasm next to the executable in build:binary
+ */
+
+import type { PathOrFileDescriptor } from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+const require = createRequire(import.meta.url);
+const fs = require("fs") as typeof import("fs");
+
+// Re-export types from the main package
+export type { PhotonImage as PhotonImageType } from "@silvia-odwyer/photon-node";
+
+type ReadFileSync = typeof fs.readFileSync;
+
+const WASM_FILENAME = "photon_rs_bg.wasm";
+
+// Lazy-loaded photon module
+let photonModule: typeof import("@silvia-odwyer/photon-node") | null = null;
+let loadPromise: Promise<typeof import("@silvia-odwyer/photon-node") | null> | null = null;
+
+function pathOrNull(file: PathOrFileDescriptor): string | null {
+	if (typeof file === "string") {
+		return file;
+	}
+	if (file instanceof URL) {
+		return fileURLToPath(file);
+	}
+	return null;
+}
+
+function getFallbackWasmPaths(): string[] {
+	const execDir = path.dirname(process.execPath);
+	return [
+		path.join(execDir, WASM_FILENAME),
+		path.join(execDir, "photon", WASM_FILENAME),
+		path.join(process.cwd(), WASM_FILENAME),
+	];
+}
+
+function patchPhotonWasmRead(): () => void {
+	const originalReadFileSync: ReadFileSync = fs.readFileSync.bind(fs);
+	const fallbackPaths = getFallbackWasmPaths();
+	const mutableFs = fs as { readFileSync: ReadFileSync };
+
+	const patchedReadFileSync: ReadFileSync = ((...args: Parameters<ReadFileSync>) => {
+		const [file, options] = args;
+		const resolvedPath = pathOrNull(file);
+
+		if (resolvedPath?.endsWith(WASM_FILENAME)) {
+			try {
+				return originalReadFileSync(...args);
+			} catch (error) {
+				const err = error as NodeJS.ErrnoException;
+				if (err?.code && err.code !== "ENOENT") {
+					throw error;
+				}
+
+				for (const fallbackPath of fallbackPaths) {
+					if (!fs.existsSync(fallbackPath)) {
+						continue;
+					}
+					if (options === undefined) {
+						return originalReadFileSync(fallbackPath);
+					}
+					return originalReadFileSync(fallbackPath, options);
+				}
+
+				throw error;
+			}
+		}
+
+		return originalReadFileSync(...args);
+	}) as ReadFileSync;
+
+	try {
+		mutableFs.readFileSync = patchedReadFileSync;
+	} catch {
+		Object.defineProperty(fs, "readFileSync", {
+			value: patchedReadFileSync,
+			writable: true,
+			configurable: true,
+		});
+	}
+
+	return () => {
+		try {
+			mutableFs.readFileSync = originalReadFileSync;
+		} catch {
+			Object.defineProperty(fs, "readFileSync", {
+				value: originalReadFileSync,
+				writable: true,
+				configurable: true,
+			});
+		}
+	};
+}
+
+/**
+ * Load the photon module asynchronously.
+ * Returns cached module on subsequent calls.
+ */
+export async function loadPhoton(): Promise<typeof import("@silvia-odwyer/photon-node") | null> {
+	if (photonModule) {
+		return photonModule;
+	}
+
+	if (loadPromise) {
+		return loadPromise;
+	}
+
+	loadPromise = (async () => {
+		const restoreReadFileSync = patchPhotonWasmRead();
+		try {
+			photonModule = await import("@silvia-odwyer/photon-node");
+			return photonModule;
+		} catch {
+			photonModule = null;
+			return photonModule;
+		} finally {
+			restoreReadFileSync();
+		}
+	})();
+
+	return loadPromise;
+}