@oh-my-pi/pi-coding-agent 14.3.0 → 14.4.1

package/src/edit/index.ts

@@ -9,6 +9,7 @@ import {
 	writethroughNoop,
 } from "../lsp";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
+import atomDescription from "../prompts/tools/atom.md" with { type: "text" };
 import chunkEditDescription from "../prompts/tools/chunk-edit.md" with { type: "text" };
 import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
@@ -17,44 +18,33 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import {
-	type ApplyPatchParams,
-	applyPatchSchema,
-	expandApplyPatchToEntries,
-	isApplyPatchParams,
-} from "./modes/apply-patch";
+import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
+import {
+	type AtomParams,
+	type AtomToolEdit,
+	atomEditParamsSchema,
+	executeAtomSingle,
+	resolveAtomEntryPaths,
+} from "./modes/atom";
 import {
 	type ChunkParams,
 	type ChunkToolEdit,
 	chunkEditParamsSchema,
 	executeChunkSingle,
-	isChunkParams,
 	parseChunkEditPath,
 	resolveAnchorStyle,
 	resolveChunkAutoIndent,
 } from "./modes/chunk";
 import {
 	executeHashlineSingle,
+	HashlineMismatchError,
 	type HashlineParams,
 	type HashlineToolEdit,
 	hashlineEditParamsSchema,
-	isHashlineParams,
 } from "./modes/hashline";
-import {
-	executePatchSingle,
-	isPatchParams,
-	type PatchEditEntry,
-	type PatchParams,
-	patchEditSchema,
-} from "./modes/patch";
-import {
-	executeReplaceSingle,
-	isReplaceParams,
-	type ReplaceEditEntry,
-	type ReplaceParams,
-	replaceEditSchema,
-} from "./modes/replace";
+import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
+import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
@@ -62,6 +52,7 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
 export * from "./modes/apply-patch";
+export * from "./modes/atom";
 export * from "./modes/chunk";
 export * from "./modes/hashline";
 export * from "./modes/patch";
@@ -74,19 +65,25 @@ type TInput =
 	| typeof replaceEditSchema
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
+	| typeof atomEditParamsSchema
 	| typeof chunkEditParamsSchema
 	| typeof vimSchema
 	| typeof applyPatchSchema;
 
 type VimParams = Static<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams | ApplyPatchParams;
+type EditParams =
+	| ReplaceParams
+	| PatchParams
+	| HashlineParams
+	| AtomParams
+	| ChunkParams
+	| VimParams
+	| ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
 	parameters: TInput;
-	invalidParamsMessage: string;
-	validate: (params: EditParams) => boolean;
 	execute: (
 		tool: EditTool,
 		params: EditParams,
@@ -109,10 +106,6 @@ function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
 	return editMode;
 }
 
