@f5-sales-demo/xcsh 21.5.6 → 21.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/xcsh",
-	"version": "21.5.6",
+	"version": "21.6.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -61,13 +61,13 @@
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
-		"@f5-sales-demo/pi-agent-core": "21.5.6",
-		"@f5-sales-demo/pi-ai": "21.5.6",
-		"@f5-sales-demo/pi-natives": "21.5.6",
-		"@f5-sales-demo/pi-resource-management": "21.5.6",
-		"@f5-sales-demo/pi-tui": "21.5.6",
-		"@f5-sales-demo/pi-utils": "21.5.6",
-		"@f5-sales-demo/xcsh-stats": "21.5.6",
+		"@f5-sales-demo/pi-agent-core": "21.6.0",
+		"@f5-sales-demo/pi-ai": "21.6.0",
+		"@f5-sales-demo/pi-natives": "21.6.0",
+		"@f5-sales-demo/pi-resource-management": "21.6.0",
+		"@f5-sales-demo/pi-tui": "21.6.0",
+		"@f5-sales-demo/pi-utils": "21.6.0",
+		"@f5-sales-demo/xcsh-stats": "21.6.0",
 		"@mozilla/readability": "^0.6",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",

package/src/config/settings-schema.ts

@@ -549,6 +549,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"context.loadingMode": {
+		type: "enum",
+		values: ["eager", "progressive"] as const,
+		default: "eager",
+		ui: {
+			tab: "model",
+			label: "Context Loading",
+			description: "Load all capabilities eagerly or activate optional context progressively",
+			submenu: true,
+		},
+	},
+
 	// Dynamic routing
 	"routing.mode": {
 		type: "enum",

package/src/context/profile.ts

@@ -0,0 +1,285 @@
+import type { Model, Usage } from "@f5-sales-demo/pi-ai";
+
+export type ContextLoadingMode = "eager" | "progressive";
+
+export type ContextComponentCategory =
+	| "system_prompt"
+	| "context_file"
+	| "skill"
+	| "plugin_catalog"
+	| "rule"
+	| "tool_description"
+	| "tool_schema"
+	| "message"
+	| "tool_result";
+
+export interface ContextComponentProfile {
+	category: ContextComponentCategory;
+	label: string;
+	bytes: number;
+	estimatedTokens: number;
+}
+
+export interface ContextToolProfile {
+	name: string;
+	descriptionBytes: number;
+	schemaBytes: number;
+	estimatedTokens: number;
+}
+
+export interface ContextMessageProfile {
+	role: string;
+	bytes: number;
+	estimatedTokens: number;
+}
+
+export interface ProviderCallProfile {
+	call: number;
+	provider: string;
+	model: string;
+	api: string;
+	payloadBytes: number;
+	estimatedPayloadTokens: number;
+	categoryBytes: Record<"system_prompt" | "tools" | "messages" | "tool_results" | "other", number>;
+	toolCount: number;
+	messageCount: number;
+	tools: ContextToolProfile[];
+	messages: ContextMessageProfile[];
+	contextWindow: number;
+	providerInputTokens?: number;
+	providerCacheReadTokens?: number;
+	providerCacheWriteTokens?: number;
+	providerPromptTokens?: number;
+	providerOutputTokens?: number;
+	windowPercentage?: number;
+}
+
+export interface ContextProfile {
+	loadingMode: ContextLoadingMode;
+	systemPromptBytes: number;
+	estimatedSystemPromptTokens: number;
+	initialToolBytes: number;
+	deferredToolBytes: number;
+	components: ContextComponentProfile[];
+	tools: ContextToolProfile[];
+	providerCalls: ProviderCallProfile[];
+}
+
+export function estimateContextTokens(bytes: number): number {
+	return bytes <= 0 ? 0 : Math.ceil(bytes / 4);
+}
+
+function jsonBytes(value: unknown): number {
+	if (value === undefined) return 0;
+	try {
+		return Buffer.byteLength(JSON.stringify(value), "utf8");
+	} catch {
+		return 0;
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function firstArray(record: Record<string, unknown>, keys: string[]): unknown[] {
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) return value;
+	}
+	return [];
+}
+
+function firstDefined(record: Record<string, unknown>, keys: string[]): unknown {
+	for (const key of keys) {
+		if (record[key] !== undefined) return record[key];
+	}
+	return undefined;
+}
+
+function safeRole(value: unknown): string {
+	if (!isRecord(value) || typeof value.role !== "string") return "unknown";
+	return ["system", "developer", "user", "assistant", "tool", "toolResult", "model"].includes(value.role)
+		? value.role
+		: "other";
+}
+
+function isToolResultMessage(value: unknown): boolean {
+	if (!isRecord(value)) return false;
+	if (value.role === "tool" || value.role === "toolResult" || value.type === "function_call_output") return true;
+	const content = Array.isArray(value.content) ? value.content : [];
+	if (content.some(block => isRecord(block) && block.type === "tool_result")) return true;
+	const parts = Array.isArray(value.parts) ? value.parts : [];
+	return parts.some(part => isRecord(part) && ("functionResponse" in part || "function_response" in part));
+}
+
+function toolName(value: unknown): string | undefined {
+	if (!isRecord(value)) return undefined;
+	if (typeof value.name === "string") return value.name;
+	if (isRecord(value.function) && typeof value.function.name === "string") return value.function.name;
+	return undefined;
+}
+
+function flattenProviderTools(tools: unknown[]): unknown[] {
+	const flattened: unknown[] = [];
+	for (const tool of tools) {
+		if (isRecord(tool) && Array.isArray(tool.functionDeclarations)) {
+			flattened.push(...tool.functionDeclarations);
+		} else {
+			flattened.push(tool);
+		}
+	}
+	return flattened;
+}
+
+function profilePayloadTool(value: unknown, index: number): ContextToolProfile {
+	const record = isRecord(value) ? value : {};
+	const definition = isRecord(record.function) ? record.function : record;
+	const descriptionBytes = jsonBytes(definition.description);
+	const schemaBytes = jsonBytes(definition.parameters ?? definition.input_schema ?? definition.schema);
+	return {
+		name: toolName(value) ?? `tool_${index + 1}`,
+		descriptionBytes,
+		schemaBytes,
+		estimatedTokens: estimateContextTokens(descriptionBytes + schemaBytes),
+	};
+}
+
+export function profileProviderPayload(payload: unknown, model: Model, call: number): ProviderCallProfile {
+	const record = isRecord(payload) ? payload : {};
+	const body = isRecord(record.request) ? record.request : record;
+	const system = firstDefined(body, ["systemInstruction", "system_instruction", "system", "instructions"]);
+	const rawTools = firstArray(body, ["tools", "functions"]);
+	const rawMessages = firstArray(body, ["contents", "messages", "input"]);
+	const tools = flattenProviderTools(rawTools);
+	const payloadBytes = jsonBytes(payload);
+	const systemBytes = jsonBytes(system);
+	const toolsBytes = jsonBytes(rawTools);
+	const toolResultBytes = rawMessages
+		.filter(isToolResultMessage)
+		.reduce<number>((sum, message) => sum + jsonBytes(message), 0);
+	const messagesBytes = rawMessages
+		.filter(message => !isToolResultMessage(message))
+		.reduce<number>((sum, message) => sum + jsonBytes(message), 0);
+	return {
+		call,
+		provider: model.provider,
+		model: model.id,
+		api: model.api,
+		payloadBytes,
+		estimatedPayloadTokens: estimateContextTokens(payloadBytes),
+		categoryBytes: {
+			system_prompt: systemBytes,
+			tools: toolsBytes,
+			messages: messagesBytes,
+			tool_results: toolResultBytes,
+			other: Math.max(0, payloadBytes - systemBytes - toolsBytes - messagesBytes - toolResultBytes),
+		},
+		toolCount: tools.length,
+		messageCount: rawMessages.length,
+		tools: tools.map(profilePayloadTool),
+		messages: rawMessages.map(message => {
+			const bytes = jsonBytes(message);
+			return { role: safeRole(message), bytes, estimatedTokens: estimateContextTokens(bytes) };
+		}),
+		contextWindow: model.contextWindow,
+	};
+}
+
+export class ContextProfileCollector {
+	readonly #profile: ContextProfile;
+	#attributedComponents: ContextComponentProfile[] = [];
+
+	constructor(loadingMode: ContextLoadingMode) {
+		this.#profile = {
+			loadingMode,
+			systemPromptBytes: 0,
+			estimatedSystemPromptTokens: 0,
+			initialToolBytes: 0,
+			deferredToolBytes: 0,
+			components: [],
+			tools: [],
+			providerCalls: [],
+		};
+	}
+
+	setPrompt(
+		systemPrompt: string,
+		tools: Iterable<{ name: string; description?: string; parameters?: unknown }>,
+	): void {
+		const systemPromptBytes = Buffer.byteLength(systemPrompt, "utf8");
+		const toolProfiles = Array.from(tools, tool => {
+			const descriptionBytes = Buffer.byteLength(tool.description ?? "", "utf8");
+			const schemaBytes = jsonBytes(tool.parameters);
+			return {
+				name: tool.name,
+				descriptionBytes,
+				schemaBytes,
+				estimatedTokens: estimateContextTokens(descriptionBytes + schemaBytes),
+			};
+		});
+		this.#profile.systemPromptBytes = systemPromptBytes;
+		this.#profile.estimatedSystemPromptTokens = estimateContextTokens(systemPromptBytes);
+		this.#profile.tools = toolProfiles;
+		this.#profile.initialToolBytes = toolProfiles.reduce(
+			(sum, tool) => sum + tool.descriptionBytes + tool.schemaBytes,
+			0,
+		);
+		this.#profile.components = [
+			{
+				category: "system_prompt",
+				label: "rendered",
+				bytes: systemPromptBytes,
+				estimatedTokens: estimateContextTokens(systemPromptBytes),
+			},
+			...toolProfiles.flatMap(tool => [
+				{
+					category: "tool_description" as const,
+					label: tool.name,
+					bytes: tool.descriptionBytes,
+					estimatedTokens: estimateContextTokens(tool.descriptionBytes),
+				},
+				{
+					category: "tool_schema" as const,
+					label: tool.name,
+					bytes: tool.schemaBytes,
+					estimatedTokens: estimateContextTokens(tool.schemaBytes),
+				},
+			]),
+			...this.#attributedComponents,
+		];
+	}
+
+	setAttributedComponents(components: ContextComponentProfile[]): void {
+		this.#attributedComponents = components.map(component => ({ ...component }));
+	}
+
+	setDeferredTools(tools: Iterable<{ description?: string; parameters?: unknown }>): void {
+		this.#profile.deferredToolBytes = Array.from(tools).reduce(
+			(sum, tool) => sum + Buffer.byteLength(tool.description ?? "", "utf8") + jsonBytes(tool.parameters),
+			0,
+		);
+	}
+
+	captureProviderPayload(payload: unknown, model: Model): void {
+		this.#profile.providerCalls.push(profileProviderPayload(payload, model, this.#profile.providerCalls.length + 1));
+	}
+
+	recordProviderUsage(model: Model, usage: Usage): void {
+		const call = [...this.#profile.providerCalls]
+			.reverse()
+			.find(candidate => candidate.model === model.id && candidate.providerPromptTokens === undefined);
+		if (!call) return;
+		const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+		call.providerInputTokens = usage.input;
+		call.providerCacheReadTokens = usage.cacheRead;
+		call.providerCacheWriteTokens = usage.cacheWrite;
+		call.providerPromptTokens = promptTokens;
+		call.providerOutputTokens = usage.output;
+		call.windowPercentage = call.contextWindow > 0 ? (promptTokens / call.contextWindow) * 100 : 0;
+	}
+
+	snapshot(): ContextProfile {
+		return structuredClone(this.#profile);
+	}
+}

package/src/debug/index.ts

@@ -8,6 +8,7 @@ import * as url from "node:url";
 import { getWorkProfile } from "@f5-sales-demo/pi-natives";
 import { Container, Loader, type SelectItem, SelectList, Spacer, Text } from "@f5-sales-demo/pi-tui";
 import { getSessionsDir } from "@f5-sales-demo/pi-utils";
+import type { ContextProfile } from "../context/profile";
 import { DynamicBorder } from "../modes/components/dynamic-border";
 import { getSelectListTheme, getSymbolTheme, theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
@@ -27,6 +28,7 @@ const DEBUG_MENU_ITEMS: SelectItem[] = [
 	{ value: "memory", label: "Report: memory issue", description: "Heap snapshot + bundle" },
 	{ value: "logs", label: "View: recent logs", description: "Show last 50 log entries" },
 	{ value: "system", label: "View: system info", description: "Show environment details" },
+	{ value: "context-profile", label: "View: Context Profile", description: "Show privacy-safe context measurements" },
 	{
 		value: "transcript",
 		label: "Export: TUI transcript",
@@ -100,6 +102,9 @@ export class DebugSelectorComponent extends Container {
 			case "system":
 				await this.#handleViewSystemInfo();
 				break;
+			case "context-profile":
+				this.#handleContextProfile();
+				break;
 			case "transcript":
 				await this.#handleTranscriptExport();
 				break;
@@ -333,6 +338,14 @@ export class DebugSelectorComponent extends Container {
 		this.ctx.ui.requestRender();
 	}
 
+	#handleContextProfile(): void {
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new DynamicBorder());
+		this.ctx.chatContainer.addChild(new Text(formatContextProfile(this.ctx.session.getContextProfile()), 1, 0));
+		this.ctx.chatContainer.addChild(new DynamicBorder());
+		this.ctx.ui.requestRender();
+	}
+
 	async #handleTranscriptExport(): Promise<void> {
 		await this.ctx.handleDebugTranscriptCommand();
 	}
@@ -431,6 +444,27 @@ export class DebugSelectorComponent extends Container {
 	}
 }
 
+export function formatContextProfile(profile: ContextProfile): string {
+	const lines = [
+		"Context Profile",
+		`Loading: ${profile.loadingMode}`,
+		`System prompt: ${profile.systemPromptBytes.toLocaleString()} bytes (~${profile.estimatedSystemPromptTokens.toLocaleString()} tokens)`,
+		`Initial tools: ${profile.initialToolBytes.toLocaleString()} bytes; deferred: ${profile.deferredToolBytes.toLocaleString()} bytes`,
+	];
+	for (const call of profile.providerCalls) {
+		const prompt = call.providerPromptTokens?.toLocaleString() ?? "pending";
+		const cacheRead = call.providerCacheReadTokens?.toLocaleString() ?? "pending";
+		const output = call.providerOutputTokens?.toLocaleString() ?? "pending";
+		const percentage = call.windowPercentage === undefined ? "pending" : `${call.windowPercentage.toFixed(3)}%`;
+		lines.push(
+			`Call ${call.call}: ${call.provider}/${call.model} — prompt ${prompt}, cache read ${cacheRead}, output ${output}, window ${percentage}`,
+			`  Payload: ${call.payloadBytes.toLocaleString()} bytes (${call.toolCount} tools, ${call.messageCount} messages)`,
+		);
+	}
+	if (profile.providerCalls.length === 0) lines.push("Provider calls: none yet");
+	return lines.join("\n");
+}
+
 /**
  * Show the debug selector.
  */

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "21.5.6",
-	"commit": "d3cadfbd84e1ec85fc4f48619ffdabe334164c90",
-	"shortCommit": "d3cadfb",
+	"version": "21.6.0",
+	"commit": "3c4117bc7ac3253a8faf13a50641787d01ac11be",
+	"shortCommit": "3c4117b",
 	"branch": "main",
-	"tag": "v21.5.6",
-	"commitDate": "2026-09-02T00:45:22+00:00",
-	"buildDate": "2026-09-02T01:15:05.987Z",
+	"tag": "v21.6.0",
+	"commitDate": "2026-09-02T04:05:59+00:00",
+	"buildDate": "2026-09-02T04:35:09.450Z",
 	"dirty": true,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5-sales-demo/xcsh",
 	"repoSlug": "f5-sales-demo/xcsh",
-	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/d3cadfbd84e1ec85fc4f48619ffdabe334164c90",
-	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v21.5.6"
+	"commitUrl": "https://github.com/f5-sales-demo/xcsh/commit/3c4117bc7ac3253a8faf13a50641787d01ac11be",
+	"releaseUrl": "https://github.com/f5-sales-demo/xcsh/releases/tag/v21.6.0"
 };

