@bytetrue/pi-vendor 0.1.0

package/src/custom-select.ts

@@ -0,0 +1,231 @@
+import { Input, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+export type CustomInputOptions = {
+	title: string;
+	placeholder?: string;
+	defaultValue?: string;
+};
+
+export type CustomInputResult = string | null;
+
+const MIN_WIDTH = 42;
+
+type Frame = {
+	top: () => string;
+	row: (content?: string) => string;
+	empty: () => string;
+	divider: () => string;
+	bottom: () => string;
+};
+
+function padAnsi(text: string, width: number): string {
+	const truncated = truncateToWidth(text, width, "…");
+	return truncated + " ".repeat(Math.max(0, width - visibleWidth(truncated)));
+}
+
+function createFrame(width: number): Frame {
+	const innerWidth = Math.max(MIN_WIDTH, width - 2);
+	const rowWidth = innerWidth - 2;
+
+	return {
+		top: () => `┌${"─".repeat(innerWidth)}┐`,
+		row: (content = "") => `│ ${padAnsi(content, rowWidth)} │`,
+		empty: () => `│${" ".repeat(innerWidth)}│`,
+		divider: () => `├${"─".repeat(innerWidth)}┤`,
+		bottom: () => `└${"─".repeat(innerWidth)}┘`,
+	};
+}
+
+/**
+ * Custom input component with border.
+ */
+export function createCustomInput(
+	options: CustomInputOptions,
+): (tui: any, theme: any, keybindings: any, done: (result: CustomInputResult) => void) => any {
+	return (tui, theme, keybindings, done) => {
+		const input = new Input();
+		if (options.defaultValue) {
+			input.setValue(options.defaultValue);
+		}
+
+		input.onSubmit = (value) => {
+			done(value.trim());
+		};
+
+		input.onEscape = () => {
+			done(null);
+		};
+
+		const component = {
+			render(width: number): string[] {
+				const frame = createFrame(width);
+				const inputLines = input.render(Math.max(8, width - 8));
+				const inputText = inputLines[0] || "";
+				const displayText = inputText.trim() ? inputText : "";
+
+				return [
+					frame.top(),
+					frame.row(theme.fg("accent", theme.bold(options.title))),
+					frame.row(theme.fg("muted", options.placeholder || "Type a value, then press Enter.")),
+					frame.divider(),
+					frame.empty(),
+					frame.row(`› ${displayText}`),
+					frame.empty(),
+					frame.divider(),
+					frame.row(theme.fg("muted", "Enter submits, Esc goes back.")),
+					frame.bottom(),
+				];
+			},
+
+			handleInput(keyData: string): void {
+				input.handleInput(keyData);
+			},
+
+			focus(): void {
+				input.focused = true;
+			},
+
+			blur(): void {
+				input.focused = false;
+			},
+		};
+
+		return component;
+	};
+}
+
+export type CustomSelectOptions = {
+	title: string;
+	items: string[];
+	defaultValue?: string;
+	maxVisible?: number;
+	escapeLabel?: string;
+};
+
+export type CustomSelectResult<T extends string> = {
+	type: "select";
+	value: T;
+};
+
+/**
+ * Custom select component with wrap-around navigation and pagination.
+ * - Up/down arrows: navigate within current page (with wrap-around)
+ * - Left/right arrows: change page
+ * - Enter: select current item
+ * - Escape: go back
+ */
+export function createCustomSelect<T extends string>(
+	options: CustomSelectOptions,
+): (tui: any, theme: any, keybindings: any, done: (result: CustomSelectResult<T> | null) => void) => any {
+	return (tui, theme, keybindings, done) => {
+		const items = options.items;
+		const totalItems = items.length;
+		const pageSize = options.maxVisible ?? 10;
+		const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+
+		let currentPage = 0;
+		let selectedIndex = 0;
+
+		// Set default value if provided
+		if (options.defaultValue) {
+			const defaultIndex = items.indexOf(options.defaultValue);
+			if (defaultIndex >= 0) {
+				currentPage = Math.floor(defaultIndex / pageSize);
+				selectedIndex = defaultIndex % pageSize;
+			}
+		}
+
+		const component = {
+			render(width: number): string[] {
+				const frame = createFrame(width);
+				const startIndex = currentPage * pageSize;
+				const endIndex = Math.min(startIndex + pageSize, totalItems);
+				const pageItems = items.slice(startIndex, endIndex);
+				const pageInfo = totalPages > 1
+					? `${totalItems} options · Page ${currentPage + 1}/${totalPages}`
+					: `${totalItems} option${totalItems === 1 ? "" : "s"}`;
+				const escapeText = options.escapeLabel ?? "goes back";
+				const helpText = totalPages > 1
+					? `↑↓ navigate, ←→ page, Enter selects, Esc ${escapeText}.`
+					: `↑↓ navigate, Enter selects, Esc ${escapeText}.`;
+				const lines = [
+					frame.top(),
+					frame.row(theme.fg("accent", theme.bold(options.title))),
+					frame.row(theme.fg("muted", pageInfo)),
+					frame.divider(),
+				];
+
+				for (let i = 0; i < pageItems.length; i++) {
+					const isSelected = i === selectedIndex;
+					const itemText = pageItems[i] ?? "";
+					const rendered = isSelected
+						? theme.fg("accent", "› ") + theme.fg("accent", theme.bold(itemText))
+						: `  ${theme.fg("text", itemText)}`;
+					lines.push(frame.row(rendered));
+				}
+
+				for (let i = pageItems.length; i < pageSize; i++) {
+					lines.push(frame.empty());
+				}
+
+				lines.push(frame.divider());
+				lines.push(frame.row(theme.fg("muted", helpText)));
+				lines.push(frame.bottom());
+				return lines;
+			},
+
+			handleInput(keyData: string): void {
+				const kb = keybindings;
+				const pageStart = currentPage * pageSize;
+				const pageEnd = Math.min(pageStart + pageSize, totalItems);
+				const pageLength = pageEnd - pageStart;
+
+				// Up arrow - wrap within page
+				if (kb.matches(keyData, "tui.select.up") || keyData === "k") {
+					selectedIndex = selectedIndex === 0 ? pageLength - 1 : selectedIndex - 1;
+				}
+				// Down arrow - wrap within page
+				else if (kb.matches(keyData, "tui.select.down") || keyData === "j") {
+					selectedIndex = selectedIndex === pageLength - 1 ? 0 : selectedIndex + 1;
+				}
+				// Left arrow - previous page
+				else if (kb.matches(keyData, "tui.editor.cursorLeft") || keyData === "h") {
+					if (currentPage > 0) {
+						currentPage--;
+						selectedIndex = 0;
+					} else {
+						// Wrap to last page
+						currentPage = totalPages - 1;
+						const lastPageLength = totalItems - (currentPage * pageSize);
+						selectedIndex = lastPageLength - 1;
+					}
+				}
+				// Right arrow - next page
+				else if (kb.matches(keyData, "tui.editor.cursorRight") || keyData === "l") {
+					if (currentPage < totalPages - 1) {
+						currentPage++;
+						selectedIndex = 0;
+					} else {
+						// Wrap to first page
+						currentPage = 0;
+						selectedIndex = 0;
+					}
+				}
+				// Enter - select
+				else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n") {
+					const globalIndex = pageStart + selectedIndex;
+					const selected = items[globalIndex];
+					if (selected) {
+						done({ type: "select", value: selected as T });
+					}
+				}
+				// Escape - go back
+				else if (kb.matches(keyData, "tui.select.cancel")) {
+					done(null);
+				}
+			},
+		};
+
+		return component;
+	};
+}

