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

package/src/utils/image-loading.ts

@@ -0,0 +1,98 @@
+import * as fs from "node:fs/promises";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
+import { resolveReadPath } from "../tools/path-utils";
+import { convertToPng } from "./image-convert";
+import { formatDimensionNote, resizeImage } from "./image-resize";
+
+export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
+export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
+
+export interface LoadImageInputOptions {
+	path: string;
+	cwd: string;
+	autoResize: boolean;
+	maxBytes?: number;
+	resolvedPath?: string;
+	detectedMimeType?: string;
+}
+
+export interface LoadedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	data: string;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: 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;
+	}
+}
+
+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 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 metadata = options.detectedMimeType
+		? { mimeType: options.detectedMimeType }
+		: await readImageMetadata(resolvedPath);
+	const mimeType = metadata?.mimeType;
+	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/title-generator.ts

@@ -5,15 +5,14 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
-const TITLE_SYSTEM_PROMPT = renderPromptTemplate(titleSystemPrompt);
+const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;

package/src/utils/tools-manager.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
+import { $which, APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
 
 const TOOLS_DIR = getToolsDir();
 const TOOL_DOWNLOAD_TIMEOUT_MS = 120_000;
@@ -96,7 +96,7 @@ export function getToolPath(tool: ToolName): string | null {
 	// Check Python tools first
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
-		return Bun.which(pythonConfig.binaryName);
+		return $which(pythonConfig.binaryName);
 	}
 
 	const config = TOOLS[tool];
@@ -109,7 +109,7 @@ export function getToolPath(tool: ToolName): string | null {
 	}
 
 	// Check system PATH
-	return Bun.which(config.binaryName);
+	return $which(config.binaryName);
 }
 
 // Fetch latest release version from GitHub
