@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/utils/frontmatter.ts

@@ -1,117 +0,0 @@
-import { logger, truncate } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
-
-function stripHtmlComments(content: string): string {
-	return content.replace(/<!--[\s\S]*?-->/g, "");
-}
-
-/** Convert kebab-case to camelCase (e.g. "thinking-level" -> "thinkingLevel") */
-function kebabToCamel(key: string): string {
-	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/** Recursively normalize object keys from kebab-case to camelCase */
-function normalizeKeys<T>(obj: T): T {
-	if (obj === null || typeof obj !== "object") {
-		return obj;
-	}
-	if (Array.isArray(obj)) {
-		return obj.map(normalizeKeys) as T;
-	}
-	const result: Record<string, unknown> = {};
-	for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-		const normalizedKey = kebabToCamel(key);
-		result[normalizedKey] = normalizeKeys(value);
-	}
-	return result as T;
-}
-
-export class FrontmatterError extends Error {
-	constructor(
-		error: Error,
-		readonly source?: unknown,
-	) {
-		super(`Failed to parse YAML frontmatter (${source}): ${error.message}`, { cause: error });
-		this.name = "FrontmatterError";
-	}
-
-	toString(): string {
-		// Format the error with stack and detail, including the error message, stack, and source if present
-		const details: string[] = [this.message];
-		if (this.source !== undefined) {
-			details.push(`Source: ${JSON.stringify(this.source)}`);
-		}
-		if (this.cause && typeof this.cause === "object" && "stack" in this.cause && this.cause.stack) {
-			details.push(`Stack:\n${this.cause.stack}`);
-		} else if (this.stack) {
-			details.push(`Stack:\n${this.stack}`);
-		}
-		return details.join("\n\n");
-	}
-}
-
-export interface FrontmatterOptions {
-	/** Source of the content (alias: source) */
-	location?: unknown;
-	/** Source of the content (alias for location) */
-	source?: unknown;
-	/** Fallback frontmatter values */
-	fallback?: Record<string, unknown>;
-	/** Normalize the content */
-	normalize?: boolean;
-	/** Level of error handling */
-	level?: "off" | "warn" | "fatal";
-}
-
-/**
- * Parse YAML frontmatter from markdown content
- * Returns { frontmatter, body } where body has frontmatter stripped
- */
-export function parseFrontmatter(
-	content: string,
-	options?: FrontmatterOptions,
-): { frontmatter: Record<string, unknown>; body: string } {
-	const { location, source, fallback, normalize = true, level = "warn" } = options ?? {};
-	const loc = location ?? source;
-	const frontmatter: Record<string, unknown> = { ...fallback };
-
-	const normalized = normalize ? stripHtmlComments(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n")) : content;
-	if (!normalized.startsWith("---")) {
-		return { frontmatter, body: normalized };
-	}
-
-	const endIndex = normalized.indexOf("\n---", 3);
-	if (endIndex === -1) {
-		return { frontmatter, body: normalized };
-	}
-
-	const metadata = normalized.slice(4, endIndex);
-	const body = normalized.slice(endIndex + 4).trim();
-
-	try {
-		// Replace tabs with spaces for YAML compatibility, use failsafe mode for robustness
-		const loaded = YAML.parse(metadata.replaceAll("\t", "  ")) as Record<string, unknown> | null;
-		return { frontmatter: normalizeKeys({ ...frontmatter, ...loaded }), body };
-	} catch (error) {
-		const err = new FrontmatterError(
-			error instanceof Error ? error : new Error(`YAML: ${error}`),
-			loc ?? `Inline '${truncate(content, 64)}'`,
-		);
-		if (level === "warn" || level === "fatal") {
-			logger.warn("Failed to parse YAML frontmatter", { err: err.toString() });
-		}
-		if (level === "fatal") {
-			throw err;
-		}
-
-		// Simple YAML parsing - just key: value pairs
-		for (const line of metadata.split("\n")) {
-			const match = line.match(/^([\w-]+):\s*(.*)$/);
-			if (match) {
-				frontmatter[match[1]] = match[2].trim();
-			}
-		}
-
-		return { frontmatter: normalizeKeys(frontmatter) as Record<string, unknown>, body };
-	}
-}

package/src/utils/image-input.ts

@@ -1,274 +0,0 @@
-import * as fs from "node:fs/promises";
-import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { formatBytes } from "@oh-my-pi/pi-utils";
-import { resolveReadPath } from "../tools/path-utils";
-import { convertToPng } from "./image-convert";
-import { formatDimensionNote, resizeImage } from "./image-resize";
-import { detectSupportedImageMimeTypeFromFile } from "./mime";
-
-export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
-const MAX_IMAGE_METADATA_HEADER_BYTES = 256 * 1024;
-export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-export interface ImageMetadata {
-	mimeType: string;
-	bytes: number;
-	width?: number;
-	height?: number;
-	channels?: number;
-	hasAlpha?: boolean;
-}
-
-export interface LoadedImageInput {
-	resolvedPath: string;
-	mimeType: string;
-	data: string;
-	textNote: string;
-	dimensionNote?: string;
-	bytes: number;
-}
-
-export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
-	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
-		return image;
-	}
-	const converted = await convertToPng(image.data, image.mimeType);
-	return converted ? { type: "image", data: converted.data, mimeType: converted.mimeType } : null;
-}
-
-export interface ReadImageMetadataOptions {
-	path: string;
-	cwd: string;
-	resolvedPath?: string;
-	detectedMimeType?: string;
-}
-
-export interface LoadImageInputOptions extends ReadImageMetadataOptions {
-	autoResize: boolean;
-	maxBytes?: number;
-}
-
-export class ImageInputTooLargeError extends Error {
-	readonly bytes: number;
-	readonly maxBytes: number;
-
-	constructor(bytes: number, maxBytes: number) {
-		super(`Image file too large: ${formatBytes(bytes)} exceeds ${formatBytes(maxBytes)} limit.`);
-		this.name = "ImageInputTooLargeError";
-		this.bytes = bytes;
-		this.maxBytes = maxBytes;
-	}
-}
-
-interface ParsedImageHeaderMetadata {
-	width?: number;
-	height?: number;
-	channels?: number;
-	hasAlpha?: boolean;
-}
-
-function parsePngMetadata(header: Buffer): ParsedImageHeaderMetadata {
-	if (header.length < 26) return {};
-	if (
-		header[0] !== 0x89 ||
-		header[1] !== 0x50 ||
-		header[2] !== 0x4e ||
-		header[3] !== 0x47 ||
-		header[4] !== 0x0d ||
-		header[5] !== 0x0a ||
-		header[6] !== 0x1a ||
-		header[7] !== 0x0a
-	) {
-		return {};
-	}
-	if (header.slice(12, 16).toString("ascii") !== "IHDR") return {};
-	const width = header.readUInt32BE(16);
-	const height = header.readUInt32BE(20);
-	const colorType = header[25];
-	if (colorType === 0) return { width, height, channels: 1, hasAlpha: false };
-	if (colorType === 2) return { width, height, channels: 3, hasAlpha: false };
-	if (colorType === 3) return { width, height, channels: 3 };
-	if (colorType === 4) return { width, height, channels: 2, hasAlpha: true };
-	if (colorType === 6) return { width, height, channels: 4, hasAlpha: true };
-	return { width, height };
-}
-
-function parseJpegMetadata(header: Buffer): ParsedImageHeaderMetadata {
-	if (header.length < 4) return {};
-	if (header[0] !== 0xff || header[1] !== 0xd8) return {};
-
-	let offset = 2;
-	while (offset + 9 < header.length) {
-		if (header[offset] !== 0xff) {
-			offset += 1;
-			continue;
-		}
-
-		let markerOffset = offset + 1;
-		while (markerOffset < header.length && header[markerOffset] === 0xff) {
-			markerOffset += 1;
-		}
-		if (markerOffset >= header.length) break;
-
-		const marker = header[markerOffset];
-		const segmentOffset = markerOffset + 1;
-
-		if (marker === 0xd8 || marker === 0xd9 || marker === 0x01) {
-			offset = segmentOffset;
-			continue;
-		}
-		if (marker >= 0xd0 && marker <= 0xd7) {
-			offset = segmentOffset;
-			continue;
-		}
-		if (segmentOffset + 1 >= header.length) break;
-
-		const segmentLength = header.readUInt16BE(segmentOffset);
-		if (segmentLength < 2) break;
-
-		const isStartOfFrame = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
-		if (isStartOfFrame) {
-			if (segmentOffset + 7 >= header.length) break;
-			const height = header.readUInt16BE(segmentOffset + 3);
-			const width = header.readUInt16BE(segmentOffset + 5);
-			const channels = header[segmentOffset + 7];
-			return {
-				width,
-				height,
-				channels: Number.isFinite(channels) ? channels : undefined,
-				hasAlpha: false,
-			};
-		}
-
-		offset = segmentOffset + segmentLength;
-	}
-
-	return {};
-}
-
-function parseGifMetadata(header: Buffer): ParsedImageHeaderMetadata {
-	if (header.length < 10) return {};
-	const signature = header.slice(0, 6).toString("ascii");
-	if (signature !== "GIF87a" && signature !== "GIF89a") return {};
-	return {
-		width: header.readUInt16LE(6),
-		height: header.readUInt16LE(8),
-		channels: 3,
-	};
-}
-
-function parseWebpMetadata(header: Buffer): ParsedImageHeaderMetadata {
-	if (header.length < 30) return {};
-	if (header.slice(0, 4).toString("ascii") !== "RIFF") return {};
-	if (header.slice(8, 12).toString("ascii") !== "WEBP") return {};
-
-	const chunkType = header.slice(12, 16).toString("ascii");
-	if (chunkType === "VP8X") {
-		const hasAlpha = (header[20] & 0x10) !== 0;
-		const width = (header[24] | (header[25] << 8) | (header[26] << 16)) + 1;
-		const height = (header[27] | (header[28] << 8) | (header[29] << 16)) + 1;
-		return { width, height, channels: hasAlpha ? 4 : 3, hasAlpha };
-	}
-	if (chunkType === "VP8L") {
-		if (header.length < 25) return {};
-		const bits = header.readUInt32LE(21);
-		const width = (bits & 0x3fff) + 1;
-		const height = ((bits >> 14) & 0x3fff) + 1;
-		const hasAlpha = ((bits >> 28) & 0x1) === 1;
-		return { width, height, channels: hasAlpha ? 4 : 3, hasAlpha };
-	}
-	if (chunkType === "VP8 ") {
-		const width = header.readUInt16LE(26) & 0x3fff;
-		const height = header.readUInt16LE(28) & 0x3fff;
-		return { width, height, channels: 3, hasAlpha: false };
-	}
-	return {};
-}
-
-function parseImageHeaderMetadata(header: Buffer, mimeType: string): ParsedImageHeaderMetadata {
-	if (mimeType === "image/png") return parsePngMetadata(header);
-	if (mimeType === "image/jpeg") return parseJpegMetadata(header);
-	if (mimeType === "image/gif") return parseGifMetadata(header);
-	if (mimeType === "image/webp") return parseWebpMetadata(header);
-	return {};
-}
-
-async function readHeader(filePath: string, maxBytes: number): Promise<Buffer> {
-	if (maxBytes <= 0) return Buffer.alloc(0);
-	const fileHandle = await fs.open(filePath, "r");
-	try {
-		const buffer = Buffer.allocUnsafe(maxBytes);
-		const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
-		return buffer.subarray(0, bytesRead);
-	} finally {
-		await fileHandle.close();
-	}
-}
-
-export async function readImageMetadata(options: ReadImageMetadataOptions): Promise<ImageMetadata | null> {
-	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
-	const mimeType = options.detectedMimeType ?? (await detectSupportedImageMimeTypeFromFile(resolvedPath));
-	if (!mimeType) return null;
-
-	const stats = await Bun.file(resolvedPath).stat();
-	const bytes = stats.size;
-	const headerBytes = Math.max(0, Math.min(bytes, MAX_IMAGE_METADATA_HEADER_BYTES));
-	const header = await readHeader(resolvedPath, headerBytes);
-	const parsed = parseImageHeaderMetadata(header, mimeType);
-
-	return {
-		mimeType,
-		bytes,
-		width: parsed.width,
-		height: parsed.height,
-		channels: parsed.channels,
-		hasAlpha: parsed.hasAlpha,
-	};
-}
-
-export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
-	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
-	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
-	const mimeType = options.detectedMimeType ?? (await detectSupportedImageMimeTypeFromFile(resolvedPath));
-	if (!mimeType) return null;
-
-	const stat = await Bun.file(resolvedPath).stat();
-	if (stat.size > maxBytes) {
-		throw new ImageInputTooLargeError(stat.size, maxBytes);
-	}
-
-	const inputBuffer = await fs.readFile(resolvedPath);
-	if (inputBuffer.byteLength > maxBytes) {
-		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
-	}
-
-	let outputData = Buffer.from(inputBuffer).toBase64();
-	let outputMimeType = mimeType;
-	let outputBytes = inputBuffer.byteLength;
-	let dimensionNote: string | undefined;
-
-	if (options.autoResize) {
-		try {
-			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
-			outputData = resized.data;
-			outputMimeType = resized.mimeType;
-			outputBytes = resized.buffer.byteLength;
-			dimensionNote = formatDimensionNote(resized);
-		} catch {
-			// keep original image when resize fails
-		}
-	}
-
-	let textNote = `Read image file [${outputMimeType}]`;
-	if (dimensionNote) {
-		textNote += `\n${dimensionNote}`;
-	}
-
-	return {
-		resolvedPath,
-		mimeType: outputMimeType,
-		data: outputData,
-		textNote,
-		dimensionNote,
-		bytes: outputBytes,
-	};
-}