package/src/enrich.ts

@@ -0,0 +1,64 @@
+import type { ProviderModelConfig } from "./models-json.js";
+import {
+	collectOfficialCandidates,
+	type OfficialModelCandidate,
+	type OfficialModelsCatalog,
+	loadOfficialCatalog,
+	stripOfficialRoutingFields,
+} from "./official-catalog.js";
+import {
+	createDefaultModelConfig,
+	createTemplateModelConfig,
+	matchTemplate,
+	type ModelTemplate,
+} from "./templates.js";
+
+export type ModelEnrichmentReady = {
+	kind: "ready";
+	source: "official" | "template" | "default";
+	model: ProviderModelConfig;
+	warning?: string;
+};
+
+export type ModelEnrichmentAmbiguous = {
+	kind: "official-ambiguous";
+	modelId: string;
+	candidates: OfficialModelCandidate[];
+};
+
+export type ModelEnrichmentResult = ModelEnrichmentReady | ModelEnrichmentAmbiguous;
+
+export type EnrichOptions = {
+	catalog?: OfficialModelsCatalog | null;
+	templates?: readonly ModelTemplate[];
+};
+
+export async function enrichModelId(modelId: string, options: EnrichOptions = {}): Promise<ModelEnrichmentResult> {
+	const catalog = options.catalog ?? (await loadOfficialCatalog());
+	const officialCandidates = collectOfficialCandidates(catalog, modelId);
+
+	// Always require user confirmation when we have official candidates (even just 1)
+	if (officialCandidates.length >= 1) {
+		return {
+			kind: "official-ambiguous",
+			modelId,
+			candidates: officialCandidates,
+		};
+	}
+
+	const template = matchTemplate(modelId, options.templates);
+	if (template) {
+		return {
+			kind: "ready",
+			source: "template",
+			model: createTemplateModelConfig(modelId, template),
+		};
+	}
+
+	return {
+		kind: "ready",
+		source: "default",
+		model: createDefaultModelConfig(modelId),
+		warning: `No official catalog or template match for ${modelId}; using safe defaults.`,
+	};
+}

