@bonginkan/maria 3.6.2 → 3.6.3

package/dist/bin/maria.cjs

@@ -462,11 +462,10 @@ var init_startup_display = __esm({
 });
 
 // src/providers/config.ts
-var USE_LEGACY_PROVIDERS2, DEFAULT_PROVIDER2, DEFAULT_MODEL2;
+var DEFAULT_PROVIDER2, DEFAULT_MODEL2;
 var init_config = __esm({
   "src/providers/config.ts"() {
     "use strict";
-    USE_LEGACY_PROVIDERS2 = process.env.USE_LEGACY_PROVIDERS === "true";
     DEFAULT_PROVIDER2 = process.env.MARIA_PROVIDER ?? "openai";
     DEFAULT_MODEL2 = process.env.MARIA_MODEL ?? "gpt-4o-mini";
   }
@@ -7246,6 +7245,29 @@ var init_manager = __esm({
       getAvailableProviders() {
         return Array.from(this.availableProviders);
       }
+      /**
+       * Get list of available models (legacy compatibility)
+       */
+      getAvailableModels() {
+        const models = [];
+        for (const providerId of this.availableProviders) {
+          switch (providerId) {
+            case "openai":
+              models.push("gpt-4o", "gpt-4o-mini", "gpt-3.5-turbo");
+              break;
+            case "anthropic":
+              models.push("claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022");
+              break;
+            case "google":
+              models.push("gemini-2.5-pro", "gemini-2.5-flash");
+              break;
+            case "grok":
+              models.push("grok-4", "grok-beta");
+              break;
+          }
+        }
+        return models;
+      }
       /**
        * Get comprehensive health status for all providers
        */
@@ -7491,242 +7513,12 @@ var init_manager = __esm({
   }
 });
 
-// src/providers/legacy-adapter.ts
-var LegacyAIProviderFactory2, ModernToLegacyProviderShim, TemplateProviderShim;
-var init_legacy_adapter = __esm({
-  "src/providers/legacy-adapter.ts"() {
-    "use strict";
-    init_manager();
-    LegacyAIProviderFactory2 = class _LegacyAIProviderFactory {
-      static instance;
-      manager;
-      currentProviderType = "template";
-      constructor() {
-        this.manager = new UnifiedAIProviderManager2();
-      }
-      static getInstance() {
-        if (!_LegacyAIProviderFactory.instance) {
-          _LegacyAIProviderFactory.instance = new _LegacyAIProviderFactory();
-        }
-        return _LegacyAIProviderFactory.instance;
-      }
-      /**
-       * Initialize providers from environment (legacy interface)
-       */
-      async initializeFromEnvironment() {
-        await this.manager.initialize();
-      }
-      /**
-       * Initialize a specific provider (legacy interface)
-       */
-      async initializeProvider(type, config2) {
-      }
-      /**
-       * Get provider (legacy interface)
-       * Returns a shim that adapts modern provider to legacy interface
-       */
-      getProvider(type) {
-        const providerType = type || this.currentProviderType;
-        const providerId = this.mapLegacyToModernType(providerType);
-        const modernProvider = this.manager.getProvider(providerId);
-        if (!modernProvider) {
-          if (providerType === "template") {
-            return new TemplateProviderShim();
-          }
-          return void 0;
-        }
-        return new ModernToLegacyProviderShim(modernProvider);
-      }
-      /**
-       * Get active provider (legacy interface)
-       */
-      async getActiveProvider() {
-        try {
-          const modernProvider = await this.manager.pick();
-          return new ModernToLegacyProviderShim(modernProvider);
-        } catch {
-          return new TemplateProviderShim();
-        }
-      }
-      /**
-       * Set active provider (legacy interface)
-       */
-      setActiveProvider(type) {
-        this.currentProviderType = type;
-        const providerId = this.mapLegacyToModernType(type);
-        try {
-          this.manager.setActiveProvider(providerId);
-        } catch {
-        }
-      }
-      /**
-       * Get available providers (legacy interface)
-       */
-      getAvailableProviders() {
-        const modernProviders = this.manager.getAvailableProviders();
-        return modernProviders.map((id) => this.mapModernToLegacyType(id)).filter((type) => type !== null);
-      }
-      /**
-       * Clear providers (legacy interface)
-       */
-      clearProviders() {
-        this.manager = new UnifiedAIProviderManager2();
-        this.currentProviderType = "template";
-      }
-      /**
-       * Map legacy provider types to modern provider IDs
-       */
-      mapLegacyToModernType(legacyType) {
-        const mapping = {
-          openai: "openai",
-          anthropic: "anthropic",
-          groq: "groq",
-          ollama: "ollama",
-          template: "openai"
-          // Default fallback
-        };
-        return mapping[legacyType] || "openai";
-      }
-      /**
-       * Map modern provider IDs to legacy provider types
-       */
-      mapModernToLegacyType(modernId) {
-        const mapping = {
-          openai: "openai",
-          anthropic: "anthropic",
-          google: null,
-          // Not supported in legacy
-          groq: "groq",
-          grok: null,
-          // Not supported in legacy
-          ollama: "ollama",
-          lmstudio: null,
-          // Not supported in legacy
-          vllm: null
-          // Not supported in legacy
-        };
-        return mapping[modernId] || null;
-      }
-    };
-    ModernToLegacyProviderShim = class {
-      constructor(modernProvider) {
-        this.modernProvider = modernProvider;
-      }
-      get name() {
-        return this.modernProvider.name;
-      }
-      async initialize(config2) {
-      }
-      async generateCompletion(request) {
-        const prompt = this.convertMessagesToPrompt(request.messages || []);
-        const modernRequest = {
-          model: request.model,
-          temperature: request.temperature,
-          maxTokens: request.maxTokens,
-          stream: false
-        };
-        const modernResponse = await this.modernProvider.complete(
-          prompt,
-          modernRequest
-        );
-        return {
-          content: modernResponse.content,
-          model: modernResponse.model || request.model || "unknown",
-          usage: modernResponse.usage,
-          finishReason: modernResponse.finishReason
-        };
-      }
-      async streamCompletion(request, onChunk) {
-        const prompt = this.convertMessagesToPrompt(request.messages || []);
-        const modernRequest = {
-          model: request.model,
-          temperature: request.temperature,
-          maxTokens: request.maxTokens,
-          stream: true
-        };
-        const stream = await this.modernProvider.stream(prompt, modernRequest);
-        let fullContent = "";
-        for await (const chunk of stream) {
-          fullContent += chunk.content;
-          onChunk(chunk.content);
-        }
-        return {
-          content: fullContent,
-          model: request.model || "unknown",
-          finishReason: "stop"
-        };
-      }
-      isAvailable() {
-        return true;
-      }
-      getAvailableModels() {
-        return [];
-      }
-      /**
-       * Convert legacy message format to simple prompt
-       */
-      convertMessagesToPrompt(messages) {
-        return messages.map((msg) => `${msg.role}: ${msg.content}`).join("\n");
-      }
-    };
-    TemplateProviderShim = class {
-      name = "Template Provider";
-      async initialize(_config) {
-      }
-      async generateCompletion(request) {
-        const prompt = request.messages?.map((m2) => m2.content).join(" ") || "No input";
-        const templateResponse = this.generateTemplateResponse(prompt);
-        return {
-          content: templateResponse,
-          model: "template",
-          finishReason: "stop"
-        };
-      }
-      async streamCompletion(request, onChunk) {
-        const response2 = await this.generateCompletion(request);
-        const chunks = this.chunkText(response2.content, 20);
-        for (const chunk of chunks) {
-          onChunk(chunk);
-          await this.delay(50);
-        }
-        return response2;
-      }
-      isAvailable() {
-        return true;
-      }
-      getAvailableModels() {
-        return ["template"];
-      }
-      generateTemplateResponse(prompt) {
-        const responses = [
-          `I understand you're asking about: ${prompt}. Here's a helpful response based on the available information.`,
-          `Regarding "${prompt}" - I can provide some guidance on this topic.`,
-          `Thank you for your question about "${prompt}". Let me help you with that.`
-        ];
-        return responses[Math.floor(Math.random() * responses.length)];
-      }
-      chunkText(text, wordsPerChunk) {
-        const words = text.split(" ");
-        const chunks = [];
-        for (let i2 = 0; i2 < words.length; i2 += wordsPerChunk) {
-          chunks.push(words.slice(i2, i2 + wordsPerChunk).join(" ") + " ");
-        }
-        return chunks;
-      }
-      delay(ms) {
-        return new Promise((resolve2) => setTimeout(resolve2, ms));
-      }
-    };
-  }
-});
-
 // src/providers/index.ts
 var init_providers = __esm({
   "src/providers/index.ts"() {
     "use strict";
     init_config();
     init_manager();
-    init_legacy_adapter();
   }
 });
 
@@ -7868,11 +7660,7 @@ var init_provider_selector = __esm({
         this.legacyProviderManager = new UnifiedAIProviderManager2(_config);
       }
       async initialize() {
-        if (USE_LEGACY_PROVIDERS2) {
-          await this.legacyProviderManager.initialize();
-        } else {
-          await this.modernProviderManager.initialize();
-        }
+        await this.modernProviderManager.initialize();
       }
       async selectProvider() {
         const providers = await this.getAvailableProviders();
@@ -20972,7 +20760,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "3.6.2",
+      version: "3.6.3",
       description: "\u{1F680} MARIA v3.6.0 - Premier Enterprise AI Development Platform. Revolutionary multimodal intelligence featuring advanced orchestration, production-grade telemetry, and sophisticated workflow templates. Delivers 93% performance enhancement with real-time TUI monitoring, ML-powered model selection, quantum-resistant security architecture, and comprehensive observability. Battle-tested for enterprise deployment with exceptional reliability.",
       keywords: [
         "ai",
@@ -23451,15 +23239,13 @@ var init_ai_response_service = __esm({
       _conversationPersistence;
       telemetry;
       initialized = false;
-      // v2.0 Provider System
-      modernProviderManager;
-      legacyProviderFactory;
+      // V2.0 Provider System (Modern Only)
+      providerManager;
       constructor() {
         this.chatContext = ChatContextService.getInstance();
         this._conversationPersistence = new ConversationPersistence();
         this.telemetry = TelemetryCollector.getInstance();
-        this.modernProviderManager = new UnifiedAIProviderManager2();
-        this.legacyProviderFactory = LegacyAIProviderFactory2.getInstance();
+        this.providerManager = new UnifiedAIProviderManager2();
         this.initializeProviders().catch(console.error);
       }
       /**
@@ -23469,18 +23255,9 @@ var init_ai_response_service = __esm({
       async initializeProviders() {
         if (this.initialized) return;
         try {
-          if (USE_LEGACY_PROVIDERS2) {
-            await this.legacyProviderFactory.initializeFromEnvironment();
-          } else {
-            await this.modernProviderManager.initialize();
-          }
+          await this.providerManager.initialize();
           this.initialized = true;
         } catch (error) {
-          try {
-            await this.legacyProviderFactory.initializeFromEnvironment();
-            this.initialized = true;
-          } catch (fallbackError) {
-          }
         }
       }
       /**
@@ -23491,14 +23268,10 @@ var init_ai_response_service = __esm({
         if (!this.initialized) {
           await this.initializeProviders();
         }
-        if (USE_LEGACY_PROVIDERS2) {
-          return this.legacyProviderFactory.getActiveProvider();
-        } else {
-          try {
-            return await this.modernProviderManager.pick(DEFAULT_PROVIDER2);
-          } catch (error) {
-            return this.legacyProviderFactory.getActiveProvider();
-          }
+        try {
+          return await this.providerManager.pick(DEFAULT_PROVIDER2);
+        } catch (error) {
+          throw new Error(`Provider initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
       }
       /**