@gajae-code/coding-agent 0.11.3 → 0.11.4

package/src/modes/components/session-observer-overlay.ts

@@ -8,10 +8,9 @@ import type { SessionMessageEntry } from "../../session/session-manager";
 import { parseSessionEntries } from "../../session/session-manager";
 import type { ObservableSession, SessionObserverRegistry } from "../session-observer-registry";
 import { theme } from "../theme/theme";
+import { composeToolText } from "./tool-transcript-format";
 import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcript-viewer-overlay";
 
-const MAX_TOOL_ARGS_CHARS = 500;
-
 /** Session-observer adapter. The shared viewer owns navigation and fold state. */
 export class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
 	#registry: SessionObserverRegistry;
@@ -191,15 +190,20 @@ function entriesFromMessages(entries: readonly SessionMessageEntry[]): Transcrip
 							.map(part => part.text)
 							.join("\n")
 							.trim() ?? "";
-					const summary = formatToolArgs(content.name, content.arguments);
-					const callText = [summary, content.intent].filter(Boolean).join("\n");
-					const resultDisplay = result?.isError ? `✗ ${resultText || "Error"}` : resultText || "✓ done";
+					const text = composeToolText({
+						name: content.name,
+						args: content.arguments,
+						intent: content.intent,
+						resultText,
+						isError: result?.isError ?? false,
+						hasResult: results.has(content.id),
+					});
 					output.push({
 						id: `tool:${content.id}`,
 						kind: "tool",
 						label: content.name,
 						payload: {
-							text: [callText, resultDisplay].filter(Boolean).join("\n"),
+							text,
 							metadata: {
 								name: content.name,
 								arguments: content.arguments,
@@ -234,23 +238,6 @@ function entriesFromMessages(entries: readonly SessionMessageEntry[]): Transcrip
 	return output;
 }
 
-function formatToolArgs(name: string, args: Record<string, unknown>): string {
-	if (name === "read" || name === "write" || name === "edit") return args.path ? `path: ${args.path}` : "";
-	if (name === "bash") return typeof args.command === "string" ? args.command.replaceAll("\t", "    ") : "";
-	if (name === "search")
-		return [
-			args.pattern ? `pattern: ${args.pattern}` : "",
-			Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
-		]
-			.filter(Boolean)
-			.join(", ");
-	return Object.entries(args)
-		.filter(([key]) => !key.startsWith("_"))
-		.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`)
-		.join(", ")
-		.slice(0, MAX_TOOL_ARGS_CHARS);
-}
-
 function truncateThinking(text: string, expanded: boolean): string {
 	const limit = expanded ? 4_000 : 200;
 	return text.length > limit ? `${text.slice(0, limit)}...` : text;

package/src/modes/components/tool-transcript-format.ts

@@ -0,0 +1,72 @@
+export const MAX_TOOL_ARGS_CHARS = 500;
+export const TOOL_RESULT_MAX_EXPANDED_LINES = 100;
+
+type ToolCallFields = {
+	name: string;
+	args: Record<string, unknown>;
+	intent?: string;
+};
+
+type ToolResultFields = {
+	resultText: string;
+	isError: boolean;
+	hasResult: boolean;
+};
+
+export type ToolTranscriptFields = ToolCallFields & ToolResultFields;
+
+export function formatToolArgs(name: string, args: Record<string, unknown>): string {
+	if (name === "read" || name === "write" || name === "edit") return args.path ? `path: ${args.path}` : "";
+	if (name === "bash") return typeof args.command === "string" ? args.command.replaceAll("\t", "    ") : "";
+	if (name === "search")
+		return [
+			args.pattern ? `pattern: ${args.pattern}` : "",
+			Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
+		]
+			.filter(Boolean)
+			.join(", ");
+	return Object.entries(args)
+		.filter(([key]) => !key.startsWith("_"))
+		.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`)
+		.join(", ")
+		.slice(0, MAX_TOOL_ARGS_CHARS);
+}
+
+export function composeToolCall({ name, args, intent }: ToolCallFields): string {
+	return [formatToolArgs(name, args), intent].filter(Boolean).join("\n");
+}
+
+export function composeToolResult({ resultText, isError, hasResult }: ToolResultFields): string {
+	const text = resultText.trim();
+	if (!hasResult) return "⏳ pending";
+	if (isError) return `✗ ${text || "Error"}`;
+	return text || "✓ done";
+}
+
+export function composeToolText(fields: ToolTranscriptFields): string {
+	return [composeToolCall(fields), composeToolResult(fields)].filter(Boolean).join("\n");
+}
+
+/**
+ * Caps result output without allocating an array for every source line. The final
+ * line count still requires scanning the result so the omitted-line count is exact.
+ */
+function expandedToolResult(result: string): string {
+	let lineCount = 1;
+	let prefixEnd = result.length;
+	for (let index = 0; index < result.length; index++) {
+		if (result[index] !== "\n") continue;
+		if (lineCount === TOOL_RESULT_MAX_EXPANDED_LINES) prefixEnd = index;
+		lineCount += 1;
+	}
+	const prefix = result.slice(0, prefixEnd);
+	return lineCount > TOOL_RESULT_MAX_EXPANDED_LINES
+		? `${prefix}\n... ${lineCount - TOOL_RESULT_MAX_EXPANDED_LINES} more lines`
+		: prefix;
+}
+
+export function toolDisplayText(fields: ToolTranscriptFields, expanded: boolean): string {
+	const call = composeToolCall(fields);
+	if (!expanded) return call;
+	return [call, expandedToolResult(composeToolResult(fields))].filter(Boolean).join("\n");
+}

package/src/modes/components/transcript-viewer-overlay.ts

@@ -11,6 +11,7 @@ import { sanitizeText } from "@gajae-code/utils";
 import { getMarkdownTheme, theme } from "../theme/theme";
 import type { TranscriptItemRegistry, TranscriptSourcePayload } from "../transcript-item-registry";
 import { DynamicBorder } from "./dynamic-border";
+import { toolDisplayText } from "./tool-transcript-format";
 
 const INDENT = "    ";
 const PAGE_SIZE = 15;
@@ -363,6 +364,29 @@ export class TranscriptViewerOverlay extends Container {
 	}
 }
 
+type ToolTranscriptMetadata = {
+	name: string;
+	arguments: Record<string, unknown>;
+	intent?: unknown;
+	resultText: string;
+	isError: boolean;
+	hasResult: boolean;
+};
+
+function hasToolTranscriptMetadata(
+	metadata: Readonly<Record<string, unknown>>,
+): metadata is Readonly<ToolTranscriptMetadata> {
+	return (
+		typeof metadata.name === "string" &&
+		metadata.arguments !== null &&
+		typeof metadata.arguments === "object" &&
+		!Array.isArray(metadata.arguments) &&
+		typeof metadata.resultText === "string" &&
+		typeof metadata.isError === "boolean" &&
+		typeof metadata.hasResult === "boolean"
+	);
+}
+
 /** Main-session adapter over the registry's canonical payload resolver. */
 export function transcriptViewerEntries(registry: TranscriptItemRegistry): TranscriptViewerEntry[] {
 	return registry.items().flatMap(item => {
@@ -375,10 +399,26 @@ export function transcriptViewerEntries(registry: TranscriptItemRegistry): Trans
 				: item.kind === "assistant-thinking"
 					? "Thinking"
 					: item.kind === "tool"
-						? "Tool"
+						? String(payload.metadata.name ?? "Tool")
 						: item.kind === "user"
 							? "User"
 							: item.kind;
-		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities }];
+		const toolMetadata = hasToolTranscriptMetadata(payload.metadata) ? payload.metadata : undefined;
+		const getDisplayText =
+			item.kind === "tool" && toolMetadata
+				? (expanded: boolean) =>
+						toolDisplayText(
+							{
+								name: toolMetadata.name,
+								args: toolMetadata.arguments,
+								intent: typeof toolMetadata.intent === "string" ? toolMetadata.intent : undefined,
+								resultText: toolMetadata.resultText,
+								isError: toolMetadata.isError,
+								hasResult: toolMetadata.hasResult,
+							},
+							expanded,
+						)
+				: undefined;
+		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities, getDisplayText }];
 	});
 }

