pi-free 1.0.8 → 2.0.0

package/index.ts

@@ -0,0 +1,186 @@
+/**
+ * Pi-Free Providers Index
+ *
+ * Provides free model filtering for ALL providers (built-in + extension)
+ * plus unique free/paid providers not covered by pi's built-in providers.
+ *
+ * Unique providers:
+ * - Kilo: OAuth-based free models
+ * - Cline: Cline bot integration
+ * - NVIDIA: NVIDIA NIM hosting (free tier available)
+ * - Qwen: OAuth-based Qwen access
+ * - Modal: Modal Labs hosting
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { createLogger } from "./lib/logger.ts";
+import {
+	applyGlobalFilter,
+	getGlobalFreeOnly,
+	getProviderRegistry,
+	isFreeModel,
+	registerWithGlobalToggle,
+} from "./lib/registry.ts";
+// Import unique provider extensions (only providers NOT built into pi)
+import cline from "./providers/cline/cline.ts";
+import cloudflare from "./providers/cloudflare/cloudflare.ts";
+import kilo from "./providers/kilo/kilo.ts";
+import modal from "./providers/modal/modal.ts";
+import nvidia from "./providers/nvidia/nvidia.ts";
+import ollama from "./providers/ollama/ollama.ts";
+import qwen from "./providers/qwen/qwen.ts";
+
+const _logger = createLogger("pi-free");
+
+// =============================================================================
+// Global Commands
+// =============================================================================
+
+function setupGlobalCommands(pi: ExtensionAPI) {
+	// /free - Global toggle for ALL providers
+	pi.registerCommand("free", {
+		description: "Toggle free-only mode for ALL providers (on/off/status)",
+		handler: async (args, ctx) => {
+			const arg = args.trim().toLowerCase();
+			const registry = getProviderRegistry();
+
+			if (arg === "on" || arg === "true" || arg === "yes") {
+				applyGlobalFilter(pi, true);
+				ctx.ui.notify(
+					"✓ Free-only mode enabled - paid models hidden for all providers",
+					"info",
+				);
+			} else if (arg === "off" || arg === "false" || arg === "no") {
+				applyGlobalFilter(pi, false);
+				ctx.ui.notify(
+					"✓ Paid models enabled - all models visible for all providers",
+					"info",
+				);
+			} else if (arg === "status" || arg === "" || !arg) {
+				const available = await ctx.modelRegistry.getAvailable();
+				const freeCount = available.filter(isFreeModel).length;
+				const status = getGlobalFreeOnly() ? "enabled" : "disabled";
+
+				// Count by provider
+				const lines = [
+					`Free-only mode: ${status}`,
+					`${freeCount}/${available.length} models free`,
+					"",
+				];
+				for (const [id, entry] of registry) {
+					const free = entry.stored.free.length;
+					const all = entry.stored.all.length || free;
+					lines.push(`${id}: ${free}/${all} free`);
+				}
+
+				ctx.ui.notify(lines.join("\n"), "info");
+			} else {
+				ctx.ui.notify("Usage: /free [on|off|status]", "warning");
+			}
+		},
+	});
+
+	// /free-providers - Show free model counts by provider
+	pi.registerCommand("free-providers", {
+		description: "Show free/paid model counts for all pi-free providers",
+		handler: async (_args, ctx) => {
+			const lines = ["📊 Pi-Free Providers:", ""];
+			const registry = getProviderRegistry();
+
+			// Providers known to not expose pricing via API (all models show as "free")
+			// OpenRouter and OpenCode expose actual pricing
+			const noPricingApi = new Set([
+				"mistral",
+				"xai",
+				"huggingface",
+				"groq",
+				"cerebras",
+			]);
+			// Freemium providers - all models share a free tier quota
+			const freemiumProviders = new Set(["nvidia"]);
+
+			for (const [id, entry] of registry) {
+				const free = entry.stored.free.length;
+				const all = entry.stored.all.length || free;
+				const indicator = entry.hasKey ? "🔑" : "🆓";
+				const paid = all - free;
+
+				if (freemiumProviders.has(id)) {
+					// Freemium: all models share a free tier (e.g., 1,000 reqs/month)
+					lines.push(`${indicator} ${id}: ${all} models (freemium)`);
+				} else if (noPricingApi.has(id)) {
+					// Provider doesn't expose pricing - can't determine free vs paid
+					lines.push(
+						`${indicator} ${id}: ${all} models (pricing not exposed by API)`,
+					);
+				} else if (paid === 0 && free > 0) {
+					// All models are actually free
+					lines.push(`${indicator} ${id}: ${free} free models`);
+				} else {
+					// Mix of free and paid
+					lines.push(
+						`${indicator} ${id}: ${free} free / ${paid} paid (${all} total)`,
+					);
+				}
+			}
+
+			if (registry.size === 0) {
+				lines.push("(No providers registered yet)");
+			}
+
+			ctx.ui.notify(lines.join("\n"), "info");
+		},
+	});
+}
+
+// =============================================================================
+// Main Entry Point
+// =============================================================================
+
+export default async function (pi: ExtensionAPI) {
+	const globalFreeOnly = getGlobalFreeOnly();
+	_logger.info(`[pi-free] Initializing (global free-only: ${globalFreeOnly})`);
+
+	// Setup global commands first
+	setupGlobalCommands(pi);
+
+	// Load all unique providers
+	// Each provider will register itself with the global toggle system
+	await Promise.allSettled([
+		cloudflare(pi),
+		modal(pi),
+		nvidia(pi),
+		kilo(pi),
+		ollama(pi),
+		// Qwen is deprecated
+		qwen(pi).catch((err) => {
+			_logger.warn("[pi-free] Qwen provider failed to load (deprecated)", err);
+		}),
+		cline(pi),
+	]);
+
+	// Setup dynamic built-in providers (Mistral, Groq, Cerebras, xAI, Hugging Face, OpenRouter)
+	// These only activate if the user has configured API keys (OpenRouter works without key too)
+	const { setupDynamicBuiltInProviders } = await import(
+		"./providers/dynamic-built-in/index.ts"
+	);
+	await setupDynamicBuiltInProviders(pi);
+
+	// Apply initial global filter if free-only mode is enabled
+	if (globalFreeOnly) {
+		_logger.info("[pi-free] Applying initial free-only filter");
+		await applyGlobalFilter(pi, true);
+	}
+
+	const registry = getProviderRegistry();
+	_logger.info(`[pi-free] Loaded with ${registry.size} providers`);
+}
+
+// Re-export registry helpers so consumers don't need deep imports
+export {
+	applyGlobalFilter,
+	getGlobalFreeOnly,
+	getProviderRegistry,
+	isFreeModel,
+	registerWithGlobalToggle,
+};

package/lib/json-persistence.ts

@@ -5,6 +5,9 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { createLogger } from "./logger.ts";
+
+const _logger = createLogger("json-persistence");
 
 export interface JSONStore<T> {
 	load(): T;
@@ -28,8 +31,7 @@ export function createJSONStore<T extends object>(
 				return cached;
 			}
 		} catch (err) {
-			// Silently fail and return default
-			void err;
+			_logger.warn("Failed to load JSON store, using default", { filepath, error: err });
 		}
 		cached = defaultValue;
 		return cached;
@@ -44,8 +46,7 @@ export function createJSONStore<T extends object>(
 			}
 			writeFileSync(filepath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
 		} catch (err) {
-			// Silently fail - persistence is best-effort
-			void err;
+			_logger.warn("Failed to save JSON store", { filepath, error: err });
 		}
 	}
 
@@ -71,8 +72,8 @@ export function createJSONLStore<T extends object>(
 					.filter((line) => line.trim())
 					.map((line) => JSON.parse(line) as T);
 			}
-		} catch {
-			// Return empty on error
+		} catch (err) {
+			_logger.warn("Failed to load JSONL store, using empty array", { filepath, error: err });
 		}
 		return [];
 	}
@@ -85,16 +86,16 @@ export function createJSONLStore<T extends object>(
 			}
 			const line = JSON.stringify(entry);
 			writeFileSync(filepath, `${line}\n`, { flag: "a", encoding: "utf-8" });
-		} catch {
-			// Silently fail
+		} catch (err) {
+			_logger.warn("Failed to append to JSONL store", { filepath, error: err });
 		}
 	}
 
 	function clear(): void {
 		try {
 			writeFileSync(filepath, "", "utf-8");
-		} catch {
-			// Silently fail
+		} catch (err) {
+			_logger.warn("Failed to clear JSONL store", { filepath, error: err });
 		}
 	}
 

package/lib/logger.ts

@@ -63,8 +63,8 @@ function appendToFile(line: string): void {
 			mkdirSync(dir, { recursive: true });
 		}
 		appendFileSync(LOG_PATH, `${line}\n`, "utf8");
-	} catch {
-		// Never throw from logger
+	} catch (err) {
+		console.error("Failed to write to log file:", err);
 	}
 }
 

package/lib/model-enhancer.ts

@@ -1,20 +1,20 @@
-/**
- * Model name enhancement helper
- * Adds Coding Index scores to model names for display in /model
- */
-
-import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
-import { enhanceModelNameWithCodingIndex } from "../provider-failover/hardcoded-benchmarks.ts";
-
-/**
- * Enhance model names with Coding Index scores
- * Use this before registering providers to show CI in /model list
- */
-export function enhanceModelsWithCodingIndex(
-	models: ProviderModelConfig[],
-): ProviderModelConfig[] {
-	return models.map((m) => ({
-		...m,
-		name: enhanceModelNameWithCodingIndex(m.name, m.id),
-	}));
-}
+/**
+ * Model name enhancement helper
+ * Adds Coding Index scores to model names for display in /model
+ */
+
+import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
+import { enhanceModelNameWithCodingIndex } from "../provider-failover/benchmark-lookup.ts";
+
+/**
+ * Enhance model names with Coding Index scores
+ * Use this before registering providers to show CI in /model list
+ */
+export function enhanceModelsWithCodingIndex(
+	models: ProviderModelConfig[],
+): ProviderModelConfig[] {
+	return models.map((m) => ({
+		...m,
+		name: enhanceModelNameWithCodingIndex(m.name, m.id),
+	}));
+}

