@gguf/coder 0.3.1 → 0.3.3

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

@@ -1,330 +0,0 @@
-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

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

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

@@ -1,214 +0,0 @@
-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

@@ -1,78 +0,0 @@
-/**
- * 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');
-	}
-}