package/src/fuzzy.ts

@@ -0,0 +1,139 @@
+/**
+ * Fuzzy matching utilities for model ID search.
+ * Matches if all query characters appear in order (not necessarily consecutive).
+ * Lower score = better match.
+ */
+
+export type FuzzyMatch = {
+	matches: boolean;
+	score: number;
+};
+
+export function fuzzyMatch(query: string, text: string): FuzzyMatch {
+	const queryLower = query.toLowerCase();
+	const textLower = text.toLowerCase();
+
+	const matchQuery = (normalizedQuery: string): FuzzyMatch => {
+		if (normalizedQuery.length === 0) {
+			return { matches: true, score: 0 };
+		}
+		if (normalizedQuery.length > textLower.length) {
+			return { matches: false, score: 0 };
+		}
+
+		let queryIndex = 0;
+		let score = 0;
+		let lastMatchIndex = -1;
+		let consecutiveMatches = 0;
+
+		for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) {
+			if (textLower[i] === normalizedQuery[queryIndex]) {
+				const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]!);
+
+				// Reward consecutive matches
+				if (lastMatchIndex === i - 1) {
+					consecutiveMatches++;
+					score -= consecutiveMatches * 5;
+				} else {
+					consecutiveMatches = 0;
+					// Penalize gaps
+					if (lastMatchIndex >= 0) {
+						score += (i - lastMatchIndex - 1) * 2;
+					}
+				}
+
+				// Reward word boundary matches
+				if (isWordBoundary) {
+					score -= 10;
+				}
+
+				// Slight penalty for later matches
+				score += i * 0.1;
+				lastMatchIndex = i;
+				queryIndex++;
+			}
+		}
+
+		if (queryIndex < normalizedQuery.length) {
+			return { matches: false, score: 0 };
+		}
+
+		// Bonus for exact match
+		if (normalizedQuery === textLower) {
+			score -= 100;
+		}
+
+		return { matches: true, score };
+	};
+
+	const primaryMatch = matchQuery(queryLower);
+	if (primaryMatch.matches) {
+		return primaryMatch;
+	}
+
+	// Handle swapped alphanumeric patterns (e.g., "gpt4" vs "4gpt")
+	const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+	const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+
+	const swappedQuery = alphaNumericMatch
+		? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}`
+		: numericAlphaMatch
+			? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}`
+			: "";
+
+	if (!swappedQuery) {
+		return primaryMatch;
+	}
+
+	const swappedMatch = matchQuery(swappedQuery);
+	if (!swappedMatch.matches) {
+		return primaryMatch;
+	}
+
+	return { matches: true, score: swappedMatch.score + 5 };
+}
+
+export type FuzzyResult<T> = {
+	item: T;
+	score: number;
+};
+
+export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[] {
+	if (!query.trim()) {
+		return items;
+	}
+
+	const tokens = query
+		.trim()
+		.split(/[\s/]+/)
+		.filter((t) => t.length > 0);
+
+	if (tokens.length === 0) {
+		return items;
+	}
+
+	const results: FuzzyResult<T>[] = [];
+
+	for (const item of items) {
+		const text = getText(item);
+		let totalScore = 0;
+		let allMatch = true;
+
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, text);
+			if (match.matches) {
+				totalScore += match.score;
+			} else {
+				allMatch = false;
+				break;
+			}
+		}
+
+		if (allMatch) {
+			results.push({ item, score: totalScore });
+		}
+	}
+
+	results.sort((a, b) => a.score - b.score);
+	return results.map((r) => r.item);
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { registerVendorCommand } from "./command.js";
+
+export { registerVendorCommand } from "./command.js";
+export type { ModelEnrichmentAmbiguous, ModelEnrichmentReady, ModelEnrichmentResult } from "./enrich.js";
+export { enrichModelId } from "./enrich.js";
+export type { ModelsJson, ProviderConfig, ProviderDraft, ProviderModelConfig } from "./models-json.js";
+export {
+	createMinimalProviderConfig,
+	createNewProviderDraft,
+	createProviderDraft,
+	getModelsJsonPath,
+	readModelsJson,
+	upsertProvider,
+	writeModelsJson,
+} from "./models-json.js";
+export type { OfficialModelCandidate, OfficialModelsCatalog, OfficialModelConfig } from "./official-catalog.js";
+export {
+	collectOfficialCandidates,
+	findOfficialCatalogPath,
+	formatOfficialCandidate,
+	loadOfficialCatalog,
+	stripOfficialRoutingFields,
+} from "./official-catalog.js";
+export type { FetchLike, OpenAIModelsProviderDraft } from "./openai-models.js";
+export {
+	buildOpenAIModelsUrl,
+	fetchOpenAIModelIds,
+	parseOpenAIModelsResponse,
+	resolveApiKeyValue,
+} from "./openai-models.js";
+export type { ModelTemplate } from "./templates.js";
+export {
+	MODEL_TEMPLATES,
+	createDefaultModelConfig,
+	createTemplateModelConfig,
+	listModelTemplates,
+	matchTemplate,
+	templateLabel,
+} from "./templates.js";
+
+export default async function registerVendor(pi: ExtensionAPI): Promise<void> {
+	registerVendorCommand(pi);
+}

