@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/cli/gallery-fixtures/web.ts

@@ -0,0 +1,158 @@
+// Gallery fixtures for the web tools (web_search, browser).
+import type { GalleryFixture } from "./types";
+
+export const webFixtures: Record<string, GalleryFixture> = {
+	web_search: {
+		label: "Web Search",
+		// Streaming: query still being typed, no recency/limit yet.
+		streamingArgs: { query: "bun vs node performance" },
+		args: {
+			query: "Bun vs Node.js performance benchmarks 2026",
+			recency: "month",
+			limit: 4,
+		},
+		result: {
+			content: [
+				{
+					type: "text",
+					text: [
+						"Bun continues to outperform Node.js on raw HTTP throughput and cold-start",
+						"time thanks to its JavaScriptCore engine and native-Zig runtime, while",
+						"Node.js retains an edge in ecosystem maturity and long-term stability.",
+						"For script-heavy workflows Bun's faster startup is the decisive factor.",
+					].join("\n"),
+				},
+			],
+			details: {
+				response: {
+					provider: "perplexity",
+					model: "sonar-pro",
+					authMode: "api_key",
+					requestId: "req_a1b2c3d4e5f6",
+					answer: [
+						"Bun continues to outperform Node.js on raw HTTP throughput and cold-start",
+						"time thanks to its JavaScriptCore engine and native-Zig runtime, while",
+						"Node.js retains an edge in ecosystem maturity and long-term stability.",
+						"For script-heavy workflows Bun's faster startup is the decisive factor.",
+					].join("\n"),
+					searchQueries: ["bun vs node.js performance benchmarks 2026", "bun http throughput vs node"],
+					sources: [
+						{
+							title: "Bun 1.2 Benchmarks: HTTP, SQLite, and Startup Time",
+							url: "https://bun.sh/blog/bun-v1.2-benchmarks",
+							snippet:
+								"Bun serves roughly 2.5x the requests per second of Node.js on a simple HTTP server and starts in under 10ms.",
+							ageSeconds: 86400 * 12,
+							author: "The Bun Team",
+						},
+						{
+							title: "Node.js vs Bun: A 2026 Performance Deep Dive",
+							url: "https://blog.platformatic.dev/nodejs-vs-bun-2026",
+							snippet:
+								"Across CPU-bound workloads the gap narrows, but Bun's faster module resolution keeps cold starts ahead.",
+							ageSeconds: 86400 * 3,
+							author: "Matteo Collina",
+						},
+						{
+							title: "Real-world API latency: Bun, Deno, and Node compared",
+							url: "https://www.theregister.com/2026/05/18/js_runtime_latency/",
+							snippet:
+								"Under sustained load p99 latencies converge, suggesting runtime choice matters less for steady-state services.",
+							ageSeconds: 86400 * 19,
+						},
+						{
+							title: "Why we migrated our CLI tooling from Node to Bun",
+							url: "https://engineering.example.com/posts/bun-cli-migration",
+							snippet:
+								"Startup dropped from 180ms to 22ms, shaving seconds off every developer command invocation.",
+							ageSeconds: 86400 * 27,
+							author: "Dana Whitfield",
+						},
+					],
+					citations: [
+						{
+							url: "https://bun.sh/blog/bun-v1.2-benchmarks",
+							title: "Bun 1.2 Benchmarks",
+							citedText: "Bun serves roughly 2.5x the requests per second of Node.js",
+						},
+					],
+					usage: {
+						inputTokens: 312,
+						outputTokens: 248,
+						totalTokens: 560,
+						searchRequests: 2,
+					},
+				},
+			},
+		},
+		errorResult: {
+			isError: true,
+			content: [{ type: "text", text: "Web search failed: provider returned HTTP 429 (rate limited)." }],
+			details: {
+				response: {
+					provider: "perplexity",
+					sources: [],
+				},
+				error: "Provider returned HTTP 429 (rate limited). Retry after 30s.",
+			},
+		},
+	},
+
+	browser: {
+		label: "Browser",
+		// Streaming: code body still arriving for a `run` action.
+		streamingArgs: {
+			action: "run",
+			name: "docs",
+			code: "const obs = await tab.observe();\n",
+		},
+		args: {
+			action: "run",
+			name: "docs",
+			code: [
+				"const obs = await tab.observe();",
+				"const heading = obs.elements.find(e => e.role === 'heading');",
+				"display({ url: obs.url, title: obs.title, headings: obs.elements.filter(e => e.role === 'heading').length });",
+				"return heading?.name ?? 'no heading found';",
+			].join("\n"),
+		},
+		result: {
+			content: [
+				{
+					type: "text",
+					text: [
+						'{ url: "https://bun.sh/docs", title: "Bun Documentation", headings: 14 }',
+						'"Get started with Bun"',
+					].join("\n"),
+				},
+			],
+			details: {
+				action: "run",
+				name: "docs",
+				url: "https://bun.sh/docs",
+				browser: "headless",
+				viewport: { width: 1280, height: 800, deviceScaleFactor: 1 },
+				result: '"Get started with Bun"',
+			},
+		},
+		errorResult: {
+			isError: true,
+			content: [
+				{
+					type: "text",
+					text: [
+						"TimeoutError: waiting for selector `aria/Sign in` failed: timeout 30000ms exceeded",
+						"    at Tab.waitFor (browser/tab.ts:212:13)",
+						"    at run (eval:3:7)",
+					].join("\n"),
+				},
+			],
+			details: {
+				action: "run",
+				name: "docs",
+				url: "https://bun.sh/docs",
+				browser: "headless",
+			},
+		},
+	},
+};

