@oh-my-pi/pi-coding-agent 1.337.0

package/examples/sdk/README.md

@@ -0,0 +1,154 @@
+# SDK Examples
+
+Programmatic usage of pi-coding-agent via `createAgentSession()`.
+
+## Examples
+
+| File                       | Description                                    |
+| -------------------------- | ---------------------------------------------- |
+| `01-minimal.ts`            | Simplest usage with all defaults               |
+| `02-custom-model.ts`       | Select model and thinking level                |
+| `03-custom-prompt.ts`      | Replace or modify system prompt                |
+| `04-skills.ts`             | Discover, filter, or replace skills            |
+| `05-tools.ts`              | Built-in tools, custom tools                   |
+| `06-hooks.ts`              | Logging, blocking, result modification         |
+| `07-context-files.ts`      | AGENTS.md context files                        |
+| `08-slash-commands.ts`     | File-based slash commands                      |
+| `09-api-keys-and-oauth.ts` | API key resolution, OAuth config               |
+| `10-settings.ts`           | Override compaction, retry, terminal settings  |
+| `11-sessions.ts`           | In-memory, persistent, continue, list sessions |
+| `12-full-control.ts`       | Replace everything, no discovery               |
+
+## Running
+
+```bash
+cd packages/coding-agent
+npx tsx examples/sdk/01-minimal.ts
+```
+
+## Quick Reference
+
+```typescript
+import { getModel } from "@oh-my-pi/pi-ai";
+import {
+	AuthStorage,
+	createAgentSession,
+	discoverAuthStorage,
+	discoverModels,
+	discoverSkills,
+	discoverHooks,
+	discoverCustomTools,
+	discoverContextFiles,
+	discoverSlashCommands,
+	loadSettings,
+	buildSystemPrompt,
+	ModelRegistry,
+	SessionManager,
+	codingTools,
+	readOnlyTools,
+	readTool,
+	bashTool,
+	editTool,
+	writeTool,
+} from "@oh-my-pi/pi-coding-agent";
+
+// Auth and models setup
+const authStorage = discoverAuthStorage();
+const modelRegistry = discoverModels(authStorage);
+
+// Minimal
+const { session } = await createAgentSession({ authStorage, modelRegistry });
+
+// Custom model
+const model = getModel("anthropic", "claude-opus-4-5");
+const { session } = await createAgentSession({ model, thinkingLevel: "high", authStorage, modelRegistry });
+
+// Modify prompt
+const { session } = await createAgentSession({
+	systemPrompt: (defaultPrompt) => defaultPrompt + "\n\nBe concise.",
+	authStorage,
+	modelRegistry,
+});
+
+// Read-only
+const { session } = await createAgentSession({ tools: readOnlyTools, authStorage, modelRegistry });
+
+// In-memory
+const { session } = await createAgentSession({
+	sessionManager: SessionManager.inMemory(),
+	authStorage,
+	modelRegistry,
+});
+
+// Full control
+const customAuth = new AuthStorage("/my/app/auth.json");
+customAuth.setRuntimeApiKey("anthropic", process.env.MY_KEY!);
+const customRegistry = new ModelRegistry(customAuth);
+
+const { session } = await createAgentSession({
+	model,
+	authStorage: customAuth,
+	modelRegistry: customRegistry,
+	systemPrompt: "You are helpful.",
+	tools: [readTool, bashTool],
+	customTools: [{ tool: myTool }],
+	hooks: [{ factory: myHook }],
+	skills: [],
+	contextFiles: [],
+	slashCommands: [],
+	sessionManager: SessionManager.inMemory(),
+});
+
+// Run prompts
+session.subscribe((event) => {
+	if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+		process.stdout.write(event.assistantMessageEvent.delta);
+	}
+});
+await session.prompt("Hello");
+```
+
+## Options
+
+| Option                      | Default                       | Description                       |
+| --------------------------- | ----------------------------- | --------------------------------- |
+| `authStorage`               | `discoverAuthStorage()`       | Credential storage                |
+| `modelRegistry`             | `discoverModels(authStorage)` | Model registry                    |
+| `cwd`                       | `process.cwd()`               | Working directory                 |
+| `agentDir`                  | `~/.pi/agent`                 | Config directory                  |
+| `model`                     | From settings/first available | Model to use                      |
+| `thinkingLevel`             | From settings/"off"           | off, low, medium, high            |
+| `systemPrompt`              | Discovered                    | String or `(default) => modified` |
+| `tools`                     | `codingTools`                 | Built-in tools                    |
+| `customTools`               | Discovered                    | Replaces discovery                |
+| `additionalCustomToolPaths` | `[]`                          | Merge with discovery              |
+| `hooks`                     | Discovered                    | Replaces discovery                |
+| `additionalHookPaths`       | `[]`                          | Merge with discovery              |
+| `skills`                    | Discovered                    | Skills for prompt                 |
+| `contextFiles`              | Discovered                    | AGENTS.md files                   |
+| `slashCommands`             | Discovered                    | File commands                     |
+| `sessionManager`            | `SessionManager.create(cwd)`  | Persistence                       |
+| `settingsManager`           | From agentDir                 | Settings overrides                |
+
+## Events
+
+```typescript
+session.subscribe((event) => {
+	switch (event.type) {
+		case "message_update":
+			if (event.assistantMessageEvent.type === "text_delta") {
+				process.stdout.write(event.assistantMessageEvent.delta);
+			}
+			break;
+		case "tool_execution_start":
+			console.log(`Tool: ${event.toolName}`);
+			break;
+		case "tool_execution_end":
+			console.log(`Result: ${event.result}`);
+			break;
+		case "agent_end":
+			console.log("Done");
+			break;
+	}
+});
+```

