@gajae-code/coding-agent 0.9.6 → 0.10.1

package/src/modes/interactive-mode.ts

@@ -21,6 +21,7 @@ import {
 	getRenderCacheRetainedBytes,
 	Loader,
 	Markdown,
+	onImageProtocolChanged,
 	ProcessTerminal,
 	Spacer,
 	Text,
@@ -81,9 +82,11 @@ import type { BashExecutionComponent } from "./components/bash-execution";
 import { CustomEditor } from "./components/custom-editor";
 import { DynamicBorder } from "./components/dynamic-border";
 import type { EvalExecutionComponent } from "./components/eval-execution";
+import { GajaePetWidget, type PetMode } from "./components/gajae-pet-widget";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
+import { IrcSplitViewComponent } from "./components/irc-sidebar";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import {
@@ -99,6 +102,7 @@ import { InputController } from "./controllers/input-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import { IrcObservationLedger } from "./irc-observation-ledger";
 import { JobsObserver } from "./jobs-observer";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
@@ -114,13 +118,42 @@ import {
 	onThemeChange,
 	theme,
 } from "./theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
-import { addChatChild, UiHelpers } from "./utils/ui-helpers";
+import type {
+	CompactionQueuedMessage,
+	InteractiveModeContext,
+	IrcArrivalSnapshot,
+	SubmittedUserInput,
+	TodoItem,
+	TodoPhase,
+	TranscriptRebuildPolicy,
+} from "./types";
+import type { ParsedIrcMessage } from "./utils/irc-message";
+import { addChatChild, prepareTranscriptRebuild, UiHelpers } from "./utils/ui-helpers";
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
 const COMPOSER_NEWLINE_HINT = process.platform === "win32" ? "Alt+Enter/Ctrl+J" : "Shift+Enter/Ctrl+J";
 export const DEFAULT_COMPOSER_PLACEHOLDER = `Type your message... ${COMPOSER_NEWLINE_HINT}: New line · Ctrl+C: Clear · Ctrl+R: Search history · Shift+Tab: Reasoning`;
 const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
+
+const IRC_SIDEBAR_TOGGLE_SHADOWING_ACTIONS: readonly AppKeybinding[] = [
+	"app.plan.toggle",
+	"app.session.new",
+	"app.session.tree",
+	"app.session.fork",
+	"app.session.resume",
+	"app.message.followUp",
+	"app.stt.toggle",
+	"app.clipboard.copyLine",
+	"app.session.observe",
+	"app.jobs.open",
+	"app.tool.backgroundFold",
+];
+
+export function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number {
+	return chatContainer.children.length === 0 || chatContainer.children.length > WELCOME_RESERVED_CONTAINER_CHILD_LIMIT
+		? 0
+		: chatContainer.render(width).length;
+}
 const FRIENDLY_KEY_PARTS: Record<string, string> = {
 	alt: "Alt",
 	cmd: "Cmd",
@@ -280,6 +313,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	keybindings: KeybindingsManager;
 	agent: Agent;
 	historyStorage?: HistoryStorage;
+	readonly ircLedger = new IrcObservationLedger();
 
 	ui: TUI;
 	chatContainer: Container;
@@ -291,6 +325,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
 	hookWidgetContainerBelow: Container;
+	petFloorContainer: Container = new Container();
+	petWidget: GajaePetWidget | undefined;
 	statusLine: StatusLineComponent;
 
 	isInitialized = false;
@@ -352,6 +388,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#baseReservedSlashCommandNames: Set<string> = new Set();
 	#cleanupUnsubscribe?: () => void;
 	#subprocessTeardownUnsubscribe?: () => void;
+	#petProtocolUnsubscribe?: () => void;
 	readonly #version: string;
 	readonly #changelogMarkdown: string | undefined;
 	#planModePreviousTools: string[] | undefined;
@@ -387,6 +424,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
+	#ircSplitView: IrcSplitViewComponent;
+	#ircSidebarAvailable = false;
+	#ircSidebarRequestedVisible = false;
 
 	constructor(
 		session: AgentSession,
@@ -423,6 +463,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui = new TUI(new ProcessTerminal(), settings.get("showHardwareCursor"));
 		this.ui.setClearOnShrink(settings.get("clearOnShrink"));
 		this.chatContainer = new Container();
+		this.#ircSplitView = new IrcSplitViewComponent(this.chatContainer, this.ircLedger, () => theme);
 		this.pendingMessagesContainer = new Container();
 		this.statusContainer = new Container();
 		this.todoContainer = new Container();
@@ -442,6 +483,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#syncEditorMaxHeight();
 			this.updateEditorChrome();
 			this.editor.invalidate();
+			this.#invalidateIrcSidebarRender();
 			this.ui.requestResizeRender();
 		};
 		process.stdout.on("resize", this.#resizeHandler);
@@ -561,7 +603,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#welcomeComponent.playIntro(() => this.ui.requestRender());
 		}
 
-		this.ui.addChild(this.chatContainer);
+		this.ui.addChild(this.#ircSplitView);
+		this.ui.setViewportAnchorComponent(this.#ircSplitView);
+
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
 		this.ui.addChild(this.todoContainer);
@@ -569,9 +613,24 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.statusLine); // Main status rail + hook statuses; composer chrome is rendered by the editor.
 		this.ui.addChild(this.hookWidgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
+		this.ui.addChild(this.petFloorContainer);
 		this.ui.addChild(this.hookWidgetContainerBelow);
 		this.ui.setBottomPinnedComponent(this.statusLine);
 		this.ui.setFocus(this.editor);
+		this.petWidget = this.#createPetWidget(this.editor);
+		this.petWidget.setMode(settings.get("pet.mode"));
+		// The async sixel capability probe can enable graphics after the saved
+		// pet mode was applied and dropped (no protocol yet at startup).
+		// Re-apply the configured mode when capability arrives so the pet
+		// appears without the user re-running /pet.
+		this.#petProtocolUnsubscribe?.();
+		this.#petProtocolUnsubscribe = onImageProtocolChanged(protocol => {
+			if (!protocol) return;
+			const saved = settings.get("pet.mode");
+			if (saved !== "off" && this.petWidget && this.petWidget.mode === "off") {
+				this.petWidget.setMode(saved);
+			}
+		});
 
 		this.#inputController.setupKeyHandlers();
 		this.#inputController.setupEditorSubmitHandler();
@@ -609,6 +668,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.updateEditorChrome();
 		this.#syncEditorMaxHeight();
 		this.isInitialized = true;
+		this.#syncIrcSidebarAvailabilityFromSettings();
 		this.ui.requestRender(true);
 
 		// GitHub star reminder (interactive-only). Register the decline-driven
@@ -874,7 +934,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		if (!submission.customType) {
 			this.pendingImages = submission.images ? [...submission.images] : [];
-			this.rebuildChatFromMessages();
+			this.rebuildChatFromMessages("reconcile-same-transcript");
 			this.editor.setText(submission.text);
 		}
 		this.updateEditorChrome();
@@ -950,8 +1010,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	#getWelcomeReservedRows(width: number): number {
+		const transcriptRows = getWelcomeTranscriptReservedRows(this.chatContainer, width);
+
 		const transientRows = [
-			this.chatContainer,
 			this.pendingMessagesContainer,
 			this.statusContainer,
 			this.todoContainer,
@@ -965,7 +1026,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.hookWidgetContainerBelow,
 		].reduce((rows, component) => rows + component.render(width).length, 0);
 
-		return transientRows + pinnedRows;
+		return transcriptRows + transientRows + pinnedRows;
 	}
 
 	#renderShortContainerRowsForWelcomeReservation(width: number, container: Container): number {
@@ -1017,7 +1078,42 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.editor.setTopBorder(undefined);
 	}
 
-	rebuildChatFromMessages(): void {
+	setPetMode(mode: PetMode): void {
+		this.petWidget?.setMode(mode);
+		settings.set("pet.mode", mode);
+		this.ui.requestRender();
+	}
+
+	previewPetMode(mode: PetMode): void {
+		this.petWidget?.previewMode(mode);
+		this.ui.requestRender();
+	}
+
+	restoreComposer(): void {
+		if (this.petWidget) {
+			this.petWidget.remountComposer();
+		} else {
+			this.editorContainer.clear();
+			this.editorContainer.addChild(this.editor);
+		}
+		this.ui.setFocus(this.editor);
+	}
+
+	#createPetWidget(editor: CustomEditor): GajaePetWidget {
+		return new GajaePetWidget({
+			ui: this.ui,
+			editor,
+			editorContainer: this.editorContainer,
+			floorContainer: this.petFloorContainer,
+			isWorking: () => this.loadingAnimation !== undefined,
+			getComposerBottomOffset: () =>
+				this.petFloorContainer.render(this.ui.terminal.columns).length +
+				this.hookWidgetContainerBelow.render(this.ui.terminal.columns).length,
+		});
+	}
+
+	rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void {
+		prepareTranscriptRebuild(this.ui, policy);
 		this.chatContainer.clear();
 		const context = this.session.buildDisplaySessionContext();
 		this.renderSessionContext(context);
@@ -1992,6 +2088,10 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	stop(): void {
+		this.#petProtocolUnsubscribe?.();
+		this.#petProtocolUnsubscribe = undefined;
+		this.petWidget?.dispose();
+		this.petWidget = undefined;
 		if (this.loadingAnimation) {
 			this.loadingAnimation.stop();
 			this.loadingAnimation = undefined;
@@ -2123,11 +2223,17 @@ export class InteractiveMode implements InteractiveModeContext {
 		nextEditor.setText(previousText);
 		previousEditor.dispose();
 
+		const petMode = this.petWidget?.mode ?? settings.get("pet.mode");
+		this.petWidget?.dispose();
+
 		this.editorContainer.clear();
 		this.editor = nextEditor;
 		this.editorContainer.addChild(nextEditor);
 		this.ui.setFocus(nextEditor);
 
+		this.petWidget = this.#createPetWidget(nextEditor);
+		this.petWidget.setMode(petMode);
+
 		this.#inputController.setupKeyHandlers();
 		this.#inputController.setupEditorSubmitHandler();
 
@@ -2284,13 +2390,32 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#uiHelpers.addMessageToChat(message, options);
 	}
 
+	addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[] {
+		return this.#uiHelpers.addLiveIrcObservationToChat(message, arrival);
+	}
+	removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined {
+		return this.#uiHelpers.removeRenderedIrcInlineComponents(observationId);
+	}
+	resetRenderedIrcInlineComponents(): readonly (readonly Component[])[] {
+		return this.#uiHelpers.resetRenderedIrcInlineComponents();
+	}
+
 	renderSessionContext(
 		sessionContext: SessionContext,
 		options?: { updateFooter?: boolean; populateHistory?: boolean },
 	): void {
 		this.#uiHelpers.renderSessionContext(sessionContext, options);
+		this.#eventController.reconcileIrcExpiryTimers(this.#uiHelpers.getRenderedIrcInlineComponents());
 	}
 
+	rebuildInitialMessages(
+		policy: TranscriptRebuildPolicy,
+		prebuiltContext?: SessionContext,
+		options?: { preserveExistingChat?: boolean },
+	): void {
+		prepareTranscriptRebuild(this.ui, policy);
+		this.#uiHelpers.renderInitialMessages(prebuiltContext, options);
+	}
 	renderInitialMessages(prebuiltContext?: SessionContext, options?: { preserveExistingChat?: boolean }): void {
 		this.#uiHelpers.renderInitialMessages(prebuiltContext, options);
 	}
@@ -2303,6 +2428,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#uiHelpers.findLastAssistantMessage();
 	}
 
+	getAssistantViewportAnchorId(message: AssistantMessage): string {
+		return this.#uiHelpers.assistantViewportAnchorId(message);
+	}
+
 	extractAssistantText(message: AssistantMessage): string {
 		return this.#uiHelpers.extractAssistantText(message);
 	}
@@ -2553,6 +2682,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showThemeSelector();
 	}
 
+	showPetSelector(): void {
+		this.#selectorController.showPetSelector();
+	}
+
 	showHistorySearch(): void {
 		this.#selectorController.showHistorySearch();
 	}
@@ -2668,6 +2801,65 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#inputController.setToolsExpanded(expanded);
 	}
 
+	#resolveEffectiveIrcSidebarToggleKey(): string | null {
+		for (const key of this.keybindings.getKeys("app.irc.sidebar.toggle")) {
+			if (this.editor.hasActionKey(key)) continue;
+			const shadowed = IRC_SIDEBAR_TOGGLE_SHADOWING_ACTIONS.some(action =>
+				this.keybindings.getKeys(action).includes(key),
+			);
+			if (!shadowed) return key;
+		}
+		return null;
+	}
+
+	captureIrcArrivalSnapshot(): IrcArrivalSnapshot {
+		return {
+			panelVisible: this.#ircSplitView.effectiveSidebarVisible(this.ui.terminal.columns),
+			panelRequestedVisible: this.#ircSidebarRequestedVisible,
+			sidebarAvailable: this.#ircSidebarAvailable,
+			resolvedToggleKey: this.#resolveEffectiveIrcSidebarToggleKey(),
+		};
+	}
+	toggleIrcSidebar(): void {
+		if (
+			!this.#ircSidebarAvailable ||
+			this.settings.get("irc.enabled") !== true ||
+			this.settings.get("irc.sidebar.enabled") !== true
+		)
+			return;
+		this.#ircSidebarRequestedVisible = !this.#ircSidebarRequestedVisible;
+		this.#ircSplitView.setVisible(this.#ircSidebarRequestedVisible);
+		this.#invalidateIrcSidebarRender();
+		this.ui.requestRender();
+	}
+
+	applyIrcSidebarAvailability(enabled: boolean): void {
+		this.#ircSidebarAvailable = enabled;
+		this.#ircSplitView.setVisible(enabled && this.#ircSidebarRequestedVisible);
+		this.#invalidateIrcSidebarRender();
+		this.ui.requestRender();
+	}
+
+	#syncIrcSidebarAvailabilityFromSettings(): void {
+		this.applyIrcSidebarAvailability(
+			this.settings.get("irc.enabled") === true && this.settings.get("irc.sidebar.enabled") === true,
+		);
+	}
+
+	resetIrcSidebarSession(): void {
+		this.ircLedger.reset();
+		this.#eventController.resetIrcObservations();
+		this.#ircSidebarRequestedVisible = false;
+		this.#ircSplitView.setVisible(false);
+		this.#uiHelpers.resetIrcSidebarHint();
+		this.#syncIrcSidebarAvailabilityFromSettings();
+	}
+
+	#invalidateIrcSidebarRender(): void {
+		clearRenderCache();
+		this.#ircSplitView.invalidate();
+	}
+
 	toggleThinkingBlockVisibility(): void {
 		this.#inputController.toggleThinkingBlockVisibility();
 	}

