@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/tui/tree-list.ts

@@ -0,0 +1,55 @@
+/**
+ * Hierarchical tree list rendering helper.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { formatMoreItems } from "../tools/render-utils";
+import type { TreeContext } from "./types";
+import { getTreeBranch, getTreeContinuePrefix } from "./utils";
+
+export interface TreeListOptions<T> {
+	items: T[];
+	expanded?: boolean;
+	maxCollapsed?: number;
+	itemType?: string;
+	renderItem: (item: T, context: TreeContext) => string | string[];
+}
+
+export function renderTreeList<T>(options: TreeListOptions<T>, theme: Theme): string[] {
+	const { items, expanded = false, maxCollapsed = 8, itemType = "item", renderItem } = options;
+	const lines: string[] = [];
+	const maxItems = expanded ? items.length : Math.min(items.length, maxCollapsed);
+
+	for (let i = 0; i < maxItems; i++) {
+		const isLast = i === maxItems - 1 && (expanded || items.length <= maxCollapsed);
+		const branch = getTreeBranch(isLast, theme);
+		const prefix = `${theme.fg("dim", branch)} `;
+		const continuePrefix = `${theme.fg("dim", getTreeContinuePrefix(isLast, theme))}`;
+		const context: TreeContext = {
+			index: i,
+			isLast,
+			depth: 0,
+			theme,
+			prefix,
+			continuePrefix,
+		};
+		const rendered = renderItem(items[i], context);
+		if (Array.isArray(rendered)) {
+			if (rendered.length === 0) continue;
+			lines.push(`${prefix}${rendered[0]}`);
+			for (let j = 1; j < rendered.length; j++) {
+				lines.push(`${continuePrefix}${rendered[j]}`);
+			}
+		} else {
+			lines.push(`${prefix}${rendered}`);
+		}
+	}
+
+	if (!expanded && items.length > maxItems) {
+		const remaining = items.length - maxItems;
+		lines.push(
+			`${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(remaining, itemType, theme))}`,
+		);
+	}
+
+	return lines;
+}

package/src/tui/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared types for TUI rendering components.
+ */
+import type { Theme } from "../modes/theme/theme";
+
+export type State = "pending" | "running" | "success" | "error" | "warning";
+export type IconType = "success" | "error" | "running" | "pending" | "warning" | "info";
+
+export interface TreeContext {
+	index: number;
+	isLast: boolean;
+	depth: number;
+	theme: Theme;
+	prefix: string;
+	continuePrefix: string;
+}

package/src/tui/utils.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared helpers for tool-rendered UI components.
+ */
+import { truncateToWidth as truncateToWidthBase, visibleWidth } from "@oh-my-pi/pi-tui";
+import type { Theme, ThemeBg } from "../modes/theme/theme";
+import type { IconType, State } from "./types";
+
+export function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
+	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
+}
+
+export function getTreeBranch(isLast: boolean, theme: Theme): string {
+	return isLast ? theme.tree.last : theme.tree.branch;
+}
+
+export function getTreeContinuePrefix(isLast: boolean, theme: Theme): string {
+	return isLast ? "   " : `${theme.tree.vertical}  `;
+}
+
+export function truncateToWidth(text: string, width: number, ellipsis: string): string {
+	return truncateToWidthBase(text, width, ellipsis);
+}
+
+export function padToWidth(text: string, width: number, bgFn?: (s: string) => string): string {
+	if (width <= 0) return bgFn ? bgFn(text) : text;
+	const paddingNeeded = Math.max(0, width - visibleWidth(text));
+	const padded = paddingNeeded > 0 ? text + " ".repeat(paddingNeeded) : text;
+	return bgFn ? bgFn(padded) : padded;
+}
+
+export function getStateBgColor(state: State): ThemeBg {
+	if (state === "success") return "toolSuccessBg";
+	if (state === "error") return "toolErrorBg";
+	return "toolPendingBg";
+}
+
+export function getStateIcon(icon: IconType, theme: Theme, spinnerFrame?: number): string {
+	if (icon === "success") return theme.styledSymbol("status.success", "success");
+	if (icon === "error") return theme.styledSymbol("status.error", "error");
+	if (icon === "warning") return theme.styledSymbol("status.warning", "warning");
+	if (icon === "info") return theme.styledSymbol("status.info", "accent");
+	if (icon === "pending") return theme.styledSymbol("status.pending", "accent");
+	if (spinnerFrame !== undefined) {
+		const frames = theme.spinnerFrames;
+		return frames[spinnerFrame % frames.length];
+	}
+	return theme.styledSymbol("status.running", "accent");
+}