package/src/mcp/discoverable-tool-metadata.ts

@@ -96,6 +96,11 @@ function buildSearchDocument(tool: DiscoverableMCPTool): DiscoverableMCPSearchDo
 
 export function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null {
 	if (!isMCPToolName(tool.name)) return null;
+	return getDiscoverableTool(tool);
+}
+
+/** Build safe search metadata for any registered tool source. */
+export function getDiscoverableTool(tool: AgentTool): DiscoverableMCPTool {
 	const toolRecord = tool as AgentTool & {
 		label?: string;
 		description?: string;
@@ -113,6 +118,10 @@ export function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | n
 	};
 }
 
+export function collectDiscoverableTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[] {
+	return Array.from(tools, getDiscoverableTool);
+}
+
 export function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[] {
 	const discoverable: DiscoverableMCPTool[] = [];
 	for (const tool of tools) {

package/src/modes/components/auth-link-presenter.ts

@@ -0,0 +1,36 @@
+import { type Container, Text } from "@f5-sales-demo/pi-tui";
+import { copyToClipboard } from "../../utils/clipboard";
+import { theme } from "../theme/theme";
+
+type AuthLinkContainer = Pick<Container, "addChild">;
+
+export interface AuthLinkPresenterOptions {
+	copy?: (url: string) => void | Promise<void>;
+	platform?: NodeJS.Platform;
+}
+
+/** Present a browser authorization target without exposing its long URL as visible terminal text. */
+export function presentAuthLink(
+	container: AuthLinkContainer,
+	url: string,
+	options: AuthLinkPresenterOptions = {},
+): void {
+	const platform = options.platform ?? process.platform;
+	const clickHint = platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
+	const hyperlink = `\x1b]8;;${url}\x07Open sign-in page\x1b]8;;\x07`;
+	container.addChild(new Text(`${theme.fg("accent", hyperlink)} ${theme.fg("dim", `(${clickHint})`)}`, 1, 0));
+	container.addChild(
+		new Text(
+			theme.fg("dim", "Sign-in URL copied when supported. Clipboard availability depends on terminal support."),
+			1,
+			0,
+		),
+	);
+
+	const copy = options.copy ?? copyToClipboard;
+	try {
+		void Promise.resolve(copy(url)).catch(() => undefined);
+	} catch {
+		// Clipboard access is best-effort; the OSC 8 link remains available.
+	}
+}

package/src/modes/components/index.ts

@@ -1,5 +1,6 @@
 // UI Components barrel export
 export * from "./assistant-message";
+export * from "./auth-link-presenter";
 export * from "./bash-execution";
 export * from "./bordered-loader";
 export * from "./branch-summary-message";

package/src/modes/components/login-dialog.ts

@@ -2,8 +2,14 @@ import { getOAuthProviders } from "@f5-sales-demo/pi-ai";
 import { Container, getKeybindings, Input, Spacer, Text, type TUI } from "@f5-sales-demo/pi-tui";
 import { theme } from "../../modes/theme/theme";
 import { openPath } from "../../utils/open";
+import { presentAuthLink } from "./auth-link-presenter";
 import { DynamicBorder } from "./dynamic-border";
 
+interface LoginDialogDependencies {
+	openUrl?: (url: string) => void;
+	presentLink?: typeof presentAuthLink;
+}
+
 /**
  * Login dialog component - replaces editor during OAuth login flow
  */
@@ -19,6 +25,7 @@ export class LoginDialogComponent extends Container {
 		tui: TUI,
 		providerId: string,
 		private onComplete: (success: boolean, message?: string) => void,
+		private dependencies: LoginDialogDependencies = {},
 	) {
 		super();
 		this.#tui = tui;
@@ -73,11 +80,7 @@ export class LoginDialogComponent extends Container {
 	showAuth(url: string, instructions?: string): void {
 		this.#contentContainer.clear();
 		this.#contentContainer.addChild(new Spacer(1));
-		this.#contentContainer.addChild(new Text(theme.fg("contentAccent", url), 1, 0));
-
-		const clickHint = process.platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
-		const hyperlink = `\x1b]8;;${url}\x07${clickHint}\x1b]8;;\x07`;
-		this.#contentContainer.addChild(new Text(theme.fg("dim", hyperlink), 1, 0));
+		(this.dependencies.presentLink ?? presentAuthLink)(this.#contentContainer, url);
 
 		if (instructions) {
 			this.#contentContainer.addChild(new Spacer(1));
@@ -85,7 +88,7 @@ export class LoginDialogComponent extends Container {
 		}
 
 		// Open browser (best-effort)
-		openPath(url);
+		(this.dependencies.openUrl ?? openPath)(url);
 
 		this.#tui.requestRender();
 	}