package/src/modes/irc-observation-ledger.ts

@@ -0,0 +1,127 @@
+import * as crypto from "node:crypto";
+
+import type { ParsedIrcMessage } from "./utils/irc-message";
+
+type InlineMode = "persistent" | "ephemeral";
+
+const MAX_RECORDS = 10_000;
+const MAX_RETAINED_UTF8_BYTES = 16 * 1024 * 1024;
+const MAX_SEEN_IDENTITIES = 100_000;
+
+export type IrcObservationRecord = Readonly<
+	ParsedIrcMessage & {
+		mode: InlineMode;
+		observedAt: number;
+		sequence: number;
+		expiresAt?: number;
+		retainedUtf8Bytes: number;
+	}
+>;
+
+function measureRetainedUtf8Bytes(message: ParsedIrcMessage): number {
+	let bytes = 4;
+	for (const value of [message.observationId, message.from, message.to, message.text, message.kind]) {
+		bytes += Buffer.byteLength(value, "utf8");
+		if (bytes > MAX_RETAINED_UTF8_BYTES) return bytes;
+	}
+	return bytes;
+}
+
+function tombstoneIdentity(observationId: string): string {
+	const hash = crypto.createHash("sha256");
+	hash.update("gjc:irc:observation-id:utf16le:v1\0");
+	for (let offset = 0; offset < observationId.length; offset += 4_096) {
+		hash.update(Buffer.from(observationId.slice(offset, offset + 4_096), "utf16le"));
+	}
+	return hash.digest("hex");
+}
+
+/** Runtime-only IRC observations. This intentionally has no persistence layer. */
+export class IrcObservationLedger {
+	#records = new Map<string, IrcObservationRecord>();
+	#retainedUtf8Bytes = 0;
+	#nextSequence = 0;
+	#seenObservationIdentities = new Set<string>();
+	#identityCapacityExhausted = false;
+	#evictedObservationIds = new Set<string>();
+
+	#rememberObservationIdentity(observationId: string): boolean {
+		const identity = tombstoneIdentity(observationId);
+		if (this.#seenObservationIdentities.has(identity) || this.#identityCapacityExhausted) return false;
+		if (this.#seenObservationIdentities.size >= MAX_SEEN_IDENTITIES) {
+			this.#identityCapacityExhausted = true;
+			return false;
+		}
+		this.#seenObservationIdentities.add(identity);
+		return true;
+	}
+
+	#evict(observationId: string): void {
+		const record = this.#records.get(observationId);
+		if (!record) return;
+		this.#records.delete(observationId);
+		this.#retainedUtf8Bytes -= record.retainedUtf8Bytes;
+		this.#evictedObservationIds.add(observationId);
+	}
+
+	#enforceBounds(): void {
+		while (this.#records.size > MAX_RECORDS || this.#retainedUtf8Bytes > MAX_RETAINED_UTF8_BYTES) {
+			const oldestObservationId = this.#records.keys().next().value;
+			if (oldestObservationId === undefined) return;
+			this.#evict(oldestObservationId);
+		}
+	}
+
+	/** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
+	observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined {
+		const existing = this.#records.get(message.observationId);
+		if (existing) return existing;
+		if (!this.#rememberObservationIdentity(message.observationId)) return undefined;
+
+		const estimatedBytes = measureRetainedUtf8Bytes(message);
+		if (estimatedBytes > MAX_RETAINED_UTF8_BYTES) return undefined;
+
+		const observedAt = Date.now();
+		const mode: InlineMode = panelVisibleAtObservation ? "ephemeral" : "persistent";
+		const record: IrcObservationRecord = Object.freeze({
+			...message,
+			mode,
+			observedAt,
+			sequence: this.#nextSequence++,
+			...(mode === "ephemeral" ? { expiresAt: observedAt + 10_000 } : {}),
+			retainedUtf8Bytes: estimatedBytes,
+		});
+		this.#records.set(record.observationId, record);
+		this.#retainedUtf8Bytes += estimatedBytes;
+		this.#enforceBounds();
+		return this.#records.get(record.observationId);
+	}
+
+	getRecord(observationId: string): IrcObservationRecord | undefined {
+		return this.#records.get(observationId);
+	}
+
+	getSidebarRecords(): readonly IrcObservationRecord[] {
+		return [...this.#records.values()];
+	}
+
+	getInlineProjection(now: number): readonly IrcObservationRecord[] {
+		return [...this.#records.values()].filter(record => record.mode === "persistent" || now < record.expiresAt!);
+	}
+
+	/** Returns and clears IDs whose retained payload was released. */
+	drainEvictedObservationIds(): readonly string[] {
+		const observationIds = [...this.#evictedObservationIds];
+		this.#evictedObservationIds.clear();
+		return observationIds;
+	}
+
+	reset(): void {
+		for (const observationId of this.#records.keys()) {
+			this.#evictedObservationIds.add(observationId);
+		}
+		this.#records.clear();
+		this.#retainedUtf8Bytes = 0;
+		this.#nextSequence = 0;
+	}
+}