@oh-my-pi/pi-coding-agent 16.1.23 → 16.2.1

package/src/utils/active-repo-context.ts

@@ -0,0 +1,143 @@
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+
+import { type GitRepository, repo } from "./git";
+
+export interface ActiveRepoContext {
+	cwd: string;
+	repoRoot: string;
+	relativeRepoRoot: string;
+	source: "single-direct-child-repo";
+}
+
+function compareEntryNames(left: fs.Dirent, right: fs.Dirent): number {
+	if (left.name < right.name) return -1;
+	if (left.name > right.name) return 1;
+	return 0;
+}
+
+function buildContext(cwd: string, repoRoot: string): ActiveRepoContext {
+	const resolvedCwd = path.resolve(cwd);
+	const resolvedRepoRoot = path.resolve(repoRoot);
+	return {
+		cwd: resolvedCwd,
+		repoRoot: resolvedRepoRoot,
+		relativeRepoRoot: path.relative(resolvedCwd, resolvedRepoRoot),
+		source: "single-direct-child-repo",
+	};
+}
+
+async function resolveRepository(cwd: string): Promise<GitRepository | null> {
+	try {
+		return await repo.resolve(cwd);
+	} catch {
+		return null;
+	}
+}
+
+function resolveRepositorySync(cwd: string): GitRepository | null {
+	try {
+		return repo.resolveSync(cwd);
+	} catch {
+		return null;
+	}
+}
+
+async function readDirectChildren(cwd: string): Promise<fs.Dirent[]> {
+	try {
+		const entries = await fsPromises.readdir(cwd, { withFileTypes: true });
+		entries.sort(compareEntryNames);
+		return entries;
+	} catch {
+		return [];
+	}
+}
+
+function readDirectChildrenSync(cwd: string): fs.Dirent[] {
+	try {
+		const entries = fs.readdirSync(cwd, { withFileTypes: true });
+		entries.sort(compareEntryNames);
+		return entries;
+	} catch {
+		return [];
+	}
+}
+
+async function resolveDirectChildDirectory(cwd: string, entry: fs.Dirent): Promise<string | null> {
+	const childPath = path.join(cwd, entry.name);
+	if (entry.isDirectory()) return childPath;
+	if (!entry.isSymbolicLink()) return null;
+	try {
+		const stat = await fsPromises.stat(childPath);
+		return stat.isDirectory() ? childPath : null;
+	} catch {
+		return null;
+	}
+}
+
+function resolveDirectChildDirectorySync(cwd: string, entry: fs.Dirent): string | null {
+	const childPath = path.join(cwd, entry.name);
+	if (entry.isDirectory()) return childPath;
+	if (!entry.isSymbolicLink()) return null;
+	try {
+		const stat = fs.statSync(childPath);
+		return stat.isDirectory() ? childPath : null;
+	} catch {
+		return null;
+	}
+}
+
+async function hasGitMarker(childPath: string): Promise<boolean> {
+	try {
+		const stat = await fsPromises.stat(path.join(childPath, ".git"));
+		return stat.isDirectory() || stat.isFile();
+	} catch {
+		return false;
+	}
+}
+
+function hasGitMarkerSync(childPath: string): boolean {
+	try {
+		const stat = fs.statSync(path.join(childPath, ".git"));
+		return stat.isDirectory() || stat.isFile();
+	} catch {
+		return false;
+	}
+}
+
+async function findSingleDirectChildRepo(cwd: string): Promise<ActiveRepoContext | null> {
+	let context: ActiveRepoContext | null = null;
+	for (const entry of await readDirectChildren(cwd)) {
+		const childPath = await resolveDirectChildDirectory(cwd, entry);
+		if (!childPath) continue;
+		if (!(await hasGitMarker(childPath))) continue;
+		if (context) return null;
+		context = buildContext(cwd, childPath);
+	}
+	return context;
+}
+
+function findSingleDirectChildRepoSync(cwd: string): ActiveRepoContext | null {
+	let context: ActiveRepoContext | null = null;
+	for (const entry of readDirectChildrenSync(cwd)) {
+		const childPath = resolveDirectChildDirectorySync(cwd, entry);
+		if (!childPath) continue;
+		if (!hasGitMarkerSync(childPath)) continue;
+		if (context) return null;
+		context = buildContext(cwd, childPath);
+	}
+	return context;
+}
+
+export async function resolveActiveRepoContext(cwd: string): Promise<ActiveRepoContext | null> {
+	const resolvedCwd = path.resolve(cwd);
+	if (await resolveRepository(resolvedCwd)) return null;
+	return findSingleDirectChildRepo(resolvedCwd);
+}
+
+export function resolveActiveRepoContextSync(cwd: string): ActiveRepoContext | null {
+	const resolvedCwd = path.resolve(cwd);
+	if (resolveRepositorySync(resolvedCwd)) return null;
+	return findSingleDirectChildRepoSync(resolvedCwd);
+}

