@gajae-code/coding-agent 0.4.5 → 0.5.1

package/src/main.ts

@@ -30,6 +30,7 @@ import { activateModelProfile } from "./config/model-profile-activation";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
+import { BUNDLED_GROK_BUILD_EXTENSION_ID, getBundledGrokBuildExtensionFactory } from "./defaults/gjc-grok-cli";
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
@@ -742,7 +743,9 @@ export async function runRootCommand(
 		await runListModelsCommand({
 			modelRegistry,
 			cwd: getProjectDir(),
-			additionalExtensionPaths: [],
+			extensionFactories: [
+				{ factory: getBundledGrokBuildExtensionFactory(), name: BUNDLED_GROK_BUILD_EXTENSION_ID },
+			],
 			settingsExtensions: [],
 			disabledExtensionIds: [],
 			disableExtensionDiscovery: true,
@@ -975,7 +978,9 @@ export async function runRootCommand(
 
 		if (mode === "rpc" || mode === "rpc-ui") {
 			const { runRpcMode } = await import("./modes/rpc/rpc-mode");
-			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined);
+			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, {
+				listen: parsedArgs.rpcListen,
+			});
 		} else if (mode === "bridge") {
 			const { runBridgeMode } = await import("./modes/bridge/bridge-mode");
 			await runBridgeMode(session, setToolUIContext);

package/src/modes/components/assistant-message.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage, ImageContent, Usage } from "@gajae-code/ai";
-import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@gajae-code/tui";
+import { type Component, Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@gajae-code/tui";
 import { formatNumber } from "@gajae-code/utils";
 import { settings } from "../../config/settings";
 import { renderDeepInterviewAssistantText } from "../../deep-interview/render-middleware";
@@ -18,6 +18,7 @@ export class AssistantMessageComponent extends Container {
 	#convertedKittyImages = new Map<string, ImageContent>();
 	#kittyConversionsInFlight = new Set<string>();
 	#responseHeader = new Text(theme.bold(theme.fg("statusLineModel", "gajae")), 1, 0);
+	#contentBlocksCache = new WeakMap<object, { source: string; component: Component }>();
 
 	constructor(
 		message?: AssistantMessage,
@@ -106,6 +107,28 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	#renderTextBlock(content: { text: string }): Component {
+		const cached = this.#contentBlocksCache.get(content);
+		if (cached?.source === content.text) return cached.component;
+		const trimmed = content.text.trim();
+		const component =
+			renderDeepInterviewAssistantText(trimmed, theme) ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
+		this.#contentBlocksCache.set(content, { source: content.text, component });
+		return component;
+	}
+
+	#renderThinkingBlock(content: { thinking: string }): Markdown {
+		const cached = this.#contentBlocksCache.get(content);
+		if (cached?.source === content.thinking) return cached.component as Markdown;
+		const trimmed = content.thinking.trim();
+		const component = new Markdown(trimmed, 1, 0, getMarkdownTheme(), {
+			color: (text: string) => theme.fg("thinkingText", text),
+			italic: true,
+		});
+		this.#contentBlocksCache.set(content, { source: content.thinking, component });
+		return component;
+	}
+
 	#renderToolImages(): void {
 		const imageEntries = Array.from(this.#toolImagesByCallId.entries()).flatMap(([toolCallId, images]) =>
 			images.map((image, index) => ({ image, key: `${toolCallId}:${index}` })),
@@ -152,12 +175,7 @@ export class AssistantMessageComponent extends Container {
 		for (let i = 0; i < message.content.length; i++) {
 			const content = message.content[i];
 			if (content.type === "text" && content.text.trim()) {
-				// Assistant text messages with no background - trim the text
-				// Set paddingY=0 to avoid extra spacing before tool executions
-				const text = content.text.trim();
-				this.#contentContainer.addChild(
-					renderDeepInterviewAssistantText(text, theme) ?? new Markdown(text, 1, 0, getMarkdownTheme()),
-				);
+				this.#contentContainer.addChild(this.#renderTextBlock(content));
 			} else if (content.type === "thinking" && content.thinking.trim()) {
 				// Add spacing only when another visible assistant content block follows.
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
@@ -172,13 +190,7 @@ export class AssistantMessageComponent extends Container {
 						this.#contentContainer.addChild(new Spacer(1));
 					}
 				} else {
-					// Thinking traces in thinkingText color, italic
-					this.#contentContainer.addChild(
-						new Markdown(content.thinking.trim(), 1, 0, getMarkdownTheme(), {
-							color: (text: string) => theme.fg("thinkingText", text),
-							italic: true,
-						}),
-					);
+					this.#contentContainer.addChild(this.#renderThinkingBlock(content));
 					if (hasVisibleContentAfter) {
 						this.#contentContainer.addChild(new Spacer(1));
 					}

package/src/modes/components/diff.ts

@@ -6,6 +6,9 @@ import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../../to
 /** SGR dim on / normal intensity — additive, preserves fg/bg colors. */
 const DIM = "\x1b[2m";
 const DIM_OFF = "\x1b[22m";
+// Single-span fast path is tuned for rendered code lines; ~500 chars covers typical terminal widths
+// while avoiding duplicate prefix/suffix scans before diffWords on pathological long lines.
+const LONG_LINE_FAST_PATH_LIMIT = 500;
 
 /**
  * Visualize leading whitespace (indentation) with dim glyphs.
@@ -53,6 +56,15 @@ function parseDiffLine(line: string): { prefix: CodeFrameMarker; lineNum: string
  * Strips leading whitespace from inverse to avoid highlighting indentation.
  */
 function renderIntraLineDiff(oldContent: string, newContent: string): { removedLine: string; addedLine: string } {
+	const fastPath = renderIntraLineDiffFastPath(oldContent, newContent);
+	if (fastPath) return fastPath;
+	return renderIntraLineDiffWithDiffWords(oldContent, newContent);
+}
+
+function renderIntraLineDiffWithDiffWords(
+	oldContent: string,
+	newContent: string,
+): { removedLine: string; addedLine: string } {
 	const wordDiff = Diff.diffWords(oldContent, newContent);
 
 	let removedLine = "";
@@ -94,6 +106,91 @@ function renderIntraLineDiff(oldContent: string, newContent: string): { removedL
 	return { removedLine, addedLine };
 }
 
+function renderIntraLineDiffFastPath(
+	oldContent: string,
+	newContent: string,
+): { removedLine: string; addedLine: string } | null {
+	if (oldContent === newContent) return { removedLine: oldContent, addedLine: newContent };
+	if (Math.min(oldContent.length, newContent.length) > LONG_LINE_FAST_PATH_LIMIT) return null;
+
+	if (isWhitespaceOnlyChange(oldContent, newContent)) return null;
+	return renderSingleSpanIntraLineDiff(oldContent, newContent);
+}
+
+function isWhitespaceOnlyChange(oldContent: string, newContent: string): boolean {
+	return oldContent.replace(/\s+/g, "") === newContent.replace(/\s+/g, "");
+}
+
+function renderSingleSpanIntraLineDiff(
+	oldContent: string,
+	newContent: string,
+): { removedLine: string; addedLine: string } | null {
+	let prefixLength = 0;
+	const maxPrefixLength = Math.min(oldContent.length, newContent.length);
+	while (
+		prefixLength < maxPrefixLength &&
+		oldContent.charCodeAt(prefixLength) === newContent.charCodeAt(prefixLength)
+	) {
+		prefixLength++;
+		if (prefixLength > LONG_LINE_FAST_PATH_LIMIT) return null;
+	}
+	let suffixLength = 0;
+	const maxSuffixLength = maxPrefixLength - prefixLength;
+	while (
+		suffixLength < maxSuffixLength &&
+		oldContent.charCodeAt(oldContent.length - 1 - suffixLength) ===
+			newContent.charCodeAt(newContent.length - 1 - suffixLength)
+	) {
+		suffixLength++;
+		if (prefixLength + suffixLength > LONG_LINE_FAST_PATH_LIMIT) return null;
+	}
+
+	const oldMiddle = oldContent.slice(prefixLength, oldContent.length - suffixLength);
+	const newMiddle = newContent.slice(prefixLength, newContent.length - suffixLength);
+	if (oldMiddle.length === 0 || newMiddle.length === 0) return null;
+	if (!isSingleDiffWordsReplacement(oldContent, newContent, prefixLength, suffixLength)) return null;
+
+	const prefix = oldContent.slice(0, prefixLength);
+	const oldLeadingWs = oldMiddle.match(/^(\s*)/)?.[1] || "";
+	const newLeadingWs = newMiddle.match(/^(\s*)/)?.[1] || "";
+	return {
+		removedLine: `${prefix}${oldLeadingWs}${theme.inverse(oldMiddle.slice(oldLeadingWs.length))}${oldContent.slice(oldContent.length - suffixLength)}`,
+		addedLine: `${prefix}${newLeadingWs}${theme.inverse(newMiddle.slice(newLeadingWs.length))}${newContent.slice(newContent.length - suffixLength)}`,
+	};
+}
+
+function isSingleDiffWordsReplacement(
+	oldContent: string,
+	newContent: string,
+	prefixLength: number,
+	suffixLength: number,
+): boolean {
+	if (prefixLength === 0 && suffixLength === 0) return false;
+	const oldEnd = oldContent.length - suffixLength;
+	const newEnd = newContent.length - suffixLength;
+	const snappedPrefixLength = snapPrefixToWhitespaceBoundary(oldContent, newContent, prefixLength);
+	const snappedOldEnd = snapEndToWhitespaceBoundary(oldContent, oldEnd);
+	const snappedNewEnd = snapEndToWhitespaceBoundary(newContent, newEnd);
+	return snappedPrefixLength === prefixLength && snappedOldEnd === oldEnd && snappedNewEnd === newEnd;
+}
+
+function snapPrefixToWhitespaceBoundary(oldContent: string, newContent: string, prefixLength: number): number {
+	let snapped = prefixLength;
+	while (snapped > 0 && !(isWhitespaceBoundary(oldContent, snapped) && isWhitespaceBoundary(newContent, snapped)))
+		snapped--;
+	return snapped;
+}
+
+function snapEndToWhitespaceBoundary(content: string, end: number): number {
+	let snapped = end;
+	while (snapped < content.length && !isWhitespaceBoundary(content, snapped)) snapped++;
+	return snapped;
+}
+
+function isWhitespaceBoundary(content: string, index: number): boolean {
+	return index <= 0 || index >= content.length || /\s/.test(content[index - 1]!) || /\s/.test(content[index]!);
+}
+
 export interface RenderDiffOptions {
 	/** File path used to resolve indentation (.editorconfig + defaults) */
 	filePath?: string;

package/src/modes/components/hook-selector.ts

@@ -3,6 +3,7 @@
  * Displays a list of string options with keyboard navigation.
  */
 import {
+	type AutocompleteProvider,
 	Container,
 	Editor,
 	Markdown,
@@ -73,6 +74,12 @@ export interface HookSelectorOptions {
 		optionLabel: string;
 		onSubmit: (text: string) => void;
 	};
+	/**
+	 * Autocomplete provider for the inline custom-input editor. When present,
+	 * the "Other (type your own)" editor gains the same `@` file-link and `/`
+	 * completion behavior as the main prompt editor.
+	 */
+	autocompleteProvider?: AutocompleteProvider;
 }
 
 class OutlinedList extends Container {
@@ -320,6 +327,7 @@ export class HookSelectorComponent extends Container {
 	#helpTextComponent: Text;
 	#baseHelpText: string;
 	#tui: TUI | undefined;
+	#autocompleteProvider: AutocompleteProvider | undefined;
 	constructor(
 		title: string,
 		options: string[],
@@ -342,6 +350,7 @@ export class HookSelectorComponent extends Container {
 		this.#outline = opts?.outline === true;
 		this.#customInput = opts?.customInput;
 		this.#tui = opts?.tui;
+		this.#autocompleteProvider = opts?.autocompleteProvider;
 
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
@@ -491,6 +500,13 @@ export class HookSelectorComponent extends Container {
 
 	/** Keys while the inline custom-input editor is open below the option list. */
 	#handleInputModeKey(keyData: string, editor: Editor): void {
+		// While the autocomplete dropdown is open, every key belongs to the
+		// editor (navigate/apply/cancel the suggestion) instead of submitting
+		// or backing out of input mode.
+		if (editor.isAutocompleteOpen()) {
+			editor.handleInput(keyData);
+			return;
+		}
 		// Escape backs out to option selection instead of cancelling the dialog,
 		// so a stray Esc never throws away the question context.
 		if (matchesKey(keyData, "escape") || matchesAppInterrupt(keyData)) {
@@ -521,6 +537,9 @@ export class HookSelectorComponent extends Container {
 		editor.setBorderVisible(false);
 		editor.setPromptGutter("> ");
 		editor.disableSubmit = true;
+		if (this.#autocompleteProvider) {
+			editor.setAutocompleteProvider(this.#autocompleteProvider);
+		}
 		this.#inlineEditor = editor;
 		this.#inputArea.addChild(new Spacer(1));
 		this.#inputArea.addChild(editor);