package/lib/open-browser.ts

@@ -0,0 +1,41 @@
+/**
+ * Cross-platform browser opener
+ *
+ * Opens a URL in the user's default browser. Handles URL-unsafe characters
+ * on Windows by using PowerShell's Start-Process instead of cmd.exe.
+ */
+
+import { spawn } from "node:child_process";
+
+/**
+ * Open a URL in the user's default browser.
+ *
+ * - Windows: uses PowerShell Start-Process (cmd.exe interprets & as command separator)
+ * - macOS: uses `open`
+ * - Linux/BSD: uses `xdg-open`
+ */
+export function openBrowser(url: string): void {
+	try {
+		if (process.platform === "win32") {
+			// PowerShell's Start-Process treats the URL as a literal string,
+			// unlike cmd.exe which interprets & as a command separator.
+			spawn(
+				"powershell.exe",
+				[
+					"-NoProfile",
+					"-NonInteractive",
+					"-Command",
+					`Start-Process "${url.replace(/"/g, '\\"')}"`,
+				],
+				{ detached: true, shell: false, windowsHide: true },
+			).unref();
+		} else if (process.platform === "darwin") {
+			spawn("open", [url], { detached: true }).unref();
+		} else {
+			spawn("xdg-open", [url], { detached: true }).unref();
+		}
+	} catch (err) {
+		// Best-effort — browser opening is non-critical
+		console.debug("Failed to open browser:", err);
+	}
+}

