pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/coding-agent/src/utils/fs-watch.ts

@@ -1,30 +0,0 @@
-import { type FSWatcher, type WatchListener, watch } from "node:fs";
-
-export const FS_WATCH_RETRY_DELAY_MS = 5000;
-
-export function closeWatcher(watcher: FSWatcher | null | undefined): void {
-	if (!watcher) {
-		return;
-	}
-
-	try {
-		watcher.close();
-	} catch {
-		// Ignore watcher close errors
-	}
-}
-
-export function watchWithErrorHandler(
-	path: string,
-	listener: WatchListener<string>,
-	onError: () => void,
-): FSWatcher | null {
-	try {
-		const watcher = watch(path, listener);
-		watcher.on("error", onError);
-		return watcher;
-	} catch {
-		onError();
-		return null;
-	}
-}

package/pi.dev-src/pi-mono/coding-agent/src/utils/git.ts

@@ -1,192 +0,0 @@
-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/pi.dev-src/pi-mono/coding-agent/src/utils/image-convert.ts

@@ -1,41 +0,0 @@
-import { applyExifOrientation } from "./exif-orientation.js";
-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 rawImage = photon.PhotonImage.new_from_byteslice(bytes);
-		const image = applyExifOrientation(photon, rawImage, bytes);
-		if (image !== rawImage) rawImage.free();
-		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/pi.dev-src/pi-mono/coding-agent/src/utils/image-resize.ts

@@ -1,176 +0,0 @@
-import type { ImageContent } from "@mariozechner/pi-ai";
-import { applyExifOrientation } from "./exif-orientation.js";
-import { loadPhoton } from "./photon.js";
-
-export interface ImageResizeOptions {
-	maxWidth?: number; // Default: 2000
-	maxHeight?: number; // Default: 2000
-	maxBytes?: number; // Default: 4.5MB of base64 payload (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 of base64 payload. 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,
-};
-
-interface EncodedCandidate {
-	data: string;
-	encodedSize: number;
-	mimeType: string;
-}
-
-function encodeCandidate(buffer: Uint8Array, mimeType: string): EncodedCandidate {
-	const data = Buffer.from(buffer).toString("base64");
-	return {
-		data,
-		encodedSize: Buffer.byteLength(data, "utf-8"),
-		mimeType,
-	};
-}
-
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Returns null if the image cannot be resized below maxBytes.
- *
- * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
- * returns null.
- *
- * 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 until 1x1
- */
-export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage | null> {
-	const opts = { ...DEFAULT_OPTIONS, ...options };
-	const inputBuffer = Buffer.from(img.data, "base64");
-	const inputBase64Size = Buffer.byteLength(img.data, "utf-8");
-
-	const photon = await loadPhoton();
-	if (!photon) {
-		return null;
-	}
-
-	let image: ReturnType<typeof photon.PhotonImage.new_from_byteslice> | undefined;
-	try {
-		const inputBytes = new Uint8Array(inputBuffer);
-		const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
-		image = applyExifOrientation(photon, rawImage, inputBytes);
-		if (image !== rawImage) rawImage.free();
-
-		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 encoded size)
-		if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < 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;
-		}
-
-		function tryEncodings(width: number, height: number, jpegQualities: number[]): EncodedCandidate[] {
-			const resized = photon!.resize(image!, width, height, photon!.SamplingFilter.Lanczos3);
-
-			try {
-				const candidates: EncodedCandidate[] = [encodeCandidate(resized.get_bytes(), "image/png")];
-				for (const quality of jpegQualities) {
-					candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
-				}
-				return candidates;
-			} finally {
-				resized.free();
-			}
-		}
-
-		const qualitySteps = Array.from(new Set([opts.jpegQuality, 85, 70, 55, 40]));
-		let currentWidth = targetWidth;
-		let currentHeight = targetHeight;
-
-		while (true) {
-			const candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
-			for (const candidate of candidates) {
-				if (candidate.encodedSize < opts.maxBytes) {
-					return {
-						data: candidate.data,
-						mimeType: candidate.mimeType,
-						originalWidth,
-						originalHeight,
-						width: currentWidth,
-						height: currentHeight,
-						wasResized: true,
-					};
-				}
-			}
-
-			if (currentWidth === 1 && currentHeight === 1) {
-				break;
-			}
-
-			const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
-			const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
-			if (nextWidth === currentWidth && nextHeight === currentHeight) {
-				break;
-			}
-
-			currentWidth = nextWidth;
-			currentHeight = nextHeight;
-		}
-
-		return null;
-	} catch {
-		return null;
-	} 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/pi.dev-src/pi-mono/coding-agent/src/utils/mime.ts

@@ -1,30 +0,0 @@
-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/pi.dev-src/pi-mono/coding-agent/src/utils/paths.ts

@@ -1,20 +0,0 @@
-/**
- * Returns true if the value is NOT a package source (npm:, git:, etc.)
- * or a URL protocol. Bare names and relative paths without ./ prefix
- * are considered local.
- */
-export function isLocalPath(value: string): boolean {
-	const trimmed = value.trim();
-	// Known non-local prefixes
-	if (
-		trimmed.startsWith("npm:") ||
-		trimmed.startsWith("git:") ||
-		trimmed.startsWith("github:") ||
-		trimmed.startsWith("http:") ||
-		trimmed.startsWith("https:") ||
-		trimmed.startsWith("ssh:")
-	) {
-		return false;
-	}
-	return true;
-}

package/pi.dev-src/pi-mono/coding-agent/src/utils/photon.ts

@@ -1,139 +0,0 @@
-/**
- * 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;
-}