package/src/cli/gallery-screenshot.ts

@@ -0,0 +1,279 @@
+/**
+ * Render `prometheus gallery` output to PNG screenshots via VHS.
+ *
+ * ANSI escapes are invisible to anything that can only read raw bytes (e.g.
+ * agents), so `--screenshot` drives the rendered gallery through a real virtual
+ * terminal (VHS + ttyd + ffmpeg) and writes the captured frame to disk. The
+ * gallery is pre-rendered to truecolor ANSI in this process — where the user's
+ * theme and symbol preset are correct — then `cat`'d inside VHS so the captured
+ * pixels match exactly what the live TUI would draw.
+ *
+ * VHS is a hard dependency of this path: if it is not installed we fail loudly
+ * rather than degrade to a lossy fallback.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $which } from "@prometheus-ai/utils";
+import { theme } from "../modes/theme/theme";
+import type { GallerySection } from "./gallery-cli";
+
+/** Nerd Font family so the gallery's icon glyphs (PUA) render instead of tofu. */
+export const DEFAULT_SCREENSHOT_FONT = "JetBrainsMono Nerd Font";
+export const DEFAULT_SCREENSHOT_FONT_SIZE = 18;
+
+/** Inner padding (px) VHS leaves around the terminal grid. */
+const PADDING = 14;
+const LINE_HEIGHT = 1.0;
+/**
+ * Upper-bound cell metrics relative to font size. Real monospace cells are
+ * smaller, so over-provisioning the canvas guarantees the gallery never
+ * soft-wraps (too few columns) or scrolls off the top (too few rows). The slack
+ * shows up only as a modest background margin, which is harmless for review.
+ */
+const CELL_WIDTH_RATIO = 0.65;
+const CELL_HEIGHT_RATIO = 1.5;
+/** Keep each image well under headless-Chromium's tall-canvas limits. */
+const MAX_IMAGE_HEIGHT_PX = 8000;
+
+export interface GalleryScreenshotOptions {
+	/** Gallery render width in columns (matches the ANSI line width). */
+	width: number;
+	/** VHS `FontFamily`. */
+	font?: string;
+	/** VHS `FontSize`. */
+	fontSize?: number;
+	/**
+	 * Output destination. When omitted, PNGs land in a fresh temp directory.
+	 * With multiple images the path is suffixed (`name-01.png`, `name-02.png`).
+	 */
+	out?: string;
+}
+
+/**
+ * Capture the gallery sections as one or more PNGs and return their absolute
+ * paths. Tall galleries are split across images so no single capture exceeds
+ * the terminal-canvas height limit.
+ */
+export async function captureGalleryScreenshots(
+	sections: GallerySection[],
+	options: GalleryScreenshotOptions,
+): Promise<string[]> {
+	const vhs = $which("vhs");
+	if (!vhs) {
+		throw new Error(
+			"`prometheus gallery --screenshot` requires VHS, which is not installed. " +
+				"Install it (e.g. `brew install vhs`, or see https://github.com/charmbracelet/vhs) and retry.",
+		);
+	}
+
+	const font = options.font ?? DEFAULT_SCREENSHOT_FONT;
+	const fontSize = options.fontSize ?? DEFAULT_SCREENSHOT_FONT_SIZE;
+	const cellHeight = fontSize * Math.max(LINE_HEIGHT, 1) * CELL_HEIGHT_RATIO;
+	const cellWidth = fontSize * CELL_WIDTH_RATIO;
+	const rowBudget = Math.max(40, Math.floor((MAX_IMAGE_HEIGHT_PX - 2 * PADDING) / cellHeight) - 2);
+	const chunks = chunkGallerySections(sections, rowBudget);
+	const themeJson = buildVhsTheme();
+
+	const baseDir = options.out
+		? path.dirname(path.resolve(options.out))
+		: fs.mkdtempSync(path.join(os.tmpdir(), "prometheus-gallery-"));
+	await fs.promises.mkdir(baseDir, { recursive: true });
+
+	const outPaths: string[] = [];
+	for (let i = 0; i < chunks.length; i++) {
+		if (chunks.length > 1) {
+			process.stderr.write(`Rendering gallery screenshot ${i + 1}/${chunks.length}…\n`);
+		}
+		const outPng = resolveScreenshotOutputPath(options.out, baseDir, i, chunks.length);
+		const lines = chunks[i].flatMap(section => section.lines);
+		await renderChunk({ vhs, lines, outPng, font, fontSize, cellWidth, cellHeight, width: options.width, themeJson });
+		outPaths.push(outPng);
+	}
+	return outPaths;
+}
+
+interface RenderChunkArgs {
+	vhs: string;
+	lines: string[];
+	outPng: string;
+	font: string;
+	fontSize: number;
+	cellWidth: number;
+	cellHeight: number;
+	width: number;
+	themeJson: string;
+}
+
+async function renderChunk(args: RenderChunkArgs): Promise<void> {
+	const rows = args.lines.length;
+	const widthPx = Math.ceil(args.width * args.cellWidth) + 2 * PADDING;
+	const heightPx = Math.ceil((rows + 2) * args.cellHeight) + 2 * PADDING;
+
+	const dir = path.dirname(args.outPng);
+	const stem = path.basename(args.outPng, path.extname(args.outPng));
+	const ansiPath = path.join(dir, `.${stem}.ansi`);
+	const tapePath = path.join(dir, `.${stem}.tape`);
+	const gifPath = path.join(dir, `.${stem}.gif`);
+
+	// CRLF so each gallery line is its own terminal row regardless of how the
+	// captured shell handles bare LF.
+	await Bun.write(ansiPath, `${args.lines.join("\r\n")}\r\n`);
+	await Bun.write(
+		tapePath,
+		buildTape({
+			gifPath,
+			outPng: args.outPng,
+			ansiPath,
+			widthPx,
+			heightPx,
+			font: args.font,
+			fontSize: args.fontSize,
+			themeJson: args.themeJson,
+		}),
+	);
+
+	try {
+		const result = await Bun.$`${args.vhs} ${tapePath}`.quiet().nothrow();
+		if (result.exitCode !== 0 || !(await Bun.file(args.outPng).exists())) {
+			const detail = result.stderr.toString().trim() || result.stdout.toString().trim();
+			throw new Error(`VHS failed to render the gallery screenshot${detail ? `: ${detail.slice(-600)}` : ""}`);
+		}
+	} finally {
+		await Promise.all([
+			fs.promises.rm(ansiPath, { force: true }),
+			fs.promises.rm(tapePath, { force: true }),
+			fs.promises.rm(gifPath, { force: true }),
+		]);
+	}
+}
+
+interface TapeArgs {
+	gifPath: string;
+	outPng: string;
+	ansiPath: string;
+	widthPx: number;
+	heightPx: number;
+	font: string;
+	fontSize: number;
+	themeJson: string;
+}
+
+function buildTape(args: TapeArgs): string {
+	// `Output` (a throwaway GIF) is mandatory for VHS to record; the screenshot
+	// is captured from the final visible frame. Setup is hidden so the typed
+	// `cat` command and shell prompt never appear in the capture, and a trailing
+	// `sleep` keeps the shell from drawing a fresh prompt under the output.
+	const shellCommand = `clear; cat ${shellSingleQuote(args.ansiPath)}; sleep 120`;
+	return `${[
+		`Output ${JSON.stringify(args.gifPath)}`,
+		`Set Width ${args.widthPx}`,
+		`Set Height ${args.heightPx}`,
+		`Set FontFamily ${JSON.stringify(args.font)}`,
+		`Set FontSize ${args.fontSize}`,
+		`Set Padding ${PADDING}`,
+		`Set LineHeight ${LINE_HEIGHT}`,
+		`Set Theme ${args.themeJson}`,
+		"Hide",
+		`Type ${JSON.stringify(shellCommand)}`,
+		"Enter",
+		"Sleep 1.2s",
+		"Show",
+		"Sleep 400ms",
+		`Screenshot ${JSON.stringify(args.outPng)}`,
+	].join("\n")}\n`;
+}
+
+/**
+ * Build the VHS terminal theme. Only background/foreground/cursor matter: the
+ * gallery emits truecolor (`38;2`/`48;2`) escapes, so the 16-color palette is
+ * never consulted — it is filler to satisfy VHS's theme schema.
+ */
+function buildVhsTheme(): string {
+	const background = parseAnsiRgb(theme.getBgAnsi("statusLineBg")) ?? (theme.isLight ? "#ffffff" : "#1a1a1a");
+	const foreground = theme.isLight ? "#1a1a1a" : "#d4d4d4";
+	const selection = theme.isLight ? "#c8d6ff" : "#404862";
+	return JSON.stringify({
+		name: "prometheus-gallery",
+		background,
+		foreground,
+		cursor: foreground,
+		selection,
+		black: "#000000",
+		red: "#ff5555",
+		green: "#50fa7b",
+		yellow: "#f1fa8c",
+		blue: "#6272ff",
+		magenta: "#ff79c6",
+		cyan: "#8be9fd",
+		white: "#bfbfbf",
+		brightBlack: "#4d4d4d",
+		brightRed: "#ff6e6e",
+		brightGreen: "#69ff94",
+		brightYellow: "#ffffa5",
+		brightBlue: "#8aa0ff",
+		brightMagenta: "#ff92df",
+		brightCyan: "#a4ffff",
+		brightWhite: "#ffffff",
+	});
+}
+
+/** Extract `#rrggbb` from a truecolor SGR escape (`…38;2;r;g;b…` / `…48;2;…`). */
+function parseAnsiRgb(ansi: string): string | undefined {
+	const match = /[34]8;2;(\d+);(\d+);(\d+)/.exec(ansi);
+	if (!match) return undefined;
+	const hex = (value: string) => Number(value).toString(16).padStart(2, "0");
+	return `#${hex(match[1])}${hex(match[2])}${hex(match[3])}`;
+}
+
+/** POSIX single-quote a path for embedding in the VHS shell command. */
+function shellSingleQuote(value: string): string {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Resolve a chunk's PNG path. A single image keeps the bare name (or the exact
+ * `out`); multiple images gain a zero-padded `-NN` suffix so they sort and never
+ * collide.
+ */
+export function resolveScreenshotOutputPath(
+	out: string | undefined,
+	baseDir: string,
+	index: number,
+	total: number,
+): string {
+	if (total === 1) {
+		return out ? path.resolve(out) : path.join(baseDir, "gallery.png");
+	}
+	const suffix = String(index + 1).padStart(2, "0");
+	if (out) {
+		const resolved = path.resolve(out);
+		const ext = path.extname(resolved) || ".png";
+		const stem = path.basename(resolved, ext);
+		return path.join(path.dirname(resolved), `${stem}-${suffix}${ext}`);
+	}
+	return path.join(baseDir, `gallery-${suffix}.png`);
+}
+
+/**
+ * Group whole tool sections into chunks that stay under `rowBudget` rows. A
+ * single section larger than the budget gets its own (taller) image rather than
+ * being split mid-renderer.
+ */
+export function chunkGallerySections(sections: GallerySection[], rowBudget: number): GallerySection[][] {
+	const chunks: GallerySection[][] = [];
+	let current: GallerySection[] = [];
+	let currentRows = 0;
+	for (const section of sections) {
+		const rows = section.lines.length;
+		if (current.length > 0 && currentRows + rows > rowBudget) {
+			chunks.push(current);
+			current = [];
+			currentRows = 0;
+		}
+		current.push(section);
+		currentRows += rows;
+	}
+	if (current.length > 0) chunks.push(current);
+	return chunks.length > 0 ? chunks : [[]];
+}