package/lib/provider-cache.ts

@@ -0,0 +1,106 @@
+/**
+ * Provider Model Cache
+ *
+ * Caches provider model lists to disk for faster startup and offline use.
+ *
+ * Flow:
+ * 1. On session_start: fetch fresh models from API, save to cache
+ * 2. On extension load: register cached models immediately (shows in --list-models)
+ * 3. If API fails: use cached models as fallback
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createJSONStore } from "./json-persistence.ts";
+import { createLogger } from "./logger.ts";
+import type { ProviderModelConfig } from "./types.ts";
+
+const _logger = createLogger("provider-cache");
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface CachedProviderModels {
+	/** Provider ID */
+	provider: string;
+	/** Cached model list */
+	models: ProviderModelConfig[];
+	/** When these models were fetched */
+	fetchedAt: string; // ISO timestamp
+}
+
+interface CacheData {
+	providers: Record<string, CachedProviderModels>;
+}
+
+// =============================================================================
+// Cache Store
+// =============================================================================
+
+const CACHE_FILE = join(homedir(), ".pi", "provider-cache.json");
+
+const _cache = createJSONStore<CacheData>(CACHE_FILE, { providers: {} });
+
+/**
+ * Load cached models for a provider.
+ * Returns undefined if no cache exists.
+ */
+export function loadProviderCache(
+	providerId: string,
+): ProviderModelConfig[] | undefined {
+	const data = _cache.load();
+	const cached = data.providers[providerId];
+
+	if (!cached) {
+		return undefined;
+	}
+
+	_logger.debug(`Loaded cached models for ${providerId}`, {
+		count: cached.models.length,
+		fetchedAt: cached.fetchedAt,
+	});
+
+	return cached.models;
+}
+
+/**
+ * Save models to cache for a provider.
+ */
+export function saveProviderCache(
+	providerId: string,
+	models: ProviderModelConfig[],
+): void {
+	const data = _cache.load();
+
+	data.providers[providerId] = {
+		provider: providerId,
+		models,
+		fetchedAt: new Date().toISOString(),
+	};
+
+	_cache.save(data);
+
+	_logger.debug(`Saved ${models.length} models to cache for ${providerId}`);
+}
+
+/**
+ * Clear cached models for a provider.
+ */
+export function clearProviderCache(providerId: string): void {
+	const data = _cache.load();
+
+	if (data.providers[providerId]) {
+		delete data.providers[providerId];
+		_cache.save(data);
+		_logger.debug(`Cleared cache for ${providerId}`);
+	}
+}
+
+/**
+ * Clear all provider caches.
+ */
+export function clearAllProviderCaches(): void {
+	_cache.save({ providers: {} });
+	_logger.debug("Cleared all provider caches");
+}