package/package.json

@@ -0,0 +1,81 @@
+{
+	"name": "@oh-my-pi/pi-coding-agent",
+	"version": "1.337.0",
+	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
+	"type": "module",
+	"piConfig": {
+		"name": "pi",
+		"configDir": ".pi"
+	},
+	"bin": {
+		"pi": "src/cli.ts"
+	},
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		},
+		"./hooks": {
+			"types": "./src/core/hooks/index.ts",
+			"import": "./src/core/hooks/index.ts"
+		}
+	},
+	"files": [
+		"src",
+		"docs",
+		"examples",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"check": "tsgo --noEmit",
+		"clean": "rm -rf dist",
+		"build": "tsgo -p tsconfig.build.json && chmod +x dist/cli.js && npm run copy-assets",
+		"build:binary": "npm run build && bun build --compile ./dist/cli.js --outfile dist/pi && npm run copy-binary-assets",
+		"copy-assets": "mkdir -p dist/modes/interactive/theme && cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && mkdir -p dist/core/export-html/vendor && cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/",
+		"copy-binary-assets": "cp package.json dist/ && cp README.md dist/ && cp CHANGELOG.md dist/ && mkdir -p dist/theme && cp src/modes/interactive/theme/*.json dist/theme/ && mkdir -p dist/export-html/vendor && cp src/core/export-html/template.html dist/export-html/ && cp src/core/export-html/vendor/*.js dist/export-html/vendor/ && cp -r docs dist/ && cp -r examples dist/",
+		"test": "vitest --run",
+		"prepublishOnly": "npm run clean && npm run build"
+	},
+	"dependencies": {
+		"@oh-my-pi/pi-agent-core": "workspace:*",
+		"@oh-my-pi/pi-ai": "workspace:*",
+		"@oh-my-pi/pi-tui": "workspace:*",
+		"@sinclair/typebox": "^0.34.46",
+		"ajv": "^8.17.1",
+		"chalk": "^5.5.0",
+		"node-html-parser": "^6.1.13",
+		"cli-highlight": "^2.1.11",
+		"diff": "^8.0.2",
+		"file-type": "^21.1.1",
+		"glob": "^11.0.3",
+		"highlight.js": "^11.11.1",
+		"marked": "^15.0.12",
+		"minimatch": "^10.1.1",
+		"strip-ansi": "^7.1.2"
+	},
+	"devDependencies": {
+		"@types/diff": "^7.0.2",
+		"@types/node": "^24.3.0",
+		"vitest": "^3.2.4"
+	},
+	"keywords": [
+		"coding-agent",
+		"ai",
+		"llm",
+		"cli",
+		"tui",
+		"agent"
+	],
+	"author": "Mario Zechner",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/coding-agent"
+	},
+	"engines": {
+		"bun": ">=1.0.0"
+	}
+}

package/src/cli/args.ts

