@nmzpy/pi-ember-stack 0.1.0

package/src/subagent/extensions/service.ts

@@ -0,0 +1,79 @@
+import { AuthStorage, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "./agents.ts";
+import { runSubAgent, type SubAgentResult } from "./runner.ts";
+import { resolveModel } from "./model.ts";
+
+export const SUBAGENT_REQUEST_EVENT = "pi-subagent:run";
+
+export interface SubagentRunRequest {
+	id: string;
+	agent: string;
+	task: string;
+	cwd?: string;
+	timeout?: number;
+	instructions?: string;
+	readOnly?: boolean;
+	signal?: AbortSignal;
+	accept?: () => boolean;
+	respond: (response: SubagentRunResponse) => void;
+}
+
+export type SubagentRunResponse =
+	| { id: string; ok: true; result: SubAgentResult }
+	| { id: string; ok: false; error: string };
+
+export async function runNamedAgent(options: {
+	agent: AgentConfig;
+	task: string;
+	cwd: string;
+	ctx: ExtensionContext;
+	timeout?: number;
+	instructions?: string;
+	signal?: AbortSignal;
+	onMessage?: (result: SubAgentResult) => void;
+}): Promise<SubAgentResult> {
+	const { model, attempted } = resolveModel(options.agent.model, options.ctx.model, options.ctx.modelRegistry);
+	if (!model) throw new Error(`No model resolved for agent "${options.agent.name}" (tried: ${attempted.join(", ") || "none"})`);
+
+	const authStorage = AuthStorage.inMemory();
+	const modelRegistry = options.ctx.modelRegistry;
+	const auth = await options.ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (auth.ok) {
+		if (auth.apiKey) authStorage.setRuntimeApiKey(model.provider, auth.apiKey);
+		// ponytail: env and headers stay on the parent modelRegistry — reuse it directly.
+	}
+
+	const timeoutController = options.timeout && options.timeout > 0 ? new AbortController() : undefined;
+	const timeoutId = timeoutController ? setTimeout(() => timeoutController.abort(), options.timeout) : undefined;
+	const signals = [options.signal, timeoutController?.signal].filter((value): value is AbortSignal => Boolean(value));
+	const signal = signals.length > 1
+		? typeof (AbortSignal as any).any === "function"
+			? (AbortSignal as any).any(signals)
+			: signals[0]
+		: signals[0];
+	const contract = options.instructions?.slice(0, 16 * 1024);
+
+	try {
+		const result = await runSubAgent({
+			cwd: options.cwd,
+			systemPrompt: contract ? `${options.agent.systemPrompt}\n\n## Task Contract\n${contract}` : options.agent.systemPrompt,
+			task: options.task,
+			tools: (options.agent.tools ?? ["read", "bash", "edit", "write", "grep", "find", "ls"]).filter((tool) => tool !== "subagent"),
+			model,
+			authStorage,
+			modelRegistry,
+			signal,
+			agentName: options.agent.name,
+			thinkingLevel: options.agent.thinking,
+			onMessage: options.onMessage,
+		});
+		if (timeoutController?.signal.aborted && !options.signal?.aborted) {
+			result.exitCode = 1;
+			result.stopReason = "timeout";
+			result.errorMessage ||= `Timeout after ${options.timeout}ms`;
+		}
+		return result;
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}

package/src/subagent/extensions/thread-viewer.ts

@@ -0,0 +1,393 @@
+/**
+ * Thread Viewer — Overlay TUI component for pi-subagent.
+ *
+ * Displays a single subagent thread's full output in an overlay.
+ * Supports keyboard navigation between threads and scrolling.
+ */
+
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, Key, truncateToWidth, Markdown } from "@earendil-works/pi-tui";
+import type { Message } from "@earendil-works/pi-ai";
+
+import { type SubAgentResult, isFailedResult, getResultOutput, getFinalOutput } from "./runner.ts";
+import { formatUsageStats } from "./render.ts";
+import type { SubagentThread } from "./threads.ts";
+import * as os from "node:os";
+
+// ---------------------------------------------------------------------------
+// Safe type guards for tool-call arguments
+// ---------------------------------------------------------------------------
+
+function asString(value: unknown, fallback = "..."): string {
+	return typeof value === "string" ? value : fallback;
+}
+
+function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+// ---------------------------------------------------------------------------
+// Tool-call formatting (same as render.ts)
+// ---------------------------------------------------------------------------
+
+function formatToolCall(
+	toolName: string,
+	args: Record<string, unknown>,
+	themeFg: (color: string, text: string) => string,
+): string {
+	const shortenPath = (p: string) => {
+		const home = os.homedir();
+		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+	};
+
+	switch (toolName) {
+		case "bash": {
+			const command = asString(args.command);
+			const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
+			return themeFg("muted", "$ ") + themeFg("toolOutput", preview);
+		}
+		case "read": {
+			const rawPath = asString(args.file_path ?? args.path);
+			const filePath = shortenPath(rawPath);
+			const offset = asNumber(args.offset);
+			const limit = asNumber(args.limit);
+			let text = themeFg("accent", filePath);
+			if (offset !== undefined || limit !== undefined) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== undefined ? startLine + limit - 1 : "";
+				text += themeFg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return themeFg("muted", "read ") + text;
+		}
+		case "write": {
+			const rawPath = asString(args.file_path ?? args.path);
+			const filePath = shortenPath(rawPath);
+			const content = asString(args.content, "");
+			const lines = content.split("\n").length;
+			let text = themeFg("muted", "write ") + themeFg("accent", filePath);
+			if (lines > 1) text += themeFg("dim", ` (${lines} lines)`);
+			return text;
+		}
+		case "edit": {
+			const rawPath = asString(args.file_path ?? args.path);
+			return themeFg("muted", "edit ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "ls": {
+			const rawPath = asString(args.path, ".");
+			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "find": {
+			const pattern = asString(args.pattern, "*");
+			const rawPath = asString(args.path, ".");
+			return (
+				themeFg("muted", "find ") +
+				themeFg("accent", pattern) +
+				themeFg("dim", ` in ${shortenPath(rawPath)}`)
+			);
+		}
+		case "grep": {
+			const pattern = asString(args.pattern);
+			const rawPath = asString(args.path, ".");
+			return (
+				themeFg("muted", "grep ") +
+				themeFg("accent", `/${pattern}/`) +
+				themeFg("dim", ` in ${shortenPath(rawPath)}`)
+			);
+		}
+		default: {
+			const argsStr = JSON.stringify(args);
+			const preview = argsStr.length > 50 ? `${argsStr.slice(0, 50)}...` : argsStr;
+			return themeFg("accent", toolName) + themeFg("dim", ` ${preview}`);
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Display helpers
+// ---------------------------------------------------------------------------
+
+type DisplayItem =
+	| { type: "text"; text: string }
+	| { type: "toolCall"; name: string; args: Record<string, unknown> };
+
+function getDisplayItems(messages: Message[]): DisplayItem[] {
+	const items: DisplayItem[] = [];
+	for (const msg of messages) {
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text" && part.text.trim()) {
+					items.push({ type: "text", text: part.text });
+				} else if (part.type === "toolCall") {
+					items.push({
+						type: "toolCall",
+						name: part.name,
+						args: asRecord(part.arguments),
+					});
+				}
+			}
+		}
+	}
+	return items;
+}
+
+// ---------------------------------------------------------------------------
+// Theme types
+// ---------------------------------------------------------------------------
+
+interface ViewerTheme {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+}
+
+// ---------------------------------------------------------------------------
+// Thread Viewer Component
+// ---------------------------------------------------------------------------
+
+export interface ThreadViewerCallbacks {
+	onClose: () => void;
+	onPrev: () => void;
+	onNext: () => void;
+	hasPrev: boolean;
+	hasNext: boolean;
+}
+
+/** Viewport height for the overlay (estimated lines). Must be > 3. */
+const OVERLAY_HEIGHT = 24;
+
+export class ThreadViewer {
+	private thread: SubagentThread;
+	private callbacks: ThreadViewerCallbacks;
+	private theme: ViewerTheme;
+	private scrollOffset = 0;
+	private cachedWidth?: number;
+	private cachedUpdatedAt?: number;
+	private cachedLines?: string[];
+
+	constructor(thread: SubagentThread, callbacks: ThreadViewerCallbacks, theme: ViewerTheme) {
+		this.thread = thread;
+		this.callbacks = callbacks;
+		this.theme = theme;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape)) {
+			this.callbacks.onClose();
+			return;
+		}
+		if (matchesKey(data, Key.alt("left"))) {
+			if (this.callbacks.hasPrev) {
+				this.scrollOffset = 0;
+				this.callbacks.onPrev();
+			}
+			return;
+		}
+		if (matchesKey(data, Key.alt("right"))) {
+			if (this.callbacks.hasNext) {
+				this.scrollOffset = 0;
+				this.callbacks.onNext();
+			}
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			if (this.scrollOffset > 0) {
+				this.scrollOffset--;
+				this.invalidate();
+			}
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.scrollOffset++;
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.pageUp)) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - OVERLAY_HEIGHT);
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.pageDown)) {
+			this.scrollOffset += OVERLAY_HEIGHT;
+			this.invalidate();
+			return;
+		}
+	}
+
+	render(width: number): string[] {
+		// Use updatedAt in cache key so running→completed transitions bust the cache
+		if (
+			this.cachedLines &&
+			this.cachedWidth === width &&
+			this.cachedUpdatedAt === this.thread.updatedAt
+		) {
+			return this.renderVisible(this.cachedLines, width);
+		}
+
+		const t = this.theme;
+		const lines: string[] = [];
+		const result = this.thread.result;
+		const isErr = result ? isFailedResult(result) : false;
+		const status = this.thread.status;
+
+		// Status icon
+		let icon: string;
+		if (status === "running") icon = t.fg("warning", "⏳");
+		else if (status === "aborted") icon = t.fg("error", "✗");
+		else if (isErr) icon = t.fg("error", "✗");
+		else icon = t.fg("success", "✓");
+
+		// Mode label
+		let modeLabel = "";
+		if (this.thread.mode === "parallel-task") modeLabel = t.fg("muted", " [parallel]");
+		else if (this.thread.mode === "chain-step") modeLabel = t.fg("muted", " [chain]");
+
+		// Header
+		let header = `${icon} ${t.fg("toolTitle", t.bold(this.thread.agentName))}${modeLabel}`;
+		if (status === "running") header += ` ${t.fg("warning", "(running...)")}`;
+		else if (status === "aborted") header += ` ${t.fg("error", "[aborted]")}`;
+		if (result && isErr && result.stopReason && result.stopReason !== "error" && result.stopReason !== "aborted") {
+			const reasonColor = result.stopReason === "timeout" ? "warning" : "error";
+			header += ` ${t.fg(reasonColor, `[${result.stopReason}]`)}`;
+		}
+		lines.push(truncateToWidth(header, width));
+
+		// Error message
+		if (result && isErr && result.errorMessage) {
+			const msgColor = result.stopReason === "timeout" ? "warning" : "error";
+			lines.push(truncateToWidth(t.fg(msgColor, `Error: ${result.errorMessage}`), width));
+		}
+
+		lines.push("");
+
+		// Task
+		lines.push(truncateToWidth(t.fg("muted", "─── Task ───"), width));
+		lines.push(truncateToWidth(t.fg("dim", this.thread.task), width));
+		lines.push("");
+
+		if (status === "running" && (!result || result.messages.length === 0)) {
+			lines.push(truncateToWidth(t.fg("muted", "(waiting for first message...)"), width));
+		} else if (result) {
+			const displayItems = getDisplayItems(result.messages);
+			const finalOutput = getFinalOutput(result.messages);
+
+			lines.push(truncateToWidth(t.fg("muted", "─── Output ───"), width));
+
+			if (displayItems.length === 0 && !finalOutput) {
+				lines.push(truncateToWidth(t.fg("muted", "(no output)"), width));
+			} else {
+				const mdTheme = getMarkdownTheme();
+
+				// Show all display items: text + tool calls
+				for (const item of displayItems) {
+					if (item.type === "toolCall") {
+						lines.push(
+							truncateToWidth(
+								t.fg("muted", "→ ") + formatToolCall(item.name, item.args, t.fg.bind(t)),
+								width,
+							),
+						);
+					} else {
+						// Assistant text — render as markdown
+						const contentWidth = Math.max(1, width - 2);
+						const md = new Markdown(item.text.trim(), 0, 0, mdTheme);
+						const mdLines = md.render(contentWidth);
+						for (const mdLine of mdLines) {
+							lines.push(`  ${truncateToWidth(mdLine, contentWidth)}`);
+						}
+					}
+				}
+				// Check if final output not already shown
+				const finalAlreadyShown = finalOutput && displayItems.some(
+					(it) => it.type === "text" && it.text.includes(finalOutput.slice(0, 100)),
+				);
+				if (finalOutput && !finalAlreadyShown) {
+					const contentWidth = Math.max(1, width - 2);
+					const md = new Markdown(finalOutput.trim(), 0, 0, mdTheme);
+					for (const mdLine of md.render(contentWidth)) {
+						lines.push(`  ${truncateToWidth(mdLine, contentWidth)}`);
+					}
+				}
+			}
+
+			// Usage stats
+			const usageStr = formatUsageStats(result.usage, result.model);
+			if (usageStr) {
+				lines.push("");
+				lines.push(truncateToWidth(t.fg("dim", usageStr), width));
+			}
+		}
+
+		lines.push("");
+
+		// Footer navigation hints
+		const navParts: string[] = [];
+		navParts.push("Esc close");
+		if (this.callbacks.hasPrev) navParts.push("alt+← prev");
+		if (this.callbacks.hasNext) navParts.push("alt+→ next");
+		navParts.push("↑↓ scroll");
+		lines.push(truncateToWidth(t.fg("dim", navParts.join(" · ")), width));
+
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		this.cachedUpdatedAt = this.thread.updatedAt;
+
+		return this.renderVisible(lines, width);
+	}
+
+	private renderVisible(allLines: string[], width: number): string[] {
+		const total = allLines.length;
+		const maxVisible = Math.max(3, OVERLAY_HEIGHT);
+
+		// Clamp scrollOffset so the last page shows a full viewport minus one indicator line
+		const maxOffset =
+			total > maxVisible
+				? Math.max(0, total - (maxVisible - 1))
+				: 0;
+		const offset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+
+		// Reserve space for scroll indicators
+		const aboveShown = offset > 0;
+		const belowShown = offset + maxVisible < total;
+		const indicatorLines = (aboveShown ? 1 : 0) + (belowShown ? 1 : 0);
+		const bodyHeight = Math.max(1, maxVisible - indicatorLines);
+
+		const visible = allLines.slice(offset, offset + bodyHeight);
+
+		// Scroll indicator at top
+		if (aboveShown) {
+			visible.unshift(truncateToWidth(
+				this.theme.fg("muted", `↑ ${offset} more lines above`),
+				width,
+			));
+		}
+		// Scroll indicator at bottom
+		if (belowShown) {
+			const remaining = total - offset - bodyHeight;
+			visible.push(truncateToWidth(
+				this.theme.fg("muted", `↓ ${remaining} more lines below`),
+				width,
+			));
+		}
+
+		return visible;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedUpdatedAt = undefined;
+		this.cachedLines = undefined;
+	}
+
+	/** Update the thread being displayed (for prev/next navigation). */
+	setThread(thread: SubagentThread, callbacks: ThreadViewerCallbacks): void {
+		this.thread = thread;
+		this.callbacks = callbacks;
+		this.scrollOffset = 0;
+		this.invalidate();
+	}
+}