package/src/utils/image-resize.ts

@@ -18,6 +18,7 @@ export interface ResizedImage {
 	width: number;
 	height: number;
 	wasResized: boolean;
+	decodeFailed?: boolean;
 	get data(): string;
 }
 
@@ -42,6 +43,83 @@ const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	minDimension: DEFAULT_MIN_DIMENSION,
 };
 
+interface ImageHeaderDimensions {
+	width: number;
+	height: number;
+	mimeType: string;
+}
+
+function readUint16BE(buffer: Uint8Array, offset: number): number {
+	return (buffer[offset] << 8) | buffer[offset + 1];
+}
+
+function readUint32BE(buffer: Uint8Array, offset: number): number {
+	return ((buffer[offset] << 24) | (buffer[offset + 1] << 16) | (buffer[offset + 2] << 8) | buffer[offset + 3]) >>> 0;
+}
+
+function readPngHeaderDimensions(buffer: Uint8Array): ImageHeaderDimensions | undefined {
+	if (buffer.length < 24) return undefined;
+	if (
+		buffer[0] !== 0x89 ||
+		buffer[1] !== 0x50 ||
+		buffer[2] !== 0x4e ||
+		buffer[3] !== 0x47 ||
+		buffer[4] !== 0x0d ||
+		buffer[5] !== 0x0a ||
+		buffer[6] !== 0x1a ||
+		buffer[7] !== 0x0a
+	) {
+		return undefined;
+	}
+	if (readUint32BE(buffer, 8) !== 13) return undefined;
+	if (buffer[12] !== 0x49 || buffer[13] !== 0x48 || buffer[14] !== 0x44 || buffer[15] !== 0x52) return undefined;
+	const width = readUint32BE(buffer, 16);
+	const height = readUint32BE(buffer, 20);
+	if (width === 0 || height === 0) return undefined;
+	return { width, height, mimeType: "image/png" };
+}
+
+function isJpegStartOfFrame(marker: number): boolean {
+	return (
+		(marker >= 0xc0 && marker <= 0xc3) ||
+		(marker >= 0xc5 && marker <= 0xc7) ||
+		(marker >= 0xc9 && marker <= 0xcb) ||
+		(marker >= 0xcd && marker <= 0xcf)
+	);
+}
+
+function readJpegHeaderDimensions(buffer: Uint8Array): ImageHeaderDimensions | undefined {
+	if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) return undefined;
+	let offset = 2;
+	while (offset + 3 < buffer.length) {
+		if (buffer[offset] !== 0xff) {
+			offset++;
+			continue;
+		}
+		while (offset < buffer.length && buffer[offset] === 0xff) offset++;
+		if (offset >= buffer.length) return undefined;
+		const marker = buffer[offset++];
+		if (marker === 0xd9 || marker === 0xda) return undefined;
+		if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) continue;
+		if (offset + 1 >= buffer.length) return undefined;
+		const segmentLength = readUint16BE(buffer, offset);
+		if (segmentLength < 2) return undefined;
+		if (isJpegStartOfFrame(marker)) {
+			if (offset + 7 >= buffer.length) return undefined;
+			const height = readUint16BE(buffer, offset + 3);
+			const width = readUint16BE(buffer, offset + 5);
+			if (width === 0 || height === 0) return undefined;
+			return { width, height, mimeType: "image/jpeg" };
+		}
+		offset += segmentLength;
+	}
+	return undefined;
+}
+
+function readImageHeaderDimensions(buffer: Uint8Array): ImageHeaderDimensions | undefined {
+	return readPngHeaderDimensions(buffer) ?? readJpegHeaderDimensions(buffer);
+}
+
 /**
  * Read `OMP_NO_WEBP` per-call so runtime toggles take effect.
  * Only `"1"` and `"true"` (case-insensitive) enable exclusion — an empty string
@@ -298,21 +376,24 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			},
 		};
 	} catch {
+		const headerDimensions = readImageHeaderDimensions(inputBuffer);
+		const fallbackMimeType = img.mimeType ?? headerDimensions?.mimeType ?? "application/octet-stream";
 		// Bun.Image rejected the input — we cannot decode/re-encode it.
-		// When the caller demanded WebP exclusion AND the original is WebP,
+		// When the caller demanded WebP exclusion AND the source might be WebP,
 		// returning the original buffer would silently violate that contract,
 		// so surface an explicit error instead.
-		if (excludeWebP && (img.mimeType === "image/webp" || !img.mimeType)) {
+		if (excludeWebP && (fallbackMimeType === "image/webp" || (!img.mimeType && !headerDimensions))) {
 			throw new Error("resizeImage: failed to decode image and cannot honor excludeWebP for a WebP source");
 		}
 		return {
 			buffer: inputBuffer,
-			mimeType: img.mimeType,
-			originalWidth: 0,
-			originalHeight: 0,
-			width: 0,
-			height: 0,
+			mimeType: fallbackMimeType,
+			originalWidth: headerDimensions?.width ?? 0,
+			originalHeight: headerDimensions?.height ?? 0,
+			width: headerDimensions?.width ?? 0,
+			height: headerDimensions?.height ?? 0,
 			wasResized: false,
+			decodeFailed: true,
 			get data() {
 				return img.data;
 			},

package/src/utils/lang-from-path.ts

@@ -202,9 +202,6 @@ function lspExtensionKey(filePath: string): string {
  * Language id for syntax highlighting and UI (icons, read tool), or undefined if unknown.
  */
 export function getLanguageFromPath(filePath: string): string | undefined {
-	const pair = EXTENSION_LANG[themeExtensionKey(filePath)];
-	if (pair) return pair[0];
-
 	const baseName = path.basename(filePath).toLowerCase();
 	if (baseName.startsWith(".env.")) return "env";
 	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
@@ -214,6 +211,9 @@ export function getLanguageFromPath(filePath: string): string | undefined {
 	if (baseName === "justfile") return "just";
 	if (baseName === "cmakelists.txt") return "cmake";
 
+	const pair = EXTENSION_LANG[themeExtensionKey(filePath)];
+	if (pair) return pair[0];
+
 	return undefined;
 }
 

package/src/utils/markit-cache.ts

@@ -0,0 +1,166 @@
+import type { Stats } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getDocumentConversionCacheDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import packageJson from "../../package.json" with { type: "json" };
+
+/**
+ * Cache schema/format revision. Bumping it changes the on-disk key prefix
+ * (`v<N>-...`), so old entries become unreachable and are pruned naturally.
+ * Bump when the cache *file* shape changes (entry JSON layout, key scheme).
+ *
+ * Converter *output* changes are handled separately: the package version is
+ * folded into the key (see {@link markitConversionCacheKey}), so any release
+ * that ships new markdown from `src/markit/converters/*` auto-invalidates the
+ * cache without a manual bump here.
+ */
+export const MARKIT_CONVERSION_CACHE_VERSION = 1;
+export const MAX_MARKIT_CONVERSION_CACHE_BYTES = 256 * 1024 * 1024;
+/** `.tmp` files older than this are treated as orphaned writes and swept. */
+const TMP_ORPHAN_MAX_AGE_MS = 5 * 60 * 1000;
+export type MarkitConversionCacheStatus = "hit" | "miss" | "skipped";
+
+export type MarkitConversionCacheReadResult = { status: "hit"; content: string } | { status: "miss" };
+
+interface MarkitConversionCacheEntry {
+	version: number;
+	content: string;
+}
+
+export function markitConversionCacheKey(bytes: Uint8Array, extension: string): string {
+	const normalizedExtension = extension.trim().toLowerCase().replace(/^\.+/, "") || "bin";
+	const safeExtension = normalizedExtension.replace(/[^a-z0-9]+/g, "_") || "bin";
+	const safeVersion = packageJson.version.replace(/[^a-z0-9]+/gi, "_");
+	const digest = new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
+	return `v${MARKIT_CONVERSION_CACHE_VERSION}-${safeVersion}-${safeExtension}-${digest}`;
+}
+
+function cacheEntryPath(key: string): string {
+	return path.join(getDocumentConversionCacheDir(), `${key}.json`);
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function parseCacheEntry(raw: string): MarkitConversionCacheEntry | null {
+	const parsed: unknown = JSON.parse(raw);
+	if (typeof parsed !== "object" || parsed === null) return null;
+	if (!("version" in parsed) || parsed.version !== MARKIT_CONVERSION_CACHE_VERSION) return null;
+	if (!("content" in parsed) || typeof parsed.content !== "string" || parsed.content.length === 0) return null;
+	return { version: MARKIT_CONVERSION_CACHE_VERSION, content: parsed.content };
+}
+
+export async function readMarkitConversionCache(key: string): Promise<MarkitConversionCacheReadResult> {
+	const target = cacheEntryPath(key);
+	let raw: string;
+	try {
+		raw = await Bun.file(target).text();
+	} catch (error) {
+		if (!isEnoent(error)) {
+			logger.debug("document conversion cache read failed", { error: errorMessage(error) });
+		}
+		return { status: "miss" };
+	}
+
+	let entry: MarkitConversionCacheEntry | null;
+	try {
+		entry = parseCacheEntry(raw);
+	} catch (error) {
+		logger.debug("document conversion cache read failed", { error: errorMessage(error) });
+		entry = null;
+	}
+
+	if (!entry) {
+		await fs.rm(target, { force: true }).catch(() => undefined);
+		return { status: "miss" };
+	}
+
+	return { status: "hit", content: entry.content };
+}
+
+export async function pruneMarkitConversionCache(cacheDir: string): Promise<void> {
+	let names: string[];
+	try {
+		names = await fs.readdir(cacheDir);
+	} catch (error) {
+		if (!isEnoent(error)) {
+			logger.debug("document conversion cache prune failed", { error: errorMessage(error) });
+		}
+		return;
+	}
+
+	const now = Date.now();
+	// Eviction is FIFO by mtime (not LRU): reads do not bump mtime, so a hot
+	// entry written long ago is evicted before a cold recent miss. The cap is a
+	// coarse disk-footprint safety valve, so the cheaper policy is intentional.
+	const entries: { path: string; size: number; mtimeMs: number }[] = [];
+	let totalBytes = 0;
+	for (const name of names) {
+		const entryPath = path.join(cacheDir, name);
+		let stat: Stats;
+		try {
+			stat = await fs.stat(entryPath);
+		} catch (error) {
+			if (!isEnoent(error)) {
+				logger.debug("document conversion cache prune failed", { error: errorMessage(error) });
+			}
+			continue;
+		}
+		if (!stat.isFile()) continue;
+
+		// Sweep orphaned `.tmp` files left by a crash/SIGKILL between writeFile
+		// and rename; they never become `.json` entries, so the size cap would
+		// otherwise never see them.
+		if (name.endsWith(".tmp")) {
+			if (now - stat.mtimeMs > TMP_ORPHAN_MAX_AGE_MS) {
+				await fs.rm(entryPath, { force: true }).catch(() => undefined);
+			}
+			continue;
+		}
+
+		if (!name.endsWith(".json")) continue;
+		entries.push({ path: entryPath, size: stat.size, mtimeMs: stat.mtimeMs });
+		totalBytes += stat.size;
+	}
+
+	if (totalBytes <= MAX_MARKIT_CONVERSION_CACHE_BYTES) return;
+
+	entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+	for (const entry of entries) {
+		if (totalBytes <= MAX_MARKIT_CONVERSION_CACHE_BYTES) break;
+		try {
+			await fs.rm(entry.path, { force: true });
+			totalBytes -= entry.size;
+		} catch (error) {
+			if (!isEnoent(error)) {
+				logger.debug("document conversion cache prune failed", { error: errorMessage(error) });
+			}
+		}
+	}
+}
+
+export async function writeMarkitConversionCache(key: string, content: string): Promise<void> {
+	const cacheDir = getDocumentConversionCacheDir();
+	const target = path.join(cacheDir, `${key}.json`);
+	// The random suffix keeps concurrent writers (same pid + same ms) from
+	// colliding on one temp path before the atomic rename.
+	const tempPath = path.join(cacheDir, `${key}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`);
+	const payload = JSON.stringify({ version: MARKIT_CONVERSION_CACHE_VERSION, content });
+	try {
+		await fs.mkdir(cacheDir, { recursive: true });
+		await Bun.write(tempPath, payload);
+		await fs.rename(tempPath, target);
+	} catch (error) {
+		await fs.rm(tempPath, { force: true }).catch(() => undefined);
+		logger.debug("document conversion cache write failed", { error: errorMessage(error) });
+		return;
+	}
+
+	// Prune is just GC: the entry is already on disk under its final name, so
+	// fire-and-forget rather than make the caller wait on a readdir + N×stat
+	// sweep on every miss (the slow path the cache exists to amortise).
+	void pruneMarkitConversionCache(cacheDir).catch(error => {
+		logger.debug("document conversion cache prune failed", { error: errorMessage(error) });
+	});
+}

package/src/utils/markit.ts

@@ -1,12 +1,20 @@
+import * as path from "node:path";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import type { Markit, StreamInfo } from "../markit";
+import type { ConversionResult, Markit, StreamInfo } from "../markit";
 import { ToolAbortError } from "../tools/tool-errors";
+import {
+	type MarkitConversionCacheStatus,
+	markitConversionCacheKey,
+	readMarkitConversionCache,
+	writeMarkitConversionCache,
+} from "./markit-cache";
 import { loadEmbeddedMupdfWasm } from "./mupdf-wasm-embed";
 
 export interface MarkitConversionResult {
 	content: string;
 	ok: boolean;
 	error?: string;
+	cache?: MarkitConversionCacheStatus;
 }
 
 export interface MarkitFileConversionOptions {
@@ -103,41 +111,101 @@ function finalizeConversion(markdown?: string): MarkitConversionResult {
 	return { content: "", ok: false, error: "Conversion produced no output" };
 }
 
-export async function convertFileWithMarkit(
-	filePath: string,
+function toBuffer(bytes: Uint8Array): Buffer {
+	return Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+	if (signal?.aborted) throw new ToolAbortError();
+}
+
+async function runCachedBufferConversion(
+	bytes: Uint8Array,
+	streamInfo: StreamInfo,
 	signal?: AbortSignal,
-	options?: MarkitFileConversionOptions,
+	cacheEnabled = true,
 ): Promise<MarkitConversionResult> {
-	const extra = options?.imageDir ? { imageDir: options.imageDir } : undefined;
+	const cacheKey = cacheEnabled
+		? markitConversionCacheKey(bytes, streamInfo.extension ?? streamInfo.mimetype ?? ".bin")
+		: undefined;
+
+	if (cacheKey) {
+		throwIfAborted(signal);
+		const cached = await readMarkitConversionCache(cacheKey);
+		throwIfAborted(signal);
+		if (cached.status === "hit") {
+			return { content: cached.content, ok: true, cache: "hit" };
+		}
+	}
+
+	throwIfAborted(signal);
+	let result: ConversionResult;
 	try {
-		const result = await runMarkitConversion(markit => markit.convertFile(filePath, extra), signal);
-		return finalizeConversion(result.markdown);
+		result = await runMarkitConversion(markit => markit.convert(toBuffer(bytes), streamInfo), signal);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {
 			throw error;
 		}
-		return { content: "", ok: false, error: normalizeError(error) };
+		return { content: "", ok: false, error: normalizeError(error), cache: cacheEnabled ? "miss" : "skipped" };
+	}
+
+	const finalized = finalizeConversion(result.markdown);
+	if (finalized.ok && cacheKey) {
+		await writeMarkitConversionCache(cacheKey, finalized.content);
+	}
+	return { ...finalized, cache: cacheEnabled ? "miss" : "skipped" };
+}
+
+export async function convertFileWithMarkit(
+	filePath: string,
+	signal?: AbortSignal,
+	options?: MarkitFileConversionOptions,
+): Promise<MarkitConversionResult> {
+	if (options?.imageDir) {
+		// Image extraction writes files into imageDir as a side effect; a
+		// markdown-only cache hit would leave the directory missing members, so
+		// this path stays uncached.
+		try {
+			const result = await runMarkitConversion(
+				markit => markit.convertFile(filePath, { imageDir: options.imageDir }),
+				signal,
+			);
+			return { ...finalizeConversion(result.markdown), cache: "skipped" };
+		} catch (error) {
+			if (error instanceof ToolAbortError) {
+				throw error;
+			}
+			return { content: "", ok: false, error: normalizeError(error), cache: "skipped" };
+		}
 	}
+
+	throwIfAborted(signal);
+	let bytes: Uint8Array;
+	try {
+		bytes = await untilAborted(signal, () => Bun.file(filePath).bytes());
+	} catch (error) {
+		if (error instanceof ToolAbortError) throw error;
+		if (error instanceof Error && error.name === "AbortError") throw new ToolAbortError();
+		return { content: "", ok: false, error: normalizeError(error), cache: "miss" };
+	}
+	const streamInfo: StreamInfo = {
+		localPath: filePath,
+		extension: path.extname(filePath).toLowerCase(),
+		filename: path.basename(filePath),
+	};
+	return runCachedBufferConversion(bytes, streamInfo, signal, true);
 }
 
 export async function convertBufferWithMarkit(
 	buffer: Uint8Array,
 	extension: string,
 	signal?: AbortSignal,
+	options?: { useCache?: boolean },
 ): Promise<MarkitConversionResult> {
 	const normalizedExtension = normalizeExtension(extension);
 	const streamInfo: StreamInfo = {
 		extension: normalizedExtension,
 		filename: `input${normalizedExtension}`,
 	};
-
-	try {
-		const result = await runMarkitConversion(markit => markit.convert(Buffer.from(buffer), streamInfo), signal);
-		return finalizeConversion(result.markdown);
-	} catch (error) {
-		if (error instanceof ToolAbortError) {
-			throw error;
-		}
-		return { content: "", ok: false, error: normalizeError(error) };
-	}
+	return runCachedBufferConversion(buffer, streamInfo, signal, options?.useCache ?? true);
 }

package/src/utils/prompt-path.ts

@@ -0,0 +1,3 @@
+export function normalizePromptPath(value: string): string {
+	return value.replace(/\\/g, "/");
+}

package/src/utils/title-generator.ts

@@ -246,7 +246,7 @@ export async function generateTitleOnline(
 			return null;
 		}
 
-		const title = normalizeGeneratedTitle(extractGeneratedTitle(response.content));
+		const title = normalizeGeneratedTitle(extractGeneratedTitle(response.content), firstMessage);
 
 		if (!title) {
 			logger.debug("title-generator: no title returned", {