@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/modes/controllers/session-focus-controller.ts

@@ -0,0 +1,112 @@
+/**
+ * SessionFocusController - Weak retargeting primitive between the rendering/
+ * input layer and the AgentSession it displays.
+ *
+ * Focusing re-points the transcript, streaming event subscription, status
+ * line, and editor prompt/interrupt at a subagent's live AgentSession (from
+ * AgentRegistry) without touching the main session underneath; unfocusing
+ * re-attaches the main session and rebuilds the transcript from its
+ * authoritative state.
+ */
+
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry, MAIN_AGENT_ID, type RegistryEvent } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
+import type { InteractiveModeContext } from "../types";
+
+export class SessionFocusController {
+	#focusedAgentId: string | undefined;
+	/** Session currently attached while focused; undefined when unfocused. */
+	#attachedSession: AgentSession | undefined;
+	#registryUnsubscribe: (() => void) | undefined;
+
+	constructor(
+		private ctx: InteractiveModeContext,
+		private registry: AgentRegistry = AgentRegistry.global(),
+		private lifecycle: () => AgentLifecycleManager = () => AgentLifecycleManager.global(),
+	) {}
+
+	get focusedAgentId(): string | undefined {
+		return this.#focusedAgentId;
+	}
+
+	/** Focused live session, undefined when unfocused. */
+	get target(): AgentSession | undefined {
+		return this.#attachedSession;
+	}
+
+	/** Focus the main view on an agent's live session. Throws an Error with a user-displayable message. */
+	async focusAgent(id: string): Promise<void> {
+		if (this.ctx.collabGuest) throw new Error("Viewing agents is unavailable in a collab session.");
+		if (id === MAIN_AGENT_ID) return this.unfocus();
+		const session = await this.lifecycle().ensureLive(id);
+		if (id === this.#focusedAgentId && session === this.#attachedSession) return;
+		this.#focusedAgentId = id;
+		this.#attachedSession = session;
+		this.#registryUnsubscribe ??= this.registry.onChange(e => this.#onRegistryEvent(e));
+		await this.#attach(session);
+		this.ctx.showStatus(`Viewing agent ${id} — Esc returns to main, ←← hops to parent`);
+	}
+
+	/** Focus the focused agent's parent agent, falling back to the main session. No-op when unfocused. */
+	async focusParent(): Promise<void> {
+		if (!this.#focusedAgentId) return;
+		const parentId = this.registry.get(this.#focusedAgentId)?.parentId;
+		if (parentId && parentId !== MAIN_AGENT_ID && this.registry.get(parentId)) {
+			return this.focusAgent(parentId);
+		}
+		return this.unfocus();
+	}
+
+	/** Return to the main session. No-op when unfocused. */
+	async unfocus(): Promise<void> {
+		if (!this.#focusedAgentId) return;
+		this.#focusedAgentId = undefined;
+		this.#attachedSession = undefined;
+		await this.#attach(this.ctx.session);
+		this.ctx.showStatus("Returned to main session");
+	}
+
+	dispose(): void {
+		this.#registryUnsubscribe?.();
+		this.#registryUnsubscribe = undefined;
+	}
+
+	#onRegistryEvent(event: RegistryEvent): void {
+		if (event.ref.id !== this.#focusedAgentId) return;
+		const gone = event.type === "removed";
+		const dead = event.type === "status_changed" && (event.ref.status === "parked" || event.ref.status === "aborted");
+		if (!gone && !dead) return;
+		void this.unfocus().then(() => {
+			this.ctx.showStatus(`Agent ${event.ref.id} is ${gone ? "gone" : event.ref.status}; returned to main session`);
+		});
+	}
+
+	/** Retarget core, both directions: swap subscription, transcript, and status line onto `target`. */
+	async #attach(target: AgentSession): Promise<void> {
+		this.ctx.unsubscribe?.();
+		this.ctx.clearTransientSessionUi();
+		this.ctx.eventController.resetTranscriptAnchors();
+		// Orphan-delta guard: when attaching mid-turn the message_start for the
+		// in-flight assistant message predates the attach. message_update carries
+		// the full accumulating message, so synthesize the missing start before
+		// the first orphaned update; every other handler is tolerant of unknown
+		// anchors (guarded by streamingComponent/pendingTools lookups).
+		let assistantStreamSynced = false;
+		this.ctx.unsubscribe = target.subscribe(async event => {
+			if (event.type === "message_start" && event.message.role === "assistant") {
+				assistantStreamSynced = true;
+			} else if (event.type === "message_update" && event.message.role === "assistant" && !assistantStreamSynced) {
+				assistantStreamSynced = true;
+				await this.ctx.eventController.handleEvent({ type: "message_start", message: event.message });
+			}
+			await this.ctx.eventController.handleEvent(event);
+		});
+		this.ctx.statusLine.setSession(target, this.#focusedAgentId);
+		this.ctx.renderInitialMessages({ clearTerminalHistory: true });
+		// Mid-turn attach: no agent_start will arrive; arm the loader/turn state manually.
+		if (target.isStreaming) await this.ctx.eventController.handleEvent({ type: "agent_start" });
+		this.ctx.updateEditorBorderColor();
+		this.ctx.ui.requestRender();
+	}
+}

package/src/modes/controllers/ssh-command-controller.ts

@@ -209,7 +209,7 @@ export class SSHCommandController {
 			const scopeLabel = scope === "user" ? "user" : "project";
 			const lines = [
 				"",
-				theme.fg("success", `✓ Added SSH host "${name}" to ${scopeLabel} config`),
+				theme.fg("success", `+ Added SSH host "${name}" to ${scopeLabel} config`),
 				"",
 				`  Host: ${host}`,
 			];
@@ -368,7 +368,7 @@ export class SSHCommandController {
 			await this.ctx.session.refreshSshTool();
 
 			this.#showMessage(
-				["", theme.fg("success", `✓ Removed SSH host "${name}" from ${scope} config`), ""].join("\n"),
+				["", theme.fg("success", `- Removed SSH host "${name}" from ${scope} config`), ""].join("\n"),
 			);
 		} catch (error) {
 			this.ctx.showError(`Failed to remove host: ${error instanceof Error ? error.message : String(error)}`);

package/src/modes/controllers/streaming-reveal.ts

@@ -0,0 +1,295 @@
+import type { AssistantMessage } from "@prometheus-ai/ai";
+import { getSegmenter } from "@prometheus-ai/tui";
+import { LRUCache } from "lru-cache/raw";
+import { hasVisibleThinking } from "../../utils/thinking-display";
+import type { AssistantMessageComponent } from "../components/assistant-message";
+
+export const STREAMING_REVEAL_FRAME_MS = 1000 / 30;
+export const MIN_STEP = 3;
+export const CATCHUP_FRAMES = 8;
+
+type AssistantContentBlock = AssistantMessage["content"][number];
+type StreamingRevealComponent = Pick<AssistantMessageComponent, "updateContent">;
+
+type StreamingRevealControllerOptions = {
+	getSmoothStreaming(): boolean;
+	getHideThinkingBlock(): boolean;
+	requestRender(): void;
+};
+
+const graphemeCountCache = new LRUCache<string, number>({ max: 128 });
+
+function countGraphemes(text: string): number {
+	if (text.length === 0) return 0;
+	const cached = graphemeCountCache.get(text);
+	if (cached !== undefined) return cached;
+	let count = 0;
+	for (const _segment of getSegmenter().segment(text)) {
+		count += 1;
+	}
+	graphemeCountCache.set(text, count);
+	return count;
+}
+
+/** Count graphemes of `text` from code-unit offset `start`, also reporting the
+ *  start offset of the final grapheme (where an append could extend a cluster). */
+function countGraphemesFrom(text: string, start: number): { count: number; tailStart: number } {
+	let count = 0;
+	let tailStart = start;
+	for (const seg of getSegmenter().segment(start === 0 ? text : text.slice(start))) {
+		count += 1;
+		tailStart = start + seg.index;
+	}
+	return { count, tailStart };
+}
+
+/** Memoizes per-block grapheme counts across reveal ticks. Streaming blocks only
+ *  grow by appending, and an append can only alter the final grapheme cluster of
+ *  the previous text, so only the suffix from that cluster needs re-segmenting. */
+class BlockUnitCounter {
+	#entries = new Map<number, { text: string; count: number; tailStart: number }>();
+
+	count(index: number, text: string): number {
+		const entry = this.#entries.get(index);
+		if (entry !== undefined) {
+			if (entry.text === text) return entry.count;
+			if (entry.count > 0 && text.length > entry.text.length && text.startsWith(entry.text)) {
+				const tail = countGraphemesFrom(text, entry.tailStart);
+				const next = { text, count: entry.count - 1 + tail.count, tailStart: tail.tailStart };
+				this.#entries.set(index, next);
+				return next.count;
+			}
+		}
+		const full = countGraphemesFrom(text, 0);
+		this.#entries.set(index, { text, count: full.count, tailStart: full.tailStart });
+		return full.count;
+	}
+
+	reset(): void {
+		this.#entries.clear();
+	}
+}
+
+function sliceGraphemes(text: string, units: number): string {
+	if (units <= 0 || text.length === 0) return "";
+	let count = 0;
+	for (const { index, segment } of getSegmenter().segment(text)) {
+		count += 1;
+		if (count >= units) {
+			const end = index + segment.length;
+			return end >= text.length ? text : text.slice(0, end);
+		}
+	}
+	return text;
+}
+
+export function visibleUnits(message: AssistantMessage, hideThinking: boolean): number {
+	let total = 0;
+	for (const block of message.content) {
+		if (block.type === "text") {
+			total += countGraphemes(block.text);
+		} else if (block.type === "thinking" && !hideThinking && hasVisibleThinking(block)) {
+			total += countGraphemes(block.thinking);
+		}
+	}
+	return total;
+}
+
+function revealTextBlock(
+	block: Extract<AssistantContentBlock, { type: "text" }>,
+	remaining: number,
+	units: number,
+): AssistantContentBlock {
+	if (remaining <= 0) return block.text.length === 0 ? block : { ...block, text: "" };
+	if (remaining >= units) return block;
+	return { ...block, text: sliceGraphemes(block.text, remaining) };
+}
+
+function revealThinkingBlock(
+	block: Extract<AssistantContentBlock, { type: "thinking" }>,
+	remaining: number,
+	units: number,
+): AssistantContentBlock {
+	if (remaining <= 0) return block.thinking.length === 0 ? block : { ...block, thinking: "" };
+	if (remaining >= units) return block;
+	return { ...block, thinking: sliceGraphemes(block.thinking, remaining) };
+}
+
+export function buildDisplayMessage(
+	target: AssistantMessage,
+	revealed: number,
+	hideThinking: boolean,
+	countOf: (index: number, text: string) => number = (_index, text) => countGraphemes(text),
+): AssistantMessage {
+	let remaining = Math.max(0, Math.floor(revealed));
+	const content: AssistantContentBlock[] = [];
+	for (let i = 0; i < target.content.length; i++) {
+		const block = target.content[i]!;
+		if (block.type === "text") {
+			const units = countOf(i, block.text);
+			content.push(revealTextBlock(block, remaining, units));
+			remaining = Math.max(0, remaining - units);
+		} else if (block.type === "thinking" && !hideThinking && hasVisibleThinking(block)) {
+			const units = countOf(i, block.thinking);
+			content.push(revealThinkingBlock(block, remaining, units));
+			remaining = Math.max(0, remaining - units);
+		} else {
+			content.push(block);
+		}
+	}
+	return { ...target, content };
+}
+
+export function nextStep(backlog: number): number {
+	return Math.max(MIN_STEP, Math.ceil(Math.max(0, backlog) / CATCHUP_FRAMES));
+}
+
+export class StreamingRevealController {
+	readonly #getSmoothStreaming: () => boolean;
+	readonly #getHideThinkingBlock: () => boolean;
+	readonly #requestRender: () => void;
+	#target: AssistantMessage | undefined;
+	#component: StreamingRevealComponent | undefined;
+	#timer: NodeJS.Timeout | undefined;
+	#revealed = 0;
+	#hideThinkingBlock = false;
+	#smoothStreaming = true;
+	readonly #unitCounter = new BlockUnitCounter();
+	readonly #countOf = (index: number, text: string): number => this.#unitCounter.count(index, text);
+
+	constructor(options: StreamingRevealControllerOptions) {
+		this.#getSmoothStreaming = options.getSmoothStreaming;
+		this.#getHideThinkingBlock = options.getHideThinkingBlock;
+		this.#requestRender = options.requestRender;
+	}
+
+	begin(component: StreamingRevealComponent, message: AssistantMessage): void {
+		this.stop();
+		this.#component = component;
+		this.#target = message;
+		this.#revealed = 0;
+		this.#hideThinkingBlock = this.#getHideThinkingBlock();
+		this.#smoothStreaming = this.#getSmoothStreaming();
+		if (!this.#smoothStreaming) {
+			component.updateContent(message, { transient: true });
+			return;
+		}
+		const total = this.#visibleUnits(message);
+		if (message.content.some(block => block.type === "toolCall")) {
+			// A tool call is a transcript-order boundary: finish any leading
+			// assistant text before EventController renders the separate tool card.
+			this.#revealed = total;
+			component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
+				transient: true,
+			});
+			return;
+		}
+		this.#renderCurrent();
+		this.#syncTimer(total);
+	}
+
+	setTarget(message: AssistantMessage): void {
+		this.#target = message;
+		if (!this.#component) return;
+		if (!this.#smoothStreaming) {
+			this.#component.updateContent(message, { transient: true });
+			return;
+		}
+		const total = this.#visibleUnits(message);
+		if (message.content.some(block => block.type === "toolCall")) {
+			// A tool call is a transcript-order boundary: finish any leading
+			// assistant text before EventController renders the separate tool card.
+			this.#revealed = total;
+			this.#stopTimer();
+			this.#component.updateContent(
+				buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock, this.#countOf),
+				{
+					transient: true,
+				},
+			);
+			return;
+		}
+		if (this.#revealed > total) {
+			this.#revealed = total;
+		}
+		this.#renderCurrent();
+		this.#syncTimer(total);
+	}
+
+	stop(): void {
+		this.#stopTimer();
+		this.#target = undefined;
+		this.#component = undefined;
+		this.#revealed = 0;
+		this.#unitCounter.reset();
+	}
+
+	/** Total reveal units of `message`, memoized per block across ticks. */
+	#visibleUnits(message: AssistantMessage): number {
+		let total = 0;
+		for (let i = 0; i < message.content.length; i++) {
+			const block = message.content[i]!;
+			if (block.type === "text") {
+				total += this.#unitCounter.count(i, block.text);
+			} else if (block.type === "thinking" && !this.#hideThinkingBlock && hasVisibleThinking(block)) {
+				total += this.#unitCounter.count(i, block.thinking);
+			}
+		}
+		return total;
+	}
+
+	#renderCurrent(): void {
+		if (!this.#target || !this.#component) return;
+		// Every controller render is an in-flight streaming snapshot, even when
+		// smooth reveal has temporarily caught up to the current target. The
+		// message_end handler performs the only stable non-transient render.
+		this.#component.updateContent(
+			buildDisplayMessage(this.#target, this.#revealed, this.#hideThinkingBlock, this.#countOf),
+			{ transient: true },
+		);
+	}
+
+	#syncTimer(total = this.#target ? this.#visibleUnits(this.#target) : 0): void {
+		if (!this.#target || !this.#component || this.#revealed >= total) {
+			this.#stopTimer();
+			return;
+		}
+		this.#startTimer();
+	}
+
+	#startTimer(): void {
+		if (this.#timer) return;
+		this.#timer = setInterval(() => {
+			this.#tick();
+		}, STREAMING_REVEAL_FRAME_MS);
+		this.#timer.unref?.();
+	}
+
+	#stopTimer(): void {
+		if (!this.#timer) return;
+		clearInterval(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#tick(): void {
+		const target = this.#target;
+		const component = this.#component;
+		if (!target || !component) {
+			this.stop();
+			return;
+		}
+		const total = this.#visibleUnits(target);
+		if (this.#revealed >= total) {
+			this.#stopTimer();
+			return;
+		}
+		this.#revealed = Math.min(total, this.#revealed + nextStep(total - this.#revealed));
+		component.updateContent(buildDisplayMessage(target, this.#revealed, this.#hideThinkingBlock, this.#countOf), {
+			transient: true,
+		});
+		this.#requestRender();
+		if (this.#revealed >= total) {
+			this.#stopTimer();
+		}
+	}
+}