-function isVimParams(params: EditParams): params is VimParams {
-	return typeof params === "object" && params !== null && "file" in params && typeof params.file === "string";
-}
-
 function resolveAllowFuzzy(session: ToolSession, rawValue: string): boolean {
 	switch (rawValue) {
 		case "true":
@@ -148,6 +141,25 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
 }
 
+/**
+ * Resolve per-entry `path` against an optional top-level `path` default.
+ * If both are absent on an entry, throws a descriptive error.
+ */
+function resolveEntryPaths<T extends { path?: string }>(
+	edits: readonly T[],
+	topLevelPath: string | undefined,
+): (T & { path: string })[] {
+	return edits.map((edit, i) => {
+		const path = (edit && typeof edit.path === "string" && edit.path) || topLevelPath;
+		if (!path) {
+			throw new Error(
+				`Edit ${i}: missing \`path\`. Provide \`path\` on this edit or supply a top-level \`path\` for the request.`,
+			);
+		}
+		return { ...edit, path };
+	});
+}
+
 /** Group items by a key, preserving insertion order. */
 function groupBy<T, K>(items: T[], key: (item: T) => K): Map<K, T[]> {
 	const map = new Map<K, T[]>();
@@ -203,7 +215,8 @@ async function executePerFile(
 			if (text) contentTexts.push(text);
 		} catch (err) {
 			const errorText = err instanceof Error ? err.message : String(err);
-			perFileResults.push({ path, diff: "", isError: true, errorText });
+			const displayErrorText = err instanceof HashlineMismatchError ? err.displayMessage : undefined;
+			perFileResults.push({ path, diff: "", isError: true, errorText, displayErrorText });
 			contentTexts.push(`Error editing ${path}: ${errorText}`);
 		}
 
@@ -307,10 +320,6 @@ export class EditTool implements AgentTool<TInput> {
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<EditToolResultDetails, TInput>> {
 		const modeDefinition = this.#getModeDefinition();
-		if (!modeDefinition.validate(params)) {
-			throw new Error(modeDefinition.invalidParamsMessage);
-		}
-
 		return modeDefinition.execute(this, params, signal, getLspBatchRequest(context?.toolCall), onUpdate);
 	}
 
@@ -323,9 +332,6 @@ export class EditTool implements AgentTool<TInput> {
 						chunkAutoIndent: resolveChunkAutoIndent(),
 					}),
 				parameters: chunkEditParamsSchema,
-				invalidParamsMessage:
-					"Invalid edit parameters for chunk mode. Expected `{ edits: [{ path: 'file:selector', ...op }, ...] }` with at least one edit. Each edit needs a `path`; supply exactly one of `write: 'content'`, `insert: { loc, body }`, or `delete: true`.",
-				validate: isChunkParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -333,8 +339,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as ChunkParams;
-					const byFile = groupBy(edits, (e: ChunkToolEdit) => parseChunkEditPath(e.path).filePath);
+					const { edits, path: topPath } = params as ChunkParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as ChunkToolEdit[], topPath);
+					const byFile = groupBy(resolved, (e: ChunkToolEdit) => parseChunkEditPath(e.path).filePath);
 					const entries = [...byFile.entries()].map(([filePath, fileEdits]) => ({
 						path: filePath,
 						run: (br: LspBatchRequest | undefined) =>
@@ -354,8 +361,6 @@ export class EditTool implements AgentTool<TInput> {
 			patch: {
 				description: () => prompt.render(patchDescription),
 				parameters: patchEditSchema,
-				invalidParamsMessage: "Invalid edit parameters for patch mode.",
-				validate: isPatchParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -363,8 +368,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as PatchParams;
-					const entries = edits.map((entry: PatchEditEntry) => ({
+					const { edits, path: topPath } = params as PatchParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as PatchEditEntry[], topPath);
+					const entries = resolved.map(entry => ({
 						path: entry.path,
 						run: (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
@@ -384,8 +390,6 @@ export class EditTool implements AgentTool<TInput> {
 			apply_patch: {
 				description: () => prompt.render(applyPatchDescription),
 				parameters: applyPatchSchema,
-				invalidParamsMessage: "Invalid edit parameters for apply_patch mode.",
-				validate: isApplyPatchParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -394,8 +398,8 @@ export class EditTool implements AgentTool<TInput> {
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
 					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
-					const perFile = entries.map((entry: PatchEditEntry) => ({
-						path: entry.path,
+					const perFile = entries.map(entry => ({
+						path: entry.path!,
 						run: (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
 								session: tool.session,
@@ -414,8 +418,6 @@ export class EditTool implements AgentTool<TInput> {
 			hashline: {
 				description: () => prompt.render(hashlineDescription),
 				parameters: hashlineEditParamsSchema,
-				invalidParamsMessage: "Invalid edit parameters for hashline mode.",
-				validate: isHashlineParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -423,8 +425,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as HashlineParams;
-					const byFile = groupBy(edits, (e: HashlineToolEdit) => e.path);
+					const { edits, path: topPath } = params as HashlineParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as HashlineToolEdit[], topPath);
+					const byFile = groupBy(resolved, e => e.path);
 					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
 						path,
 						run: (br: LspBatchRequest | undefined) =>
@@ -441,11 +444,38 @@ export class EditTool implements AgentTool<TInput> {
 					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
+			atom: {
+				description: () => prompt.render(atomDescription),
+				parameters: atomEditParamsSchema,
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits, path: topPath } = params as AtomParams & { path?: string };
+					const resolved = resolveAtomEntryPaths(edits as AtomToolEdit[], topPath);
+					const byFile = groupBy(resolved, e => e.path);
+					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
+						path,
+						run: (br: LspBatchRequest | undefined) =>
+							executeAtomSingle({
+								session: tool.session,
+								path,
+								edits: fileEdits,
+								signal,
+								batchRequest: br,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
+				},
+			},
 			replace: {
 				description: () => prompt.render(replaceDescription),
 				parameters: replaceEditSchema,
-				invalidParamsMessage: "Invalid edit parameters for replace mode.",
-				validate: isReplaceParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -453,8 +483,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as ReplaceParams;
-					const entries = edits.map((entry: ReplaceEditEntry) => ({
+					const { edits, path: topPath } = params as ReplaceParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as ReplaceEditEntry[], topPath);
+					const entries = resolved.map(entry => ({
 						path: entry.path,
 						run: (br: LspBatchRequest | undefined) =>
 							executeReplaceSingle({
@@ -474,8 +505,6 @@ export class EditTool implements AgentTool<TInput> {
 			vim: {
 				description: () => this.#vimTool.description,
 				parameters: vimSchema,
-				invalidParamsMessage: "Invalid edit parameters for vim mode.",
-				validate: isVimParams,
 				execute: async (
 					tool: EditTool,
 					params: EditParams,