@@ -0,0 +1,246 @@
+/**
+ * CLI argument parsing and help display
+ */
+
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import chalk from "chalk";
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config.js";
+import { allTools, type ToolName } from "../core/tools/index.js";
+
+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[];
+	hooks?: string[];
+	customTools?: string[];
+	print?: boolean;
+	export?: string;
+	noSkills?: boolean;
+	skills?: string[];
+	listModels?: string | true;
+	messages: string[];
+	fileArgs: string[];
+}
+
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+export function isValidThinkingLevel(level: string): level is ThinkingLevel {
+	return VALID_THINKING_LEVELS.includes(level as ThinkingLevel);
+}
+
+export function parseArgs(args: string[]): Args {
+	const result: Args = {
+		messages: [],
+		fileArgs: [],
+	};
+
+	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 === "--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 === "--hook" && i + 1 < args.length) {
+			result.hooks = result.hooks ?? [];
+			result.hooks.push(args[++i]);
+		} else if (arg === "--tool" && i + 1 < args.length) {
+			result.customTools = result.customTools ?? [];
+			result.customTools.push(args[++i]);
+		} else if (arg === "--no-skills") {
+			result.noSkills = true;
+		} else if (arg === "--skills" && i + 1 < args.length) {
+			// Comma-separated glob patterns for skill filtering
+			result.skills = args[++i].split(",").map((s) => s.trim());
+		} 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.startsWith("@")) {
+			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+		} 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("Options:")}
+  --provider <name>              Provider name (default: google)
+  --model <id>                   Model ID (default: gemini-2.5-flash)
+  --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
+  --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
+                                 Available: read, bash, edit, write, grep, find, ls
+  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --hook <path>                  Load a hook file (can be used multiple times)
+  --tool <path>                  Load a custom tool file (can be used multiple times)
+  --no-skills                    Disable skills discovery and loading
+  --skills <patterns>            Comma-separated glob patterns to filter skills (e.g., git-*,docker)
+  --export <file>                Export session file to HTML and exit
+  --list-models [search]         List available models (with optional fuzzy search)
+  --help, -h                     Show this help
+  --version, -v                  Show version number
+
+${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"
+
+  # 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:")}
+  ${chalk.dim("# Model providers")}
+  ANTHROPIC_API_KEY       - Anthropic Claude API key
+  ANTHROPIC_OAUTH_TOKEN   - Anthropic OAuth token (alternative to API key)
+  OPENAI_API_KEY          - OpenAI GPT API key
+  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
+  MISTRAL_API_KEY         - Mistral API key
+  ZAI_API_KEY             - ZAI API key
+  GITHUB_TOKEN            - GitHub Copilot models (or GH_TOKEN, COPILOT_GITHUB_TOKEN)
+
+  ${chalk.dim("# Web search providers")}
+  EXA_API_KEY             - Exa search API key
+  PERPLEXITY_API_KEY      - Perplexity search API key
+
+  ${chalk.dim("# Configuration")}
+  ${ENV_AGENT_DIR.padEnd(23)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
+
+${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/src/cli/file-processor.ts

@@ -0,0 +1,72 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+
+import { access, readFile, stat } from "node:fs/promises";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import chalk from "chalk";
+import { resolve } from "path";
+import { resolveReadPath } from "../core/tools/path-utils.js";
+import { detectSupportedImageMimeTypeFromFile } from "../utils/mime.js";
+
+export interface ProcessedFiles {
+	text: string;
+	images: ImageContent[];
+}
+
+/** Process @file arguments into text content and image attachments */
+export async function processFileArguments(fileArgs: string[]): Promise<ProcessedFiles> {
+	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");
+
+			const attachment: ImageContent = {
+				type: "image",
+				mimeType,
+				data: base64Content,
+			};
+
+			images.push(attachment);
+
+			// Add text reference to image
+			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/src/cli/list-models.ts

@@ -0,0 +1,104 @@
+/**
+ * List available models with optional fuzzy search
+ */
+
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../core/model-registry.js";
+import { fuzzyFilter } from "../utils/fuzzy.js";
+
+/**
+ * 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();
+}
+
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export async function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void> {
+	const models = await 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 (searchPattern) {
+		filteredModels = fuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`);
+	}
+
+	if (filteredModels.length === 0) {
+		console.log(`No models matching "${searchPattern}"`);
+		return;
+	}
+
+	// Sort by provider, then by model id
+	filteredModels.sort((a, b) => {
+		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,
+		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",
+		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)),
+		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.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.context.padEnd(widths.context),
+			row.maxOut.padEnd(widths.maxOut),
+			row.thinking.padEnd(widths.thinking),
+			row.images.padEnd(widths.images),
+		].join("  ");
+		console.log(line);
+	}
+}