@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.1

package/src/tools/search.ts

@@ -22,7 +22,7 @@ import {
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
-	resolveMultiSearchPath,
+	resolveExplicitSearchPaths,
 	resolveToCwd,
 } from "./path-utils";
 import {
@@ -37,9 +37,10 @@ import { toolResult } from "./tool-result";
 
 const searchSchema = Type.Object({
 	pattern: Type.String({ description: "regex pattern", examples: ["function\\s+\\w+", "TODO"] }),
-	path: Type.String({
-		description: "file, directory, glob, comma-separated paths, or internal URL to search",
-		examples: ["src/", "src/foo.ts", "src/**/*.ts"],
+	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to search" }), {
+		minItems: 1,
+		description: "files, directories, globs, or internal URLs to search",
+		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
 	}),
 	i: Type.Optional(Type.Boolean({ description: "case-insensitive search", default: false })),
 	gitignore: Type.Optional(Type.Boolean({ description: "respect gitignore", default: true })),
@@ -48,7 +49,7 @@ const searchSchema = Type.Object({
 
 export type SearchToolInput = Static<typeof searchSchema>;
 
-const DEFAULT_MATCH_LIMIT = 20;
+const DEFAULT_MATCH_LIMIT = 500;
 
 export interface SearchToolDetails {
 	truncation?: TruncationResult;
@@ -93,7 +94,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<SearchToolDetails>> {
-		const { pattern, path: searchDir, i, gitignore, skip } = params;
+		const { pattern, paths, i, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();
@@ -117,13 +118,19 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			let searchPath: string;
 			let scopePath: string;
 			let exactFilePaths: string[] | undefined;
+			let multiTargets: Array<{ basePath: string; glob?: string }> | undefined;
 			let globFilter: string | undefined;
-			const rawPath = normalizePathLikeInput(searchDir);
-			if (rawPath.length === 0) {
-				throw new ToolError("`path` must be a non-empty path or glob");
+			const rawPaths = paths.map(normalizePathLikeInput);
+			if (rawPaths.some(rawPath => rawPath.length === 0)) {
+				throw new ToolError("`paths` must contain non-empty paths or globs");
 			}
 			const internalRouter = this.session.internalRouter;
-			if (internalRouter?.canHandle(rawPath)) {
+			const resolvedPathInputs: string[] = [];
+			for (const rawPath of rawPaths) {
+				if (!internalRouter?.canHandle(rawPath)) {
+					resolvedPathInputs.push(rawPath);
+					continue;
+				}
 				if (hasGlobPathChars(rawPath)) {
 					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
 				}
@@ -131,28 +138,30 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
-				searchPath = resource.sourcePath;
+				resolvedPathInputs.push(resource.sourcePath);
+			}
+			if (resolvedPathInputs.length === 1) {
+				const parsedPath = parseSearchPath(resolvedPathInputs[0] ?? ".");
+				searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+				globFilter = parsedPath.glob;
 				scopePath = formatScopePath(searchPath);
 			} else {
-				const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
-				if (multiSearchPath) {
-					searchPath = multiSearchPath.basePath;
-					globFilter = multiSearchPath.exactFilePaths ? undefined : multiSearchPath.glob;
-					exactFilePaths = multiSearchPath.exactFilePaths;
-					scopePath = multiSearchPath.scopePath;
-				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					globFilter = parsedPath.glob;
-					scopePath = formatScopePath(searchPath);
+				const multiSearchPath = await resolveExplicitSearchPaths(resolvedPathInputs, this.session.cwd, globFilter);
+				if (!multiSearchPath) {
+					throw new ToolError("`paths` must contain at least one path or glob");
 				}
+				searchPath = multiSearchPath.basePath;
+				exactFilePaths = multiSearchPath.exactFilePaths;
+				multiTargets = multiSearchPath.targets;
+				globFilter = exactFilePaths || multiTargets ? undefined : multiSearchPath.glob;
+				scopePath = multiSearchPath.scopePath;
 			}
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				const hint = scopePath.includes(",") ? ` (comma-separated paths must each exist relative to cwd)` : "";
+				const hint = rawPaths.length > 1 ? " (`paths` entries must each exist relative to cwd)" : "";
 				throw new ToolError(`Path not found: ${scopePath}${hint}`);
 			}
 
@@ -163,19 +172,26 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			// Run grep
 			let result: GrepResult;
 			try {
-				if (exactFilePaths) {
+				if (exactFilePaths || multiTargets) {
 					const matches: GrepMatch[] = [];
 					let limitReached = false;
-					for (const exactFilePath of exactFilePaths) {
-						const fileResult = await grep(
+					let totalMatches = 0;
+					let filesSearched = 0;
+					const targets = exactFilePaths
+						? exactFilePaths.map(filePath => ({ basePath: filePath, glob: undefined as string | undefined }))
+						: (multiTargets ?? []);
+					for (const target of targets) {
+						const targetResult = await grep(
 							{
 								pattern: normalizedPattern,
-								path: exactFilePath,
+								path: target.basePath,
+								glob: target.glob,
 								ignoreCase,
 								multiline: effectiveMultiline,
 								hidden: true,
 								gitignore: useGitignore,
 								cache: false,
+								maxCount: exactFilePaths ? undefined : internalLimit,
 								contextBefore: normalizedContextBefore,
 								contextAfter: normalizedContextAfter,
 								maxColumns: DEFAULT_MAX_COLUMN,
@@ -183,16 +199,21 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							},
 							undefined,
 						);
-						limitReached = limitReached || Boolean(fileResult.limitReached);
-						const relativeFilePath = path.relative(searchPath, exactFilePath).replace(/\\/g, "/");
-						matches.push(...fileResult.matches.map(match => ({ ...match, path: relativeFilePath })));
+						limitReached = limitReached || Boolean(targetResult.limitReached);
+						totalMatches += targetResult.totalMatches;
+						filesSearched += targetResult.filesSearched;
+						for (const match of targetResult.matches) {
+							const absolute = path.resolve(target.basePath, match.path);
+							const rebased = path.relative(searchPath, absolute).replace(/\\/g, "/");
+							matches.push({ ...match, path: rebased });
+						}
 					}
 					const offsetMatches = matches.slice(normalizedSkip);
 					result = {
 						matches: offsetMatches,
-						totalMatches: offsetMatches.length,
+						totalMatches: exactFilePaths ? offsetMatches.length : totalMatches,
 						filesWithMatches: new Set(offsetMatches.map(match => match.path)).size,
-						filesSearched: exactFilePaths.length,
+						filesSearched: exactFilePaths ? exactFilePaths.length : filesSearched,
 						limitReached,
 					};
 				} else {
@@ -261,7 +282,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				: result.matches.slice(0, effectiveLimit);
 			const matchLimitReached = result.matches.length > effectiveLimit;
 			const nextSkip = normalizedSkip + selectedMatches.length;
-			const limitMessage = `Result limit reached; narrow path or use skip=${nextSkip}.`;
+			const limitMessage = `Result limit reached; narrow paths or use skip=${nextSkip}.`;
 			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			if (selectedMatches.length === 0) {
@@ -381,7 +402,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 
 interface SearchRenderArgs {
 	pattern: string;
-	path?: string;
+	paths?: string[];
 	i?: boolean;
 	gitignore?: boolean;
 	skip?: number;
@@ -393,7 +414,7 @@ export const searchToolRenderer = {
 	inline: true,
 	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.path) meta.push(`in ${args.path}`);
+		if (args.paths?.length) meta.push(`in ${args.paths.join(", ")}`);
 		if (args.i) meta.push("case:insensitive");
 		if (args.gitignore === false) meta.push("gitignore:false");
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);

package/src/utils/edit-mode.ts

@@ -1,12 +1,11 @@
-import { $env, $flag } from "@oh-my-pi/pi-utils";
+import { $env } from "@oh-my-pi/pi-utils";
 
-export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch" | "atom";
+export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
 const EDIT_MODE_IDS = {
 	apply_patch: "apply_patch",
-	atom: "atom",
 	hashline: "hashline",
 	patch: "patch",
 	replace: "replace",
@@ -38,14 +37,6 @@ export function resolveEditMode(session: EditModeSessionLike): EditMode {
 	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
 	if (envMode) return envMode;
 
-	if (!$flag("PI_STRICT_EDIT_MODE")) {
-		if (activeModel?.includes("spark")) return "apply_patch";
-		if (activeModel?.includes("nano")) return "replace";
-		if (activeModel?.includes("mini")) return "replace";
-		if (activeModel?.includes("haiku")) return "replace";
-		if (activeModel?.includes("flash")) return "replace";
-	}
-
 	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));
 	return settingsMode ?? DEFAULT_EDIT_MODE;
 }

package/src/utils/file-display-mode.ts

@@ -29,7 +29,7 @@ export function resolveFileDisplayMode(session: FileDisplayModeSession, options?
 	const { settings } = session;
 	const hasEditTool = session.hasEditTool ?? true;
 	const editMode = resolveEditMode(session);
-	const usesHashLineAnchors = editMode === "hashline" || editMode === "atom";
+	const usesHashLineAnchors = editMode === "hashline";
 	const raw = options?.raw === true;
 	const hashLines = !raw && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
 	return {

package/src/utils/git.ts

@@ -368,50 +368,68 @@ async function writeTempPatch(content: string): Promise<string> {
 
 type EntryType = "directory" | "file";
 
-function isOptionalGitMetadataUnavailable(err: unknown): boolean {
-	return isEnoent(err) || hasFsCode(err, "ENFILE") || hasFsCode(err, "EMFILE");
+function shouldRetry(err: unknown, n: number) {
+	if (isEnoent(err) || hasFsCode(err, "ENFILE") || hasFsCode(err, "EMFILE")) return false;
+	if (hasFsCode(err, "EINTR")) return n < EINTR_MAX_RETRIES;
+	if (n > EINTR_MAX_RETRIES) throw err;
+	throw err;
+}
+
+/**
+ * Bounded retry for synchronous I/O against `EINTR`. POSIX permits short syscalls
+ * to be interrupted by signals; when that happens libc traditionally retries.
+ * Node's sync wrappers surface the raw `EINTR` so we replicate the retry locally.
+ * Any other error (and persistent EINTR after `EINTR_MAX_RETRIES`) is rethrown
+ * for the caller's normal "optional metadata" classifier to handle.
+ */
+const EINTR_MAX_RETRIES = 3;
+function retryOnEintrSync<T>(op: () => T): T | null {
+	for (let attempt = 0; attempt <= EINTR_MAX_RETRIES; attempt += 1) {
+		try {
+			return op();
+		} catch (err) {
+			if (shouldRetry(err, attempt)) continue;
+			return null;
+		}
+	}
+	throw new Error("retryOnEintrSync: exhausted without resolution");
+}
+async function retryOnEintr<T>(op: () => Promise<T>): Promise<T | null> {
+	for (let attempt = 0; attempt <= EINTR_MAX_RETRIES; attempt += 1) {
+		try {
+			return await op();
+		} catch (err) {
+			if (shouldRetry(err, attempt)) continue;
+			return null;
+		}
+	}
+	throw new Error("retryOnEintr: exhausted without resolution");
 }
 
 function getEntryTypeSync(gitEntryPath: string): EntryType | null {
-	try {
+	return retryOnEintrSync(() => {
 		const stat = fs.statSync(gitEntryPath);
 		if (stat.isDirectory()) return "directory";
 		if (stat.isFile()) return "file";
 		return null;
-	} catch (err) {
-		if (isOptionalGitMetadataUnavailable(err)) return null;
-		throw err;
-	}
+	});
 }
 
 async function getEntryType(gitEntryPath: string): Promise<EntryType | null> {
-	try {
+	return retryOnEintr(async () => {
 		const stat = await fs.promises.stat(gitEntryPath);
 		if (stat.isDirectory()) return "directory";
 		if (stat.isFile()) return "file";
 		return null;
-	} catch (err) {
-		if (isOptionalGitMetadataUnavailable(err)) return null;
-		throw err;
-	}
+	});
 }
 
 function readOptionalTextSync(filePath: string): string | null {
-	try {
-		return fs.readFileSync(filePath, "utf8");
-	} catch (err) {
-		if (isOptionalGitMetadataUnavailable(err)) return null;
-		throw err;
-	}
+	return retryOnEintrSync(() => fs.readFileSync(filePath, "utf8"));
 }
 
 async function readOptionalText(filePath: string): Promise<string | null> {
-	try {
-		return await Bun.file(filePath).text();
-	} catch (err) {
-		if (isOptionalGitMetadataUnavailable(err)) return null;
-		throw err;
-	}
+	return retryOnEintr(async () => await Bun.file(filePath).text());
 }
 
 function parseGitDirPointer(content: string): string | null {
@@ -1258,6 +1276,23 @@ export async function restore(cwd: string, options: RestoreOptions = {}): Promis
 	await runEffect(cwd, args, { signal: options.signal });
 }
 
+/**
+ * Run `git reset` with options. Default is a soft reset (no flag); pass `hard: true` for a destructive reset.
+ *
+ * NOTE: stage.reset() handles the per-file unstaging case. This helper exists for tree-wide resets.
+ */
+export async function reset(
+	cwd: string,
+	options: { hard?: boolean; mixed?: boolean; soft?: boolean; target?: string; signal?: AbortSignal } = {},
+): Promise<void> {
+	const args = ["reset"];
+	if (options.hard) args.push("--hard");
+	else if (options.mixed) args.push("--mixed");
+	else if (options.soft) args.push("--soft");
+	if (options.target) args.push(options.target);
+	await runEffect(cwd, args, { signal: options.signal });
+}
+
 export async function clean(
 	cwd: string,
 	options: { ignoredOnly?: boolean; paths?: readonly string[]; signal?: AbortSignal } = {},

package/src/utils/session-color.ts

@@ -33,18 +33,6 @@ export function getSessionAccentHex(name: string): string {
 	return hslToHex(nameToHue(name), 0.9, 0.72);
 }
 
-/**
- * Auto-generated titles should not drive the session accent.
- * Legacy sessions with unknown title source keep the old behavior.
- */
-export function getSessionAccentHexForTitle(
-	name: string | undefined,
-	titleSource: "auto" | "user" | undefined,
-): string | undefined {
-	if (!name || titleSource === "auto") return undefined;
-	return getSessionAccentHex(name);
-}
-
 /**
  * Convert a hex accent color to an ANSI-16m foreground escape sequence.
  * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.

package/src/utils/title-generator.ts

@@ -2,15 +2,13 @@
  * Generate session titles using a smol, fast model.
  */
 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 { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 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 = prompt.render(titleSystemPrompt);
 
@@ -19,22 +17,14 @@ const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 const MAX_INPUT_CHARS = 2000;
 
-function getTitleModel(
-	registry: ModelRegistry,
-	settings: Settings,
-	currentModel?: Model<Api>,
-): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
+function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
-	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry);
-	if (titleModel) {
-		return { model: titleModel.model, thinkingLevel: titleModel.thinkingLevel };
-	}
+	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry)?.model;
+	if (titleModel) return titleModel;
 
-	if (currentModel) {
-		return { model: currentModel };
-	}
+	if (currentModel) return currentModel;
 
 	return undefined;
 }
@@ -44,7 +34,7 @@ function getTitleModel(
  *
  * @param firstMessage The first user message
  * @param registry Model registry
- * @param settings Settings used to resolve the smol role, including per-role thinking
+ * @param settings Settings used to resolve the smol role
  * @param sessionId Optional session id for sticky API key selection
  */
 export async function generateSessionTitle(
@@ -54,8 +44,8 @@ export async function generateSessionTitle(
 	sessionId?: string,
 	currentModel?: Model<Api>,
 ): Promise<string | null> {
-	const candidate = getTitleModel(registry, settings, currentModel);
-	if (!candidate) {
+	const model = getTitleModel(registry, settings, currentModel);
+	if (!model) {
 		logger.debug("title-generator: no title model found");
 		return null;
 	}
@@ -67,17 +57,20 @@ export async function generateSessionTitle(
 ${truncatedMessage}
 </user-message>`;
 
-	const apiKey = await registry.getApiKey(candidate.model, sessionId);
+	const apiKey = await registry.getApiKey(model, sessionId);
 	if (!apiKey) {
 		logger.debug("title-generator: no API key for smol model", {
-			provider: candidate.model.provider,
-			id: candidate.model.id,
+			provider: model.provider,
+			id: model.id,
 		});
 		return null;
 	}
 
+	// Title generation is a 3-6 word task; force reasoning off so reasoning models
+	// don't burn the entire output budget on internal thinking and return an empty
+	// string. With reasoning disabled, 30 tokens of output is plenty.
 	const request = {
-		model: `${candidate.model.provider}/${candidate.model.id}`,
+		model: `${model.provider}/${model.id}`,
 		systemPrompt: TITLE_SYSTEM_PROMPT,
 		userMessage,
 		maxTokens: 30,
@@ -86,7 +79,7 @@ ${truncatedMessage}
 
 	try {
 		const response = await completeSimple(
-			candidate.model,
+			model,
 			{
 				systemPrompt: request.systemPrompt,
 				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
@@ -94,7 +87,7 @@ ${truncatedMessage}
 			{
 				apiKey,
 				maxTokens: 30,
-				reasoning: toReasoningEffort(candidate.thinkingLevel),
+				disableReasoning: true,
 			},
 		);
 
@@ -153,13 +146,8 @@ function getFallbackTerminalTitle(cwd: string | undefined): string | undefined {
 	return sanitizeTerminalTitlePart(baseName);
 }
 
-export function formatSessionTerminalTitle(
-	sessionName: string | undefined,
-	cwd?: string,
-	titleSource?: "auto" | "user" | undefined,
-): string {
-	const label =
-		sanitizeTerminalTitlePart(titleSource === "auto" ? undefined : sessionName) ?? getFallbackTerminalTitle(cwd);
+export function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string {
+	const label = sanitizeTerminalTitlePart(sessionName) ?? getFallbackTerminalTitle(cwd);
 	return label ? `${DEFAULT_TERMINAL_TITLE}: ${label}` : DEFAULT_TERMINAL_TITLE;
 }
 
@@ -170,12 +158,8 @@ export function setTerminalTitle(title: string): void {
 	process.stdout.write(`\x1b]0;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
 }
 
-export function setSessionTerminalTitle(
-	sessionName: string | undefined,
-	cwd?: string,
-	titleSource?: "auto" | "user" | undefined,
-): void {
-	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd, titleSource));
+export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void {
+	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd));
 }
 
 /**

package/src/autoresearch/apply-contract-to-state.ts

@@ -1,24 +0,0 @@
-import { inferMetricUnitFromName } from "./helpers";
-import type { AutoresearchContract, ExperimentState } from "./types";
-
-/**
- * Updates session fields from a validated `autoresearch.md` parse (same fields as `init_experiment`).
- * Does not touch `name`, `currentSegment`, `results`, `bestMetric`, `confidence`, or `maxExperiments`.
- */
-export function applyAutoresearchContractToExperimentState(
-	contract: AutoresearchContract,
-	state: ExperimentState,
-): void {
-	const benchmarkContract = contract.benchmark;
-	state.metricName = benchmarkContract.primaryMetric ?? state.metricName;
-	state.metricUnit = benchmarkContract.metricUnit;
-	state.bestDirection = benchmarkContract.direction ?? "lower";
-	state.secondaryMetrics = benchmarkContract.secondaryMetrics.map(name => ({
-		name,
-		unit: inferMetricUnitFromName(name),
-	}));
-	state.benchmarkCommand = benchmarkContract.command?.trim() ?? state.benchmarkCommand;
-	state.scopePaths = [...contract.scopePaths];
-	state.offLimits = [...contract.offLimits];
-	state.constraints = [...contract.constraints];
-}