gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/packages/gsd-agent-modes/src/cli/args.ts

@@ -1,350 +0,0 @@
-/**
- * CLI argument parsing and help display
- */
-
-import type { ThinkingLevel } from "@gsd/pi-agent-core";
-import chalk from "chalk";
-import {
-	APP_NAME,
-	CONFIG_DIR_NAME,
-	ENV_AGENT_DIR,
-	allTools,
-} from "../pi-coding-agent-compat.js";
-import type { ToolName } from "@gsd/agent-types";
-
-// isValidThinkingLevel and VALID_THINKING_LEVELS removed from pi-coding-agent 0.67.2 — define locally.
-export const VALID_THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
-export function isValidThinkingLevel(value: string): value is ThinkingLevel {
-	return (VALID_THINKING_LEVELS as string[]).includes(value);
-}
-
-export type Mode = "text" | "json" | "rpc";
-
-export interface Args {
-	provider?: string;
-	model?: string;
-	apiKey?: string;
-	systemPrompt?: string;
-	appendSystemPrompt?: string;
-	thinking?: ThinkingLevel;
-	continue?: boolean;
-	resume?: boolean;
-	help?: boolean;
-	version?: boolean;
-	mode?: Mode;
-	noSession?: boolean;
-	session?: string;
-	sessionDir?: string;
-	models?: string[];
-	tools?: ToolName[];
-	noTools?: boolean;
-	extensions?: string[];
-	noExtensions?: boolean;
-	print?: boolean;
-	export?: string;
-	noSkills?: boolean;
-	skills?: string[];
-	promptTemplates?: string[];
-	noPromptTemplates?: boolean;
-	themes?: string[];
-	noThemes?: boolean;
-	listModels?: string | true;
-	discover?: boolean;
-	addProvider?: string;
-	addProviderBaseUrl?: string;
-	addProviderApiKey?: string;
-	discoverModels?: string | true;
-	offline?: boolean;
-	verbose?: boolean;
-	messages: string[];
-	fileArgs: string[];
-	/** Unknown flags (potentially extension flags) - map of flag name to value */
-	unknownFlags: Map<string, boolean | string>;
-	/** --bare: suppress CLAUDE.md/AGENTS.md, user skills, prompt templates, themes, project preferences */
-	bare?: boolean;
-}
-
-/** Public type alias for Args — used in @gsd/agent-modes public API as GsdArgs */
-export type GsdArgs = Args;
-
-export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
-	const result: Args = {
-		messages: [],
-		fileArgs: [],
-		unknownFlags: new Map(),
-	};
-
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i];
-
-		if (arg === "--help" || arg === "-h") {
-			result.help = true;
-		} else if (arg === "--version" || arg === "-v") {
-			result.version = true;
-		} else if (arg === "--mode" && i + 1 < args.length) {
-			const mode = args[++i];
-			if (mode === "text" || mode === "json" || mode === "rpc") {
-				result.mode = mode;
-			}
-		} else if (arg === "--continue" || arg === "-c") {
-			result.continue = true;
-		} else if (arg === "--resume" || arg === "-r") {
-			result.resume = true;
-		} else if (arg === "--provider" && i + 1 < args.length) {
-			result.provider = args[++i];
-		} else if (arg === "--model" && i + 1 < args.length) {
-			result.model = args[++i];
-		} else if (arg === "--api-key" && i + 1 < args.length) {
-			result.apiKey = args[++i];
-		} else if (arg === "--system-prompt" && i + 1 < args.length) {
-			result.systemPrompt = args[++i];
-		} else if (arg === "--append-system-prompt" && i + 1 < args.length) {
-			result.appendSystemPrompt = args[++i];
-		} else if (arg === "--no-session") {
-			result.noSession = true;
-		} else if (arg === "--session" && i + 1 < args.length) {
-			result.session = args[++i];
-		} else if (arg === "--session-dir" && i + 1 < args.length) {
-			result.sessionDir = args[++i];
-		} else if (arg === "--models" && i + 1 < args.length) {
-			result.models = args[++i].split(",").map((s) => s.trim());
-		} else if (arg === "--no-tools") {
-			result.noTools = true;
-		} else if (arg === "--tools" && i + 1 < args.length) {
-			const toolNames = args[++i].split(",").map((s) => s.trim());
-			const validTools: ToolName[] = [];
-			for (const name of toolNames) {
-				if (name in allTools) {
-					validTools.push(name as ToolName);
-				} else {
-					console.error(
-						chalk.yellow(`Warning: Unknown tool "${name}". Valid tools: ${Object.keys(allTools).join(", ")}`),
-					);
-				}
-			}
-			result.tools = validTools;
-		} else if (arg === "--thinking" && i + 1 < args.length) {
-			const level = args[++i];
-			if (isValidThinkingLevel(level)) {
-				result.thinking = level;
-			} else {
-				console.error(
-					chalk.yellow(
-						`Warning: Invalid thinking level "${level}". Valid values: ${VALID_THINKING_LEVELS.join(", ")}`,
-					),
-				);
-			}
-		} else if (arg === "--print" || arg === "-p") {
-			result.print = true;
-		} else if (arg === "--export" && i + 1 < args.length) {
-			result.export = args[++i];
-		} else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
-			result.extensions = result.extensions ?? [];
-			result.extensions.push(args[++i]);
-		} else if (arg === "--no-extensions" || arg === "-ne") {
-			result.noExtensions = true;
-		} else if (arg === "--skill" && i + 1 < args.length) {
-			result.skills = result.skills ?? [];
-			result.skills.push(args[++i]);
-		} else if (arg === "--prompt-template" && i + 1 < args.length) {
-			result.promptTemplates = result.promptTemplates ?? [];
-			result.promptTemplates.push(args[++i]);
-		} else if (arg === "--theme" && i + 1 < args.length) {
-			result.themes = result.themes ?? [];
-			result.themes.push(args[++i]);
-		} else if (arg === "--no-skills" || arg === "-ns") {
-			result.noSkills = true;
-		} else if (arg === "--no-prompt-templates" || arg === "-np") {
-			result.noPromptTemplates = true;
-		} else if (arg === "--no-themes") {
-			result.noThemes = true;
-		} else if (arg === "--list-models") {
-			// Check if next arg is a search pattern (not a flag or file arg)
-			if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
-				result.listModels = args[++i];
-			} else {
-				result.listModels = true;
-			}
-		} else if (arg === "--discover") {
-			result.discover = true;
-		} else if (arg === "--add-provider" && i + 1 < args.length) {
-			result.addProvider = args[++i];
-		} else if (arg === "--base-url" && i + 1 < args.length) {
-			result.addProviderBaseUrl = args[++i];
-		} else if (arg === "--discover-models") {
-			if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
-				result.discoverModels = args[++i];
-			} else {
-				result.discoverModels = true;
-			}
-		} else if (arg === "--verbose") {
-			result.verbose = true;
-		} else if (arg === "--bare") {
-			result.bare = true;
-		} else if (arg === "--offline") {
-			result.offline = true;
-		} else if (arg.startsWith("@")) {
-			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
-		} else if (arg.startsWith("--") && extensionFlags) {
-			// Check if it's an extension-registered flag
-			const flagName = arg.slice(2);
-			const extFlag = extensionFlags.get(flagName);
-			if (extFlag) {
-				if (extFlag.type === "boolean") {
-					result.unknownFlags.set(flagName, true);
-				} else if (extFlag.type === "string" && i + 1 < args.length) {
-					result.unknownFlags.set(flagName, args[++i]);
-				}
-			}
-			// Unknown flags without extensionFlags are silently ignored (first pass)
-		} else if (!arg.startsWith("-")) {
-			result.messages.push(arg);
-		}
-	}
-
-	return result;
-}
-
-export function printHelp(): void {
-	console.log(`${chalk.bold(APP_NAME)} - AI coding assistant with read, bash, edit, write tools
-
-${chalk.bold("Usage:")}
-  ${APP_NAME} [options] [@files...] [messages...]
-
-${chalk.bold("Commands:")}
-  ${APP_NAME} install <source> [-l]    Install extension source and add to settings
-  ${APP_NAME} remove <source> [-l]     Remove extension source from settings
-  ${APP_NAME} update [source]          Update installed extensions (skips pinned sources)
-  ${APP_NAME} list                     List installed extensions from settings
-  ${APP_NAME} config                   Open TUI to enable/disable package resources
-  ${APP_NAME} <command> --help         Show help for install/remove/update/list
-
-${chalk.bold("Options:")}
-  --provider <name>              Provider name (default: google)
-  --model <pattern>              Model pattern or ID (supports "provider/id" and optional ":<thinking>")
-  --api-key <key>                API key (defaults to env vars)
-  --system-prompt <text>         System prompt (default: coding assistant prompt)
-  --append-system-prompt <text>  Append text or file contents to the system prompt
-  --mode <mode>                  Output mode: text (default), json, or rpc
-  --print, -p                    Non-interactive mode: process prompt and exit
-  --continue, -c                 Continue previous session
-  --resume, -r                   Select a session to resume
-  --session <path>               Use specific session file
-  --session-dir <dir>            Directory for session storage and lookup
-  --no-session                   Don't save session (ephemeral)
-  --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
-                                 Supports globs (anthropic/*, *sonnet*) and fuzzy matching
-  --no-tools                     Disable all built-in tools
-  --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
-                                 Available: read, bash, edit, write, lsp, grep, find, ls
-  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
-  --extension, -e <path>         Load an extension file (can be used multiple times)
-  --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
-  --skill <path>                 Load a skill file or directory (can be used multiple times)
-  --no-skills, -ns               Disable skills discovery and loading
-  --prompt-template <path>       Load a prompt template file or directory (can be used multiple times)
-  --no-prompt-templates, -np     Disable prompt template discovery and loading
-  --theme <path>                 Load a theme file or directory (can be used multiple times)
-  --no-themes                    Disable theme discovery and loading
-  --export <file>                Export session file to HTML and exit
-  --list-models [search]         List available models (with optional fuzzy search)
-  --discover                     Include discovered models in --list-models output
-  --discover-models [provider]   Discover models from provider APIs (all or specific)
-  --add-provider <name>          Add a provider to models.json (use with --base-url, --api-key)
-  --base-url <url>               Base URL for --add-provider
-  --verbose                      Force verbose startup (overrides quietStartup setting)
-  --offline                      Disable startup network operations (same as PI_OFFLINE=1)
-  --help, -h                     Show this help
-  --version, -v                  Show version number
-
-Extensions can register additional flags (e.g., --plan from plan-mode extension).
-
-${chalk.bold("Examples:")}
-  # Interactive mode
-  ${APP_NAME}
-
-  # Interactive mode with initial prompt
-  ${APP_NAME} "List all .ts files in src/"
-
-  # Include files in initial message
-  ${APP_NAME} @prompt.md @image.png "What color is the sky?"
-
-  # Non-interactive mode (process and exit)
-  ${APP_NAME} -p "List all .ts files in src/"
-
-  # Multiple messages (interactive)
-  ${APP_NAME} "Read package.json" "What dependencies do we have?"
-
-  # Continue previous session
-  ${APP_NAME} --continue "What did we discuss?"
-
-  # Use different model
-  ${APP_NAME} --provider openai --model gpt-4o-mini "Help me refactor this code"
-
-  # Use model with provider prefix (no --provider needed)
-  ${APP_NAME} --model openai/gpt-4o "Help me refactor this code"
-
-  # Use model with thinking level shorthand
-  ${APP_NAME} --model sonnet:high "Solve this complex problem"
-
-  # Limit model cycling to specific models
-  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o
-
-  # Limit to a specific provider with glob pattern
-  ${APP_NAME} --models "github-copilot/*"
-
-  # Cycle models with fixed thinking levels
-  ${APP_NAME} --models sonnet:high,haiku:low
-
-  # Start with a specific thinking level
-  ${APP_NAME} --thinking high "Solve this complex problem"
-
-  # Read-only mode (no file modifications possible)
-  ${APP_NAME} --tools read,grep,find,ls -p "Review the code in src/"
-
-  # Export a session file to HTML
-  ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
-  ${APP_NAME} --export session.jsonl output.html
-
-${chalk.bold("Environment Variables:")}
-  ANTHROPIC_API_KEY                - Anthropic Claude API key
-  ANTHROPIC_OAUTH_TOKEN            - Anthropic OAuth token (alternative to API key)
-  OPENAI_API_KEY                   - OpenAI GPT API key
-  AZURE_OPENAI_API_KEY             - Azure OpenAI API key
-  AZURE_OPENAI_BASE_URL            - Azure OpenAI base URL (https://{resource}.openai.azure.com/openai/v1)
-  AZURE_OPENAI_RESOURCE_NAME       - Azure OpenAI resource name (alternative to base URL)
-  AZURE_OPENAI_API_VERSION         - Azure OpenAI API version (default: v1)
-  AZURE_OPENAI_DEPLOYMENT_NAME_MAP - Azure OpenAI model=deployment map (comma-separated)
-  GEMINI_API_KEY                   - Google Gemini API key
-  GROQ_API_KEY                     - Groq API key
-  CEREBRAS_API_KEY                 - Cerebras API key
-  XAI_API_KEY                      - xAI Grok API key
-  OPENROUTER_API_KEY               - OpenRouter API key
-  AI_GATEWAY_API_KEY               - Vercel AI Gateway API key
-  ZAI_API_KEY                      - ZAI API key
-  MISTRAL_API_KEY                  - Mistral API key
-  OLLAMA_API_KEY                   - Ollama Cloud API key
-  MINIMAX_API_KEY                  - MiniMax API key
-  OPENCODE_API_KEY                 - OpenCode Zen/OpenCode Go API key
-  KIMI_API_KEY                     - Kimi For Coding API key
-  AWS_PROFILE                      - AWS profile for Amazon Bedrock
-  AWS_ACCESS_KEY_ID                - AWS access key for Amazon Bedrock
-  AWS_SECRET_ACCESS_KEY            - AWS secret key for Amazon Bedrock
-  AWS_BEARER_TOKEN_BEDROCK         - Bedrock API key (bearer token)
-  AWS_REGION                       - AWS region for Amazon Bedrock (e.g., us-east-1)
-  ${ENV_AGENT_DIR.padEnd(32)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
-  PI_PACKAGE_DIR                   - Override package directory (for Nix/Guix store paths)
-  PI_OFFLINE                       - Disable startup network operations when set to 1/true/yes
-  PI_SHARE_VIEWER_URL              - Base URL for /share command (default: https://pi.dev/session/)
-  PI_AI_ANTIGRAVITY_VERSION        - Override Antigravity User-Agent version (e.g., 1.23.0)
-
-${chalk.bold("Available Tools (default: read, bash, edit, write):")}
-  read   - Read file contents
-  bash   - Execute bash commands
-  edit   - Edit files with find/replace
-  write  - Write files (creates/overwrites)
-  grep   - Search file contents (read-only, off by default)
-  find   - Find files by glob pattern (read-only, off by default)
-  ls     - List directory contents (read-only, off by default)
-`);
-}