package/src/utils/mime.ts

@@ -1,53 +0,0 @@
-import * as fs from "node:fs/promises";
-
-const FILE_TYPE_SNIFF_BYTES = 12;
-
-function detectMimeFromBytes(buf: Buffer, bytesRead: number): string | null {
-	if (bytesRead >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
-		return "image/jpeg";
-	}
-	if (
-		bytesRead >= 8 &&
-		buf[0] === 0x89 &&
-		buf[1] === 0x50 &&
-		buf[2] === 0x4e &&
-		buf[3] === 0x47 &&
-		buf[4] === 0x0d &&
-		buf[5] === 0x0a &&
-		buf[6] === 0x1a &&
-		buf[7] === 0x0a
-	) {
-		return "image/png";
-	}
-	if (bytesRead >= 4 && buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x38) {
-		return "image/gif";
-	}
-	if (
-		bytesRead >= 12 &&
-		buf[0] === 0x52 &&
-		buf[1] === 0x49 &&
-		buf[2] === 0x46 &&
-		buf[3] === 0x46 &&
-		buf[8] === 0x57 &&
-		buf[9] === 0x45 &&
-		buf[10] === 0x42 &&
-		buf[11] === 0x50
-	) {
-		return "image/webp";
-	}
-	return null;
-}
-
-export async function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null> {
-	const fileHandle = await fs.open(filePath, "r");
-	try {
-		const buffer = Buffer.allocUnsafe(FILE_TYPE_SNIFF_BYTES);
-		const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
-		if (bytesRead === 0) {
-			return null;
-		}
-		return detectMimeFromBytes(buffer, bytesRead);
-	} finally {
-		await fileHandle.close();
-	}
-}