package/src/utils/changelog.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 
 export interface ChangelogEntry {
 	major: number;
@@ -11,13 +11,9 @@ export interface ChangelogEntry {
  * Parse changelog entries from CHANGELOG.md
  * Scans for ## lines and collects content until next ## or EOF
  */
-export function parseChangelog(changelogPath: string): ChangelogEntry[] {
-	if (!existsSync(changelogPath)) {
-		return [];
-	}
-
+export async function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]> {
 	try {
-		const content = readFileSync(changelogPath, "utf-8");
+		const content = await Bun.file(changelogPath).text();
 		const lines = content.split("\n");
 		const entries: ChangelogEntry[] = [];
 
@@ -65,7 +61,10 @@ export function parseChangelog(changelogPath: string): ChangelogEntry[] {
 
 		return entries;
 	} catch (error) {
-		console.error(`Warning: Could not parse changelog: ${error}`);
+		if (isEnoent(error)) {
+			return [];
+		}
+		logger.error(`Warning: Could not parse changelog: ${error}`);
 		return [];
 	}
 }
@@ -92,8 +91,8 @@ export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): C
 		content: "",
 	};
 
-	return entries.filter((entry) => compareVersions(entry, last) > 0);
+	return entries.filter(entry => compareVersions(entry, last) > 0);
 }
 
 // Re-export getChangelogPath from paths.ts for convenience
-export { getChangelogPath } from "@oh-my-pi/pi-coding-agent/config";
+export { getChangelogPath } from "../config";

package/src/utils/clipboard.ts

@@ -1,5 +1,5 @@
-import { unlink } from "node:fs/promises";
-import { platform } from "node:os";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
 