package/src/subagent/extensions/threads.ts

@@ -0,0 +1,116 @@
+/**
+ * Thread Store for pi-subagent.
+ *
+ * In-memory registry tracking all subagent invocations during a pi session.
+ * Enables the /agent command to list and switch between subagent threads.
+ * Supports subscriptions so UIs can react to thread status changes.
+ */
+
+import type { SubAgentResult } from "./runner.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type ThreadMode = "single" | "parallel-task" | "chain-step";
+export type ThreadStatus = "running" | "completed" | "failed" | "aborted";
+
+export interface SubagentThread {
+	id: string;
+	agentName: string;
+	task: string;
+	mode: ThreadMode;
+	status: ThreadStatus;
+	result?: SubAgentResult;
+	toolCallId?: string;
+	createdAt: number;
+	updatedAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Thread Store
+// ---------------------------------------------------------------------------
+
+export class ThreadStore {
+	private threads = new Map<string, SubagentThread>();
+	private order: string[] = [];
+	private listeners = new Set<() => void>();
+
+	/** Subscribe to thread store changes. Returns an unsubscribe function. */
+	subscribe(listener: () => void): () => void {
+		this.listeners.add(listener);
+		return () => { this.listeners.delete(listener); };
+	}
+
+	private notify(): void {
+		for (const listener of this.listeners) {
+			try { listener(); } catch { /* best effort */ }
+		}
+	}
+
+	createThread(params: {
+		agentName: string;
+		task: string;
+		mode: ThreadMode;
+		toolCallId?: string;
+	}): SubagentThread {
+		const id = cryptoGenId();
+		const now = Date.now();
+		const thread: SubagentThread = {
+			id,
+			agentName: params.agentName,
+			task: params.task,
+			mode: params.mode,
+			status: "running",
+			toolCallId: params.toolCallId,
+			createdAt: now,
+			updatedAt: now,
+		};
+		this.threads.set(id, thread);
+		this.order.push(id);
+		this.notify();
+		return thread;
+	}
+
+	updateThread(id: string, updates: Partial<Pick<SubagentThread, "status" | "result">>): void {
+		const thread = this.threads.get(id);
+		if (!thread) return;
+		if (updates.status) thread.status = updates.status;
+		if (updates.result) thread.result = updates.result;
+		thread.updatedAt = Date.now();
+		this.notify();
+	}
+
+	getThread(id: string): SubagentThread | undefined {
+		return this.threads.get(id);
+	}
+
+	getAllThreads(): SubagentThread[] {
+		return this.order.map((id) => this.threads.get(id)!).filter(Boolean);
+	}
+
+	clear(): void {
+		this.threads.clear();
+		this.order = [];
+		this.notify();
+	}
+}
+
+/** Singleton instance. */
+export const threadStore = new ThreadStore();
+
+// ---------------------------------------------------------------------------
+// ID generation (UUID v4 style, good enough for in-memory use)
+// ---------------------------------------------------------------------------
+
+function cryptoGenId(): string {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) {
+		return crypto.randomUUID();
+	}
+	// Fallback for environments without crypto (very unlikely in Node)
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = (Math.random() * 16) | 0;
+		const v = c === "x" ? r : (r & 0x3) | 0x8;
+		return v.toString(16);
+	});
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}