@@ -249,7 +249,7 @@ async function downloadTool(tool: ToolName, signal?: AbortSignal): Promise<strin
 // Install a Python package via uv (preferred) or pip
 async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<boolean> {
 	// Try uv first (faster, better isolation)
-	const uv = Bun.which("uv");
+	const uv = $which("uv");
 	if (uv) {
 		const result = await ptree.exec(["uv", "tool", "install", pkg], {
 			signal,
@@ -261,7 +261,7 @@ async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<
 	}
 
 	// Fall back to pip
-	const pip = Bun.which("pip3") || Bun.which("pip");
+	const pip = $which("pip3") || $which("pip");
 	if (pip) {
 		const result = await ptree.exec(["pip", "install", "--user", pkg], {
 			signal,
@@ -316,7 +316,7 @@ export async function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOpt
 		const success = await installPythonPackage(pythonConfig.package, signal);
 		if (success) {
 			// Re-check for the command after installation
-			const path = Bun.which(pythonConfig.binaryName);
+			const path = $which(pythonConfig.binaryName);
 			if (path) {
 				if (!silent) {
 					logger.debug(`${pythonConfig.name} installed successfully`);

package/src/web/scrapers/choosealicense.ts

@@ -1,4 +1,4 @@
-import { parseFrontmatter } from "../../utils/frontmatter";
+import { parseFrontmatter } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 import { asString } from "./utils";

package/src/web/search/index.ts

@@ -7,8 +7,8 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../../config/prompt-templates";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -213,7 +213,7 @@ export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRende
 	readonly strict = true;
 
 	constructor(_session: ToolSession) {
-		this.description = renderPromptTemplate(webSearchDescription);
+		this.description = prompt.render(webSearchDescription);
 	}
 
 	async execute(
@@ -231,7 +231,7 @@ export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRende
 export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails> = {
 	name: "web_search",
 	label: "Web Search",
-	description: renderPromptTemplate(webSearchDescription),
+	description: prompt.render(webSearchDescription),
 	parameters: webSearchSchema,
 
 	async execute(

package/src/web/search/render.ts

@@ -188,7 +188,7 @@ export function renderSearchResult(
 								: typeof src.url === "string" && src.url.trim()
 									? src.url
 									: "Untitled";
-						const title = truncateToWidth(titleText, 70);
+						const title = truncateToWidth(titleText, MAX_SNIPPET_LINE_LEN);
 						const url = typeof src.url === "string" ? src.url : "";
 						const domain = url ? getDomain(url) : "";
 						const age =
@@ -196,11 +196,13 @@ export function renderSearchResult(
 						const metaParts: string[] = [];
 						if (domain) metaParts.push(theme.fg("dim", `(${domain})`));
 						if (typeof src.author === "string" && src.author.trim())
-							metaParts.push(theme.fg("muted", src.author));
+							metaParts.push(theme.fg("muted", truncateToWidth(src.author.trim(), 40)));
 						if (age) metaParts.push(theme.fg("muted", age));
 						const metaSep = theme.fg("dim", theme.sep.dot);
 						const metaSuffix = metaParts.length > 0 ? ` ${metaParts.join(metaSep)}` : "";
-						const srcLines: string[] = [`${theme.fg("accent", title)}${metaSuffix}`];
+						const srcLines: string[] = [
+							truncateToWidth(`${theme.fg("accent", title)}${metaSuffix}`, MAX_SNIPPET_LINE_LEN),
+						];
 						const snippetText = typeof src.snippet === "string" ? src.snippet : "";
 						if (snippetText.trim()) {
 							const snippetLines = getPreviewLines(snippetText, MAX_SNIPPET_LINES, MAX_SNIPPET_LINE_LEN);
@@ -208,7 +210,7 @@ export function renderSearchResult(
 								srcLines.push(theme.fg("muted", `${theme.format.dash} ${snippetLine}`));
 							}
 						}
-						if (url) srcLines.push(theme.fg("mdLinkUrl", url));
+						if (url) srcLines.push(theme.fg("mdLinkUrl", truncateToWidth(url, MAX_SNIPPET_LINE_LEN)));
 						return srcLines;
 					},
 				},

package/src/autoresearch/command-initialize.md

@@ -1,34 +0,0 @@
-Set up autoresearch for this intent:
-
-{{intent}}
-
-{{branch_status_line}}
-
-Collected setup:
-
-- benchmark command: `{{benchmark_command}}`
-- primary metric: `{{metric_name}}`
-- metric unit: `{{metric_unit}}`
-- direction: `{{direction}}`
-- tradeoff metrics:
-{{{secondary_metrics_block}}}
-- files in scope:
-{{{scope_paths_block}}}
-- off limits:
-{{{off_limits_block}}}
-- constraints:
-{{{constraints_block}}}
-
-Explain briefly what autoresearch will do in this repository, then initialize the workspace.
-
-Your first actions:
-- write `autoresearch.md`
-- record the collected benchmark command, primary metric, metric unit, direction, tradeoff metrics, scope, off-limits list, and constraints in `autoresearch.md`
-- add a short preflight section in `autoresearch.md` covering prerequisites, one-time setup, and the comparability invariant that must stay fixed across runs
-- explicitly mark the ground-truth evaluator, fixed datasets, and other measurement-critical files as off-limits or hard constraints when they define the benchmark contract
-- write or update `autoresearch.program.md` when you learn durable heuristics, failure patterns, or repo-specific strategy that future resume turns should inherit
-- define the benchmark entrypoint in `autoresearch.sh`
-- optionally add `autoresearch.checks.sh` if correctness or quality needs a hard gate
-- run `init_experiment` with the exact collected benchmark command, metric definition, scope paths, off-limits list, and constraints
-- run and log the baseline
-- keep iterating until interrupted or until the configured iteration cap is reached

package/src/commit/git/errors.ts

@@ -1,9 +0,0 @@
-export class GitError extends Error {
-	constructor(
-		readonly command: string,
-		readonly stderr: string,
-	) {
-		super(`${command} failed: ${stderr || "unknown error"}`);
-		this.name = "GitError";
-	}
-}

package/src/commit/git/index.ts

@@ -1,210 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { logger, Snowflake } from "@oh-my-pi/pi-utils";
-import type { FileDiff, FileHunks, NumstatEntry } from "../../commit/types";
-import { parseDiffHunks, parseFileDiffs, parseFileHunks, parseNumstat } from "./diff";
-import { GitError } from "./errors";
-import { commit, push, resetStaging, runGitCommand, stageFiles } from "./operations";
-
-export type HunkSelection = {
-	path: string;
-	hunks: { type: "all" } | { type: "indices"; indices: number[] } | { type: "lines"; start: number; end: number };
-};
-
-export class ControlledGit {
-	constructor(private readonly cwd: string) {}
-
-	async getDiff(staged: boolean): Promise<string> {
-		const args = staged ? ["diff", "--cached"] : ["diff"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff");
-		return result.stdout;
-	}
-
-	async getDiffForFiles(files: string[], staged = true): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--", ...files] : ["diff", "--", ...files];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff (files)");
-		return result.stdout;
-	}
-
-	async getChangedFiles(staged: boolean): Promise<string[]> {
-		const args = staged ? ["diff", "--cached", "--name-only"] : ["diff", "--name-only"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --name-only");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getStat(staged: boolean): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--stat"] : ["diff", "--stat"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --stat");
-		return result.stdout;
-	}
-
-	async getStatForFiles(files: string[], staged = true): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--stat", "--", ...files] : ["diff", "--stat", "--", ...files];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --stat (files)");
-		return result.stdout;
-	}
-
-	async getNumstat(staged: boolean): Promise<NumstatEntry[]> {
-		const args = staged ? ["diff", "--cached", "--numstat"] : ["diff", "--numstat"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --numstat");
-		return parseNumstat(result.stdout);
-	}
-
-	async getRecentCommits(count: number): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["log", `-n${count}`, "--pretty=format:%s"]);
-		this.#ensureSuccess(result, "git log");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getStagedFiles(): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["diff", "--cached", "--name-only"]);
-		this.#ensureSuccess(result, "git diff --cached --name-only");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getUntrackedFiles(): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["ls-files", "--others", "--exclude-standard"]);
-		this.#ensureSuccess(result, "git ls-files --others --exclude-standard");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async stageAll(): Promise<void> {
-		const result = await stageFiles(this.cwd, []);
-		this.#ensureSuccess(result, "git add -A");
-	}
-
-	async stageFiles(files: string[]): Promise<void> {
-		const result = await stageFiles(this.cwd, files);
-		this.#ensureSuccess(result, "git add");
-	}
-
-	async stageHunks(selections: HunkSelection[]): Promise<void> {
-		if (selections.length === 0) return;
-		const diff = await this.getDiff(false);
-		const fileDiffs = parseFileDiffs(diff);
-		const fileDiffMap = new Map(fileDiffs.map(entry => [entry.filename, entry]));
-		const patchParts: string[] = [];
-		for (const selection of selections) {
-			const fileDiff = fileDiffMap.get(selection.path);
-			if (!fileDiff) {
-				throw new GitError("git apply --cached", `No diff found for ${selection.path}`);
-			}
-			if (fileDiff.isBinary) {
-				if (selection.hunks.type !== "all") {
-					throw new GitError("git apply --cached", `Cannot select hunks for binary file ${selection.path}`);
-				}
-				patchParts.push(fileDiff.content);
-				continue;
-			}
-
-			if (selection.hunks.type === "all") {
-				patchParts.push(fileDiff.content);
-				continue;
-			}
-
-			const fileHunks = parseFileHunks(fileDiff);
-			const selectedHunks = selectHunks(fileHunks, selection.hunks);
-			if (selectedHunks.length === 0) {
-				throw new GitError("git apply --cached", `No hunks selected for ${selection.path}`);
-			}
-			const header = extractFileHeader(fileDiff.content);
-			const filePatch = [header, ...selectedHunks.map(hunk => hunk.content)].join("\n");
-			patchParts.push(filePatch);
-		}
-
-		const patch = joinPatch(patchParts);
-		if (!patch.trim()) return;
-		const tempPath = path.join(os.tmpdir(), `omp-hunks-${Snowflake.next()}.patch`);
-		try {
-			await Bun.write(tempPath, patch);
-			const result = await runGitCommand(this.cwd, ["apply", "--cached", "--binary", tempPath]);
-			this.#ensureSuccess(result, "git apply --cached");
-		} finally {
-			await fs.rm(tempPath, { force: true });
-		}
-	}
-
-	async resetStaging(files: string[] = []): Promise<void> {
-		const result = await resetStaging(this.cwd, files);
-		this.#ensureSuccess(result, "git reset");
-	}
-
-	async commit(message: string): Promise<void> {
-		const result = await commit(this.cwd, message);
-		this.#ensureSuccess(result, "git commit");
-	}
-
-	async push(): Promise<void> {
-		const result = await push(this.cwd);
-		this.#ensureSuccess(result, "git push");
-	}
-
-	parseDiffFiles(diff: string): FileDiff[] {
-		return parseFileDiffs(diff);
-	}
-
-	parseDiffHunks(diff: string): FileHunks[] {
-		return parseDiffHunks(diff);
-	}
-
-	async getHunks(files: string[], staged = true): Promise<FileHunks[]> {
-		const diff = await this.getDiffForFiles(files, staged);
-		return this.parseDiffHunks(diff);
-	}
-
-	#ensureSuccess(result: { exitCode: number; stderr: string }, label: string): void {
-		if (result.exitCode !== 0) {
-			logger.error("commit git command failed", { label, stderr: result.stderr });
-			throw new GitError(label, result.stderr);
-		}
-	}
-}
-
-function extractFileHeader(diff: string): string {
-	const lines = diff.split("\n");
-	const headerLines: string[] = [];
-	for (const line of lines) {
-		if (line.startsWith("@@")) break;
-		headerLines.push(line);
-	}
-	return headerLines.join("\n");
-}
-
-export function joinPatch(parts: string[]): string {
-	return `${parts
-		.map(part => (part.endsWith("\n") ? part : `${part}\n`))
-		.join("\n")
-		.replace(/\n+$/, "")}\n`;
-}
-
-function selectHunks(file: FileHunks, selector: HunkSelection["hunks"]): FileHunks["hunks"] {
-	if (selector.type === "indices") {
-		const wanted = new Set(selector.indices.map(value => Math.max(1, Math.floor(value))));
-		return file.hunks.filter(hunk => wanted.has(hunk.index + 1));
-	}
-	if (selector.type === "lines") {
-		const start = Math.floor(selector.start);
-		const end = Math.floor(selector.end);
-		return file.hunks.filter(hunk => hunk.newStart <= end && hunk.newStart + hunk.newLines - 1 >= start);
-	}
-	return file.hunks;
-}

package/src/commit/git/operations.ts

@@ -1,54 +0,0 @@
-import { $ } from "bun";
-
-interface GitResult {
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-}
-
-export async function runGitCommand(cwd: string, args: string[]): Promise<GitResult> {
-	const result = await $`git ${args}`.cwd(cwd).quiet().nothrow();
-	const stdout = result.text();
-	const stderr = result.stderr?.toString() ?? "";
-	return {
-		exitCode: result.exitCode ?? 0,
-		stdout,
-		stderr,
-	};
-}
-
-export async function stageFiles(cwd: string, files: string[]): Promise<GitResult> {
-	const args = files.length === 0 ? ["add", "-A"] : ["add", "--", ...files];
-	return runGitCommand(cwd, args);
-}
-
-export async function resetStaging(cwd: string, files: string[]): Promise<GitResult> {
-	const args = files.length === 0 ? ["reset"] : ["reset", "--", ...files];
-	return runGitCommand(cwd, args);
-}
-
-export async function push(cwd: string): Promise<GitResult> {
-	return runGitCommand(cwd, ["push"]);
-}
-
-export async function commit(cwd: string, message: string): Promise<GitResult> {
-	const child = Bun.spawn(["git", "commit", "-F", "-"], {
-		cwd,
-		stdin: Buffer.from(message),
-		stdout: "pipe",
-		stderr: "pipe",
-		windowsHide: true,
-	});
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(child.stdout).text(),
-		new Response(child.stderr).text(),
-		child.exited,
-	]);
-
-	return {
-		exitCode: exitCode ?? 0,
-		stdout: stdout.trim(),
-		stderr: stderr.trim(),
-	};
-}