@gguf/coder 0.3.0 → 0.3.1

package/source/model-database/model-fetcher.ts

@@ -0,0 +1,330 @@
+import {CACHE_MODELS_EXPIRATION_MS} from '@/constants';
+import {ModelEntry} from '@/types/index';
+import {logError} from '@/utils/message-queue';
+
+// Cache for fetched model data
+interface ModelCache {
+	models: ModelEntry[];
+	timestamp: number;
+}
+
+// OpenRouter API response structure
+interface OpenRouterModel {
+	id: string;
+	name: string;
+	description: string;
+	created: number;
+	context_length: number;
+	architecture: {
+		modality: string;
+		input_modalities: string[];
+		output_modalities: string[];
+		tokenizer: string;
+	};
+	pricing: {
+		prompt: string;
+		completion: string;
+	};
+	supported_parameters?: string[];
+}
+
+interface OpenRouterResponse {
+	data: OpenRouterModel[];
+}
+
+const OPENROUTER_API = 'https://openrouter.ai/api/v1/models';
+
+let modelCache: ModelCache | null = null;
+
+/**
+ * Known open-weight model prefixes/patterns
+ */
+const OPEN_WEIGHT_PATTERNS = [
+	'meta-llama/',
+	'mistralai/',
+	'qwen/',
+	'deepseek/',
+	'google/gemma',
+	'microsoft/phi',
+	'nvidia/',
+	'cohere/command-r',
+	'databricks/',
+	'allenai/',
+	'huggingfaceh4/',
+	'openchat/',
+	'teknium/',
+	'nousresearch/',
+	'cognitivecomputations/',
+	'thebloke/',
+	'codellama/',
+	'/llama',
+	'/mistral',
+	'/qwen',
+	'/deepseek',
+	'/gemma',
+	'/phi-',
+	'/wizardlm',
+	'/vicuna',
+	'/falcon',
+	'/starcoder',
+	'/codestral',
+	'/devstral',
+];
+
+/**
+ * Check if a model is open-weight based on ID
+ */
+function isOpenWeight(modelId: string): boolean {
+	const lowerId = modelId.toLowerCase();
+	return OPEN_WEIGHT_PATTERNS.some(pattern => lowerId.includes(pattern));
+}
+
+/**
+ * Extract author from model ID
+ */
+function extractAuthor(modelId: string): string {
+	const parts = modelId.split('/');
+	if (parts.length >= 2) {
+		const author = parts[0];
+		// Capitalize first letter
+		return author.charAt(0).toUpperCase() + author.slice(1);
+	}
+	return 'Unknown';
+}
+
+/**
+ * Check if model supports text input and output
+ */
+function supportsTextInTextOut(model: OpenRouterModel): boolean {
+	const inputMods = model.architecture?.input_modalities || [];
+	const outputMods = model.architecture?.output_modalities || [];
+
+	const hasTextInput = inputMods.length === 0 || inputMods.includes('text');
+	const hasTextOutput = outputMods.length === 0 || outputMods.includes('text');
+
+	return hasTextInput && hasTextOutput;
+}
+
+/**
+ * Check if model is relevant for coding (has tool support or is a known coding model)
+ */
+function isRelevantForCoding(model: OpenRouterModel): boolean {
+	const modelId = model.id.toLowerCase();
+	const modelName = model.name.toLowerCase();
+	const description = (model.description || '').toLowerCase();
+
+	// Must support text in/out
+	if (!supportsTextInTextOut(model)) return false;
+
+	// Skip embedding models
+	if (modelId.includes('embed') || modelName.includes('embed')) return false;
+
+	// Skip image/audio only models
+	if (
+		modelId.includes('dall-e') ||
+		modelId.includes('stable-diffusion') ||
+		modelId.includes('whisper') ||
+		modelId.includes('tts') ||
+		modelId.includes('imagen')
+	) {
+		return false;
+	}
+
+	// Has tool calling support
+	if (model.supported_parameters?.includes('tools')) return true;
+
+	// Known coding-capable models
+	const codingPatterns = [
+		'gpt',
+		'claude',
+		'gemini',
+		'deepseek',
+		'qwen',
+		'coder',
+		'codestral',
+		'devstral',
+		'llama',
+		'mistral',
+		'phi',
+		'command',
+		'grok',
+		'codex',
+	];
+
+	if (codingPatterns.some(p => modelId.includes(p) || modelName.includes(p))) {
+		return true;
+	}
+
+	// Description mentions coding
+	if (
+		description.includes('code') ||
+		description.includes('programming') ||
+		description.includes('developer')
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Calculate cost score (0-10 scale, 10 = free/cheapest)
+ */
+function calculateCostScore(
+	promptPrice: string,
+	completionPrice: string,
+): number {
+	const input = parseFloat(promptPrice) || 0;
+	const output = parseFloat(completionPrice) || 0;
+
+	// Price per million tokens (prices are per token)
+	const inputPerMillion = input * 1_000_000;
+	const outputPerMillion = output * 1_000_000;
+
+	// Weighted average (output typically more important)
+	const avgCost = inputPerMillion * 0.3 + outputPerMillion * 0.7;
+
+	if (avgCost === 0) return 10;
+	if (avgCost < 0.1) return 9;
+	if (avgCost < 0.5) return 8;
+	if (avgCost < 1) return 7;
+	if (avgCost < 2) return 6;
+	if (avgCost < 5) return 5;
+	if (avgCost < 10) return 4;
+	if (avgCost < 20) return 3;
+	if (avgCost < 50) return 2;
+	return 1;
+}
+
+/**
+ * Format cost details string
+ */
+function formatCostDetails(
+	promptPrice: string,
+	completionPrice: string,
+	isLocal: boolean,
+): string {
+	const input = parseFloat(promptPrice) || 0;
+	const output = parseFloat(completionPrice) || 0;
+
+	if (input === 0 && output === 0) {
+		return isLocal ? 'Free (open weights)' : 'Free';
+	}
+
+	// Convert to per million tokens
+	const inputPerMillion = input * 1_000_000;
+	const outputPerMillion = output * 1_000_000;
+
+	return `$${inputPerMillion.toFixed(2)}/M in, $${outputPerMillion.toFixed(
+		2,
+	)}/M out`;
+}
+
+/**
+ * Format context length for display
+ */
+function formatContextLength(contextLength: number): string {
+	if (contextLength >= 1_000_000) {
+		return `${(contextLength / 1_000_000).toFixed(1)}M`;
+	}
+	if (contextLength >= 1000) {
+		return `${Math.round(contextLength / 1000)}K`;
+	}
+	return `${contextLength}`;
+}
+
+/**
+ * Fetch models from OpenRouter API
+ */
+async function fetchOpenRouterModels(): Promise<OpenRouterModel[]> {
+	try {
+		const response = await fetch(OPENROUTER_API);
+		if (!response.ok) {
+			throw new Error(`OpenRouter API returned ${response.status}`);
+		}
+
+		const data = (await response.json()) as OpenRouterResponse;
+		return data.data || [];
+	} catch (error) {
+		logError('Failed to fetch OpenRouter models', true, {error});
+		return [];
+	}
+}
+
+/**
+ * Fetch and process models from OpenRouter
+ */
+export async function fetchModels(): Promise<ModelEntry[]> {
+	// Check cache first
+	if (
+		modelCache &&
+		Date.now() - modelCache.timestamp < CACHE_MODELS_EXPIRATION_MS
+	) {
+		return modelCache.models;
+	}
+
+	const openRouterModels = await fetchOpenRouterModels();
+	const models: ModelEntry[] = [];
+
+	for (const model of openRouterModels) {
+		// Skip if not relevant for coding
+		if (!isRelevantForCoding(model)) continue;
+
+		const isLocal = isOpenWeight(model.id);
+		const costScore = calculateCostScore(
+			model.pricing.prompt,
+			model.pricing.completion,
+		);
+
+		const entry: ModelEntry = {
+			id: model.id,
+			name: model.name,
+			author: extractAuthor(model.id),
+			size: formatContextLength(model.context_length),
+			local: isLocal,
+			api: true,
+			contextLength: model.context_length,
+			created: model.created,
+			quality: {
+				cost: costScore,
+			},
+			costType: costScore >= 9 ? ('free' as const) : ('paid' as const),
+			costDetails: formatCostDetails(
+				model.pricing.prompt,
+				model.pricing.completion,
+				isLocal,
+			),
+			hasToolSupport: model.supported_parameters?.includes('tools') || false,
+		};
+
+		models.push(entry);
+	}
+
+	// Sort by created date (newest first)
+	models.sort((a, b) => (b.created || 0) - (a.created || 0));
+
+	// Update cache
+	modelCache = {
+		models,
+		timestamp: Date.now(),
+	};
+
+	return models;
+}
+
+/**
+ * Clear the model cache (useful for forcing a refresh)
+ */
+export function clearModelCache(): void {
+	modelCache = null;
+}
+
+/**
+ * Check if models are currently cached
+ */
+export function isModelsCached(): boolean {
+	return (
+		modelCache !== null &&
+		Date.now() - modelCache.timestamp < CACHE_MODELS_EXPIRATION_MS
+	);
+}

package/source/models/index.ts

@@ -0,0 +1 @@
+export {getModelContextLimit} from './models-dev-client.js';

package/source/models/models-cache.spec.ts

@@ -0,0 +1,214 @@
+import test from 'ava';
+import { unlink, writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { CachedModelsData } from './models-types.js';
+import {
+	readCache,
+	writeCache,
+} from './models-cache.js';
+
+// Get the actual cache file path that will be used
+// We need to import dynamically to get the actual path at runtime
+let actualCachePath: string;
+
+async function getCacheFilePath(): Promise<string> {
+	// Import dynamically to avoid module resolution issues during testing
+	const { xdgCache } = await import('xdg-basedir');
+	const path = await import('node:path');
+
+	const DEFAULT_CACHE_DIR =
+		process.platform === 'darwin'
+			? path.join(process.env.HOME || '~', 'Library', 'Caches')
+			: path.join(process.env.HOME || '~', '.cache');
+
+	const cacheBase = xdgCache || DEFAULT_CACHE_DIR;
+	return path.join(cacheBase, 'coder', 'models.json');
+}
+
+// ============================================================================
+// Setup and Teardown
+// ============================================================================
+
+test.before(async () => {
+	actualCachePath = await getCacheFilePath();
+});
+
+test.afterEach.always(async () => {
+	// Clean up test cache file after each test
+	if (actualCachePath && existsSync(actualCachePath)) {
+		try {
+			await unlink(actualCachePath);
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+});
+
+// ============================================================================
+// Tests for readCache
+// ============================================================================
+
+test('readCache returns null when cache file does not exist', async t => {
+	// Ensure cache file doesn't exist
+	if (existsSync(actualCachePath)) {
+		await unlink(actualCachePath);
+	}
+
+	const result = await readCache();
+	t.is(result, null);
+});
+
+test('readCache returns valid cached data', async t => {
+	const mockData: CachedModelsData = {
+		data: { models: [] } as any,
+		fetchedAt: Date.now() - 1000,
+		expiresAt: Date.now() + 1000000, // Not expired
+	};
+
+	// Ensure directory exists
+	const dir = join(actualCachePath, '..');
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch {
+		// Directory may already exist
+	}
+
+	await writeFile(actualCachePath, JSON.stringify(mockData), 'utf-8');
+
+	const result = await readCache();
+
+	t.truthy(result);
+	t.deepEqual(result?.data, mockData.data);
+	t.is(result?.fetchedAt, mockData.fetchedAt);
+	t.is(result?.expiresAt, mockData.expiresAt);
+});
+
+test('readCache returns null when cache is expired', async t => {
+	const expiredData: CachedModelsData = {
+		data: { models: [] } as any,
+		fetchedAt: Date.now() - 1000000,
+		expiresAt: Date.now() - 1000, // Expired
+	};
+
+	// Ensure directory exists
+	const dir = join(actualCachePath, '..');
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch {
+		// Directory may already exist
+	}
+
+	await writeFile(actualCachePath, JSON.stringify(expiredData), 'utf-8');
+
+	const result = await readCache();
+
+	t.is(result, null);
+});
+
+test('readCache returns null on JSON parse error', async t => {
+	// Ensure directory exists
+	const dir = join(actualCachePath, '..');
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch {
+		// Directory may already exist
+	}
+
+	await writeFile(actualCachePath, 'invalid json{{{', 'utf-8');
+
+	const result = await readCache();
+
+	t.is(result, null);
+});
+
+// ============================================================================
+// Tests for writeCache
+// ============================================================================
+
+test('writeCache writes cache data correctly', async t => {
+	const mockData = { models: [{ id: 'test-model' }] } as any;
+
+	await writeCache(mockData);
+
+	// Verify the file was written
+	const exists = existsSync(actualCachePath);
+	t.true(exists);
+
+	// Verify the content
+	const content = await readFile(actualCachePath, 'utf-8');
+	const writtenData = JSON.parse(content) as CachedModelsData;
+
+	t.truthy(writtenData.data);
+	t.truthy(writtenData.fetchedAt);
+	t.truthy(writtenData.expiresAt);
+	t.true(writtenData.expiresAt > Date.now());
+});
+
+test('writeCache creates directory if it does not exist', async t => {
+	const mockData = { models: [] } as any;
+
+	// This should not throw even if directory doesn't exist
+	await t.notThrowsAsync(async () => {
+		await writeCache(mockData);
+	});
+
+	// Verify the file was created
+	t.true(existsSync(actualCachePath));
+});
+
+// ============================================================================
+// Integration-like tests
+// ============================================================================
+
+test('cache expiration is calculated correctly', async t => {
+	const mockData = { models: [] } as any;
+	const now = Date.now();
+
+	await writeCache(mockData);
+
+	const content = await readFile(actualCachePath, 'utf-8');
+	const writtenData = JSON.parse(content) as CachedModelsData;
+
+	// Get the expiration constant
+	const { CACHE_MODELS_EXPIRATION_MS } = await import('@/constants');
+
+	// Expiration should be roughly CACHE_MODELS_EXPIRATION_MS in the future
+	t.true(writtenData.expiresAt >= now + CACHE_MODELS_EXPIRATION_MS - 100);
+	t.true(writtenData.expiresAt <= now + CACHE_MODELS_EXPIRATION_MS + 100);
+});
+
+test('readCache and writeCache round-trip correctly', async t => {
+	const originalData = {
+		models: [
+			{ id: 'model1', name: 'Test Model 1' },
+			{ id: 'model2', name: 'Test Model 2' },
+		],
+	} as any;
+
+	// Write the cache
+	await writeCache(originalData);
+
+	// Read it back
+	const readResult = await readCache();
+
+	t.truthy(readResult);
+	t.deepEqual(readResult?.data, originalData);
+});
+
+test('writeCache overwrites existing cache', async t => {
+	// Write first cache
+	const firstData = { models: [{ id: 'model1' }] } as any;
+	await writeCache(firstData);
+
+	// Write second cache (should overwrite)
+	const secondData = { models: [{ id: 'model2' }, { id: 'model3' }] } as any;
+	await writeCache(secondData);
+
+	// Read back
+	const readResult = await readCache();
+
+	t.truthy(readResult);
+	t.deepEqual(readResult?.data, secondData);
+});

package/source/models/models-cache.ts

@@ -0,0 +1,78 @@
+/**
+ * Cache management for models.dev data
+ * Stores model database in XDG_CACHE_HOME for fast lookup
+ */
+
+import {constants} from 'node:fs';
+import {access, mkdir, readFile, writeFile} from 'node:fs/promises';
+import * as path from 'node:path';
+import {CACHE_MODELS_EXPIRATION_MS} from '@/constants';
+import {formatError} from '@/utils/error-formatter';
+import {getLogger} from '@/utils/logging';
+import {xdgCache} from 'xdg-basedir';
+import type {CachedModelsData, ModelsDevDatabase} from './models-types.js';
+
+const DEFAULT_CACHE_DIR =
+	process.platform === 'darwin'
+		? path.join(process.env.HOME || '~', 'Library', 'Caches')
+		: path.join(process.env.HOME || '~', '.cache');
+
+function getCacheDir(): string {
+	const cacheBase = xdgCache || DEFAULT_CACHE_DIR;
+	return path.join(cacheBase, 'coder');
+}
+
+function getCacheFilePath(): string {
+	return path.join(getCacheDir(), 'models.json');
+}
+
+async function ensureCacheDir(): Promise<void> {
+	const dir = getCacheDir();
+
+	try {
+		await access(dir, constants.F_OK);
+	} catch {
+		await mkdir(dir, {recursive: true});
+	}
+}
+
+export async function readCache(): Promise<CachedModelsData | null> {
+	try {
+		const cachePath = getCacheFilePath();
+
+		await access(cachePath, constants.F_OK);
+
+		const content = await readFile(cachePath, 'utf-8');
+		const cached = JSON.parse(content) as CachedModelsData;
+
+		// Check if cache is expired
+		if (Date.now() > cached.expiresAt) {
+			return null;
+		}
+
+		return cached;
+	} catch (error) {
+		// If there's any error reading cache, return null to trigger fresh fetch
+		const logger = getLogger();
+		logger.warn({error: formatError(error)}, 'Failed to read models cache');
+		return null;
+	}
+}
+
+export async function writeCache(data: ModelsDevDatabase): Promise<void> {
+	try {
+		await ensureCacheDir();
+
+		const cached: CachedModelsData = {
+			data,
+			fetchedAt: Date.now(),
+			expiresAt: Date.now() + CACHE_MODELS_EXPIRATION_MS,
+		};
+
+		const cachePath = getCacheFilePath();
+		await writeFile(cachePath, JSON.stringify(cached, null, 2), 'utf-8');
+	} catch (error) {
+		const logger = getLogger();
+		logger.warn({error: formatError(error)}, 'Failed to write models cache');
+	}
+}