package/src/modes/controllers/input-controller.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
 import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@gajae-code/tui";
-import { $env, sanitizeText } from "@gajae-code/utils";
+import { $env, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
 import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
@@ -22,12 +22,14 @@ import { getUserMessageViewportAnchorIds } from "../../session/session-manager";
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
-import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
+import { ensureSupportedImageInput, ImageInputTooLargeError } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
-import { formatPastedImageReference, resolvePastedImagePath } from "../../utils/pasted-image-path";
+import { loadPastedImageBatch, PastedImageBatchError } from "../../utils/pasted-image-loading";
+import { formatPastedImageReference, parsePastedImagePaths } from "../../utils/pasted-image-path";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 import { ActionRegistry, APP_ACTION_METADATA } from "../action-registry";
 import { CommandPalette, type CommandPaletteAction, type CommandPaletteEntry } from "../components/command-palette";
+import type { PasteTextContext } from "../components/custom-editor";
 import { QueuePaneComponent } from "../components/queue-pane";
 import { type QueuedMessageMoveDirection, QueuedMessageSelectorComponent } from "../components/queued-message-selector";
 
@@ -44,14 +46,23 @@ const EMPTY_EDITOR_DOUBLE_ESCAPE_WINDOW_MS = 500;
 const IMAGE_PLACEHOLDER_PATTERN = /\[image ([1-9]\d*)\]/g;
 const IMAGE_PLACEHOLDER_PRESENT_PATTERN = /\[image [1-9]\d*\]/;
 
+interface InputControllerDependencies {
+	loadPastedImageBatch?: typeof loadPastedImageBatch;
+}
+
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 
 export class InputController {
 	readonly actionRegistry: ActionRegistry<void>;
+	readonly #loadPastedImageBatch: typeof loadPastedImageBatch;
 
-	constructor(private ctx: InteractiveModeContext) {
+	constructor(
+		private ctx: InteractiveModeContext,
+		dependencies: InputControllerDependencies = {},
+	) {
+		this.#loadPastedImageBatch = dependencies.loadPastedImageBatch ?? loadPastedImageBatch;
 		this.actionRegistry = new ActionRegistry({
 			context: undefined,
 			showError: actionId => this.ctx.showError(actionId),
@@ -585,11 +596,11 @@ export class InputController {
 		);
 		this.ctx.editor.onCopyPrompt = () => this.#executeAction("app.clipboard.copyPrompt");
 		this.#registerCommandPaletteAction("app.clipboard.copyPrompt", copyPrompt);
-		this.ctx.editor.onPasteText = text => this.handleTextPaste(text);
-		this.ctx.editor.onPastePendingInputCleared = (reason, droppedInputCount) => {
+		this.ctx.editor.onPasteText = (text, context) => this.handleTextPaste(text, context);
+		this.ctx.editor.onPastePendingInputCleared = (reason, restoredInputCount) => {
 			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
 			this.ctx.showWarning(
-				`Paste handling ${reasonText}; discarded ${droppedInputCount} buffered input event${droppedInputCount === 1 ? "" : "s"}.`,
+				`Paste handling ${reasonText}; restored the original paste and ${restoredInputCount} buffered input event${restoredInputCount === 1 ? "" : "s"}.`,
 			);
 		};
 		const expandTools = () => this.toggleToolOutputExpansion();
@@ -1522,46 +1533,96 @@ export class InputController {
 		return true;
 	}
 
-	handleTextPaste(text: string): boolean | Promise<boolean> {
-		const imagePath = resolvePastedImagePath(text, { cwd: this.ctx.sessionManager.getCwd() });
-		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
+	handleTextPaste(text: string, context: PasteTextContext): boolean | Promise<boolean> {
+		if (this.ctx.isBashMode || this.ctx.isPythonMode) return false;
+		const parsed = parsePastedImagePaths(text, { cwd: this.ctx.sessionManager.getCwd() });
+		if (!parsed) return false;
+		if (parsed.kind === "too-many") {
+			this.ctx.showStatus(`Cannot attach more than ${parsed.maxCandidates} pasted images.`);
+			return false;
+		}
+		return this.#attachPastedImagePaths(parsed.paths, parsed.requiresConfirmation, context);
 	}
 
-	/**
-	 * Returns `false` on every failure path so the editor replays the original
-	 * bracketed paste — the raw path text must never be lost when attachment
-	 * is impossible (unsupported content, oversized image, load error).
-	 */
-	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
+	/** Return false on every failure so CustomEditor restores the exact paste. */
+	async #attachPastedImagePaths(
+		imagePaths: readonly string[],
+		requiresConfirmation: boolean,
+		context: PasteTextContext,
+	): Promise<boolean> {
+		const signal = context.signal;
+		const editor = this.ctx.editor;
+		const editorText = editor.getText();
+		const pendingImages = this.ctx.pendingImages;
+		const pendingImageCount = pendingImages.length;
 		try {
-			const image = await loadImageInput({
-				path: imagePath,
-				cwd: this.ctx.sessionManager.getCwd(),
+			if (requiresConfirmation) {
+				const selection = await this.ctx.showHookSelector(
+					`Attach ${imagePaths.length} pasted images?\nOnly attach files you intend to send to the model.`,
+					["Attach images", "Paste paths literally"],
+					{ signal, helpText: "Enter: choose · Esc: paste paths literally" },
+				);
+				signal.throwIfAborted();
+				if (selection !== "Attach images") return false;
+			}
+
+			const loaded = await this.#loadPastedImageBatch({
+				paths: imagePaths,
 				autoResize: this.ctx.settings.get("images.autoResize"),
+				sourcePolicy: requiresConfirmation ? "confirmed" : "automatic-temp",
+				signal,
 			});
-			if (!image) {
-				this.ctx.showStatus("Unsupported pasted image file");
-				return false;
-			}
+			signal.throwIfAborted();
+			return context.commit(() => {
+				if (
+					this.ctx.editor !== editor ||
+					editor.getText() !== editorText ||
+					this.ctx.pendingImages !== pendingImages ||
+					pendingImages.length !== pendingImageCount
+				) {
+					return false;
+				}
 
-			this.ctx.pendingImages = [
-				...this.ctx.pendingImages,
-				{
-					type: "image",
-					data: image.data,
-					mimeType: image.mimeType,
-				},
-			];
-			this.ctx.editor.insertText(`${formatPastedImageReference(this.#nextImagePlaceholder(), image.resolvedPath)} `);
-			this.ctx.showStatus(`Attached image: ${path.basename(image.resolvedPath)}`, { dim: true });
-			this.ctx.ui.requestRender();
-			return true;
+				const firstImageNumber = pendingImages.length + 1;
+				const references = loaded.sourcePaths.map((sourcePath, index) =>
+					formatPastedImageReference(`[image ${firstImageNumber + index}]`, sourcePath),
+				);
+				try {
+					editor.insertText(`${references.join(" ")} `);
+					this.ctx.pendingImages = [...pendingImages, ...loaded.images];
+				} catch (error) {
+					try {
+						editor.setText(editorText);
+					} catch {
+						// Preserve the original mutation error when rollback itself fails.
+					} finally {
+						this.ctx.pendingImages = pendingImages;
+					}
+					throw error;
+				}
+
+				try {
+					this.ctx.showStatus(
+						loaded.images.length === 1
+							? `Attached image: ${path.basename(loaded.sourcePaths[0] ?? "")}`
+							: `Attached ${loaded.images.length} images`,
+						{ dim: true },
+					);
+					this.ctx.ui.requestRender();
+				} catch (error) {
+					logger.warn("Pasted images attached but status rendering failed", { error: String(error) });
+				}
+				return true;
+			});
 		} catch (error) {
-			if (error instanceof ImageInputTooLargeError) {
+			if (signal.aborted) return false;
+			if (error instanceof ImageInputTooLargeError || error instanceof PastedImageBatchError) {
 				this.ctx.showStatus(error.message);
 				return false;
 			}
-			this.ctx.showStatus("Failed to attach pasted image");
+			this.ctx.showStatus(
+				imagePaths.length === 1 ? "Failed to attach pasted image" : "Failed to attach pasted images",
+			);
 			return false;
 		}
 	}

package/src/modes/controllers/selector-controller.ts

@@ -1060,7 +1060,7 @@ export class SelectorController {
 			};
 			wizard = new CustomProviderWizardComponent(
 				input => {
-					void submit(input);
+					return submit(input);
 				},
 				() => {
 					done();

package/src/modes/interactive-mode.ts

@@ -62,6 +62,7 @@ import {
 } from "./components/pet-capability";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { StatusLineComponent } from "./components/tool-status-header";
+import { composeToolText } from "./components/tool-transcript-format";
 import {
 	WelcomeComponent,
 	type WelcomeLogoMode,
@@ -1817,17 +1818,27 @@ export class InteractiveMode implements InteractiveModeContext {
 						result?.content
 							.filter(part => part.type === "text")
 							.map(part => part.text)
-							.join("\n") ?? "";
+							.join("\n")
+							.trim() ?? "";
 					items.push({
 						kind: "tool",
 						source: { toolCallId: content.id, content, result },
 						getPayload: () => ({
-							text: resultText || JSON.stringify(content.arguments, null, 2),
+							text: composeToolText({
+								name: content.name,
+								args: content.arguments,
+								intent: content.intent,
+								resultText,
+								isError: result?.isError ?? false,
+								hasResult: toolResults.has(content.id),
+							}),
 							metadata: {
 								name: content.name,
 								arguments: content.arguments,
 								intent: content.intent,
 								isError: result?.isError ?? false,
+								resultText,
+								hasResult: toolResults.has(content.id),
 							},
 							source: { content, result },
 						}),