package/src/modes/controllers/tan-command-controller.ts

@@ -0,0 +1,173 @@
+import * as fs from "node:fs/promises";
+import type { AssistantMessage } from "@prometheus-ai/ai";
+import { prompt, Snowflake } from "@prometheus-ai/utils";
+import backgroundTanDispatchPrompt from "../../prompts/system/background-tan-dispatch.md" with { type: "text" };
+import { AgentRegistry, MAIN_AGENT_ID } from "../../registry/agent-registry";
+import * as sdk from "../../sdk";
+import type { AgentSession } from "../../session/agent-session";
+import { SessionManager } from "../../session/session-manager";
+import { createMCPProxyTools, createSubagentSettings } from "../../task/executor";
+import type { InteractiveModeContext } from "../types";
+
+const TAN_LABEL_PREVIEW_LENGTH = 80;
+
+function previewWork(work: string): string {
+	const singleLine = work.trim().replace(/\s+/g, " ");
+	if (singleLine.length <= TAN_LABEL_PREVIEW_LENGTH) return singleLine;
+	return `${singleLine.slice(0, TAN_LABEL_PREVIEW_LENGTH - 1)}…`;
+}
+
+function extractAssistantText(message: AssistantMessage | undefined): string {
+	if (!message) return "";
+	return message.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("")
+		.trim();
+}
+
+async function removeCloneSession(cloneFile: string): Promise<void> {
+	await Promise.allSettled([
+		fs.rm(cloneFile, { force: true }),
+		fs.rm(cloneFile.slice(0, -6), { recursive: true, force: true }),
+	]);
+}
+
+export class TanCommandController {
+	constructor(private readonly ctx: InteractiveModeContext) {}
+
+	async start(work: string): Promise<void> {
+		const trimmedWork = work.trim();
+		if (!trimmedWork) {
+			this.ctx.showStatus("Usage: /tan <work>");
+			return;
+		}
+
+		const session = this.ctx.session;
+		if (session.isStreaming) {
+			this.ctx.showWarning("Wait for the current response to finish or abort it before using /tan.");
+			return;
+		}
+
+		const model = session.model;
+		if (!model) {
+			this.ctx.showError("No active model available for /tan.");
+			return;
+		}
+
+		const manager = session.asyncJobManager;
+		if (!manager) {
+			this.ctx.showError("Background jobs are disabled; enable async jobs to use /tan.");
+			return;
+		}
+
+		const parentFile = this.ctx.sessionManager.getSessionFile();
+		if (!parentFile) {
+			this.ctx.showError("/tan requires a persisted session.");
+			return;
+		}
+
+		const parentSessionId = session.sessionId;
+		const thinkingLevel = session.configuredThinkingLevel();
+		const systemPrompt = [...session.systemPrompt];
+		const toolNames = session.getActiveToolNames();
+		const modelRegistry = session.modelRegistry;
+		const ownerId = session.getAgentId() ?? MAIN_AGENT_ID;
+		const mcpManager = this.ctx.mcpManager;
+		const cwd = this.ctx.sessionManager.getCwd();
+		// Nest the clone inside the parent's artifact directory (like a subagent
+		// session) rather than as a top-level sibling, so it shares the parent's
+		// artifacts in place — no copy needed.
+		const sessionDir = parentFile.slice(0, -6);
+		const settings = createSubagentSettings(this.ctx.settings);
+		const customTools = mcpManager ? createMCPProxyTools(mcpManager) : undefined;
+		const enableLsp = this.ctx.settings.get("task.enableLsp") !== false;
+		const agentRegistry = AgentRegistry.global();
+		const cloneId = `Tan-${Snowflake.next()}`;
+		const label = `/tan ${previewWork(trimmedWork)}`;
+
+		await this.ctx.sessionManager.ensureOnDisk();
+		await this.ctx.sessionManager.flush();
+
+		let cloneFile = "";
+		let jobId = "";
+		try {
+			const cloneManager = await SessionManager.forkFrom(parentFile, cwd, sessionDir, undefined, {
+				suppressBreadcrumb: true,
+			});
+			cloneFile = cloneManager.getSessionFile() ?? "";
+			if (!cloneFile) throw new Error("Forked session did not create a session file.");
+
+			jobId = manager.register(
+				"task",
+				label,
+				async ({ signal }) => {
+					if (signal.aborted) throw new Error("Aborted before execution");
+
+					let clone: AgentSession | undefined;
+					try {
+						const created = await sdk.createAgentSession({
+							cwd,
+							sessionManager: cloneManager,
+							model,
+							thinkingLevel,
+							systemPrompt,
+							toolNames,
+							providerSessionId: `${parentSessionId}:tan:${Snowflake.next()}`,
+							providerPromptCacheKey: parentSessionId,
+							modelRegistry,
+							authStorage: modelRegistry.authStorage,
+							settings,
+							hasUI: false,
+							enableMCP: false,
+							customTools,
+							enableLsp,
+							agentId: cloneId,
+							agentDisplayName: "tan",
+							parentTaskPrefix: cloneId,
+							agentRegistry,
+							disableExtensionDiscovery: true,
+						});
+						clone = created.session;
+						const abortClone = () => {
+							void clone?.abort();
+						};
+						signal.addEventListener("abort", abortClone, { once: true });
+						try {
+							if (signal.aborted) {
+								abortClone();
+								throw new Error("Aborted before execution");
+							}
+							await clone.prompt(trimmedWork, { attribution: "user" });
+							await clone.waitForIdle();
+							return extractAssistantText(clone.getLastAssistantMessage()) || "(no output)";
+						} finally {
+							signal.removeEventListener("abort", abortClone);
+						}
+					} finally {
+						await clone?.dispose();
+					}
+				},
+				{ ownerId },
+			);
+		} catch (error) {
+			if (cloneFile) await removeCloneSession(cloneFile);
+			this.ctx.showError(error instanceof Error ? error.message : String(error));
+			return;
+		}
+
+		const content = prompt.render(backgroundTanDispatchPrompt, { jobId, work: trimmedWork });
+		await session.sendCustomMessage(
+			{
+				customType: "background-tan-dispatch",
+				content,
+				display: true,
+				attribution: "user",
+				details: { jobId, work: trimmedWork, sessionFile: cloneFile },
+			},
+			{ triggerTurn: false },
+		);
+		this.ctx.rebuildChatFromMessages();
+		this.ctx.showStatus(`Dispatched background tan ${jobId}`);
+	}
+}