package/src/cli/grievances-cli.ts

@@ -199,7 +199,7 @@ function makeProgressBar(total: number, width = 30): ProgressBar {
  * ignoring the user-facing consent gate (manual push is the user's
  * explicit "yes ship these now" intent).
  *
- * Requires endpoint configuration (default `qa.prometheus.trivlab.com/v1/grievances`).
+ * Requires endpoint configuration (default `qa.prometheus.sh/v1/grievances`).
  */
 export async function pushGrievances(options: PushGrievancesOptions): Promise<void> {
 	const db = openAutoQaDb();

package/src/cli/list-models.ts

@@ -1,137 +1,13 @@
 /**
- * List available models with optional fuzzy search
+ * Backward-compatible `--list-models` entry point.
+ *
+ * The supported model catalog surface is `prometheus models`; this wrapper keeps
+ * the legacy flag routed through the same renderer and extension discovery path.
  */
-import { type Api, getSupportedEfforts, type Model } from "@prometheus-ai/ai";
-import { fuzzyFilter } from "@prometheus-ai/tui";
-import { formatNumber } from "@prometheus-ai/utils";
 import type { ModelRegistry } from "../config/model-registry";
-import { discoverAndLoadExtensions, loadExtensions } from "../extensibility/extensions";
-import { EventBus } from "../utils/event-bus";
+import { runModelsListing } from "./models-cli";
 
-interface ProviderRow {
-	provider: string;
-	model: string;
-	context: string;
-	maxOut: string;
-	thinking: string;
-	images: string;
-}
-
-interface CanonicalRow {
-	canonical: string;
-	selected: string;
-	variants: string;
-	context: string;
-	maxOut: string;
-}
-
-function writeLine(line = ""): void {
-	process.stdout.write(`${line}\n`);
-}
-
-function renderTable<T extends Record<string, string>>(rows: T[], headers: T): void {
-	const widths = Object.fromEntries(
-		Object.keys(headers).map(key => [key, Math.max(headers[key]!.length, ...rows.map(row => row[key]!.length))]),
-	) as Record<keyof T, number>;
-
-	const headerLine = Object.keys(headers)
-		.map(key => headers[key as keyof T]!.padEnd(widths[key as keyof T]))
-		.join("  ");
-	writeLine(headerLine);
-
-	for (const row of rows) {
-		const line = Object.keys(headers)
-			.map(key => row[key as keyof T]!.padEnd(widths[key as keyof T]))
-			.join("  ");
-		writeLine(line);
-	}
-}
-
-/**
- * List available models, optionally filtered by search pattern
- */
-export async function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void> {
-	const models = modelRegistry.getAvailable();
-
-	if (models.length === 0) {
-		writeLine("No models available. Set API keys in environment variables.");
-		return;
-	}
-
-	let filteredModels: Model<Api>[] = models;
-	if (searchPattern) {
-		filteredModels = fuzzyFilter(models, searchPattern, model => `${model.provider} ${model.id}`);
-	}
-
-	const filteredCanonical = modelRegistry
-		.getCanonicalModels({ availableOnly: true, candidates: filteredModels })
-		.map(record => {
-			const selected = modelRegistry.resolveCanonicalModel(record.id, {
-				availableOnly: true,
-				candidates: filteredModels,
-			});
-			if (!selected) return undefined;
-			return {
-				canonical: record.id,
-				selected: `${selected.provider}/${selected.id}`,
-				variants: String(record.variants.length),
-				context: formatNumber(selected.contextWindow),
-				maxOut: formatNumber(selected.maxTokens),
-			} satisfies CanonicalRow;
-		})
-		.filter((row): row is CanonicalRow => row !== undefined)
-		.sort((left, right) => left.canonical.localeCompare(right.canonical));
-
-	if (filteredModels.length === 0 && filteredCanonical.length === 0) {
-		writeLine(`No models matching "${searchPattern}"`);
-		return;
-	}
-
-	filteredModels.sort((left, right) => {
-		const providerCmp = left.provider.localeCompare(right.provider);
-		if (providerCmp !== 0) return providerCmp;
-		return left.id.localeCompare(right.id);
-	});
-
-	const providerRows = filteredModels.map(model => ({
-		provider: model.provider,
-		model: model.id,
-		context: formatNumber(model.contextWindow),
-		maxOut: formatNumber(model.maxTokens),
-		thinking: model.thinking ? getSupportedEfforts(model).join(",") : model.reasoning ? "yes" : "-",
-		images: model.input.includes("image") ? "yes" : "no",
-	})) satisfies ProviderRow[];
-
-	if (filteredCanonical.length > 0) {
-		writeLine("Canonical models");
-		renderTable(filteredCanonical, {
-			canonical: "canonical",
-			selected: "selected",
-			variants: "variants",
-			context: "context",
-			maxOut: "max-out",
-		});
-		if (providerRows.length > 0) {
-			writeLine();
-		}
-	}
-
-	if (providerRows.length > 0) {
-		writeLine("Provider models");
-		renderTable(providerRows, {
-			provider: "provider",
-			model: "model",
-			context: "context",
-			maxOut: "max-out",
-			thinking: "thinking",
-			images: "images",
-		});
-	}
-}
-
-/**
- * Options for the `--list-models` command entry point.
- */
+/** Options for the legacy `--list-models` command entry point. */
 export interface RunListModelsOptions {
 	modelRegistry: ModelRegistry;
 	cwd: string;
@@ -146,49 +22,15 @@ export interface RunListModelsOptions {
 	searchPattern?: string;
 }
 
-/**
- * Loads extensions (CLI `-e` paths and `settings.extensions`) and surfaces
- * any provider/model registrations on the supplied `modelRegistry` before
- * delegating to {@link listModels}. This is the single entry point used by
- * `--list-models` and exists to ensure extension-contributed providers are
- * visible in the listing (issue #905). The load is intentionally narrow:
- * no agent loop, no MCP servers, no custom-tool registration.
- */
 export async function runListModelsCommand(options: RunListModelsOptions): Promise<void> {
-	const {
-		modelRegistry,
-		cwd,
-		additionalExtensionPaths = [],
-		settingsExtensions = [],
-		disabledExtensionIds = [],
-		disableExtensionDiscovery = false,
-		searchPattern,
-	} = options;
-
-	const eventBus = new EventBus();
-	const extensionsResult = disableExtensionDiscovery
-		? await loadExtensions(additionalExtensionPaths, cwd, eventBus)
-		: await discoverAndLoadExtensions(
-				[...additionalExtensionPaths, ...settingsExtensions],
-				cwd,
-				eventBus,
-				disabledExtensionIds,
-			);
-
-	for (const { path: extPath, error } of extensionsResult.errors) {
-		process.stderr.write(`Failed to load extension: ${extPath}: ${error}\n`);
-	}
-
-	// Mirror sdk.ts: drain pending provider registrations into the registry.
-	const activeSources = extensionsResult.extensions.map(extension => extension.path);
-	modelRegistry.syncExtensionSources(activeSources);
-	for (const sourceId of new Set(activeSources)) {
-		modelRegistry.clearSourceRegistrations(sourceId);
-	}
-	for (const { name, config, sourceId } of extensionsResult.runtime.pendingProviderRegistrations) {
-		modelRegistry.registerProvider(name, config, sourceId);
-	}
-	extensionsResult.runtime.pendingProviderRegistrations = [];
-
-	await listModels(modelRegistry, searchPattern);
+	await runModelsListing({
+		modelRegistry: options.modelRegistry,
+		cwd: options.cwd,
+		action: "ls",
+		pattern: options.searchPattern,
+		additionalExtensionPaths: options.additionalExtensionPaths,
+		settingsExtensions: options.settingsExtensions,
+		disabledExtensionIds: options.disabledExtensionIds,
+		disableExtensionDiscovery: options.disableExtensionDiscovery,
+	});
 }