package/lib/registry.ts

@@ -0,0 +1,144 @@
+/**
+ * Global Provider Registry for pi-free.
+ *
+ * Decoupled from index.ts so providers can import toggle logic
+ * without creating a circular dependency.
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@mariozechner/pi-coding-agent";
+import { getFreeOnly, saveConfig } from "../config.ts";
+import { createLogger } from "./logger.ts";
+
+const _logger = createLogger("pi-free");
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface ProviderEntry {
+	id: string;
+	stored: { free: ProviderModelConfig[]; all: ProviderModelConfig[] };
+	reRegister: (models: ProviderModelConfig[]) => void;
+	hasKey: boolean;
+}
+
+// =============================================================================
+// State
+// =============================================================================
+
+const providerRegistry = new Map<string, ProviderEntry>();
+let globalFreeOnly = getFreeOnly();
+
+// Providers that expose actual per-model pricing via API
+const PRICING_EXPOSED_PROVIDERS = new Set([
+	"openrouter",
+	"opencode",
+	"kilo",
+	"cline",
+]);
+
+// =============================================================================
+// Free-model detection
+// =============================================================================
+
+/**
+ * Check if a model is free.
+ *
+ * For providers with pricing APIs: uses cost (input === 0 && output === 0)
+ * For providers without pricing: ONLY uses name-based check (name includes "free")
+ */
+export function isFreeModel(
+	model: ProviderModelConfig & { provider?: string },
+): boolean {
+	const provider = model.provider;
+	const hasPricing = provider && PRICING_EXPOSED_PROVIDERS.has(provider);
+
+	// For providers WITH pricing API: cost-based check
+	if (hasPricing) {
+		if ((model.cost?.input ?? 0) === 0 && (model.cost?.output ?? 0) === 0) {
+			return true;
+		}
+	}
+
+	// For providers WITHOUT pricing API: ONLY name-based check
+	if (model.name.toLowerCase().includes("free")) {
+		return true;
+	}
+
+	return false;
+}
+
+// =============================================================================
+// Registration
+// =============================================================================
+
+/** Register a provider with the global free/paid toggle system */
+export function registerWithGlobalToggle(
+	providerId: string,
+	stored: { free: ProviderModelConfig[]; all: ProviderModelConfig[] },
+	reRegister: (models: ProviderModelConfig[]) => void,
+	hasKey: boolean = false,
+): void {
+	providerRegistry.set(providerId, {
+		id: providerId,
+		stored,
+		reRegister,
+		hasKey,
+	});
+	_logger.info(
+		`[pi-free] Registered ${providerId} with global toggle (${stored.free.length} free, ${stored.all.length} total)`,
+	);
+}
+
+/** Get current global free-only state */
+export function getGlobalFreeOnly(): boolean {
+	return globalFreeOnly;
+}
+
+/** Access the raw registry (used by /free-providers command) */
+export function getProviderRegistry(): ReadonlyMap<string, ProviderEntry> {
+	return providerRegistry;
+}
+
+// =============================================================================
+// Global filter application
+// =============================================================================
+
+export function applyGlobalFilter(_pi: ExtensionAPI, freeOnly: boolean): void {
+	globalFreeOnly = freeOnly;
+	saveConfig({ free_only: freeOnly });
+
+	for (const [providerId, entry] of providerRegistry) {
+		try {
+			if (freeOnly) {
+				// Show only free models
+				if (entry.stored.free.length > 0) {
+					entry.reRegister(entry.stored.free);
+					_logger.info(
+						`[pi-free] ${providerId}: filtered to ${entry.stored.free.length} free models`,
+					);
+				} else {
+					_logger.warn(`[pi-free] ${providerId}: no free models available`);
+				}
+			} else {
+				// Show all models (paid + free)
+				const allModels =
+					entry.stored.all.length > 0 ? entry.stored.all : entry.stored.free;
+				if (allModels.length > 0) {
+					entry.reRegister(allModels);
+					_logger.info(
+						`[pi-free] ${providerId}: showing all ${allModels.length} models`,
+					);
+				}
+			}
+		} catch (err) {
+			_logger.error(
+				`[pi-free] Failed to apply filter to ${providerId}`,
+				err instanceof Error ? { error: err.message } : { error: String(err) },
+			);
+		}
+	}
+}