refactor: extract constants, parameterize validators, simplify factory

Quick-win refactors from the Refactoring Guru catalog:

- Replace Magic Number with Symbolic Constant: extract DEFAULT_TIMEOUT_MS,
  DEFAULT_MAX_RETRIES, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, default
  models per provider, and validation prompt into src/constants.ts.
- Parameterize Method: collapse validateTemperature / validateTopP /
  validateMaxTokens (and the inline timeout/maxRetries checks) into a
  single validateNumberInRange helper with bounds metadata.
- Inline Class / Remove Middle Man: drop the unused ProviderRegistry
  class from utils/factory.ts. createProvider now dispatches through
  the PROVIDER_REGISTRY const directly instead of a parallel switch.

Also fixes stale VERSION constant in src/index.ts (was 1.3.1).

src/utils/factory.ts

@@ -1,23 +1,22 @@
 /**
- * Factory utilities for creating AI providers
- * Provides convenient methods for instantiating and configuring providers
+ * Factory utilities for creating AI providers.
  */
 
-import type { AIProviderConfig } from '../types/index.js';
 import { ClaudeProvider, type ClaudeConfig } from '../providers/claude.js';
 import { OpenAIProvider, type OpenAIConfig } from '../providers/openai.js';
 import { GeminiProvider, type GeminiConfig } from '../providers/gemini.js';
 import { OpenWebUIProvider, type OpenWebUIConfig } from '../providers/openwebui.js';
 import { BaseAIProvider } from '../providers/base.js';
 
-/**
- * Supported AI provider types
- */
-export type ProviderType = 'claude' | 'openai' | 'gemini' | 'openwebui';
+export const PROVIDER_REGISTRY = {
+  claude: ClaudeProvider,
+  openai: OpenAIProvider,
+  gemini: GeminiProvider,
+  openwebui: OpenWebUIProvider
+} as const;
+
+export type ProviderType = keyof typeof PROVIDER_REGISTRY;
 
-/**
- * Configuration map for different provider types
- */
 export interface ProviderConfigMap {
   claude: ClaudeConfig;
   openai: OpenAIConfig;
@@ -25,144 +24,38 @@ export interface ProviderConfigMap {
   openwebui: OpenWebUIConfig;
 }
 
-/**
- * Factory function to create AI providers
- * @param type - The type of provider to create
- * @param config - Configuration for the provider
- * @returns Configured AI provider instance
- */
 export function createProvider<T extends ProviderType>(
   type: T,
   config: ProviderConfigMap[T]
 ): BaseAIProvider {
-  switch (type) {
-    case 'claude':
-      return new ClaudeProvider(config as ClaudeConfig);
-    case 'openai':
-      return new OpenAIProvider(config as OpenAIConfig);
-    case 'gemini':
-      return new GeminiProvider(config as GeminiConfig);
-    case 'openwebui':
-      return new OpenWebUIProvider(config as OpenWebUIConfig);
-    default:
-      throw new Error(`Unsupported provider type: ${type}`);
+  const ProviderClass = PROVIDER_REGISTRY[type];
+  if (!ProviderClass) {
+    throw new Error(`Unsupported provider type: ${type}`);
   }
+  return new ProviderClass(config as any);
 }
 
-/**
- * Create a Claude provider with simplified configuration
- * @param apiKey - Anthropic API key
- * @param options - Optional additional configuration
- * @returns Configured Claude provider instance
- */
 export function createClaudeProvider(
   apiKey: string,
   options: Partial<Omit<ClaudeConfig, 'apiKey'>> = {}
 ): ClaudeProvider {
-  return new ClaudeProvider({
-    apiKey,
-    ...options
-  });
+  return new ClaudeProvider({ apiKey, ...options });
 }
 
-/**
- * Create an OpenAI provider with simplified configuration
- * @param apiKey - OpenAI API key
- * @param options - Optional additional configuration
- * @returns Configured OpenAI provider instance
- */
 export function createOpenAIProvider(
   apiKey: string,
   options: Partial<Omit<OpenAIConfig, 'apiKey'>> = {}
 ): OpenAIProvider {
-  return new OpenAIProvider({
-    apiKey,
-    ...options
-  });
+  return new OpenAIProvider({ apiKey, ...options });
 }
 
-/**
- * Create a Gemini provider with simplified configuration
- * @param apiKey - Google AI API key
- * @param options - Optional additional configuration
- * @returns Configured Gemini provider instance
- */
 export function createGeminiProvider(
   apiKey: string,
   options: Partial<Omit<GeminiConfig, 'apiKey'>> = {}
 ): GeminiProvider {
-  return new GeminiProvider({
-    apiKey,
-    ...options
-  });
+  return new GeminiProvider({ apiKey, ...options });
 }
 
-/**
- * Create an OpenWebUI provider instance
- */
 export function createOpenWebUIProvider(config: OpenWebUIConfig): OpenWebUIProvider {
   return new OpenWebUIProvider(config);
 }
-
-/**
- * Provider registry for dynamic provider creation
- */
-export class ProviderRegistry {
-  private static providers = new Map<string, new (config: AIProviderConfig) => BaseAIProvider>();
-
-  /**
-   * Register a new provider type
-   * @param name - Name of the provider
-   * @param providerClass - Provider class constructor
-   */
-  static register(name: string, providerClass: new (config: AIProviderConfig) => BaseAIProvider): void {
-    this.providers.set(name.toLowerCase(), providerClass);
-  }
-
-  /**
-   * Create a provider by name
-   * @param name - Name of the provider
-   * @param config - Configuration for the provider
-   * @returns Provider instance
-   */
-  static create(name: string, config: AIProviderConfig): BaseAIProvider {
-    const ProviderClass = this.providers.get(name.toLowerCase());
-    if (!ProviderClass) {
-      throw new Error(`Provider '${name}' is not registered`);
-    }
-    return new ProviderClass(config);
-  }
-
-  /**
-   * Get list of registered provider names
-   * @returns Array of registered provider names
-   */
-  static getRegisteredProviders(): string[] {
-    return Array.from(this.providers.keys());
-  }
-
-  /**
-   * Check if a provider is registered
-   * @param name - Name of the provider
-   * @returns True if provider is registered
-   */
-  static isRegistered(name: string): boolean {
-    return this.providers.has(name.toLowerCase());
-  }
-}
-
-// Pre-register built-in providers
-ProviderRegistry.register('claude', ClaudeProvider);
-ProviderRegistry.register('openai', OpenAIProvider);
-ProviderRegistry.register('gemini', GeminiProvider);
-ProviderRegistry.register('openwebui', OpenWebUIProvider);
-
-/**
- * Registry of all available providers
- */
-export const PROVIDER_REGISTRY = {
-  claude: ClaudeProvider,
-  openai: OpenAIProvider,
-  gemini: GeminiProvider,
-  openwebui: OpenWebUIProvider
-} as const;