package/packages/gsd-agent-modes/src/cli/config-selector.ts

@@ -1,54 +0,0 @@
-/**
- * TUI config selector for `pi config` command
- */
-
-import { ProcessTerminal, TUI } from "@gsd/pi-tui";
-import { ConfigSelectorComponent } from "../modes/interactive/components/config-selector.js";
-import {
-	initTheme,
-} from "@gsd/pi-coding-agent";
-import { stopThemeWatcher } from "../pi-coding-agent-compat.js";
-import type { ResolvedPaths, SettingsManager } from "@gsd/agent-types";
-
-export interface ConfigSelectorOptions {
-	resolvedPaths: ResolvedPaths;
-	settingsManager: SettingsManager;
-	cwd: string;
-	agentDir: string;
-}
-
-/** Show TUI config selector and return when closed */
-export async function selectConfig(options: ConfigSelectorOptions): Promise<void> {
-	// Initialize theme before showing TUI
-	initTheme(options.settingsManager.getTheme(), true);
-
-	return new Promise((resolve) => {
-		const ui = new TUI(new ProcessTerminal());
-		let resolved = false;
-
-		const selector = new ConfigSelectorComponent(
-			options.resolvedPaths,
-			options.settingsManager,
-			options.cwd,
-			options.agentDir,
-			() => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					stopThemeWatcher();
-					resolve();
-				}
-			},
-			() => {
-				ui.stop();
-				stopThemeWatcher();
-				process.exit(0);
-			},
-			() => ui.requestRender(),
-		);
-
-		ui.addChild(selector);
-		ui.setFocus(selector.getResourceList());
-		ui.start();
-	});
-}

