@oh-my-pi/pi-coding-agent 15.12.2 → 15.12.4

package/src/cli/models-cli.ts

@@ -0,0 +1,427 @@
+/**
+ * `omp models` — list, search, and refresh available models.
+ *
+ * Subcommands:
+ * - `ls` (default): list every available model with a canonical + provider view.
+ * - `find <substring>`: list models whose provider, id, or name contains the substring.
+ * - `refresh`: force an online catalog re-fetch (ignoring the model cache TTL),
+ *   then list. This is the supported replacement for `rm -rf ~/.omp/models.db`
+ *   when a provider ships a new model that the 24h cache has not picked up yet.
+ *
+ * `ls`/`find` use the cache when fresh (`online-if-uncached`); only `refresh`
+ * forces the network (`online`).
+ */
+import type { Api, Effort, Model } from "@oh-my-pi/pi-ai";
+import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+import { formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
+import chalk from "chalk";
+import { ModelRegistry } from "../config/model-registry";
+import { Settings } from "../config/settings";
+import { discoverAndLoadExtensions, loadExtensions } from "../extensibility/extensions";
+import { discoverAuthStorage } from "../sdk";
+import { EventBus } from "../utils/event-bus";
+
+export type ModelsAction = "ls" | "find" | "refresh" | "canonical";
+
+export interface ModelsCommandArgs {
+	action: ModelsAction;
+	/** Search substring for `find`, or optional filter for `ls`. */
+	pattern?: string;
+	flags: {
+		json?: boolean;
+		/** CLI `-e <path>` extension paths to load before listing (issue #905). */
+		extensions?: string[];
+		/** Skip extension discovery; only load explicit `extensions`. */
+		noExtensions?: boolean;
+		/** Extra `config.yml` overlays to apply for this invocation. */
+		config?: string[];
+	};
+}
+
+/**
+ * Known action keywords. Any other first token (e.g. `openai-codex`) is treated
+ * as a provider/substring filter for the default `ls` view, so every provider
+ * name doubles as an `omp models <provider>` shortcut.
+ */
+const KNOWN_ACTIONS: Record<string, ModelsAction> = {
+	ls: "ls",
+	list: "ls",
+	find: "find",
+	refresh: "refresh",
+	canonical: "canonical",
+};
+
+/** Resolve the two positional args into an action + filter (provider names fall through to `ls`). */
+export function resolveModelsArgs(
+	first: string | undefined,
+	second: string | undefined,
+): { action: ModelsAction; pattern: string | undefined } {
+	const known = first === undefined ? undefined : KNOWN_ACTIONS[first];
+	if (known) {
+		return { action: known, pattern: second };
+	}
+	return { action: "ls", pattern: first };
+}
+
+interface ModelJson {
+	provider: string;
+	id: string;
+	selector: string;
+	name: string;
+	contextWindow: number | null;
+	maxTokens: number | null;
+	reasoning: boolean;
+	/** Supported thinking efforts when the model thinks, otherwise null. */
+	thinking: readonly Effort[] | null;
+	input: ("text" | "image")[];
+	cost: Model<Api>["cost"];
+}
+
+interface CanonicalJson {
+	id: string;
+	selected: string;
+	variants: number;
+	contextWindow: number | null;
+	maxTokens: number | null;
+}
+
+interface ModelsJson {
+	models: ModelJson[];
+}
+
+interface CanonicalModelsJson {
+	canonical: CanonicalJson[];
+}
+
+function writeLine(line = ""): void {
+	process.stdout.write(`${line}\n`);
+}
+
+function formatLimit(n: number | null): string {
+	return n === null ? "-" : formatNumber(n);
+}
+
+function byProviderThenId(left: Model<Api>, right: Model<Api>): number {
+	const providerCmp = left.provider.localeCompare(right.provider);
+	if (providerCmp !== 0) return providerCmp;
+	return left.id.localeCompare(right.id);
+}
+
+function toModelJson(model: Model<Api>): ModelJson {
+	return {
+		provider: model.provider,
+		id: model.id,
+		selector: `${model.provider}/${model.id}`,
+		name: model.name,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens,
+		reasoning: model.reasoning,
+		thinking: model.thinking ? getSupportedEfforts(model) : null,
+		input: model.input,
+		cost: model.cost,
+	};
+}
+
+type ColumnAlign = "left" | "right";
+
+interface BoxColumn {
+	header: string;
+	align?: ColumnAlign;
+}
+
+/** Right- or left-pad a plain (ANSI-free) cell to `width` display columns. */
+function padCell(text: string, width: number, align: ColumnAlign = "left"): string {
+	const space = width - Bun.stringWidth(text);
+	if (space <= 0) return text;
+	const fill = " ".repeat(space);
+	return align === "right" ? fill + text : text + fill;
+}
+
+/**
+ * Render `rows` as a box-drawing table. Cells must be plain text (no ANSI); the
+ * header row is bolded and the borders dimmed (both no-ops on non-TTY output).
+ */
+function boxTable(columns: BoxColumn[], rows: string[][]): string[] {
+	const widths = columns.map((column, index) =>
+		Math.max(Bun.stringWidth(column.header), ...rows.map(row => Bun.stringWidth(row[index] ?? ""))),
+	);
+	const bar = chalk.dim("│");
+	const segments = widths.map(width => "─".repeat(width + 2));
+	const renderRow = (cells: string[], bold: boolean): string => {
+		const padded = columns.map((column, index) => {
+			const cell = padCell(cells[index] ?? "", widths[index]!, column.align);
+			return bold ? chalk.bold(cell) : cell;
+		});
+		return `${bar} ${padded.join(` ${bar} `)} ${bar}`;
+	};
+	const lines = [chalk.dim(`┌${segments.join("┬")}┐`)];
+	lines.push(
+		renderRow(
+			columns.map(column => column.header),
+			true,
+		),
+	);
+	lines.push(chalk.dim(`├${segments.join("┼")}┤`));
+	for (const row of rows) {
+		lines.push(renderRow(row, false));
+	}
+	lines.push(chalk.dim(`└${segments.join("┴")}┘`));
+	return lines;
+}
+
+/** `omp models ls`/`find`: provider-grouped listing (one box table per provider). */
+function renderProviderModels(
+	modelRegistry: ModelRegistry,
+	action: ModelsAction,
+	pattern: string | undefined,
+	json: boolean,
+): void {
+	const available = modelRegistry.getAvailable();
+	const needle = pattern?.toLowerCase();
+	let filtered = available;
+
+	if (needle) {
+		let exactFound = false;
+		if (action !== "find") {
+			const exact = available.filter(m => m.provider.toLowerCase() === needle);
+			if (exact.length > 0) {
+				filtered = exact;
+				exactFound = true;
+			}
+		}
+		if (!exactFound) {
+			filtered = available.filter(
+				model =>
+					model.id.toLowerCase().includes(needle) ||
+					model.provider.toLowerCase().includes(needle) ||
+					`${model.provider}/${model.id}`.toLowerCase().includes(needle) ||
+					model.name.toLowerCase().includes(needle),
+			);
+		}
+	}
+
+	if (json) {
+		const output: ModelsJson = { models: filtered.slice().sort(byProviderThenId).map(toModelJson) };
+		writeLine(JSON.stringify(output));
+		return;
+	}
+
+	if (available.length === 0) {
+		writeLine("No models available. Set API keys in environment variables.");
+		return;
+	}
+	if (filtered.length === 0) {
+		writeLine(`No models matching "${pattern}"`);
+		return;
+	}
+
+	// One section per provider: bold heading + a box table of that provider's models.
+	const byProvider = new Map<string, Model<Api>[]>();
+	for (const model of filtered.slice().sort(byProviderThenId)) {
+		let group = byProvider.get(model.provider);
+		if (!group) {
+			group = [];
+			byProvider.set(model.provider, group);
+		}
+		group.push(model);
+	}
+
+	let firstProvider = true;
+	for (const [provider, models] of byProvider) {
+		if (!firstProvider) writeLine();
+		firstProvider = false;
+		writeLine(`${chalk.bold.cyan(provider)} ${chalk.dim(`(${models.length})`)}`);
+		const rows = models.map(model => [
+			model.id,
+			formatLimit(model.contextWindow),
+			formatLimit(model.maxTokens),
+			model.thinking ? getSupportedEfforts(model).join(",") : model.reasoning ? "yes" : "-",
+			model.input.includes("image") ? "yes" : "no",
+		]);
+		for (const line of boxTable(
+			[
+				{ header: "model" },
+				{ header: "context", align: "right" },
+				{ header: "max-out", align: "right" },
+				{ header: "thinking" },
+				{ header: "images" },
+			],
+			rows,
+		)) {
+			writeLine(line);
+		}
+	}
+}
+
+/** `omp models canonical`: the coalesced canonical view (one row per canonical id). */
+function renderCanonicalModels(modelRegistry: ModelRegistry, pattern: string | undefined, json: boolean): void {
+	const selections = modelRegistry.getCanonicalModelSelections({ availableOnly: true });
+	const needle = pattern?.toLowerCase();
+	const filtered = needle
+		? selections.filter(
+				({ record, model }) =>
+					record.id.toLowerCase().includes(needle) ||
+					`${model.provider}/${model.id}`.toLowerCase().includes(needle),
+			)
+		: selections;
+
+	if (json) {
+		const output: CanonicalModelsJson = {
+			canonical: filtered
+				.map(({ record, model }) => ({
+					id: record.id,
+					selected: `${model.provider}/${model.id}`,
+					variants: record.variants.length,
+					contextWindow: model.contextWindow,
+					maxTokens: model.maxTokens,
+				}))
+				.sort((left, right) => left.id.localeCompare(right.id)),
+		};
+		writeLine(JSON.stringify(output));
+		return;
+	}
+
+	if (selections.length === 0) {
+		writeLine("No models available. Set API keys in environment variables.");
+		return;
+	}
+	if (filtered.length === 0) {
+		writeLine(`No canonical models matching "${pattern}"`);
+		return;
+	}
+
+	const rows = filtered
+		.slice()
+		.sort((left, right) => left.record.id.localeCompare(right.record.id))
+		.map(({ record, model }) => [
+			record.id,
+			`${model.provider}/${model.id}`,
+			String(record.variants.length),
+			formatLimit(model.contextWindow),
+			formatLimit(model.maxTokens),
+		]);
+	for (const line of boxTable(
+		[
+			{ header: "canonical" },
+			{ header: "selected" },
+			{ header: "variants", align: "right" },
+			{ header: "context", align: "right" },
+			{ header: "max-out", align: "right" },
+		],
+		rows,
+	)) {
+		writeLine(line);
+	}
+}
+
+/**
+ * Options for {@link runModelsListing}: render the catalog from a caller-supplied
+ * registry. Loads extensions (CLI `-e` paths and configured `settings.extensions`)
+ * and discovers their providers before rendering so extension-contributed models
+ * appear (issue #905). The caller is responsible for refreshing built-in providers.
+ */
+export interface RunModelsListingOptions {
+	modelRegistry: ModelRegistry;
+	cwd: string;
+	action?: ModelsAction;
+	pattern?: string;
+	json?: boolean;
+	/** CLI-supplied extension paths (e.g. from `-e <path>`). */
+	additionalExtensionPaths?: string[];
+	/** Extension paths configured under `extensions:` in user settings. */
+	settingsExtensions?: string[];
+	/** Disabled extension ids from settings (`disabledExtensions`). */
+	disabledExtensionIds?: string[];
+	/** When true, skip discovery and only load `additionalExtensionPaths`. */
+	disableExtensionDiscovery?: boolean;
+}
+
+export async function runModelsListing(options: RunModelsListingOptions): Promise<void> {
+	const {
+		modelRegistry,
+		cwd,
+		action = "ls",
+		pattern,
+		json = false,
+		additionalExtensionPaths = [],
+		settingsExtensions = [],
+		disabledExtensionIds = [],
+		disableExtensionDiscovery = false,
+	} = 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 = [];
+	// Discover runtime (extension) provider catalogs now that they are registered.
+	await modelRegistry.refreshRuntimeProviders(action === "refresh" ? "online" : "online-if-uncached");
+
+	if (action === "canonical") {
+		renderCanonicalModels(modelRegistry, pattern, json);
+	} else {
+		renderProviderModels(modelRegistry, action, pattern, json);
+	}
+}
+
+/**
+ * Entry point for the standalone `omp models` command: bootstraps auth storage,
+ * settings, and the model registry, force/cache-refreshes built-in providers per
+ * the chosen action, then delegates to {@link runModelsListing}.
+ */
+export async function runModelsCommand(command: ModelsCommandArgs): Promise<void> {
+	const { action, pattern } = command;
+	const json = command.flags.json ?? false;
+
+	if (action === "find" && (!pattern || pattern.trim().length === 0)) {
+		process.stderr.write("`omp models find` requires a search substring, e.g. `omp models find minimax`\n");
+		process.exitCode = 1;
+		return;
+	}
+
+	const cwd = getProjectDir();
+	const authStorage = await discoverAuthStorage();
+	try {
+		const settings = await Settings.init({ cwd, configFiles: command.flags.config });
+		const modelRegistry = new ModelRegistry(authStorage);
+
+		if (action === "refresh" && !json && process.stderr.isTTY) {
+			process.stderr.write("Refreshing models from all providers…\n");
+		}
+		await modelRegistry.refresh(action === "refresh" ? "online" : "online-if-uncached");
+
+		const cliExtensionPaths = command.flags.noExtensions ? [] : (command.flags.extensions ?? []);
+		await runModelsListing({
+			modelRegistry,
+			cwd,
+			action,
+			pattern,
+			json,
+			additionalExtensionPaths: cliExtensionPaths,
+			settingsExtensions: settings.get("extensions") ?? [],
+			disabledExtensionIds: settings.get("disabledExtensions") ?? [],
+			disableExtensionDiscovery: Boolean(command.flags.noExtensions),
+		});
+	} finally {
+		authStorage.close();
+	}
+}

package/src/cli-commands.ts

@@ -27,6 +27,7 @@ export const commands: CommandEntry[] = [
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
 	{ name: "install", load: () => import("./commands/install").then(m => m.default) },
 	{ name: "join", load: () => import("./commands/join").then(m => m.default) },
+	{ name: "models", load: () => import("./commands/models").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
 	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },
@@ -36,6 +37,7 @@ export const commands: CommandEntry[] = [
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "usage", load: () => import("./commands/usage").then(m => m.default) },
 	{ name: "tiny-models", load: () => import("./commands/tiny-models").then(m => m.default) },
+	{ name: "token", load: () => import("./commands/token").then(m => m.default) },
 	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];

package/src/collab/host.ts

@@ -365,13 +365,8 @@ export class CollabHost {
 		const name = peer.name;
 		const content: string | (TextContent | ImageContent)[] =
 			images && images.length > 0 ? [{ type: "text", text }, ...images] : text;
-		const details: CollabPromptDetails & { __pendingDisplayTag?: string } = { from: name };
+		const details: CollabPromptDetails = { from: name };
 		if (this.#ctx.session.isStreaming) {
-			// Mid-turn guest prompts are steered: register the pending-display twin
-			// so queuedMessageCount reflects the queued steer (host pending bar +
-			// guests' "queued ×N" badge). The tag dequeues the entry when the agent
-			// consumes the message (mirrors the skill-prompt path).
-			details.__pendingDisplayTag = this.#ctx.session.enqueueCustomMessageDisplay(text, "steer");
 			this.#ctx.updatePendingMessagesDisplay();
 			this.#ctx.ui.requestRender();
 			this.#scheduleStateBroadcast();
@@ -385,7 +380,7 @@ export class CollabHost {
 					details,
 					attribution: "user",
 				},
-				{ streamingBehavior: "steer" },
+				{ streamingBehavior: "steer", queueChipText: text },
 			)
 			.catch(err => {
 				logger.warn("collab guest prompt failed", { error: String(err) });
@@ -416,21 +411,23 @@ export class CollabHost {
 
 	#buildState(): CollabSessionState {
 		const session = this.#ctx.session;
-		// Context numbers come from the status line's breakdown — not
-		// session.getContextUsage() — so guests render exactly what the host's
-		// own footer shows.
+		// Context numbers come from the status line's memoized breakdown so guests
+		// render exactly the same anchored, provider-real count the host's own
+		// status line shows.
 		const breakdown = this.#ctx.statusLine.getCachedContextBreakdown();
+		const tokens = breakdown.usedTokens;
 		return {
 			isStreaming: session.isStreaming,
+			isAborting: session.isAborting,
 			queuedMessageCount: session.queuedMessageCount,
 			sessionName: session.sessionName,
 			cwd: this.#ctx.sessionManager.getCwd(),
 			model: session.model,
 			thinkingLevel: session.thinkingLevel,
 			contextUsage: {
-				tokens: breakdown.usedTokens,
+				tokens,
 				contextWindow: breakdown.contextWindow,
-				percent: breakdown.contextWindow > 0 ? (breakdown.usedTokens / breakdown.contextWindow) * 100 : null,
+				percent: tokens !== null && breakdown.contextWindow > 0 ? (tokens / breakdown.contextWindow) * 100 : null,
 			},
 			participants: this.participants,
 		};

package/src/commands/launch.ts

@@ -124,9 +124,6 @@ export default class Index extends Command {
 		export: Flags.string({
 			description: "Export session file to HTML and exit",
 		}),
-		"list-models": Flags.string({
-			description: "List available models (with optional fuzzy search)",
-		}),
 		"no-title": Flags.boolean({
 			description: "Disable title auto-generation",
 		}),

package/src/commands/models.ts

@@ -0,0 +1,61 @@
+/**
+ * List, search, and refresh available models.
+ */
+import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { resolveModelsArgs, runModelsCommand } from "../cli/models-cli";
+
+export default class Models extends Command {
+	static description = "List, search, and refresh available models";
+
+	static args = {
+		action: Args.string({
+			description: "ls (default) | find | refresh | canonical | <provider>",
+			required: false,
+		}),
+		pattern: Args.string({
+			description: "Filter/search substring, or provider name (required for find)",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		extension: Flags.string({
+			char: "e",
+			description: "Load an extension file before listing (repeatable)",
+			multiple: true,
+		}),
+		"no-extensions": Flags.boolean({
+			description: "Disable extension discovery (explicit -e paths still work)",
+		}),
+		config: Flags.string({
+			description: "Load an extra config.yml-style overlay for this run (repeatable)",
+			multiple: true,
+		}),
+	};
+
+	static examples = [
+		`# List every available model, grouped by provider\n  ${APP_NAME} models`,
+		`# List one provider's models (any provider name works)\n  ${APP_NAME} models openai-codex`,
+		`# Find models by substring\n  ${APP_NAME} models find minimax`,
+		`# Force a fresh catalog fetch (replaces rm -rf ~/.omp/models.db)\n  ${APP_NAME} models refresh`,
+		`# Show the coalesced canonical model view\n  ${APP_NAME} models canonical`,
+		`# Machine-readable output\n  ${APP_NAME} models --json`,
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Models);
+		const { action, pattern } = resolveModelsArgs(args.action, args.pattern);
+		await runModelsCommand({
+			action,
+			pattern,
+			flags: {
+				json: flags.json,
+				extensions: flags.extension,
+				noExtensions: flags["no-extensions"],
+				config: flags.config,
+			},
+		});
+	}
+}

package/src/commands/token.ts

@@ -0,0 +1,89 @@
+/**
+ * Get the API key or OAuth token for a provider.
+ */
+
+import { PROVIDER_REGISTRY } from "@oh-my-pi/pi-ai";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import chalk from "chalk";
+import { isAuthenticated, ModelRegistry } from "../config/model-registry";
+import { discoverAuthStorage } from "../sdk";
+
+export default class Token extends Command {
+	static description = "Get the API key or OAuth token for a provider";
+
+	static args = {
+		provider: Args.string({
+			description: "Provider ID (e.g. anthropic, openai)",
+			required: true,
+		}),
+	};
+
+	static flags = {
+		raw: Flags.boolean({
+			description: "Output the raw credential value without parsing nested JSON structures",
+			default: false,
+		}),
+		"force-refresh": Flags.boolean({
+			description: "Force refresh the OAuth token even if it has not expired",
+			default: false,
+		}),
+	};
+
+	static examples = [
+		"# Get API key for Anthropic\n  omp token anthropic",
+		"# Get raw Copilot credential JSON\n  omp token github-copilot --raw",
+		"# Force refresh and get Gemini CLI token\n  omp token google-gemini-cli --force-refresh",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Token);
+		const providerName = args.provider ?? "";
+		const provider = providerName.toLowerCase();
+
+		const authStorage = await discoverAuthStorage();
+		const modelRegistry = new ModelRegistry(authStorage);
+
+		// Resolve the API key / token
+		const apiKey = await modelRegistry.getApiKeyForProvider(provider, undefined, {
+			forceRefresh: flags["force-refresh"],
+		});
+
+		if (!isAuthenticated(apiKey)) {
+			// Find all active/configured providers
+			const activeProviders = new Set<string>();
+			for (const p of PROVIDER_REGISTRY) {
+				if (authStorage.hasAuth(p.id)) {
+					activeProviders.add(p.id);
+				}
+			}
+			const all = authStorage.getAll();
+			for (const p in all) {
+				if (authStorage.hasAuth(p)) {
+					activeProviders.add(p);
+				}
+			}
+
+			const msg = `No active credential found for provider "${providerName}".`;
+			process.stderr.write(`${chalk.red(msg)}\n`);
+			if (activeProviders.size > 0) {
+				process.stderr.write(`Configured providers: ${Array.from(activeProviders).sort().join(", ")}\n`);
+			}
+			process.exitCode = 1;
+			return;
+		}
+
+		if (!flags.raw) {
+			try {
+				const parsed = JSON.parse(apiKey);
+				if (parsed && typeof parsed === "object" && typeof parsed.token === "string") {
+					process.stdout.write(`${parsed.token}\n`);
+					return;
+				}
+			} catch {
+				// Not a JSON string, print as-is
+			}
+		}
+
+		process.stdout.write(`${apiKey}\n`);
+	}
+}

package/src/commit/agentic/tools/analyze-file.ts

@@ -1,5 +1,5 @@
 import { prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import analyzeFilePrompt from "../../../commit/agentic/prompts/analyze-file.md" with { type: "text" };
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { NumstatEntry } from "../../../commit/types";

package/src/commit/agentic/tools/git-file-diff.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";

package/src/commit/agentic/tools/git-hunk.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { DiffHunk, FileHunks } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";

package/src/commit/agentic/tools/git-overview.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agentic/state";
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";