@oh-my-pi/pi-coding-agent 13.17.1 → 13.17.6

package/src/tools/archive-reader.ts

@@ -0,0 +1,315 @@
+import { unzipSync } from "fflate";
+import { ToolError } from "./tool-errors";
+
+export type ArchiveFormat = "zip" | "tar" | "tar.gz";
+
+export interface ArchivePathCandidate {
+	archivePath: string;
+	subPath: string;
+}
+
+export interface ArchiveNode {
+	path: string;
+	isDirectory: boolean;
+	size: number;
+	mtimeMs?: number;
+}
+
+export interface ArchiveDirectoryEntry extends ArchiveNode {
+	name: string;
+}
+
+export interface ExtractedArchiveFile extends ArchiveNode {
+	bytes: Uint8Array;
+}
+
+interface TarStorage {
+	type: "tar";
+	file: File;
+}
+
+interface ZipStorage {
+	type: "zip";
+	bytes: Uint8Array;
+}
+
+type EntryStorage = TarStorage | ZipStorage;
+
+interface ArchiveIndexEntry extends ArchiveNode {
+	storage?: EntryStorage;
+}
+
+function normalizeArchiveLookupPath(rawPath?: string): string | undefined {
+	if (!rawPath) return "";
+
+	const parts = rawPath.replace(/\\/g, "/").split("/");
+	const normalizedParts: string[] = [];
+	for (const part of parts) {
+		if (!part || part === ".") continue;
+		if (part === "..") return undefined;
+		normalizedParts.push(part);
+	}
+
+	return normalizedParts.join("/");
+}
+
+function normalizeArchiveEntryPath(rawPath: string): string | undefined {
+	const parts = rawPath.replace(/\\/g, "/").split("/");
+	const normalizedParts: string[] = [];
+	for (const part of parts) {
+		if (!part || part === ".") continue;
+		if (part === "..") return undefined;
+		normalizedParts.push(part);
+	}
+
+	if (normalizedParts.length === 0) return undefined;
+	return normalizedParts.join("/");
+}
+
+function isArchiveDirectoryName(rawPath: string): boolean {
+	return rawPath.endsWith("/") || rawPath.endsWith("\\");
+}
+
+function upsertArchiveEntry(map: Map<string, ArchiveIndexEntry>, entry: ArchiveIndexEntry): void {
+	const existing = map.get(entry.path);
+	if (!existing) {
+		map.set(entry.path, entry);
+		return;
+	}
+
+	if (existing.isDirectory && !entry.isDirectory) {
+		map.set(entry.path, entry);
+		return;
+	}
+
+	if (!existing.isDirectory && entry.isDirectory) {
+		return;
+	}
+
+	map.set(entry.path, {
+		...existing,
+		size: existing.size || entry.size,
+		mtimeMs: existing.mtimeMs ?? entry.mtimeMs,
+		storage: existing.storage ?? entry.storage,
+	});
+}
+
+function ensureParentDirectories(map: Map<string, ArchiveIndexEntry>): void {
+	for (const entry of [...map.values()]) {
+		const parts = entry.path.split("/");
+		const stop = parts.length - 1;
+		for (let index = 1; index <= stop; index++) {
+			const dirPath = parts.slice(0, index).join("/");
+			if (!dirPath || map.has(dirPath)) continue;
+			map.set(dirPath, {
+				path: dirPath,
+				isDirectory: true,
+				size: 0,
+			});
+		}
+	}
+}
+
+function getArchiveFormatFromPath(filePath: string): ArchiveFormat | undefined {
+	const normalized = filePath.toLowerCase();
+	if (normalized.endsWith(".tar.gz") || normalized.endsWith(".tgz")) return "tar.gz";
+	if (normalized.endsWith(".tar")) return "tar";
+	if (normalized.endsWith(".zip")) return "zip";
+	return undefined;
+}
+
+async function readTarEntries(bytes: Uint8Array): Promise<ArchiveIndexEntry[]> {
+	let archive: Bun.Archive;
+	try {
+		archive = new Bun.Archive(bytes);
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	let files: Map<string, File>;
+	try {
+		files = await archive.files();
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	const entries: ArchiveIndexEntry[] = [];
+	for (const [rawPath, file] of files) {
+		const normalizedPath = normalizeArchiveEntryPath(rawPath);
+		if (!normalizedPath) continue;
+		const mtimeMs = file.lastModified > 0 ? file.lastModified : undefined;
+		entries.push({
+			path: normalizedPath,
+			isDirectory: false,
+			size: file.size,
+			mtimeMs,
+			storage: { type: "tar", file },
+		});
+	}
+
+	return entries;
+}
+
+function readZipEntries(bytes: Uint8Array): ArchiveIndexEntry[] {
+	let files: Record<string, Uint8Array>;
+	try {
+		files = unzipSync(bytes);
+	} catch (error) {
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	}
+
+	const entries: ArchiveIndexEntry[] = [];
+	for (const [rawPath, fileBytes] of Object.entries(files)) {
+		const normalizedPath = normalizeArchiveEntryPath(rawPath);
+		if (!normalizedPath) continue;
+		const isDirectory = isArchiveDirectoryName(rawPath);
+		entries.push({
+			path: normalizedPath,
+			isDirectory,
+			size: isDirectory ? 0 : fileBytes.byteLength,
+			storage: isDirectory ? undefined : { type: "zip", bytes: fileBytes },
+		});
+	}
+
+	return entries;
+}
+
+export function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[] {
+	const normalized = filePath.replace(/\\/g, "/");
+	const pattern = /\.(?:tar\.gz|tgz|zip|tar)(?=(?::|$))/gi;
+	const seen = new Set<string>();
+	const candidates: ArchivePathCandidate[] = [];
+
+	let match: RegExpExecArray | null;
+	while (true) {
+		match = pattern.exec(normalized);
+		if (match === null) {
+			break;
+		}
+		const end = match.index + match[0].length;
+		const archivePath = filePath.slice(0, end);
+		const subPath = normalized.slice(end).replace(/^:+/, "");
+		const key = `${archivePath}\0${subPath}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		candidates.push({ archivePath, subPath });
+	}
+
+	return candidates.sort((left, right) => right.archivePath.length - left.archivePath.length);
+}
+
+export class ArchiveReader {
+	readonly format: ArchiveFormat;
+	#entries = new Map<string, ArchiveIndexEntry>();
+
+	constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[]) {
+		this.format = format;
+		for (const entry of entries) {
+			upsertArchiveEntry(this.#entries, entry);
+		}
+		ensureParentDirectories(this.#entries);
+	}
+
+	getNode(subPath?: string): ArchiveNode | undefined {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) return undefined;
+		if (normalizedPath === "") {
+			return { path: "", isDirectory: true, size: 0 };
+		}
+
+		const entry = this.#entries.get(normalizedPath);
+		if (!entry) return undefined;
+		return {
+			path: entry.path,
+			isDirectory: entry.isDirectory,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+		};
+	}
+
+	listDirectory(subPath?: string): ArchiveDirectoryEntry[] {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) {
+			throw new ToolError("Archive path cannot contain '..'");
+		}
+
+		if (normalizedPath) {
+			const entry = this.#entries.get(normalizedPath);
+			if (!entry) {
+				throw new ToolError(`Archive path '${normalizedPath}' not found`);
+			}
+			if (!entry.isDirectory) {
+				throw new ToolError(`Archive path '${normalizedPath}' is not a directory`);
+			}
+		}
+
+		const prefix = normalizedPath ? `${normalizedPath}/` : "";
+		const children = new Map<string, ArchiveDirectoryEntry>();
+
+		for (const entry of this.#entries.values()) {
+			if (normalizedPath) {
+				if (!entry.path.startsWith(prefix) || entry.path === normalizedPath) continue;
+			}
+
+			const relativePath = normalizedPath ? entry.path.slice(prefix.length) : entry.path;
+			const nextSegment = relativePath.split("/")[0];
+			if (!nextSegment) continue;
+
+			const childPath = normalizedPath ? `${normalizedPath}/${nextSegment}` : nextSegment;
+			if (children.has(childPath)) continue;
+
+			const childEntry = this.#entries.get(childPath);
+			const isDirectory = childEntry?.isDirectory ?? relativePath.includes("/");
+			children.set(childPath, {
+				name: nextSegment,
+				path: childPath,
+				isDirectory,
+				size: isDirectory ? 0 : (childEntry?.size ?? entry.size),
+				mtimeMs: childEntry?.mtimeMs ?? entry.mtimeMs,
+			});
+		}
+
+		return [...children.values()].sort((left, right) =>
+			left.name.toLowerCase().localeCompare(right.name.toLowerCase()),
+		);
+	}
+
+	async readFile(subPath: string): Promise<ExtractedArchiveFile> {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (!normalizedPath) {
+			throw new ToolError("Archive file path is required");
+		}
+
+		const entry = this.#entries.get(normalizedPath);
+		if (!entry) {
+			throw new ToolError(`Archive file '${normalizedPath}' not found`);
+		}
+		if (entry.isDirectory) {
+			throw new ToolError(`Archive path '${normalizedPath}' is a directory`);
+		}
+		if (!entry.storage) {
+			throw new ToolError(`Archive file '${normalizedPath}' has no readable storage`);
+		}
+
+		const bytes = entry.storage.type === "tar" ? await entry.storage.file.bytes() : entry.storage.bytes;
+
+		return {
+			path: entry.path,
+			isDirectory: false,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+			bytes,
+		};
+	}
+}
+
+export async function openArchive(filePath: string): Promise<ArchiveReader> {
+	const format = getArchiveFormatFromPath(filePath);
+	if (!format) {
+		throw new ToolError(`Unsupported archive format: ${filePath}`);
+	}
+
+	const bytes = await Bun.file(filePath).bytes();
+	const entries = format === "zip" ? readZipEntries(bytes) : await readTarEntries(bytes);
+	return new ArchiveReader(format, entries);
+}

package/src/tools/fetch.ts

@@ -20,7 +20,7 @@ import { extractWithParallel, findParallelApiKey, getParallelExtractContent } fr
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
-import { convertWithMarkitdown, fetchBinary } from "../web/scrapers/utils";
+import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
@@ -34,7 +34,7 @@ import { clampTimeout } from "./tool-timeouts";
 // =============================================================================
 
 const FETCH_DEFAULT_MAX_LINES = 300;
-// Convertible document types (markitdown supported)
+// Convertible document types handled by markit.
 const CONVERTIBLE_MIMES = new Set([
 	"application/pdf",
 	"application/msword",
@@ -45,6 +45,7 @@ const CONVERTIBLE_MIMES = new Set([
 	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
 	"application/rtf",
 	"application/epub+zip",
+	"application/x-ipynb+json",
 	"application/zip",
 	"image/png",
 	"image/jpeg",
@@ -65,6 +66,7 @@ const CONVERTIBLE_EXTENSIONS = new Set([
 	".xlsx",
 	".rtf",
 	".epub",
+	".ipynb",
 	".png",
 	".jpg",
 	".jpeg",
@@ -164,7 +166,7 @@ function getExtensionHint(url: string, contentDisposition?: string): string {
 }
 
 /**
- * Check if content type is convertible via markitdown
+ * Check if content type is convertible via markit.
  */
 function isConvertible(mime: string, extensionHint: string): boolean {
 	if (CONVERTIBLE_MIMES.has(mime)) return true;
@@ -711,18 +713,18 @@ async function renderUrl(
 				notes.push("Fetched image binary");
 				const conversionExtension = getExtensionHint(finalUrl, binary.contentDisposition) || extHint;
 				let convertedText: string | null = null;
-				const converted = await convertWithMarkitdown(binary.buffer, conversionExtension, timeout, signal);
+				const converted = await convertWithMarkit(binary.buffer, conversionExtension, timeout, signal);
 				if (converted.ok) {
 					if (converted.content.trim().length > 50) {
-						notes.push("Converted with markitdown");
+						notes.push("Converted with markit");
 						convertedText = converted.content;
 					} else {
-						notes.push("markitdown conversion produced no usable output");
+						notes.push("markit conversion produced no usable output");
 					}
 				} else if (converted.error) {
-					notes.push(`markitdown conversion failed: ${converted.error}`);
+					notes.push(`markit conversion failed: ${converted.error}`);
 				} else {
-					notes.push("markitdown conversion failed");
+					notes.push("markit conversion failed");
 				}
 
 				if (binary.buffer.byteLength > MAX_INLINE_IMAGE_SOURCE_BYTES) {
@@ -736,7 +738,7 @@ async function renderUrl(
 						url,
 						finalUrl,
 						contentType: imageMimeType,
-						method: convertedText ? "markitdown" : "image-too-large",
+						method: convertedText ? "markit" : "image-too-large",
 						content: output.content,
 						fetchedAt,
 						truncated: output.truncated,
@@ -761,7 +763,7 @@ async function renderUrl(
 						url,
 						finalUrl,
 						contentType: imageMimeType,
-						method: convertedText ? "markitdown" : "image-invalid",
+						method: convertedText ? "markit" : "image-invalid",
 						content: output.content,
 						fetchedAt,
 						truncated: output.truncated,
@@ -779,7 +781,7 @@ async function renderUrl(
 						url,
 						finalUrl,
 						contentType: imageMimeType,
-						method: convertedText ? "markitdown" : "image-too-large",
+						method: convertedText ? "markit" : "image-too-large",
 						content: output.content,
 						fetchedAt,
 						truncated: output.truncated,
@@ -819,27 +821,27 @@ async function renderUrl(
 		const binary = await fetchBinary(finalUrl, timeout, signal);
 		if (binary.ok) {
 			const ext = getExtensionHint(finalUrl, binary.contentDisposition) || extHint;
-			const converted = await convertWithMarkitdown(binary.buffer, ext, timeout, signal);
+			const converted = await convertWithMarkit(binary.buffer, ext, timeout, signal);
 			if (converted.ok) {
 				if (converted.content.trim().length > 50) {
-					notes.push("Converted with markitdown");
+					notes.push("Converted with markit");
 					const output = finalizeOutput(converted.content);
 					return {
 						url,
 						finalUrl,
 						contentType: mime,
-						method: "markitdown",
+						method: "markit",
 						content: output.content,
 						fetchedAt,
 						truncated: output.truncated,
 						notes,
 					};
 				}
-				notes.push("markitdown conversion produced no usable output");
+				notes.push("markit conversion produced no usable output");
 			} else if (converted.error) {
-				notes.push(`markitdown conversion failed: ${converted.error}`);
+				notes.push(`markit conversion failed: ${converted.error}`);
 			} else {
-				notes.push("markitdown conversion failed");
+				notes.push("markit conversion failed");
 			}
 		} else if (binary.error) {
 			notes.push(`Binary fetch failed: ${binary.error}`);
@@ -1007,7 +1009,7 @@ async function renderUrl(
 				const binary = await fetchBinary(docUrl, timeout, signal);
 				if (binary.ok) {
 					const ext = getExtensionHint(docUrl, binary.contentDisposition);
-					const converted = await convertWithMarkitdown(binary.buffer, ext, timeout, signal);
+					const converted = await convertWithMarkit(binary.buffer, ext, timeout, signal);
 					if (converted.ok && converted.content.trim().length > htmlResult.content.length) {
 						notes.push(`Extracted and converted document: ${docUrl}`);
 						const output = finalizeOutput(converted.content);
@@ -1023,7 +1025,7 @@ async function renderUrl(
 						};
 					}
 					if (!converted.ok && converted.error) {
-						notes.push(`markitdown conversion failed: ${converted.error}`);
+						notes.push(`markit conversion failed: ${converted.error}`);
 					}
 				} else if (binary.error) {
 					notes.push(`Binary fetch failed: ${binary.error}`);

package/src/tools/gh-cli.ts

@@ -0,0 +1,125 @@
+import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
+
+export interface GhCommandResult {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}
+
+export interface GhCommandOptions {
+	repoProvided?: boolean;
+	trimOutput?: boolean;
+}
+
+export function isGhAvailable(): boolean {
+	return Boolean(Bun.which("gh"));
+}
+
+function formatGhFailure(args: string[], stdout: string, stderr: string, options?: GhCommandOptions): string {
+	const output = stderr || stdout;
+	const message = output.trim();
+
+	if (message.includes("gh auth login") || message.includes("not logged into any GitHub hosts")) {
+		return "GitHub CLI is not authenticated. Run `gh auth login`.";
+	}
+
+	if (
+		!options?.repoProvided &&
+		(message.includes("not a git repository") ||
+			message.includes("no git remotes found") ||
+			message.includes("unable to determine current repository"))
+	) {
+		return "GitHub repository context is unavailable. Pass `repo` explicitly or run the tool inside a GitHub checkout.";
+	}
+
+	if (message.length > 0) {
+		return message;
+	}
+
+	return `GitHub CLI command failed: gh ${args.join(" ")}`;
+}
+
+export async function runGhCommand(
+	cwd: string,
+	args: string[],
+	signal?: AbortSignal,
+	options?: GhCommandOptions,
+): Promise<GhCommandResult> {
+	throwIfAborted(signal);
+
+	if (!isGhAvailable()) {
+		throw new ToolError("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/.");
+	}
+
+	try {
+		const child = Bun.spawn(["gh", ...args], {
+			cwd,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+			windowsHide: true,
+			signal,
+		});
+
+		if (!child.stdout || !child.stderr) {
+			throw new ToolError("Failed to capture GitHub CLI output.");
+		}
+
+		const [stdout, stderr, exitCode] = await Promise.all([
+			new Response(child.stdout).text(),
+			new Response(child.stderr).text(),
+			child.exited,
+		]);
+
+		throwIfAborted(signal);
+
+		return {
+			exitCode: exitCode ?? 0,
+			stdout: options?.trimOutput === false ? stdout : stdout.trim(),
+			stderr: options?.trimOutput === false ? stderr : stderr.trim(),
+		};
+	} catch (error) {
+		if (signal?.aborted) {
+			throw new ToolAbortError();
+		}
+		throw error;
+	}
+}
+
+export async function runGhJson<T>(
+	cwd: string,
+	args: string[],
+	signal?: AbortSignal,
+	options?: GhCommandOptions,
+): Promise<T> {
+	const result = await runGhCommand(cwd, args, signal, options);
+
+	if (result.exitCode !== 0) {
+		throw new ToolError(formatGhFailure(args, result.stdout, result.stderr, options));
+	}
+
+	if (!result.stdout) {
+		throw new ToolError("GitHub CLI returned empty output.");
+	}
+
+	try {
+		return JSON.parse(result.stdout) as T;
+	} catch {
+		throw new ToolError("GitHub CLI returned invalid JSON output.");
+	}
+}
+
+export async function runGhText(
+	cwd: string,
+	args: string[],
+	signal?: AbortSignal,
+	options?: GhCommandOptions,
+): Promise<string> {
+	const result = await runGhCommand(cwd, args, signal, options);
+
+	if (result.exitCode !== 0) {
+		throw new ToolError(formatGhFailure(args, result.stdout, result.stderr, options));
+	}
+
+	return result.stdout;
+}