package/packages/gsd-agent-modes/src/cli/file-processor.ts

@@ -1,107 +0,0 @@
-/**
- * Process @file CLI arguments into text content and image attachments
- */
-
-import { access, readFile, stat } from "node:fs/promises";
-import type { ImageContent } from "@gsd/pi-ai";
-import chalk from "chalk";
-import { resolve } from "path";
-import {
-	detectSupportedImageMimeTypeFromFile,
-	formatDimensionNote,
-	resizeImage,
-	resolveReadPath,
-} from "../pi-coding-agent-compat.js";
-
-export interface ProcessedFiles {
-	text: string;
-	images: ImageContent[];
-}
-
-export interface ProcessFileOptions {
-	/** Whether to auto-resize images to 2000x2000 max. Default: true */
-	autoResizeImages?: boolean;
-}
-
-/** Process @file arguments into text content and image attachments */
-export async function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles> {
-	const autoResizeImages = options?.autoResizeImages ?? true;
-	let text = "";
-	const images: ImageContent[] = [];
-
-	for (const fileArg of fileArgs) {
-		// Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
-		const absolutePath = resolve(resolveReadPath(fileArg, process.cwd()));
-
-		// Check if file exists
-		try {
-			await access(absolutePath);
-		} catch {
-			console.error(chalk.red(`Error: File not found: ${absolutePath}`));
-			process.exit(1);
-		}
-
-		// Check if file is empty
-		const stats = await stat(absolutePath);
-		if (stats.size === 0) {
-			// Skip empty files
-			continue;
-		}
-
-		const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
-
-		if (mimeType) {
-			// Handle image file
-			const content = await readFile(absolutePath);
-			const base64Content = content.toString("base64");
-
-			let attachment: ImageContent;
-			let dimensionNote: string | undefined;
-
-			if (autoResizeImages) {
-				const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
-				if (resized !== null) {
-					dimensionNote = formatDimensionNote(resized);
-					attachment = {
-						type: "image",
-						mimeType: resized.mimeType,
-						data: resized.data,
-					};
-				} else {
-					attachment = {
-						type: "image",
-						mimeType,
-						data: base64Content,
-					};
-				}
-			} else {
-				attachment = {
-					type: "image",
-					mimeType,
-					data: base64Content,
-				};
-			}
-
-			images.push(attachment);
-
-			// Add text reference to image with optional dimension note
-			if (dimensionNote) {
-				text += `<file name="${absolutePath}">${dimensionNote}</file>\n`;
-			} else {
-				text += `<file name="${absolutePath}"></file>\n`;
-			}
-		} else {
-			// Handle text file
-			try {
-				const content = await readFile(absolutePath, "utf-8");
-				text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
-			} catch (error: unknown) {
-				const message = error instanceof Error ? error.message : String(error);
-				console.error(chalk.red(`Error: Could not read file ${absolutePath}: ${message}`));
-				process.exit(1);
-			}
-		}
-	}
-
-	return { text, images };
-}