@@ -16,23 +16,23 @@ function baseMimeType(mimeType: string): string {
 
 function selectPreferredImageMimeType(mimeTypes: string[]): string | null {
 	const normalized = mimeTypes
-		.map((t) => t.trim())
+		.map(t => t.trim())
 		.filter(Boolean)
-		.map((t) => ({ raw: t, base: baseMimeType(t) }));
+		.map(t => ({ raw: t, base: baseMimeType(t) }));
 
 	for (const preferred of PREFERRED_IMAGE_MIME_TYPES) {
-		const match = normalized.find((t) => t.base === preferred);
+		const match = normalized.find(t => t.base === preferred);
 		if (match) {
 			return match.raw;
 		}
 	}
 
-	const anyImage = normalized.find((t) => t.base.startsWith("image/"));
+	const anyImage = normalized.find(t => t.base.startsWith("image/"));
 	return anyImage?.raw ?? null;
 }
 
 export async function copyToClipboard(text: string): Promise<void> {
-	const p = platform();
+	const p = os.platform();
 	const timeout = 5000;
 
 	try {
@@ -83,7 +83,7 @@ export interface ClipboardImage {
  * - Windows: uses PowerShell
  */
 export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
-	const p = platform();
+	const p = os.platform();
 	const timeout = 3000;
 	let promise: Promise<ClipboardImage | null>;
 	switch (p) {
@@ -125,7 +125,7 @@ async function readImageWayland(): Promise<ClipboardReadResult> {
 
 	const typeList = types
 		.split(/\r?\n/)
-		.map((t) => t.trim())
+		.map(t => t.trim())
 		.filter(Boolean);
 
 	const selectedType = selectPreferredImageMimeType(typeList);
@@ -149,7 +149,7 @@ async function readImageX11(): Promise<ClipboardReadResult> {
 
 	const candidateTypes = targets
 		.split(/\r?\n/)
-		.map((t) => t.trim())
+		.map(t => t.trim())
 		.filter(Boolean);
 
 	const selectedType = selectPreferredImageMimeType(candidateTypes);
@@ -207,7 +207,7 @@ async function readImageMacOS(): Promise<ClipboardImage | null> {
 		const file = Bun.file(tempFile);
 		if (await file.exists()) {
 			const buffer = await file.bytes();
-			await unlink(tempFile).catch(() => {});
+			await fs.unlink(tempFile).catch(() => {});
 
 			if (buffer.length > 0) {
 				return {

package/src/utils/file-mentions.ts

@@ -5,18 +5,12 @@
  * we automatically inject the file contents as a FileMentionMessage
  * so the agent doesn't need to read them manually.
  */
-
 import path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { FileMentionMessage } from "@oh-my-pi/pi-coding-agent/session/messages";
-import { resolveReadPath } from "@oh-my-pi/pi-coding-agent/tools/path-utils";
-import { formatAge } from "@oh-my-pi/pi-coding-agent/tools/render-utils";
-import {
-	DEFAULT_MAX_BYTES,
-	formatSize,
-	truncateHead,
-	truncateStringToBytesFromStart,
-} from "@oh-my-pi/pi-coding-agent/tools/truncate";
+import type { FileMentionMessage } from "../session/messages";
+import { resolveReadPath } from "../tools/path-utils";
+import { formatAge } from "../tools/render-utils";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead, truncateStringToBytesFromStart } from "../tools/truncate";
 
 /** Regex to match @filepath patterns in text */
 const FILE_MENTION_REGEX = /@([^\s@]+)/g;

package/src/utils/frontmatter.ts

@@ -38,7 +38,9 @@ export class FrontmatterError extends Error {
 }
 
 export interface FrontmatterOptions {
-	/** Source of the content */
+	/** Source of the content (alias: source) */
+	location?: unknown;
+	/** Source of the content (alias for location) */
 	source?: unknown;
 	/** Fallback frontmatter values */
 	fallback?: Record<string, unknown>;
@@ -56,7 +58,8 @@ export function parseFrontmatter(
 	content: string,
 	options?: FrontmatterOptions,
 ): { frontmatter: Record<string, unknown>; body: string } {
-	const { source, fallback, normalize = true, level = "warn" } = options ?? {};
+	const { location, source, fallback, normalize = true, level = "warn" } = options ?? {};
+	const loc = location ?? source;
 	const frontmatter: Record<string, unknown> = Object.assign({}, fallback);
 
 	const normalized = normalize ? stripHtmlComments(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n")) : content;
@@ -77,7 +80,7 @@ export function parseFrontmatter(
 		const loaded = YAML.parse(metadata.replaceAll("\t", "  ")) as Record<string, unknown> | null;
 		return { frontmatter: Object.assign(frontmatter, loaded), body: body };
 	} catch (error) {
-		const err = new FrontmatterError(toError(error), source ?? `Inline '${truncate(content, 64)}'`);
+		const err = new FrontmatterError(toError(error), loc ?? `Inline '${truncate(content, 64)}'`);
 		if (level === "warn" || level === "fatal") {
 			logger.warn("Failed to parse YAML frontmatter", { err: err.toString() });
 		}

package/src/utils/fuzzy.ts

@@ -71,7 +71,7 @@ export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) =>
 	const tokens = query
 		.trim()
 		.split(/\s+/)
-		.filter((t) => t.length > 0);
+		.filter(t => t.length > 0);
 
 	if (tokens.length === 0) {
 		return items;
@@ -104,5 +104,5 @@ export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) =>
 	// Sort by score (asc, lower is better)
 	results.sort((a, b) => a.totalScore - b.totalScore);
 
-	return results.map((r) => r.item);
+	return results.map(r => r.item);
 }

package/src/utils/image-convert.ts

@@ -1,4 +1,4 @@
-import * as photon from "@oh-my-pi/pi-coding-agent/vendor/photon";
+import * as photon from "../vendor/photon";
 
 /**
  * Convert image to PNG format for terminal display.

package/src/utils/image-resize.ts

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import * as photon from "@oh-my-pi/pi-coding-agent/vendor/photon";
+import * as photon from "../vendor/photon";
 
 export interface ImageResizeOptions {
 	maxWidth?: number; // Default: 2000

package/src/utils/mime.ts

@@ -1,4 +1,4 @@
-import { open } from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import { fileTypeFromBuffer } from "file-type";
 
 const IMAGE_MIME_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
@@ -6,7 +6,7 @@ const IMAGE_MIME_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image
 const FILE_TYPE_SNIFF_BYTES = 4100;
 
 export async function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null> {
-	const fileHandle = await open(filePath, "r");
+	const fileHandle = await fs.open(filePath, "r");
 	try {
 		const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
 		const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);

package/src/utils/shell-snapshot.ts

@@ -5,11 +5,9 @@
  * .bashrc/.zshrc, which can be sourced before each command to provide a familiar
  * shell experience.
  */
-
-import { unlinkSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { postmortem } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
@@ -19,10 +17,10 @@ let cachedSnapshotPath: string | null = null;
  * Get the user's shell config file path.
  */
 function getShellConfigFile(shell: string): string {
-	const home = homedir();
-	if (shell.includes("zsh")) return join(home, ".zshrc");
-	if (shell.includes("bash")) return join(home, ".bashrc");
-	return join(home, ".profile");
+	const home = os.homedir();
+	if (shell.includes("zsh")) return path.join(home, ".zshrc");
+	if (shell.includes("bash")) return path.join(home, ".bashrc");
+	return path.join(home, ".profile");
 }
 
 /**
@@ -131,12 +129,12 @@ export async function getOrCreateSnapshot(
 	const rcFile = getShellConfigFile(shell);
 
 	// Create snapshot directory
-	const snapshotDir = join(tmpdir(), "omp-shell-snapshots");
-	await mkdir(snapshotDir, { recursive: true });
+	const snapshotDir = path.join(os.tmpdir(), "omp-shell-snapshots");
+	await fs.promises.mkdir(snapshotDir, { recursive: true });
 
 	// Generate unique snapshot path
 	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
-	const snapshotPath = join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
+	const snapshotPath = path.join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
 
 	// Generate and execute snapshot script
 	const script = await generateSnapshotScript(shell, snapshotPath, rcFile);
@@ -167,6 +165,6 @@ export function getSnapshotSourceCommand(snapshotPath: string | null): string {
 
 postmortem.register("shell-snapshot", () => {
 	if (cachedSnapshotPath) {
-		unlinkSync(cachedSnapshotPath);
+		fs.unlinkSync(cachedSnapshotPath);
 	}
 });

package/src/utils/shell.ts

@@ -1,7 +1,6 @@
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
-import { SettingsManager } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
+import * as fs from "node:fs";
 import { $ } from "bun";
+import { SettingsManager } from "../config/settings-manager";
 
 export interface ShellConfig {
 	shell: string;
@@ -17,7 +16,7 @@ let cachedShellConfig: ShellConfig | null = null;
  */
 async function isExecutable(path: string): Promise<boolean> {
 	try {
-		await access(path, constants.X_OK);
+		await fs.promises.access(path, fs.constants.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -138,7 +137,7 @@ export async function getShellConfig(): Promise<ShellConfig> {
 				`  1. Install Git for Windows: https://git-scm.com/download/win\n` +
 				`  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
 				`  3. Set shellPath in ~/.omp/agent/settings.json\n\n` +
-				`Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+				`Searched Git Bash in:\n${paths.map(p => `  ${p}`).join("\n")}`,
 		);
 	}
 

package/src/utils/title-generator.ts

@@ -1,14 +1,13 @@
 /**
  * Generate session titles using a smol, fast model.
  */
-
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import type { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { parseModelString, SMOL_MODEL_PRIORITY } from "@oh-my-pi/pi-coding-agent/config/model-resolver";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import titleSystemPrompt from "@oh-my-pi/pi-coding-agent/prompts/system/title-system.md" with { type: "text" };
 import { logger } from "@oh-my-pi/pi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { parseModelString, SMOL_MODEL_PRIORITY } from "../config/model-resolver";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
 
 const TITLE_SYSTEM_PROMPT = renderPromptTemplate(titleSystemPrompt);
 
@@ -21,7 +20,7 @@ function getTitleModelCandidates(registry: ModelRegistry, savedSmolModel?: strin
 	const candidates: Model<Api>[] = [];
 	const addCandidate = (model?: Model<Api>): void => {
 		if (!model) return;
-		const exists = candidates.some((candidate) => candidate.provider === model.provider && candidate.id === model.id);
+		const exists = candidates.some(candidate => candidate.provider === model.provider && candidate.id === model.id);
 		if (!exists) {
 			candidates.push(model);
 		}
@@ -30,17 +29,17 @@ function getTitleModelCandidates(registry: ModelRegistry, savedSmolModel?: strin
 	if (savedSmolModel) {
 		const parsed = parseModelString(savedSmolModel);
 		if (parsed) {
-			const match = availableModels.find((model) => model.provider === parsed.provider && model.id === parsed.id);
+			const match = availableModels.find(model => model.provider === parsed.provider && model.id === parsed.id);
 			addCandidate(match);
 		}
 	}
 
 	for (const pattern of SMOL_MODEL_PRIORITY) {
 		const needle = pattern.toLowerCase();
-		const exactMatch = availableModels.find((model) => model.id.toLowerCase() === needle);
+		const exactMatch = availableModels.find(model => model.id.toLowerCase() === needle);
 		addCandidate(exactMatch);
 
-		const fuzzyMatch = availableModels.find((model) => model.id.toLowerCase().includes(needle));
+		const fuzzyMatch = availableModels.find(model => model.id.toLowerCase().includes(needle));
 		addCandidate(fuzzyMatch);
 	}
 

package/src/utils/tools-manager.ts

@@ -1,9 +1,9 @@
-import { chmod, mkdir, rename, rm } from "node:fs/promises";
-import { arch, platform } from "node:os";
-import { join } from "node:path";
-import { APP_NAME, getBinDir } from "@oh-my-pi/pi-coding-agent/config";
-import { createTempDir, logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logger, TempDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
+import { APP_NAME, getBinDir } from "../config";
 
 const TOOLS_DIR = getBinDir();
 
@@ -148,7 +148,7 @@ export async function getToolPath(tool: ToolName): Promise<string | null> {
 	if (!config) return null;
 
 	// Check our tools directory first
-	const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+	const localPath = path.join(TOOLS_DIR, config.binaryName + (os.platform() === "win32" ? ".exe" : ""));
 	if (await Bun.file(localPath).exists()) {
 		return localPath;
 	}
@@ -187,8 +187,8 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	const config = TOOLS[tool];
 	if (!config) throw new Error(`Unknown tool: ${tool}`);
 
-	const plat = platform();
-	const architecture = arch();
+	const plat = os.platform();
+	const architecture = os.arch();
 
 	// Get latest version
 	const version = await getLatestVersion(config.repo);
@@ -200,64 +200,64 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	}
 
 	// Create tools directory
-	await mkdir(TOOLS_DIR, { recursive: true });
+	await fs.mkdir(TOOLS_DIR, { recursive: true });
 
 	const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
 	const binaryExt = plat === "win32" ? ".exe" : "";
-	const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
+	const binaryPath = path.join(TOOLS_DIR, config.binaryName + binaryExt);
 
 	// Handle direct binary downloads (no archive extraction needed)
 	if (config.isDirectBinary) {
 		await downloadFile(downloadUrl, binaryPath);
 		if (plat !== "win32") {
-			await chmod(binaryPath, 0o755);
+			await fs.chmod(binaryPath, 0o755);
 		}
 		return binaryPath;
 	}
 
 	// Download archive
-	const archivePath = join(TOOLS_DIR, assetName);
+	const archivePath = path.join(TOOLS_DIR, assetName);
 	await downloadFile(downloadUrl, archivePath);
 
 	// Extract
-	const tmp = await createTempDir("@omp-tools-extract-");
+	const tmp = await TempDir.create("@omp-tools-extract-");
 
 	try {
 		if (assetName.endsWith(".tar.gz")) {
 			const archive = new Bun.Archive(await Bun.file(archivePath).arrayBuffer());
 			const files = await archive.files();
-			for (const [path, file] of files) {
-				await Bun.write(join(tmp.path, path), file);
+			for (const [filePath, file] of files) {
+				await Bun.write(path.join(tmp.path(), filePath), file);
 			}
 		} else if (assetName.endsWith(".zip")) {
-			await mkdir(tmp.path, { recursive: true });
-			await $`unzip -o ${archivePath} -d ${tmp.path}`.quiet().nothrow();
+			await fs.mkdir(tmp.path(), { recursive: true });
+			await $`unzip -o ${archivePath} -d ${tmp.path()}`.quiet().nothrow();
 		}
 
 		// Find the binary in extracted files
 		// ast-grep releases the binary directly in the zip, not in a subdirectory
 		let extractedBinary: string;
 		if (tool === "sg") {
-			extractedBinary = join(tmp.path, config.binaryName + binaryExt);
+			extractedBinary = path.join(tmp.path(), config.binaryName + binaryExt);
 		} else {
-			const extractedDir = join(tmp.path, assetName.replace(/\.(tar\.gz|zip)$/, ""));
-			extractedBinary = join(extractedDir, config.binaryName + binaryExt);
+			const extractedDir = path.join(tmp.path(), assetName.replace(/\.(tar\.gz|zip)$/, ""));
+			extractedBinary = path.join(extractedDir, config.binaryName + binaryExt);
 		}
 
 		if (await Bun.file(extractedBinary).exists()) {
-			await rename(extractedBinary, binaryPath);
+			await fs.rename(extractedBinary, binaryPath);
 		} else {
 			throw new Error(`Binary not found in archive: ${extractedBinary}`);
 		}
 
 		// Make executable (Unix only)
 		if (plat !== "win32") {
-			await chmod(binaryPath, 0o755);
+			await fs.chmod(binaryPath, 0o755);
 		}
 	} finally {
 		// Cleanup
 		await tmp.remove();
-		await rm(archivePath, { force: true });
+		await fs.rm(archivePath, { force: true });
 	}
 
 	return binaryPath;