@oh-my-pi/pi-coding-agent 6.9.0 → 7.0.0

package/src/core/tools/bash.ts

@@ -20,9 +20,7 @@ export const BASH_DEFAULT_PREVIEW_LINES = 10;
 const bashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
-	workdir: Type.Optional(
-		Type.String({ description: "Working directory for the command (default: current directory)" }),
-	),
+	cwd: Type.Optional(Type.String({ description: "Working directory for the command (default: current directory)" })),
 });
 
 export interface BashToolDetails {
@@ -53,7 +51,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 
 	public async execute(
 		_toolCallId: string,
-		{ command, timeout, workdir }: { command: string; timeout?: number; workdir?: string },
+		{ command, timeout, cwd }: { command: string; timeout?: number; cwd?: string },
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
 		ctx?: AgentToolContext,
@@ -73,7 +71,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			}
 		}
 
-		const commandCwd = workdir ? resolveToCwd(workdir, this.session.cwd) : this.session.cwd;
+		const commandCwd = cwd ? resolveToCwd(cwd, this.session.cwd) : this.session.cwd;
 		let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
 		try {
 			cwdStat = await Bun.file(commandCwd).stat();
@@ -143,7 +141,7 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 interface BashRenderArgs {
 	command?: string;
 	timeout?: number;
-	workdir?: string;
+	cwd?: string;
 }
 
 interface BashRenderContext {
@@ -166,7 +164,7 @@ export const bashToolRenderer = {
 		const command = args.command || uiTheme.format.ellipsis;
 		const prompt = uiTheme.fg("accent", "$");
 		const cwd = process.cwd();
-		let displayWorkdir = args.workdir;
+		let displayWorkdir = args.cwd;
 
 		if (displayWorkdir) {
 			const resolvedCwd = resolve(cwd);

package/src/core/tools/find.ts

@@ -87,10 +87,22 @@ export async function runFd(fdPath: string, args: string[], signal?: AbortSignal
 		throw err;
 	}
 
+	let exitError: unknown;
+	try {
+		await child.exited;
+	} catch (err) {
+		exitError = err;
+		if (err instanceof ptree.Exception && err.aborted) {
+			throw new Error("Operation aborted");
+		}
+	}
+
+	const exitCode = child.exitCode ?? (exitError instanceof ptree.Exception ? exitError.exitCode : null);
+
 	return {
 		stdout,
 		stderr: child.peekStderr(),
-		exitCode: child.exitCode,
+		exitCode,
 	};
 }
 
@@ -271,11 +283,12 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const { stdout, stderr, exitCode } = await runFd(fdPath, args, signal);
 			const output = stdout.trim();
 
-			if (exitCode !== 0 && !output) {
-				throw new Error(stderr.trim() || `fd exited with code ${exitCode ?? -1}`);
-			}
-
+			// fd exit codes: 0 = found files, 1 = no matches, other = error
+			// Treat exit code 1 with no output as "no files found"
 			if (!output) {
+				if (exitCode !== 0 && exitCode !== 1) {
+					throw new Error(stderr.trim() || `fd failed (exit ${exitCode})`);
+				}
 				return {
 					content: [{ type: "text", text: "No files found matching pattern" }],
 					details: { scopePath, fileCount: 0, files: [], truncated: false },

package/src/core/tools/index.ts

@@ -221,7 +221,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			});
 		} else if (!isTestEnv && getPreludeDocs().length === 0) {
 			const sessionFile = session.getSessionFile?.() ?? undefined;
-			const warmSessionId = sessionFile ? `session:${sessionFile}:workdir:${session.cwd}` : `cwd:${session.cwd}`;
+			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
 			void warmPythonEnvironment(session.cwd, warmSessionId, session.settings?.getPythonSharedGateway?.()).catch(
 				(err) => {
 					logger.warn("Failed to warm Python environment", {

package/src/core/tools/lsp/index.ts

@@ -243,6 +243,14 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 
 const FILE_SEARCH_MAX_DEPTH = 5;
 const IGNORED_DIRS = new Set(["node_modules", "target", "dist", "build", ".git"]);
+const DIAGNOSTIC_MESSAGE_LIMIT = 50;
+
+function limitDiagnosticMessages(messages: string[]): string[] {
+	if (messages.length <= DIAGNOSTIC_MESSAGE_LIMIT) {
+		return messages;
+	}
+	return messages.slice(0, DIAGNOSTIC_MESSAGE_LIMIT);
+}
 
 function findFileByExtensions(baseDir: string, extensions: string[], maxDepth: number): string | null {
 	const normalized = extensions.map((ext) => ext.toLowerCase());
@@ -563,12 +571,13 @@ async function getDiagnosticsForFile(
 	}
 
 	const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
+	const limited = limitDiagnosticMessages(formatted);
 	const summary = formatDiagnosticsSummary(uniqueDiagnostics);
 	const hasErrors = uniqueDiagnostics.some((d) => d.severity === 1);
 
 	return {
 		server: serverNames.join(", "),
-		messages: formatted,
+		messages: limited,
 		summary,
 		errored: hasErrors,
 	};
@@ -788,16 +797,18 @@ function mergeDiagnostics(
 
 	let summary = options.enableDiagnostics ? "no issues" : "OK";
 	let errored = false;
+	let limitedMessages = messages;
 	if (messages.length > 0) {
 		const summaryInfo = summarizeDiagnosticMessages(messages);
 		summary = summaryInfo.summary;
 		errored = summaryInfo.errored;
+		limitedMessages = limitDiagnosticMessages(messages);
 	}
 	const formatter = hasFormatter ? (formatted ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED) : undefined;
 
 	return {
 		server: servers.size > 0 ? Array.from(servers).join(", ") : undefined,
-		messages,
+		messages: limitedMessages,
 		summary,
 		errored,
 		formatter,

package/src/core/tools/patch/applicator.ts

@@ -11,6 +11,7 @@ import { resolveToCwd } from "../path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch, seekSequence } from "./fuzzy";
 import {
 	adjustIndentation,
+	convertLeadingTabsToSpaces,
 	countLeadingWhitespace,
 	detectLineEnding,
 	getLeadingWhitespace,
@@ -82,6 +83,34 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		return newLines;
 	}
 
+	// If pattern already matches actual exactly (including indentation), preserve agent's intended changes
+	if (patternLines.length === actualLines.length) {
+		let exactMatch = true;
+		for (let i = 0; i < patternLines.length; i++) {
+			if (patternLines[i] !== actualLines[i]) {
+				exactMatch = false;
+				break;
+			}
+		}
+		if (exactMatch) {
+			return newLines;
+		}
+	}
+
+	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
+	if (patternLines.length === newLines.length) {
+		let indentationOnly = true;
+		for (let i = 0; i < patternLines.length; i++) {
+			if (patternLines[i].trim() !== newLines[i].trim()) {
+				indentationOnly = false;
+				break;
+			}
+		}
+		if (indentationOnly) {
+			return newLines;
+		}
+	}
+
 	// Detect indent character from actual content
 	let indentChar = " ";
 	for (const line of actualLines) {
@@ -92,6 +121,55 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 	}
 
+	let patternTabOnly = true;
+	let actualSpaceOnly = true;
+	let patternMixed = false;
+	let actualMixed = false;
+
+	for (const line of patternLines) {
+		if (line.trim().length === 0) continue;
+		const ws = getLeadingWhitespace(line);
+		if (ws.includes(" ")) patternTabOnly = false;
+		if (ws.includes(" ") && ws.includes("\t")) patternMixed = true;
+	}
+
+	for (const line of actualLines) {
+		if (line.trim().length === 0) continue;
+		const ws = getLeadingWhitespace(line);
+		if (ws.includes("\t")) actualSpaceOnly = false;
+		if (ws.includes(" ") && ws.includes("\t")) actualMixed = true;
+	}
+
+	if (!patternMixed && !actualMixed && patternTabOnly && actualSpaceOnly) {
+		let ratio: number | undefined;
+		const lineCount = Math.min(patternLines.length, actualLines.length);
+		let consistent = true;
+		for (let i = 0; i < lineCount; i++) {
+			const patternLine = patternLines[i];
+			const actualLine = actualLines[i];
+			if (patternLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+			const patternIndent = countLeadingWhitespace(patternLine);
+			const actualIndent = countLeadingWhitespace(actualLine);
+			if (patternIndent === 0) continue;
+			if (actualIndent % patternIndent !== 0) {
+				consistent = false;
+				break;
+			}
+			const nextRatio = actualIndent / patternIndent;
+			if (!ratio) {
+				ratio = nextRatio;
+			} else if (ratio !== nextRatio) {
+				consistent = false;
+				break;
+			}
+		}
+
+		if (consistent && ratio) {
+			const converted = convertLeadingTabsToSpaces(newLines.join("\n"), ratio).split("\n");
+			return converted;
+		}
+	}
+
 	// Build a map from trimmed content to actual lines (by content, not position)
 	// This handles fuzzy matches where pattern and actual may not be positionally aligned
 	const contentToActualLines = new Map<string, string[]>();
@@ -106,18 +184,29 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 	}
 
-	// Compute fallback delta from all non-empty lines (for truly new lines)
-	let totalDelta = 0;
-	let deltaCount = 0;
+	let patternMin = Infinity;
+	for (const line of patternLines) {
+		if (line.trim().length === 0) continue;
+		patternMin = Math.min(patternMin, countLeadingWhitespace(line));
+	}
+	if (patternMin === Infinity) {
+		patternMin = 0;
+	}
+
+	let delta: number | undefined;
+	const deltas: number[] = [];
 	for (let i = 0; i < Math.min(patternLines.length, actualLines.length); i++) {
-		if (patternLines[i].trim().length > 0 && actualLines[i].trim().length > 0) {
-			const pIndent = countLeadingWhitespace(patternLines[i]);
-			const aIndent = countLeadingWhitespace(actualLines[i]);
-			totalDelta += aIndent - pIndent;
-			deltaCount++;
-		}
+		const patternLine = patternLines[i];
+		const actualLine = actualLines[i];
+		if (patternLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+		const pIndent = countLeadingWhitespace(patternLine);
+		const aIndent = countLeadingWhitespace(actualLine);
+		deltas.push(aIndent - pIndent);
+	}
+
+	if (deltas.length > 0 && deltas.every((value) => value === deltas[0])) {
+		delta = deltas[0];
 	}
-	const avgDelta = deltaCount > 0 ? Math.round(totalDelta / deltaCount) : 0;
 
 	// Track which actual lines we've used to handle duplicate content correctly
 	const usedActualLines = new Map<string, number>(); // trimmed content -> count used
@@ -132,6 +221,12 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 
 		// Check if this is a context line (same trimmed content exists in actual)
 		if (matchingActualLines && matchingActualLines.length > 0) {
+			if (matchingActualLines.length === 1) {
+				return matchingActualLines[0];
+			}
+			if (matchingActualLines.includes(newLine)) {
+				return newLine;
+			}
 			const usedCount = usedActualLines.get(trimmed) ?? 0;
 			if (usedCount < matchingActualLines.length) {
 				usedActualLines.set(trimmed, usedCount + 1);
@@ -140,13 +235,16 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 			}
 		}
 
-		// This is a new/added line - apply average delta
-		if (avgDelta > 0) {
-			return indentChar.repeat(avgDelta) + newLine;
-		}
-		if (avgDelta < 0) {
-			const toRemove = Math.min(-avgDelta, countLeadingWhitespace(newLine));
-			return newLine.slice(toRemove);
+		// This is a new/added line - apply consistent delta if safe
+		if (delta && delta !== 0) {
+			const newIndent = countLeadingWhitespace(newLine);
+			if (newIndent === patternMin) {
+				if (delta > 0) {
+					return indentChar.repeat(delta) + newLine;
+				}
+				const toRemove = Math.min(-delta, newIndent);
+				return newLine.slice(toRemove);
+			}
 		}
 		return newLine;
 	});

package/src/core/tools/patch/index.ts

@@ -48,7 +48,7 @@ export { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch as findEditMatch, f
 
 // Normalization
 export {
-	adjustIndentation as adjustNewTextIndentation,
+	adjustIndentation,
 	detectLineEnding,
 	normalizeToLF,
 	restoreLineEndings,

package/src/core/tools/patch/normalize.ts

@@ -92,6 +92,114 @@ export function detectIndentChar(text: string): string {
 	return " ";
 }
 
+function gcd(a: number, b: number): number {
+	let x = Math.abs(a);
+	let y = Math.abs(b);
+	while (y !== 0) {
+		const temp = y;
+		y = x % y;
+		x = temp;
+	}
+	return x;
+}
+
+interface IndentProfile {
+	lines: string[];
+	indentStrings: string[];
+	indentCounts: number[];
+	min: number;
+	char: " " | "\t" | undefined;
+	spaceOnly: boolean;
+	tabOnly: boolean;
+	mixed: boolean;
+	unit: number;
+	nonEmptyCount: number;
+}
+
+function buildIndentProfile(text: string): IndentProfile {
+	const lines = text.split("\n");
+	const indentStrings: string[] = [];
+	const indentCounts: number[] = [];
+	let min = Infinity;
+	let char: " " | "\t" | undefined;
+	let spaceOnly = true;
+	let tabOnly = true;
+	let mixed = false;
+	let nonEmptyCount = 0;
+	let unit = 0;
+
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		nonEmptyCount++;
+		const indent = getLeadingWhitespace(line);
+		indentStrings.push(indent);
+		indentCounts.push(indent.length);
+		min = Math.min(min, indent.length);
+		if (indent.includes(" ")) {
+			tabOnly = false;
+		}
+		if (indent.includes("\t")) {
+			spaceOnly = false;
+		}
+		if (indent.includes(" ") && indent.includes("\t")) {
+			mixed = true;
+		}
+		if (indent.length > 0) {
+			const currentChar = indent[0] as " " | "\t";
+			if (!char) {
+				char = currentChar;
+			} else if (char !== currentChar) {
+				mixed = true;
+			}
+		}
+	}
+
+	if (min === Infinity) {
+		min = 0;
+	}
+
+	if (spaceOnly && nonEmptyCount > 0) {
+		let current = 0;
+		for (const count of indentCounts) {
+			if (count === 0) continue;
+			current = current === 0 ? count : gcd(current, count);
+		}
+		unit = current;
+	}
+
+	if (tabOnly && nonEmptyCount > 0) {
+		unit = 1;
+	}
+
+	return {
+		lines,
+		indentStrings,
+		indentCounts,
+		min,
+		char,
+		spaceOnly,
+		tabOnly,
+		mixed,
+		unit,
+		nonEmptyCount,
+	};
+}
+
+export function convertLeadingTabsToSpaces(text: string, spacesPerTab: number): string {
+	if (spacesPerTab <= 0) return text;
+	return text
+		.split("\n")
+		.map((line) => {
+			const trimmed = line.trimStart();
+			if (trimmed.length === 0) return line;
+			const leading = getLeadingWhitespace(line);
+			if (!leading.includes("\t") || leading.includes(" ")) return line;
+			const converted = " ".repeat(leading.length * spacesPerTab);
+			return converted + trimmed;
+		})
+		.join("\n");
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Unicode Normalization
 // ═══════════════════════════════════════════════════════════════════════════
@@ -191,27 +299,94 @@ export function normalizeForFuzzy(line: string): string {
  * to each line in newText.
  */
 export function adjustIndentation(oldText: string, actualText: string, newText: string): string {
-	const oldMin = minIndent(oldText);
-	const actualMin = minIndent(actualText);
-	const delta = actualMin - oldMin;
+	// If old text already matches actual text exactly, preserve agent's intended indentation
+	if (oldText === actualText) {
+		return newText;
+	}
+
+	// If the patch is purely an indentation change (same trimmed content), apply exactly as specified
+	const oldLines = oldText.split("\n");
+	const newLines = newText.split("\n");
+	if (oldLines.length === newLines.length) {
+		let indentationOnly = true;
+		for (let i = 0; i < oldLines.length; i++) {
+			if (oldLines[i].trim() !== newLines[i].trim()) {
+				indentationOnly = false;
+				break;
+			}
+		}
+		if (indentationOnly) {
+			return newText;
+		}
+	}
+
+	const oldProfile = buildIndentProfile(oldText);
+	const actualProfile = buildIndentProfile(actualText);
+	const newProfile = buildIndentProfile(newText);
+
+	if (newProfile.nonEmptyCount === 0 || oldProfile.nonEmptyCount === 0 || actualProfile.nonEmptyCount === 0) {
+		return newText;
+	}
+
+	if (oldProfile.mixed || actualProfile.mixed || newProfile.mixed) {
+		return newText;
+	}
+
+	if (oldProfile.char && actualProfile.char && oldProfile.char !== actualProfile.char) {
+		if (actualProfile.spaceOnly && oldProfile.tabOnly && newProfile.tabOnly && actualProfile.unit > 0) {
+			let consistent = true;
+			const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+			for (let i = 0; i < lineCount; i++) {
+				const oldLine = oldProfile.lines[i];
+				const actualLine = actualProfile.lines[i];
+				if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+				const oldIndent = getLeadingWhitespace(oldLine);
+				const actualIndent = getLeadingWhitespace(actualLine);
+				if (oldIndent.length === 0) continue;
+				if (actualIndent.length !== oldIndent.length * actualProfile.unit) {
+					consistent = false;
+					break;
+				}
+			}
+			return consistent ? convertLeadingTabsToSpaces(newText, actualProfile.unit) : newText;
+		}
+		return newText;
+	}
+
+	const lineCount = Math.min(oldProfile.lines.length, actualProfile.lines.length);
+	const deltas: number[] = [];
+	for (let i = 0; i < lineCount; i++) {
+		const oldLine = oldProfile.lines[i];
+		const actualLine = actualProfile.lines[i];
+		if (oldLine.trim().length === 0 || actualLine.trim().length === 0) continue;
+		deltas.push(countLeadingWhitespace(actualLine) - countLeadingWhitespace(oldLine));
+	}
+
+	if (deltas.length === 0) {
+		return newText;
+	}
+
+	const delta = deltas[0];
+	if (!deltas.every((value) => value === delta)) {
+		return newText;
+	}
 
 	if (delta === 0) {
 		return newText;
 	}
 
-	const indentChar = detectIndentChar(actualText);
-	const lines = newText.split("\n");
+	if (newProfile.char && actualProfile.char && newProfile.char !== actualProfile.char) {
+		return newText;
+	}
 
-	const adjusted = lines.map((line) => {
+	const indentChar = actualProfile.char ?? oldProfile.char ?? detectIndentChar(actualText);
+	const adjusted = newText.split("\n").map((line) => {
 		if (line.trim().length === 0) {
-			return line; // Preserve empty/whitespace-only lines as-is
+			return line;
 		}
-
 		if (delta > 0) {
 			return indentChar.repeat(delta) + line;
 		}
-
-		// Remove indentation (delta < 0)
 		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
 		return line.slice(toRemove);
 	});