package/packages/gsd-agent-modes/src/cli/list-models.ts

@@ -1,141 +0,0 @@
-/**
- * List available models with optional fuzzy search and discovery support
- */
-
-import type { Api, Model } from "@gsd/pi-ai";
-import { fuzzyFilter } from "@gsd/pi-tui";
-import type { ModelRegistry } from "@gsd/agent-types";
-
-export interface ListModelsOptions {
-	/** Include discovered models in output */
-	discover?: boolean;
-	/** Search pattern for fuzzy filtering */
-	searchPattern?: string;
-}
-
-/**
- * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
- */
-function formatTokenCount(count: number): string {
-	if (count >= 1_000_000) {
-		const millions = count / 1_000_000;
-		return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
-	}
-	if (count >= 1_000) {
-		const thousands = count / 1_000;
-		return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
-	}
-	return count.toString();
-}
-
-/**
- * Discover models from provider APIs and print results.
- * Note: discoverModels was removed from ModelRegistry in pi-coding-agent 0.67.2.
- */
-export async function discoverAndPrintModels(
-	_modelRegistry: ModelRegistry,
-	_provider?: string,
-): Promise<void> {
-	console.log("Model discovery is not available in this version.");
-}
-
-/**
- * List available models, optionally filtered by search pattern.
- * Accepts either a string (backward compat) or ListModelsOptions.
- */
-export async function listModels(
-	modelRegistry: ModelRegistry,
-	optionsOrSearch?: string | ListModelsOptions,
-): Promise<void> {
-	const options: ListModelsOptions =
-		typeof optionsOrSearch === "string"
-			? { searchPattern: optionsOrSearch }
-			: optionsOrSearch ?? {};
-
-	// discoverModels removed in 0.67.2 — skip discovery
-	const models: Model<Api>[] = modelRegistry.getAvailable();
-
-	if (models.length === 0) {
-		console.log("No models available. Set API keys in environment variables.");
-		return;
-	}
-
-	// Apply fuzzy filter if search pattern provided
-	let filteredModels: Model<Api>[] = models;
-	if (options.searchPattern) {
-		filteredModels = fuzzyFilter(models, options.searchPattern, (m) => `${m.provider} ${m.id}`);
-	}
-
-	if (filteredModels.length === 0) {
-		console.log(`No models matching "${options.searchPattern}"`);
-		return;
-	}
-
-	// Sort by model name descending (newest first), then provider, then id
-	filteredModels.sort((a, b) => {
-		const nameCmp = b.name.localeCompare(a.name);
-		if (nameCmp !== 0) return nameCmp;
-		const providerCmp = a.provider.localeCompare(b.provider);
-		if (providerCmp !== 0) return providerCmp;
-		return a.id.localeCompare(b.id);
-	});
-
-	// Calculate column widths
-	const rows = filteredModels.map((m) => ({
-		provider: m.provider,
-		model: m.id,
-		name: m.name,
-		context: formatTokenCount(m.contextWindow),
-		maxOut: formatTokenCount(m.maxTokens),
-		thinking: m.reasoning ? "yes" : "no",
-		images: m.input.includes("image") ? "yes" : "no",
-	}));
-
-	const headers = {
-		provider: "provider",
-		model: "model",
-		name: "name",
-		context: "context",
-		maxOut: "max-out",
-		thinking: "thinking",
-		images: "images",
-	};
-
-	const widths = {
-		provider: Math.max(headers.provider.length, ...rows.map((r) => r.provider.length)),
-		model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
-		name: Math.max(headers.name.length, ...rows.map((r) => r.name.length)),
-		context: Math.max(headers.context.length, ...rows.map((r) => r.context.length)),
-		maxOut: Math.max(headers.maxOut.length, ...rows.map((r) => r.maxOut.length)),
-		thinking: Math.max(headers.thinking.length, ...rows.map((r) => r.thinking.length)),
-		images: Math.max(headers.images.length, ...rows.map((r) => r.images.length)),
-	};
-
-	// Print header
-	const headerLine = [
-		headers.provider.padEnd(widths.provider),
-		headers.model.padEnd(widths.model),
-		headers.name.padEnd(widths.name),
-		headers.context.padEnd(widths.context),
-		headers.maxOut.padEnd(widths.maxOut),
-		headers.thinking.padEnd(widths.thinking),
-		headers.images.padEnd(widths.images),
-	].join("  ");
-	console.log(headerLine);
-
-	// Print rows
-	for (const row of rows) {
-		const line = [
-			row.provider.padEnd(widths.provider),
-			row.model.padEnd(widths.model),
-			row.name.padEnd(widths.name),
-			row.context.padEnd(widths.context),
-			row.maxOut.padEnd(widths.maxOut),
-			row.thinking.padEnd(widths.thinking),
-			row.images.padEnd(widths.images),
-		]
-			.join("  ")
-			.trimEnd();
-		console.log(line);
-	}
-}