package/src/models-json.ts

@@ -0,0 +1,123 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export type ProviderModelConfig = {
+	id: string;
+	name?: string;
+	api?: string;
+	baseUrl?: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: Record<string, string | null>;
+	input?: Array<"text" | "image">;
+	cost?: Record<string, number>;
+	contextWindow?: number;
+	maxTokens?: number;
+	headers?: Record<string, string>;
+	compat?: Record<string, unknown>;
+	[key: string]: unknown;
+};
+
+export type ProviderConfig = {
+	name?: string;
+	baseUrl?: string;
+	api?: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	authHeader?: boolean;
+	compat?: Record<string, unknown>;
+	models?: ProviderModelConfig[];
+	[key: string]: unknown;
+};
+
+export type ModelsJson = {
+	providers?: Record<string, ProviderConfig>;
+	[key: string]: unknown;
+};
+
+export type ProviderDraft = {
+	key: string;
+	originalKey: string;
+	config: ProviderConfig;
+};
+
+export type ProviderUpsertOptions = {
+	previousKey?: string;
+};
+
+function cloneJson<T>(value: T): T {
+	return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export function getModelsJsonPath(): string {
+	const baseDir = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+	return join(baseDir, "models.json");
+}
+
+export function createMinimalProviderConfig(): ProviderConfig {
+	return {
+		baseUrl: "",
+		api: "openai-completions",
+		apiKey: "$ENV_VAR",
+		models: [],
+	};
+}
+
+function normalizeProviderConfig(config: ProviderConfig): ProviderConfig {
+	const next = cloneJson(config);
+	next.models = Array.isArray(next.models) ? next.models.map((model) => cloneJson(model)) : [];
+	return next;
+}
+
+export function createProviderDraft(key: string, config: ProviderConfig): ProviderDraft {
+	return {
+		key,
+		originalKey: key,
+		config: normalizeProviderConfig(config),
+	};
+}
+
+export function createNewProviderDraft(key: string): ProviderDraft {
+	return createProviderDraft(key, createMinimalProviderConfig());
+}
+
+export function readModelsJson(path = getModelsJsonPath()): ModelsJson {
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && (error as { code?: string }).code === "ENOENT") {
+			return { providers: {} };
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to read models.json at ${path}: ${message}`);
+	}
+
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+		throw new Error(`Invalid models.json at ${path}: expected a JSON object`);
+	}
+
+	const providers = (raw as ModelsJson).providers;
+	if (providers !== undefined && (providers === null || typeof providers !== "object" || Array.isArray(providers))) {
+		throw new Error(`Invalid models.json at ${path}: providers must be an object`);
+	}
+
+	return raw as ModelsJson;
+}
+
+export function writeModelsJson(models: ModelsJson, path = getModelsJsonPath()): void {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(models, null, 2)}\n`, "utf8");
+}
+
+export function upsertProvider(modelsJson: ModelsJson, draft: ProviderDraft, options: ProviderUpsertOptions = {}): ModelsJson {
+	const providers = { ...(modelsJson.providers ?? {}) };
+	if (options.previousKey && options.previousKey !== draft.key) {
+		delete providers[options.previousKey];
+	}
+	providers[draft.key] = normalizeProviderConfig(draft.config);
+	return {
+		...modelsJson,
+		providers,
+	};
+}