package/src/utils/prompt-format.ts

@@ -1,170 +0,0 @@
-export type PromptRenderPhase = "pre-render" | "post-render";
-
-export interface PromptFormatOptions {
-	renderPhase?: PromptRenderPhase;
-	replaceAsciiSymbols?: boolean;
-	boldRfc2119Keywords?: boolean;
-}
-
-// Opening XML tag (not self-closing, not closing)
-const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
-// Closing XML tag
-const CLOSING_XML = /^<\/([a-z_-]+)>$/;
-// Handlebars block start: {{#if}}, {{#has}}, {{#list}}, etc.
-const OPENING_HBS = /^\{\{#/;
-// Handlebars block end: {{/if}}, {{/has}}, {{/list}}, etc.
-const CLOSING_HBS = /^\{\{\//;
-// List item (- or * or 1.)
-const LIST_ITEM = /^(?:[-*]\s|\d+\.\s)/;
-// Code fence
-const CODE_FENCE = /^```/;
-// Table row
-const TABLE_ROW = /^\|.*\|$/;
-// Table separator (|---|---|)
-const TABLE_SEP = /^\|[-:\s|]+\|$/;
-
-/** RFC 2119 keywords used in prompts. */
-const RFC2119_KEYWORDS = /\b(?:MUST NOT|SHOULD NOT|SHALL NOT|RECOMMENDED|REQUIRED|OPTIONAL|SHOULD|SHALL|MUST|MAY)\b/g;
-
-function boldRfc2119Keywords(line: string): string {
-	return line.replace(RFC2119_KEYWORDS, (match, offset, source) => {
-		const isAlreadyBold =
-			source[offset - 2] === "*" &&
-			source[offset - 1] === "*" &&
-			source[offset + match.length] === "*" &&
-			source[offset + match.length + 1] === "*";
-		if (isAlreadyBold) {
-			return match;
-		}
-		return `**${match}**`;
-	});
-}
-
-/** Compact a table row by trimming cell padding */
-function compactTableRow(line: string): string {
-	const cells = line.split("|");
-	return cells.map(c => c.trim()).join("|");
-}
-
-/** Compact a table separator row */
-function compactTableSep(line: string): string {
-	const cells = line.split("|").filter(c => c.trim());
-	const normalized = cells.map(c => {
-		const trimmed = c.trim();
-		const left = trimmed.startsWith(":");
-		const right = trimmed.endsWith(":");
-		if (left && right) return ":---:";
-		if (left) return ":---";
-		if (right) return "---:";
-		return "---";
-	});
-	return `|${normalized.join("|")}|`;
-}
-
-function replaceCommonAsciiSymbols(line: string): string {
-	return line
-		.replace(/\.{3}/g, "…")
-		.replace(/<->/g, "↔")
-		.replace(/->/g, "→")
-		.replace(/<-/g, "←")
-		.replace(/!=/g, "≠")
-		.replace(/<=/g, "≤")
-		.replace(/>=/g, "≥");
-}
-
-export function formatPromptContent(content: string, options: PromptFormatOptions = {}): string {
-	const {
-		renderPhase = "post-render",
-		replaceAsciiSymbols = false,
-		boldRfc2119Keywords: shouldBoldRfc2119 = false,
-	} = options;
-	const isPreRender = renderPhase === "pre-render";
-	const lines = content.split("\n");
-	const result: string[] = [];
-	let inCodeBlock = false;
-	const topLevelTags: string[] = [];
-
-	for (let i = 0; i < lines.length; i++) {
-		let line = lines[i].trimEnd();
-		let trimmedStart = line.trimStart();
-		if (CODE_FENCE.test(trimmedStart)) {
-			inCodeBlock = !inCodeBlock;
-			result.push(line);
-			continue;
-		}
-
-		if (inCodeBlock) {
-			result.push(line);
-			continue;
-		}
-
-		if (replaceAsciiSymbols) {
-			line = replaceCommonAsciiSymbols(line);
-		}
-		trimmedStart = line.trimStart();
-		const trimmed = line.trim();
-
-		const isOpeningXml = OPENING_XML.test(trimmedStart) && !trimmedStart.endsWith("/>");
-		if (isOpeningXml && line.length === trimmedStart.length) {
-			const match = OPENING_XML.exec(trimmedStart);
-			if (match) topLevelTags.push(match[1]);
-		}
-
-		const closingMatch = CLOSING_XML.exec(trimmedStart);
-		if (closingMatch) {
-			const tagName = closingMatch[1];
-			if (topLevelTags.length > 0 && topLevelTags[topLevelTags.length - 1] === tagName) {
-				topLevelTags.pop();
-			}
-		} else if (isPreRender && trimmedStart.startsWith("{{")) {
-			/* keep indentation as-is in pre-render for Handlebars markers */
-		} else if (TABLE_SEP.test(trimmedStart)) {
-			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
-			line = `${leadingWhitespace}${compactTableSep(trimmedStart)}`;
-		} else if (TABLE_ROW.test(trimmedStart)) {
-			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
-			line = `${leadingWhitespace}${compactTableRow(trimmedStart)}`;
-		}
-
-		if (shouldBoldRfc2119) {
-			line = boldRfc2119Keywords(line);
-		}
-
-		const isBlank = trimmed === "";
-		if (isBlank) {
-			const prevLine = result[result.length - 1]?.trim() ?? "";
-			const nextLine = lines[i + 1]?.trim() ?? "";
-
-			if (LIST_ITEM.test(nextLine)) {
-				continue;
-			}
-
-			if (OPENING_XML.test(prevLine) || (isPreRender && OPENING_HBS.test(prevLine))) {
-				continue;
-			}
-
-			if (CLOSING_XML.test(nextLine) || (isPreRender && CLOSING_HBS.test(nextLine))) {
-				continue;
-			}
-
-			const prevIsBlank = prevLine === "";
-			if (prevIsBlank) {
-				continue;
-			}
-		}
-
-		if (CLOSING_XML.test(trimmed) || (isPreRender && CLOSING_HBS.test(trimmed))) {
-			while (result.length > 0 && result[result.length - 1].trim() === "") {
-				result.pop();
-			}
-		}
-
-		result.push(line);
-	}
-
-	while (result.length > 0 && result[result.length - 1].trim() === "") {
-		result.pop();
-	}
-
-	return result.join("\n");
-}