@bonginkan/maria 3.6.1 → 3.6.3

package/dist/bin/maria.cjs

@@ -42,7 +42,7 @@ function getVersion() {
     const packageJson2 = getPackageJson();
     _cachedVersion = packageJson2.version;
     return _cachedVersion;
-  } catch (error2) {
+  } catch (error) {
     _cachedVersion = "latest";
     return _cachedVersion;
   }
@@ -100,8 +100,8 @@ function getPackageJson() {
     const packageJsonContent = (0, import_fs.readFileSync)(packageJsonPath, "utf-8");
     _cachedPackageJson = JSON.parse(packageJsonContent);
     return _cachedPackageJson;
-  } catch (error2) {
-    throw new Error(`Failed to read package.json: ${error2}`);
+  } catch (error) {
+    throw new Error(`Failed to read package.json: ${error}`);
   }
 }
 var import_fs, import_path, _cachedVersion, _cachedPackageJson, VERSION;
@@ -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";
   }
@@ -2376,10 +2375,10 @@ var require_ponyfill_es2018 = __commonJS({
         });
         return promise;
       }
-      function WritableStreamDealWithRejection(stream, error2) {
+      function WritableStreamDealWithRejection(stream, error) {
         const state = stream._state;
         if (state === "writable") {
-          WritableStreamStartErroring(stream, error2);
+          WritableStreamStartErroring(stream, error);
           return;
         }
         WritableStreamFinishErroring(stream);
@@ -2430,10 +2429,10 @@ var require_ponyfill_es2018 = __commonJS({
         stream._inFlightWriteRequest._resolve(void 0);
         stream._inFlightWriteRequest = void 0;
       }
-      function WritableStreamFinishInFlightWriteWithError(stream, error2) {
-        stream._inFlightWriteRequest._reject(error2);
+      function WritableStreamFinishInFlightWriteWithError(stream, error) {
+        stream._inFlightWriteRequest._reject(error);
         stream._inFlightWriteRequest = void 0;
-        WritableStreamDealWithRejection(stream, error2);
+        WritableStreamDealWithRejection(stream, error);
       }
       function WritableStreamFinishInFlightClose(stream) {
         stream._inFlightCloseRequest._resolve(void 0);
@@ -2452,14 +2451,14 @@ var require_ponyfill_es2018 = __commonJS({
           defaultWriterClosedPromiseResolve(writer);
         }
       }
-      function WritableStreamFinishInFlightCloseWithError(stream, error2) {
-        stream._inFlightCloseRequest._reject(error2);
+      function WritableStreamFinishInFlightCloseWithError(stream, error) {
+        stream._inFlightCloseRequest._reject(error);
         stream._inFlightCloseRequest = void 0;
         if (stream._pendingAbortRequest !== void 0) {
-          stream._pendingAbortRequest._reject(error2);
+          stream._pendingAbortRequest._reject(error);
           stream._pendingAbortRequest = void 0;
         }
-        WritableStreamDealWithRejection(stream, error2);
+        WritableStreamDealWithRejection(stream, error);
       }
       function WritableStreamCloseQueuedOrInFlight(stream) {
         if (stream._closeRequest === void 0 && stream._inFlightCloseRequest === void 0) {
@@ -2676,18 +2675,18 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return WritableStreamDefaultWriterClose(writer);
       }
-      function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error2) {
+      function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
         if (writer._closedPromiseState === "pending") {
-          defaultWriterClosedPromiseReject(writer, error2);
+          defaultWriterClosedPromiseReject(writer, error);
         } else {
-          defaultWriterClosedPromiseResetToRejected(writer, error2);
+          defaultWriterClosedPromiseResetToRejected(writer, error);
         }
       }
-      function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error2) {
+      function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
         if (writer._readyPromiseState === "pending") {
-          defaultWriterReadyPromiseReject(writer, error2);
+          defaultWriterReadyPromiseReject(writer, error);
         } else {
-          defaultWriterReadyPromiseResetToRejected(writer, error2);
+          defaultWriterReadyPromiseResetToRejected(writer, error);
         }
       }
       function WritableStreamDefaultWriterGetDesiredSize(writer) {
@@ -2922,9 +2921,9 @@ var require_ponyfill_es2018 = __commonJS({
           WritableStreamDefaultControllerProcessWrite(controller, value);
         }
       }
-      function WritableStreamDefaultControllerErrorIfNeeded(controller, error2) {
+      function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
         if (controller._controlledWritableStream._state === "writable") {
-          WritableStreamDefaultControllerError(controller, error2);
+          WritableStreamDefaultControllerError(controller, error);
         }
       }
       function WritableStreamDefaultControllerProcessClose(controller) {
@@ -2967,10 +2966,10 @@ var require_ponyfill_es2018 = __commonJS({
         const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
         return desiredSize <= 0;
       }
-      function WritableStreamDefaultControllerError(controller, error2) {
+      function WritableStreamDefaultControllerError(controller, error) {
         const stream = controller._controlledWritableStream;
         WritableStreamDefaultControllerClearAlgorithms(controller);
-        WritableStreamStartErroring(stream, error2);
+        WritableStreamStartErroring(stream, error);
       }
       function streamBrandCheckException$2(name2) {
         return new TypeError(`WritableStream.prototype.${name2} can only be used on a WritableStream`);
@@ -3114,12 +3113,12 @@ var require_ponyfill_es2018 = __commonJS({
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
-              const error2 = signal.reason !== void 0 ? signal.reason : new DOMException2("Aborted", "AbortError");
+              const error = signal.reason !== void 0 ? signal.reason : new DOMException2("Aborted", "AbortError");
               const actions = [];
               if (!preventAbort) {
                 actions.push(() => {
                   if (dest._state === "writable") {
-                    return WritableStreamAbort(dest, error2);
+                    return WritableStreamAbort(dest, error);
                   }
                   return promiseResolvedWith(void 0);
                 });
@@ -3127,12 +3126,12 @@ var require_ponyfill_es2018 = __commonJS({
               if (!preventCancel) {
                 actions.push(() => {
                   if (source._state === "readable") {
-                    return ReadableStreamCancel(source, error2);
+                    return ReadableStreamCancel(source, error);
                   }
                   return promiseResolvedWith(void 0);
                 });
               }
-              shutdownWithAction(() => Promise.all(actions.map((action) => action())), true, error2);
+              shutdownWithAction(() => Promise.all(actions.map((action) => action())), true, error);
             };
             if (signal.aborted) {
               abortAlgorithm();
@@ -3235,25 +3234,25 @@ var require_ponyfill_es2018 = __commonJS({
               return null;
             }
           }
-          function shutdown(isError, error2) {
+          function shutdown(isError, error) {
             if (shuttingDown) {
               return;
             }
             shuttingDown = true;
             if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) {
-              uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error2));
+              uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error));
             } else {
-              finalize(isError, error2);
+              finalize(isError, error);
             }
           }
-          function finalize(isError, error2) {
+          function finalize(isError, error) {
             WritableStreamDefaultWriterRelease(writer);
             ReadableStreamReaderGenericRelease(reader2);
             if (signal !== void 0) {
               signal.removeEventListener("abort", abortAlgorithm);
             }
             if (isError) {
-              reject(error2);
+              reject(error);
             } else {
               resolve2(void 0);
             }
@@ -4648,8 +4647,8 @@ var require_ponyfill_es2018 = __commonJS({
         const stream = controller._controlledTransformStream;
         const readableController = stream._readable._readableStreamController;
         ReadableStreamDefaultControllerClose(readableController);
-        const error2 = new TypeError("TransformStream terminated");
-        TransformStreamErrorWritableAndUnblockWrite(stream, error2);
+        const error = new TypeError("TransformStream terminated");
+        TransformStreamErrorWritableAndUnblockWrite(stream, error);
       }
       function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
         const controller = stream._transformStreamController;
@@ -4807,11 +4806,11 @@ var require_streams = __commonJS({
           };
           Object.assign(globalThis, require("stream/web"));
           process2.emitWarning = emitWarning;
-        } catch (error2) {
+        } catch (error) {
           process2.emitWarning = emitWarning;
-          throw error2;
+          throw error;
         }
-      } catch (error2) {
+      } catch (error) {
         Object.assign(globalThis, require_ponyfill_es2018());
       }
     }
@@ -4835,7 +4834,7 @@ var require_streams = __commonJS({
           });
         };
       }
-    } catch (error2) {
+    } catch (error) {
     }
   }
 });
@@ -5725,15 +5724,15 @@ async function consumeBody(data2) {
   try {
     for await (const chunk of body) {
       if (data2.size > 0 && accumBytes + chunk.length > data2.size) {
-        const error2 = new FetchError(`content size at ${data2.url} over limit: ${data2.size}`, "max-size");
-        body.destroy(error2);
-        throw error2;
+        const error = new FetchError(`content size at ${data2.url} over limit: ${data2.size}`, "max-size");
+        body.destroy(error);
+        throw error;
       }
       accumBytes += chunk.length;
       accum.push(chunk);
     }
-  } catch (error2) {
-    const error_ = error2 instanceof FetchBaseError ? error2 : new FetchError(`Invalid response body while trying to fetch ${data2.url}: ${error2.message}`, "system", error2);
+  } catch (error) {
+    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data2.url}: ${error.message}`, "system", error);
     throw error_;
   }
   if (body.readableEnded === true || body._readableState.ended === true) {
@@ -5742,8 +5741,8 @@ async function consumeBody(data2) {
         return import_node_buffer.Buffer.from(accum.join(""));
       }
       return import_node_buffer.Buffer.concat(accum, accumBytes);
-    } catch (error2) {
-      throw new FetchError(`Could not create Buffer from response body for ${data2.url}: ${error2.message}`, "system", error2);
+    } catch (error) {
+      throw new FetchError(`Could not create Buffer from response body for ${data2.url}: ${error.message}`, "system", error);
     }
   } else {
     throw new FetchError(`Premature close of server response while trying to fetch ${data2.url}`);
@@ -5801,8 +5800,8 @@ var init_body = __esm({
         this.size = size;
         if (body instanceof import_node_stream.default) {
           body.on("error", (error_) => {
-            const error2 = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
-            this[INTERNALS].error = error2;
+            const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
+            this[INTERNALS].error = error;
           });
         }
       }
@@ -5990,16 +5989,16 @@ var init_headers = __esm({
     import_node_http = __toESM(require("http"), 1);
     validateHeaderName = typeof import_node_http.default.validateHeaderName === "function" ? import_node_http.default.validateHeaderName : (name2) => {
       if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name2)) {
-        const error2 = new TypeError(`Header name must be a valid HTTP token [${name2}]`);
-        Object.defineProperty(error2, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
-        throw error2;
+        const error = new TypeError(`Header name must be a valid HTTP token [${name2}]`);
+        Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
+        throw error;
       }
     };
     validateHeaderValue = typeof import_node_http.default.validateHeaderValue === "function" ? import_node_http.default.validateHeaderValue : (name2, value) => {
       if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
-        const error2 = new TypeError(`Invalid character in header content ["${name2}"]`);
-        Object.defineProperty(error2, "code", { value: "ERR_INVALID_CHAR" });
-        throw error2;
+        const error = new TypeError(`Invalid character in header content ["${name2}"]`);
+        Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" });
+        throw error;
       }
     };
     Headers = class _Headers extends URLSearchParams {
@@ -6711,15 +6710,15 @@ async function fetch2(url, options_) {
     const { signal } = request;
     let response2 = null;
     const abort = () => {
-      const error2 = new AbortError("The operation was aborted.");
-      reject(error2);
+      const error = new AbortError("The operation was aborted.");
+      reject(error);
       if (request.body && request.body instanceof import_node_stream2.default.Readable) {
-        request.body.destroy(error2);
+        request.body.destroy(error);
       }
       if (!response2 || !response2.body) {
         return;
       }
-      response2.body.emit("error", error2);
+      response2.body.emit("error", error);
     };
     if (signal && signal.aborted) {
       abort();
@@ -6739,13 +6738,13 @@ async function fetch2(url, options_) {
         signal.removeEventListener("abort", abortAndFinalize);
       }
     };
-    request_.on("error", (error2) => {
-      reject(new FetchError(`request to ${request.url} failed, reason: ${error2.message}`, "system", error2));
+    request_.on("error", (error) => {
+      reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
       finalize();
     });
-    fixResponseChunkedTransferBadEnding(request_, (error2) => {
+    fixResponseChunkedTransferBadEnding(request_, (error) => {
       if (response2 && response2.body) {
-        response2.body.destroy(error2);
+        response2.body.destroy(error);
       }
     });
     if (process.version < "v14") {
@@ -6756,9 +6755,9 @@ async function fetch2(url, options_) {
         });
         s2.prependListener("close", (hadError) => {
           if (response2 && endedWithEventsCount < s2._eventsCount && !hadError) {
-            const error2 = new Error("Premature close");
-            error2.code = "ERR_STREAM_PREMATURE_CLOSE";
-            response2.body.emit("error", error2);
+            const error = new Error("Premature close");
+            error.code = "ERR_STREAM_PREMATURE_CLOSE";
+            response2.body.emit("error", error);
           }
         });
       });
@@ -6839,9 +6838,9 @@ async function fetch2(url, options_) {
           signal.removeEventListener("abort", abortAndFinalize);
         });
       }
-      let body = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error2) => {
-        if (error2) {
-          reject(error2);
+      let body = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error) => {
+        if (error) {
+          reject(error);
         }
       });
       if (process.version < "v12.10") {
@@ -6867,9 +6866,9 @@ async function fetch2(url, options_) {
         finishFlush: import_node_zlib.default.Z_SYNC_FLUSH
       };
       if (codings === "gzip" || codings === "x-gzip") {
-        body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createGunzip(zlibOptions), (error2) => {
-          if (error2) {
-            reject(error2);
+        body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createGunzip(zlibOptions), (error) => {
+          if (error) {
+            reject(error);
           }
         });
         response2 = new Response(body, responseOptions);
@@ -6877,22 +6876,22 @@ async function fetch2(url, options_) {
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
-        const raw = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error2) => {
-          if (error2) {
-            reject(error2);
+        const raw = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error) => {
+          if (error) {
+            reject(error);
           }
         });
         raw.once("data", (chunk) => {
           if ((chunk[0] & 15) === 8) {
-            body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflate(), (error2) => {
-              if (error2) {
-                reject(error2);
+            body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflate(), (error) => {
+              if (error) {
+                reject(error);
               }
             });
           } else {
-            body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflateRaw(), (error2) => {
-              if (error2) {
-                reject(error2);
+            body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createInflateRaw(), (error) => {
+              if (error) {
+                reject(error);
               }
             });
           }
@@ -6908,9 +6907,9 @@ async function fetch2(url, options_) {
         return;
       }
       if (codings === "br") {
-        body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createBrotliDecompress(), (error2) => {
-          if (error2) {
-            reject(error2);
+        body = (0, import_node_stream2.pipeline)(body, import_node_zlib.default.createBrotliDecompress(), (error) => {
+          if (error) {
+            reject(error);
           }
         });
         response2 = new Response(body, responseOptions);
@@ -6935,9 +6934,9 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
   request.on("socket", (socket) => {
     const onSocketClose = () => {
       if (isChunkedTransfer && !properLastChunkReceived) {
-        const error2 = new Error("Premature close");
-        error2.code = "ERR_STREAM_PREMATURE_CLOSE";
-        errorCallback(error2);
+        const error = new Error("Premature close");
+        error.code = "ERR_STREAM_PREMATURE_CLOSE";
+        errorCallback(error);
       }
     };
     const onData = (buf) => {
@@ -7005,11 +7004,11 @@ var init_base_provider = __esm({
             latencyMs,
             timestamp: Date.now()
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             ok: false,
             latencyMs: Date.now() - startTime,
-            reason: error2 instanceof Error ? error2.message : "Unknown error",
+            reason: error instanceof Error ? error.message : "Unknown error",
             timestamp: Date.now()
           };
         }
@@ -7038,9 +7037,9 @@ var init_base_provider = __esm({
             );
           }
           return response2.json();
-        } catch (error2) {
+        } catch (error) {
           clearTimeout(timeoutId);
-          throw error2;
+          throw error;
         }
       }
       // Helper method for streaming requests
@@ -7067,9 +7066,9 @@ var init_base_provider = __esm({
             );
           }
           return this.parseStreamResponse(response2);
-        } catch (error2) {
+        } catch (error) {
           clearTimeout(timeoutId);
-          throw error2;
+          throw error;
         }
       }
       // Default stream parsing - override in subclasses for provider-specific logic
@@ -7112,10 +7111,10 @@ var init_base_provider = __esm({
         for (let attempt = 0; attempt < maxRetries; attempt++) {
           try {
             return await operation();
-          } catch (error2) {
-            lastError = error2;
-            if (this.isNonRetryableError(error2)) {
-              throw error2;
+          } catch (error) {
+            lastError = error;
+            if (this.isNonRetryableError(error)) {
+              throw error;
             }
             if (attempt < maxRetries - 1) {
               const delay = Math.pow(2, attempt) * 1e3;
@@ -7126,8 +7125,8 @@ var init_base_provider = __esm({
         throw lastError;
       }
       // Check if error should not be retried
-      isNonRetryableError(error2) {
-        const message = error2?.message?.toLowerCase() || "";
+      isNonRetryableError(error) {
+        const message = error?.message?.toLowerCase() || "";
         return message.includes("invalid api key") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("not found");
       }
     };
@@ -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
        */
@@ -7255,10 +7277,10 @@ var init_manager = __esm({
           async ([id, provider2]) => {
             try {
               health[id] = await provider2.health();
-            } catch (error2) {
+            } catch (error) {
               health[id] = {
                 ok: false,
-                reason: error2 instanceof Error ? error2.message : "Unknown error",
+                reason: error instanceof Error ? error.message : "Unknown error",
                 timestamp: Date.now()
               };
             }
@@ -7281,10 +7303,10 @@ var init_manager = __esm({
               if (health.ok) {
                 this.availableProviders.add(id);
               }
-            } catch (error2) {
+            } catch (error) {
               this.healthCache.set(id, {
                 ok: false,
-                reason: error2 instanceof Error ? error2.message : "Health check failed",
+                reason: error instanceof Error ? error.message : "Health check failed",
                 timestamp: Date.now()
               });
             }
@@ -7345,10 +7367,10 @@ var init_manager = __esm({
           const health = await provider2.health();
           this.healthCache.set(id, health);
           return health;
-        } catch (error2) {
+        } catch (error) {
           const health = {
             ok: false,
-            reason: error2 instanceof Error ? error2.message : "Health check failed",
+            reason: error instanceof Error ? error.message : "Health check failed",
             timestamp: now
           };
           this.healthCache.set(id, health);
@@ -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();
   }
 });
 
@@ -7858,22 +7650,17 @@ var init_provider_selector = __esm({
     import_chalk2 = __toESM(require("chalk"), 1);
     import_inquirer = __toESM(require("inquirer"), 1);
     init_providers();
-    init_manager();
     ProviderSelector = class {
       config;
       modernProviderManager;
       legacyProviderManager;
       constructor(_config) {
         this.config = _config;
-        this.modernProviderManager = new UnifiedAIProviderManager2();
+        this.modernProviderManager = new UnifiedAIProviderManager();
         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();
@@ -8165,8 +7952,8 @@ async function importReactComponent(specifier) {
   try {
     const _module = await safeDynamicImport(specifier);
     return _module;
-  } catch (error2) {
-    console.warn(`Failed to load React component ${specifier}:`, error2);
+  } catch (error) {
+    console.warn(`Failed to load React component ${specifier}:`, error);
     throw new Error(
       `React component ${specifier} is not available in this environment`
     );
@@ -8186,604 +7973,61 @@ var init_import_helper = __esm({
   }
 });
 
-// src/config/config-manager.ts
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key2 in source) {
-    if (source[key2] === void 0) continue;
-    const sourceValue = source[key2];
-    const targetValue = result[key2];
-    if (Array.isArray(sourceValue)) {
-      result[key2] = [...sourceValue];
-    } else if (sourceValue && typeof sourceValue === "object" && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-      result[key2] = deepMerge(targetValue, sourceValue);
-    } else {
-      result[key2] = sourceValue;
-    }
+// src/config/loader.ts
+async function loadEnvironmentConfig() {
+  if (environmentLoaded) {
+    return;
   }
-  return result;
-}
-var import_zod, PROVIDER_MODELS, ConfigValidationError, ConfigLoadError, PriorityModeSchema, ApiKeysSchema, LocalProvidersSchema, ProviderConfigSchema, ConfigSchema, ConfigManagerV2;
-var init_config_manager = __esm({
-  "src/config/config-manager.ts"() {
-    "use strict";
-    import_zod = require("zod");
-    PROVIDER_MODELS = {
-      openai: [
-        "gpt-5-mini-2025-08-07",
-        "gpt-5-mini",
-        "gpt-5",
-        "gpt-4o",
-        "gpt-4o-mini",
-        "gpt-4-turbo",
-        "o1-preview",
-        "o1-mini"
-      ],
-      anthropic: [
-        "claude-3-opus-20240229",
-        "claude-3-sonnet-20240229",
-        "claude-3-haiku-20240307",
-        "claude-3-5-sonnet-20241022"
-      ],
-      google: ["gemini-2.0-flash-exp", "gemini-1.5-pro", "gemini-1.5-flash"],
-      groq: [
-        "llama-3.1-70b-versatile",
-        "llama-3.1-8b-instant",
-        "mixtral-8x7b-32768"
-      ],
-      grok: ["grok-beta", "grok-vision-beta"],
-      lmstudio: ["*"],
-      // Local models - accept any
-      ollama: ["*"],
-      // Local models - accept any
-      vllm: ["*"]
-      // Local models - accept any
-    };
-    ConfigValidationError = class extends Error {
-      constructor(message, field, value, suggestion) {
-        super(message);
-        this.field = field;
-        this.value = value;
-        this.suggestion = suggestion;
-        this.name = "ConfigValidationError";
-      }
-    };
-    ConfigLoadError = class extends Error {
-      constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "ConfigLoadError";
-      }
-    };
-    PriorityModeSchema = import_zod.z.enum(["privacy-first", "performance", "cost-effective", "auto"]).default("privacy-first");
-    ApiKeysSchema = import_zod.z.object({
-      OPENAI_API_KEY: import_zod.z.string().optional(),
-      ANTHROPIC_API_KEY: import_zod.z.string().optional(),
-      GOOGLE_API_KEY: import_zod.z.string().optional(),
-      GROQ_API_KEY: import_zod.z.string().optional(),
-      GROK_API_KEY: import_zod.z.string().optional()
-    }).partial().default({});
-    LocalProvidersSchema = import_zod.z.object({
-      lmstudio: import_zod.z.boolean().default(false),
-      ollama: import_zod.z.boolean().default(false),
-      vllm: import_zod.z.boolean().default(false)
-    }).default({ lmstudio: false, ollama: false, vllm: false });
-    ProviderConfigSchema = import_zod.z.object({
-      enabled: import_zod.z.boolean().default(false),
-      apiKey: import_zod.z.string().optional(),
-      apiBase: import_zod.z.string().url().optional(),
-      models: import_zod.z.record(import_zod.z.any()).default({})
-    }).default({ enabled: false, models: Record });
-    ConfigSchema = import_zod.z.object({
-      priority: PriorityModeSchema,
-      providers: import_zod.z.record(ProviderConfigSchema).default({}),
-      autoStart: import_zod.z.boolean().default(true),
-      healthMonitoring: import_zod.z.boolean().default(true),
-      language: import_zod.z.string().default("auto"),
-      offlineMode: import_zod.z.boolean().default(false),
-      // Extended configuration
-      model: import_zod.z.string().default("gpt-5-mini"),
-      provider: import_zod.z.string().default("openai"),
-      apiKeys: ApiKeysSchema.optional(),
-      localProviders: LocalProvidersSchema.optional(),
-      enabledProviders: import_zod.z.array(import_zod.z.string()).optional(),
-      // Advanced settings
-      maxRetries: import_zod.z.number().min(0).max(10).default(3),
-      timeout: import_zod.z.number().min(1e3).max(3e5).default(3e4),
-      // 30s default
-      concurrentRequests: import_zod.z.number().min(1).max(20).default(5),
-      cacheEnabled: import_zod.z.boolean().default(true),
-      logLevel: import_zod.z.enum(["error", "warn", "info", "debug"]).default("info"),
-      telemetryEnabled: import_zod.z.boolean().default(true)
-    }).strip();
-    ConfigManagerV2 = class _ConfigManagerV2 {
-      config;
-      sourceMap;
-      constructor(initialConfig = {}, source = "defaults") {
-        try {
-          this.config = this.validateAndTransform(this.loadDefaultConfig());
-          this.sourceMap = this.initializeSourceMap();
-          if (Object.keys(initialConfig).length > 0) {
-            this.mergeAndValidate(initialConfig, source);
-          }
-        } catch (error2) {
-          throw new ConfigLoadError(
-            `Failed to initialize ConfigManager: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
-            error2 instanceof Error ? error2 : void 0
-          );
-        }
-      }
-      // Utility function for parsing boolean values from environment variables
-      static parseBool(value, defaultValue = false) {
-        if (!value) return defaultValue;
-        return /^(1|true|yes|on)$/i.test(value.trim());
-      }
-      static parseNumber(value, defaultValue) {
-        if (!value) return defaultValue;
-        const parsed = parseInt(value, 10);
-        return isNaN(parsed) ? defaultValue : parsed;
-      }
-      loadDefaultConfig() {
-        return {
-          priority: "privacy-first",
-          providers: {},
-          autoStart: true,
-          healthMonitoring: true,
-          language: "auto",
-          offlineMode: false,
-          model: "gpt-5-mini",
-          provider: "openai",
-          maxRetries: 3,
-          timeout: 3e4,
-          concurrentRequests: 5,
-          cacheEnabled: true,
-          logLevel: "info",
-          telemetryEnabled: true
-        };
-      }
-      initializeSourceMap() {
-        const keys = Object.keys(this.config);
-        return keys.reduce(
-          (map, key2) => ({ ...map, [key2]: "defaults" }),
-          {}
-        );
-      }
-      // Validate and transform configuration using Zod schema
-      validateAndTransform(config2) {
-        try {
-          const validated = ConfigSchema.parse(config2);
-          this.validateProviderModelConsistency(validated);
-          return validated;
-        } catch (innerError) {
-          if (error instanceof import_zod.z.ZodError) {
-            const firstError = error.errors[0];
-            throw new ConfigValidationError(
-              `Configuration validation failed: ${firstError.message}`,
-              firstError.path.join("."),
-              firstError.received,
-              this.getSuggestionForError(firstError)
-            );
-          }
-          throw error;
-        }
-      }
-      // Custom provider/model consistency validation
-      validateProviderModelConsistency(config2) {
-        const { provider: provider2, model } = config2;
-        if (provider2 && model) {
-          const allowedModels = PROVIDER_MODELS[provider2];
-          if (allowedModels && !allowedModels.includes("*") && !allowedModels.includes(model)) {
-            throw new ConfigValidationError(
-              `Model "${model}" is not supported by provider "${provider2}"`,
-              "model",
-              model,
-              `Available models for ${provider2}: ${allowedModels.join(", ")}`
-            );
-          }
-        }
-      }
-      // Provide helpful suggestions for validation errors
-      getSuggestionForError(error2) {
-        switch (error2.code) {
-          case "invalid_enum_value":
-            return `Valid options: ${error2.options.join(", ")}`;
-          case "too_small":
-            return `Minimum value: ${error2.minimum}`;
-          case "too_big":
-            return `Maximum value: ${error2.maximum}`;
-          case "invalid_type":
-            return `Expected ${error2.expected}, got ${error2.received}`;
-          case "invalid_string":
-            if (error2.validation === "url") {
-              return "Must be a valid URL (e.g., https://api.example.com)";
-            }
-            return "Invalid string format";
-          default:
-            return "Please check the configuration documentation";
-        }
-      }
-      // Phase 2: Advanced merge with validation and source tracking
-      mergeAndValidate(newConfig, source = "defaults") {
-        try {
-          const mergedConfig = deepMerge(
-            this.config,
-            newConfig
-          );
-          const validatedConfig = this.validateAndTransform(mergedConfig);
-          this.updateSourceMap(newConfig, source);
-          this.config = validatedConfig;
-        } catch (error2) {
-          throw new ConfigValidationError(
-            `Failed to merge configuration: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
-            "merge",
-            newConfig,
-            "Check configuration format and values"
-          );
-        }
-      }
-      updateSourceMap(newConfig, source) {
-        for (const key2 of Object.keys(newConfig)) {
-          if (key2 in this.sourceMap) {
-            this.sourceMap[key2] = source;
-          }
-        }
-      }
-      get(key2, defaultValue) {
-        const value = this.config[key2];
-        return value !== void 0 ? value : defaultValue;
-      }
-      // Type-safe set method with validation
-      set(key2, value, source = "manual") {
-        try {
-          const updatedConfig = { ...this.config, [key2]: value };
-          const validatedConfig = this.validateAndTransform(updatedConfig);
-          this.config = validatedConfig;
-          this.sourceMap[key2] = source;
-        } catch (innerError) {
-          throw new ConfigValidationError(
-            `Failed to set ${String(key2)}: ${error instanceof Error ? error.message : "Invalid value"}`,
-            String(key2),
-            value,
-            error instanceof ConfigValidationError ? error.suggestion : void 0
-          );
-        }
-      }
-      // Bulk update with validation
-      update(updates, source = "manual") {
-        this.mergeAndValidate(updates, source);
-      }
-      // Get configuration source information
-      getSource(key2) {
-        return this.sourceMap[key2];
-      }
-      // Get all source mappings
-      getSourceMap() {
-        return { ...this.sourceMap };
-      }
-      // Validate current configuration
-      validate() {
-        try {
-          this.validateAndTransform(this.config);
-          return { isValid: true, errors: [] };
-        } catch (error2) {
-          const errors = [];
-          if (error2 instanceof ConfigValidationError) {
-            errors.push(`${error2.field}: ${error2.message}`);
-          } else {
-            errors.push(
-              error2 instanceof Error ? error2.message : "Unknown validation error"
-            );
-          }
-          return { isValid: false, errors };
-        }
-      }
-      getAll(options) {
-        const configCopy = { ...this.config };
-        if (options?.maskSensitive && configCopy.apiKeys) {
-          configCopy.apiKeys = Object.fromEntries(
-            Object.entries(configCopy.apiKeys).map(([key2, value]) => [
-              key2,
-              value ? "***MASKED***" : value
-            ])
-          );
-        }
-        const result = options?.includeSourceMap ? { config: configCopy, sources: this.sourceMap } : configCopy;
-        if (options?.format) {
-          switch (options.format) {
-            case "json":
-              return JSON.stringify(result, null, 2);
-            case "yaml":
-              return this.toYamlLike(result);
-            default:
-              return result;
-          }
-        }
-        return result;
-      }
-      toYamlLike(obj, indent = 0) {
-        const spaces = "  ".repeat(indent);
-        let result = "";
-        for (const [key2, value] of Object.entries(obj)) {
-          if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            result += `${spaces}${key2}:
-${this.toYamlLike(value, indent + 1)}`;
-          } else if (Array.isArray(value)) {
-            result += `${spaces}${key2}:
-`;
-            for (const _item of value) {
-              result += `${spaces}  - ${_item}
-`;
-            }
-          } else {
-            result += `${spaces}${key2}: ${value}
-`;
-          }
-        }
-        return result;
-      }
-      // Phase 2: Enhanced environment loading with comprehensive hierarchy
-      static fromEnvironment() {
-        const envConfig = {
-          priority: process.env["MARIA_PRIORITY"] || void 0,
-          provider: process.env["MARIA_PROVIDER"] || process.env["PROVIDER"] || void 0,
-          model: process.env["MARIA_MODEL"] || process.env["MODEL"] || void 0,
-          language: process.env["MARIA_LANGUAGE"] || process.env["LANGUAGE"] || void 0,
-          offlineMode: _ConfigManagerV2.parseBool(process.env["MARIA_OFFLINE_MODE"]),
-          apiKeys: {
-            OPENAI_API_KEY: process.env["OPENAI_API_KEY"] || void 0,
-            ANTHROPIC_API_KEY: process.env["ANTHROPIC_API_KEY"] || void 0,
-            GOOGLE_API_KEY: process.env["GOOGLE_AI_API_KEY"] || process.env["GOOGLE_API_KEY"] || process.env["GEMINI_API_KEY"] || void 0,
-            GROQ_API_KEY: process.env["GROQ_API_KEY"] || void 0,
-            GROK_API_KEY: process.env["GROK_API_KEY"] || process.env["XAI_API_KEY"] || void 0
-          },
-          localProviders: {
-            lmstudio: _ConfigManagerV2.parseBool(
-              process.env["LMSTUDIO_ENABLED"],
-              true
-            ),
-            ollama: _ConfigManagerV2.parseBool(process.env["OLLAMA_ENABLED"], true),
-            vllm: _ConfigManagerV2.parseBool(process.env["VLLM_ENABLED"], true)
-          },
-          autoStart: _ConfigManagerV2.parseBool(
-            process.env["AUTO_START_LLMS"],
-            true
-          ),
-          healthMonitoring: _ConfigManagerV2.parseBool(
-            process.env["HEALTH_MONITORING"],
-            true
-          ),
-          // Advanced environment settings
-          maxRetries: _ConfigManagerV2.parseNumber(process.env["MARIA_MAX_RETRIES"]),
-          timeout: _ConfigManagerV2.parseNumber(process.env["MARIA_TIMEOUT"]),
-          concurrentRequests: _ConfigManagerV2.parseNumber(
-            process.env["MARIA_CONCURRENT_REQUESTS"]
-          ),
-          cacheEnabled: _ConfigManagerV2.parseBool(
-            process.env["MARIA_CACHE_ENABLED"]
-          ),
-          logLevel: process.env["MARIA_LOG_LEVEL"] || process.env["LOG_LEVEL"] || void 0,
-          telemetryEnabled: _ConfigManagerV2.parseBool(
-            process.env["MARIA_TELEMETRY"],
-            true
-          )
-        };
-        const cleanedConfig = _ConfigManagerV2.removeUndefined(envConfig);
-        return new _ConfigManagerV2(cleanedConfig, "env");
-      }
-      // Configuration hierarchy: defaults < file < env < CLI
-      static async loadHierarchical(options = {}) {
-        try {
-          const manager = new _ConfigManagerV2({}, "defaults");
-          try {
-            const fileConfig = await _ConfigManagerV2.loadFromFile(
-              options.configPath
-            );
-            if (fileConfig) {
-              manager.mergeAndValidate(fileConfig, "file");
-            }
-          } catch (innerError) {
-            console.warn(
-              `Warning: Could not load config file - ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-          }
-          const envManager = _ConfigManagerV2.fromEnvironment();
-          manager.mergeAndValidate(envManager.config, "env");
-          if (options.cliOptions && Object.keys(options.cliOptions).length > 0) {
-            manager.mergeAndValidate(options.cliOptions, "cli");
-          }
-          return manager;
-        } catch (error2) {
-          throw new ConfigLoadError(
-            `Failed to load hierarchical configuration: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
-            error2 instanceof Error ? error2 : void 0
-          );
-        }
-      }
-      static removeUndefined(obj) {
-        const result = {};
-        for (const [key2, value] of Object.entries(obj)) {
-          if (value !== void 0) {
-            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-              const nested = _ConfigManagerV2.removeUndefined(value);
-              if (Object.keys(nested).length > 0) {
-                result[key2] = nested;
-              }
-            } else {
-              result[key2] = value;
-            }
-          }
-        }
-        return result;
-      }
-      static async loadFromFile(configPath) {
-        const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs7 = await importNodeBuiltin2("fs");
-        const _path = await importNodeBuiltin2("_path");
-        const os5 = await importNodeBuiltin2("os");
-        const targetPath = configPath || _path.join(os5.homedir(), ".maria", "config.json");
-        try {
-          const data2 = await fs7.promises.readFile(targetPath, "utf-8");
-          return JSON.parse(data2);
-        } catch (innerError) {
-          if (error?.code === "ENOENT") {
-            return null;
-          }
-          throw new ConfigLoadError(
-            `Failed to load config from ${targetPath}: ${error instanceof Error ? error.message : "Unknown error"}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      async save(configPath, options) {
-        const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs7 = await importNodeBuiltin2("fs");
-        const _path = await importNodeBuiltin2("_path");
-        const os5 = await importNodeBuiltin2("os");
-        const targetPath = configPath || _path.join(os5.homedir(), ".maria", "config.json");
-        try {
-          if (options?.backup) {
-            try {
-              await fs7.promises.access(targetPath);
-              const backupPath = `${targetPath}.backup.${Date.now()}`;
-              await fs7.promises.copyFile(targetPath, backupPath);
-            } catch {
-            }
-          }
-          await fs7.promises.mkdir(_path.dirname(targetPath), { recursive: true });
-          const dataToSave = this.getAll({
-            maskSensitive: options?.maskSensitive ?? true,
-            includeSourceMap: options?.includeSourceMap ?? false
-          });
-          await fs7.promises.writeFile(
-            targetPath,
-            JSON.stringify(dataToSave, null, 2),
-            { mode: 384 }
-          );
-          console.log(`\u2705 Configuration saved to ${targetPath}`);
-        } catch (error2) {
-          throw new ConfigLoadError(
-            `Failed to save configuration to ${targetPath}: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
-            error2 instanceof Error ? error2 : void 0
-          );
-        }
-      }
-      // Enhanced loading with automatic fallback chain
-      static async load(configPath) {
-        try {
-          return await _ConfigManagerV2.loadHierarchical({ configPath });
-        } catch (innerError) {
-          console.warn(
-            "Hierarchical config loading failed, falling back to environment:",
-            error
-          );
-          return _ConfigManagerV2.fromEnvironment();
-        }
-      }
-      // Export configuration in various formats
-      async export(format, outputPath) {
-        const config2 = this.getAll({ maskSensitive: false });
-        let content;
-        switch (format) {
-          case "json":
-            content = JSON.stringify(config2, null, 2);
-            break;
-          case "yaml":
-            content = this.toYamlLike(config2);
-            break;
-          case "env":
-            content = this.toEnvFormat(config2);
-            break;
-          default:
-            throw new Error(`Unsupported export format: ${format}`);
-        }
-        if (outputPath) {
-          const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-          const fs7 = await importNodeBuiltin2("fs");
-          const _path = await importNodeBuiltin2(
-            "_path"
-          );
-          await fs7.promises.mkdir(_path.dirname(outputPath), { recursive: true });
-          await fs7.promises.writeFile(outputPath, content, "utf-8");
-          console.log(`\u2705 Configuration exported to ${outputPath}`);
-        }
-        return content;
-      }
-      toEnvFormat(config2) {
-        const envVars = [];
-        const flatten = (obj, prefix = "") => {
-          for (const [key2, value] of Object.entries(obj)) {
-            const envKey = prefix ? `${prefix}_${key2.toUpperCase()}` : key2.toUpperCase();
-            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-              flatten(value, envKey);
-            } else if (Array.isArray(value)) {
-              envVars.push(`${envKey}=${value.join(",")}`);
-            } else {
-              envVars.push(`${envKey}=${value}`);
-            }
-          }
-        };
-        flatten(config2, "MARIA");
-        return envVars.join("\n");
-      }
-      // Configuration diff and merge preview
-      previewMerge(newConfig) {
-        const changes = [];
-        const warnings = [];
-        try {
-          const mergedConfig = deepMerge(this.config, newConfig);
-          const compareObjects = (current, updated, _path = "") => {
-            const allKeys = /* @__PURE__ */ new Set([
-              ...Object.keys(current || object),
-              ...Object.keys(updated || object)
-            ]);
-            for (const key2 of allKeys) {
-              const fieldPath = _path ? `${_path}.${key2}` : key2;
-              const currentValue = current?.[key2];
-              const updatedValue = updated?.[key2];
-              if (currentValue === void 0 && updatedValue !== void 0) {
-                changes.push({
-                  field: fieldPath,
-                  current: void 0,
-                  new: updatedValue,
-                  action: "add"
-                });
-              } else if (currentValue !== void 0 && updatedValue === void 0) {
-                changes.push({
-                  field: fieldPath,
-                  current: currentValue,
-                  new: void 0,
-                  action: "remove"
-                });
-              } else if (JSON.stringify(currentValue) !== JSON.stringify(updatedValue)) {
-                if (typeof currentValue === "object" && typeof updatedValue === "object") {
-                  compareObjects(currentValue, updatedValue, fieldPath);
-                } else {
-                  changes.push({
-                    field: fieldPath,
-                    current: currentValue,
-                    new: updatedValue,
-                    action: "update"
-                  });
-                }
-              }
-            }
-          };
-          compareObjects(this.config, mergedConfig);
-          try {
-            this.validateAndTransform(mergedConfig);
-          } catch (error2) {
-            if (error2 instanceof ConfigValidationError) {
-              warnings.push(`Validation warning: ${error2.message}`);
+  try {
+    const { importNodeBuiltin: importNodeBuiltin2, safeDynamicImport: safeDynamicImport2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
+    const fs7 = await safeDynamicImport2("fs-extra").catch(
+      () => importNodeBuiltin2("fs")
+    );
+    const _path = await importNodeBuiltin2("_path");
+    const _envPath = _path.join(process.cwd(), ".env.local");
+    if (await fs7.pathExists(_envPath)) {
+      const _envContent = await fs7.readFile(_envPath, "utf-8");
+      console.log("Loading environment from:", _envPath);
+      environmentLoaded = true;
+      const _lines = _envContent.split("\n");
+      for (const line of _lines) {
+        const _trimmed = line.trim();
+        if (_trimmed && !_trimmed.startsWith("#")) {
+          const _equalIndex = _trimmed.indexOf("=");
+          if (_equalIndex > 0) {
+            const _key = _trimmed.substring(0, _equalIndex).trim();
+            const _value = _trimmed.substring(_equalIndex + 1).trim();
+            if (_key && _value && !process.env[_key]) {
+              const _cleanValue = _value.replace(/^["']|["']$/g, "");
+              process.env[_key] = _cleanValue;
             }
           }
-        } catch (innerError) {
-          warnings.push(
-            `Merge preview failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
         }
-        return { changes, warnings };
       }
-    };
+    }
+  } catch (_error) {
+  }
+}
+var environmentLoaded;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    environmentLoaded = false;
+  }
+});
+
+// src/config/models.ts
+var init_models = __esm({
+  "src/config/models.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/index.ts
+var init_config2 = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_models();
   }
 });
 
@@ -12218,8 +11462,8 @@ var init_SessionStateMachine = __esm({
         this.controller = void 0;
         return this.to("Completed");
       }
-      fail(error2) {
-        this._ctx.meta = { ...this._ctx.meta || {}, error: error2 };
+      fail(error) {
+        this._ctx.meta = { ...this._ctx.meta || {}, error };
         this.inflight = false;
         this.clearDeadline();
         this.controller = void 0;
@@ -12253,32 +11497,32 @@ var init_SessionStateMachine = __esm({
 });
 
 // src/services/interactive-session/types/errors.ts
-function isSessionError(error2) {
-  return error2 instanceof SessionError;
+function isSessionError(error) {
+  return error instanceof SessionError;
 }
-function isRecoverableError(error2) {
-  if (isSessionError(error2)) {
-    return error2.recoverable;
+function isRecoverableError(error) {
+  if (isSessionError(error)) {
+    return error.recoverable;
   }
   return false;
 }
-function toSessionError(error2) {
-  if (isSessionError(error2)) {
-    return error2;
+function toSessionError(error) {
+  if (isSessionError(error)) {
+    return error;
   }
-  if (error2 instanceof Error) {
-    if (error2.message.includes("cancel") || error2.message.includes("abort")) {
-      return new UserCancelError(error2.message);
+  if (error instanceof Error) {
+    if (error.message.includes("cancel") || error.message.includes("abort")) {
+      return new UserCancelError(error.message);
     }
-    if (error2.message.includes("timeout") || error2.message.includes("deadline")) {
-      return new DeadlineError(error2.message, 15e3);
+    if (error.message.includes("timeout") || error.message.includes("deadline")) {
+      return new DeadlineError(error.message, 15e3);
     }
-    if (error2.message.includes("network") || error2.message.includes("fetch")) {
-      return new NetworkError(error2.message);
+    if (error.message.includes("network") || error.message.includes("fetch")) {
+      return new NetworkError(error.message);
     }
-    return new InternalError(error2.message, error2);
+    return new InternalError(error.message, error);
   }
-  return new InternalError(String(error2), error2);
+  return new InternalError(String(error), error);
 }
 var SessionError, UserCancelError, DeadlineError, InternalError, NetworkError;
 var init_errors = __esm({
@@ -12356,8 +11600,8 @@ var init_SessionManager = __esm({
         while (this.running) {
           try {
             await this.runTurn();
-          } catch (error2) {
-            const sessionError = toSessionError(error2);
+          } catch (error) {
+            const sessionError = toSessionError(error);
             this.display.error(`Session error: ${sessionError.message}`);
             if (!isRecoverableError(sessionError)) {
               this.display.error("Fatal error, ending session");
@@ -12444,12 +11688,12 @@ var init_SessionManager = __esm({
             );
           }
           this.fsm.send({ type: "STREAM_DONE" });
-        } catch (error2) {
+        } catch (error) {
           if (this.currentSpinnerId) {
             this.display.stopSpinner(this.currentSpinnerId);
             this.currentSpinnerId = void 0;
           }
-          const sessionError = toSessionError(error2);
+          const sessionError = toSessionError(error);
           metric.errorCode = sessionError.code;
           if (sessionError instanceof DeadlineError) {
             metric.deadline = true;
@@ -12478,11 +11722,11 @@ var init_SessionManager = __esm({
             return null;
           }
           return input4.trim();
-        } catch (error2) {
+        } catch (error) {
           if (this.fsm.signal?.aborted) {
             throw new DeadlineError("Input timeout", this.options.deadlineMs);
           }
-          throw error2;
+          throw error;
         }
       }
       /**
@@ -12763,9 +12007,9 @@ var init_ChalkAdapter = __esm({
             if (signal?.aborted) break;
             process.stdout.write(chunk);
           }
-        } catch (error2) {
+        } catch (error) {
           if (!signal?.aborted) {
-            throw error2;
+            throw error;
           }
         } finally {
           process.stdout.write("\n");
@@ -14934,8 +14178,8 @@ var init_SlashCommandHandler = __esm({
             return await this.executeWithTimeout(command, context2, options.timeout);
           }
           return await command.execute(context2);
-        } catch (error2) {
-          if (error2 instanceof Error && error2.name === "AbortError") {
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
             return {
               success: false,
               error: "Command execution timed out",
@@ -14944,7 +14188,7 @@ var init_SlashCommandHandler = __esm({
           }
           return {
             success: false,
-            error: error2 instanceof Error ? error2.message : "Unknown error",
+            error: error instanceof Error ? error.message : "Unknown error",
             messages: []
           };
         }
@@ -14963,9 +14207,9 @@ var init_SlashCommandHandler = __esm({
           const result = await command.execute(contextWithSignal);
           clearTimeout(timeoutId);
           return result;
-        } catch (error2) {
+        } catch (error) {
           clearTimeout(timeoutId);
-          throw error2;
+          throw error;
         }
       }
       /**
@@ -15206,10 +14450,10 @@ var init_MemoryService = __esm({
             }
           });
           this.warmupInBackground();
-        } catch (error2) {
+        } catch (error) {
           this._initialized = false;
           this._initializationPromise = null;
-          throw new Error(`Memory system initialization failed: ${error2}`);
+          throw new Error(`Memory system initialization failed: ${error}`);
         }
       }
       /**
@@ -15221,8 +14465,8 @@ var init_MemoryService = __esm({
           try {
             this._engine?.loadInitialContext();
             this._engine?.preloadCache();
-          } catch (error2) {
-            console.warn("Memory warmup warning:", error2);
+          } catch (error) {
+            console.warn("Memory warmup warning:", error);
           }
         });
       }
@@ -15344,60 +14588,60 @@ var init_MemoryService = __esm({
 });
 
 // src/services/interactive-session/services/ConfigService.ts
-var fs2, path2, import_zod2, SessionConfigSchema, ConfigService;
+var fs2, path2, import_zod, SessionConfigSchema, ConfigService;
 var init_ConfigService = __esm({
   "src/services/interactive-session/services/ConfigService.ts"() {
     "use strict";
     fs2 = __toESM(require("fs/promises"), 1);
     path2 = __toESM(require("path"), 1);
-    import_zod2 = require("zod");
-    SessionConfigSchema = import_zod2.z.object({
-      ui: import_zod2.z.object({
-        theme: import_zod2.z.enum(["default", "dark", "light", "solarized"]).default("default"),
-        colors: import_zod2.z.object({
-          primary: import_zod2.z.string().default("#00A8E8"),
-          success: import_zod2.z.string().default("#00C851"),
-          warning: import_zod2.z.string().default("#FFB300"),
-          error: import_zod2.z.string().default("#FF3547"),
-          info: import_zod2.z.string().default("#33B5E5")
+    import_zod = require("zod");
+    SessionConfigSchema = import_zod.z.object({
+      ui: import_zod.z.object({
+        theme: import_zod.z.enum(["default", "dark", "light", "solarized"]).default("default"),
+        colors: import_zod.z.object({
+          primary: import_zod.z.string().default("#00A8E8"),
+          success: import_zod.z.string().default("#00C851"),
+          warning: import_zod.z.string().default("#FFB300"),
+          error: import_zod.z.string().default("#FF3547"),
+          info: import_zod.z.string().default("#33B5E5")
         }).default({}),
-        spinner: import_zod2.z.object({
-          style: import_zod2.z.enum(["dots", "line", "star", "square"]).default("dots"),
-          color: import_zod2.z.string().default("cyan")
+        spinner: import_zod.z.object({
+          style: import_zod.z.enum(["dots", "line", "star", "square"]).default("dots"),
+          color: import_zod.z.string().default("cyan")
         }).default({}),
-        showTimestamps: import_zod2.z.boolean().default(false),
-        showDebugInfo: import_zod2.z.boolean().default(false)
+        showTimestamps: import_zod.z.boolean().default(false),
+        showDebugInfo: import_zod.z.boolean().default(false)
       }).default({}),
-      behavior: import_zod2.z.object({
-        autoApproval: import_zod2.z.boolean().default(false),
-        confirmBeforeExit: import_zod2.z.boolean().default(true),
-        historySize: import_zod2.z.number().min(0).max(1e4).default(1e3),
-        commandTimeout: import_zod2.z.number().min(0).default(3e4),
+      behavior: import_zod.z.object({
+        autoApproval: import_zod.z.boolean().default(false),
+        confirmBeforeExit: import_zod.z.boolean().default(true),
+        historySize: import_zod.z.number().min(0).max(1e4).default(1e3),
+        commandTimeout: import_zod.z.number().min(0).default(3e4),
         // 30秒
-        retryAttempts: import_zod2.z.number().min(0).max(10).default(3),
-        streamingEnabled: import_zod2.z.boolean().default(true)
+        retryAttempts: import_zod.z.number().min(0).max(10).default(3),
+        streamingEnabled: import_zod.z.boolean().default(true)
       }).default({}),
-      memory: import_zod2.z.object({
-        enablePersistence: import_zod2.z.boolean().default(false),
-        maxMemoryUsage: import_zod2.z.number().min(0).default(512),
+      memory: import_zod.z.object({
+        enablePersistence: import_zod.z.boolean().default(false),
+        maxMemoryUsage: import_zod.z.number().min(0).default(512),
         // MB
-        cacheSize: import_zod2.z.number().min(0).default(100),
+        cacheSize: import_zod.z.number().min(0).default(100),
         // MB
-        gcInterval: import_zod2.z.number().min(0).default(3e5)
+        gcInterval: import_zod.z.number().min(0).default(3e5)
         // 5分
       }).default({}),
-      shortcuts: import_zod2.z.record(import_zod2.z.string()).default({
+      shortcuts: import_zod.z.record(import_zod.z.string()).default({
         clear: "cls",
         quit: "exit",
         h: "help",
         s: "status",
         m: "models"
       }),
-      advanced: import_zod2.z.object({
-        debugMode: import_zod2.z.boolean().default(false),
-        verboseLogging: import_zod2.z.boolean().default(false),
-        experimentalFeatures: import_zod2.z.boolean().default(false),
-        telemetryEnabled: import_zod2.z.boolean().default(false)
+      advanced: import_zod.z.object({
+        debugMode: import_zod.z.boolean().default(false),
+        verboseLogging: import_zod.z.boolean().default(false),
+        experimentalFeatures: import_zod.z.boolean().default(false),
+        telemetryEnabled: import_zod.z.boolean().default(false)
       }).default({})
     });
     ConfigService = class {
@@ -15435,7 +14679,7 @@ var init_ConfigService = __esm({
         try {
           const configFile = await fs2.readFile(this._configPath, "utf-8");
           return JSON.parse(configFile);
-        } catch (error2) {
+        } catch (error) {
           return {};
         }
       }
@@ -15446,7 +14690,7 @@ var init_ConfigService = __esm({
         try {
           const configFile = await fs2.readFile(this._userConfigPath, "utf-8");
           return JSON.parse(configFile);
-        } catch (error2) {
+        } catch (error) {
           return {};
         }
       }
@@ -15471,11 +14715,11 @@ var init_ConfigService = __esm({
       validateConfig() {
         try {
           SessionConfigSchema.parse(this._config);
-        } catch (error2) {
-          if (error2 instanceof import_zod2.z.ZodError) {
-            throw new Error(`Configuration validation failed: ${error2.message}`);
+        } catch (error) {
+          if (error instanceof import_zod.z.ZodError) {
+            throw new Error(`Configuration validation failed: ${error.message}`);
           }
-          throw error2;
+          throw error;
         }
       }
       /**
@@ -15554,8 +14798,8 @@ var init_ConfigService = __esm({
             "utf-8"
           );
           this._isDirty = false;
-        } catch (error2) {
-          throw new Error(`Failed to save configuration: ${error2}`);
+        } catch (error) {
+          throw new Error(`Failed to save configuration: ${error}`);
         }
       }
       /**
@@ -15566,8 +14810,8 @@ var init_ConfigService = __esm({
           clearTimeout(this._saveDebounceTimer);
         }
         this._saveDebounceTimer = setTimeout(() => {
-          this.save().catch((error2) => {
-            console.error("Auto-save failed:", error2);
+          this.save().catch((error) => {
+            console.error("Auto-save failed:", error);
           });
         }, 5e3);
       }
@@ -15822,8 +15066,8 @@ var init_RouterService = __esm({
             ),
             metadata: analysis2.metadata
           };
-        } catch (error2) {
-          console.warn("Intelligent routing failed:", error2);
+        } catch (error) {
+          console.warn("Intelligent routing failed:", error);
           return {
             type: "conversation",
             confidence: 0.3
@@ -16046,11 +15290,11 @@ var init_RouterService = __esm({
 });
 
 // src/services/interactive-session/services/ValidationService.ts
-var import_zod3, ValidationService;
+var import_zod2, ValidationService;
 var init_ValidationService = __esm({
   "src/services/interactive-session/services/ValidationService.ts"() {
     "use strict";
-    import_zod3 = require("zod");
+    import_zod2 = require("zod");
     ValidationService = class {
       _config;
       _customRules = /* @__PURE__ */ new Map();
@@ -16082,23 +15326,23 @@ var init_ValidationService = __esm({
       initializeSchemas() {
         this._schemas.set(
           "command",
-          import_zod3.z.object({
-            name: import_zod3.z.string().min(1).max(50),
-            args: import_zod3.z.array(import_zod3.z.string()).max(this._config.maxCommandArgs),
-            flags: import_zod3.z.record(import_zod3.z.string()).optional()
+          import_zod2.z.object({
+            name: import_zod2.z.string().min(1).max(50),
+            args: import_zod2.z.array(import_zod2.z.string()).max(this._config.maxCommandArgs),
+            flags: import_zod2.z.record(import_zod2.z.string()).optional()
           })
         );
         this._schemas.set(
           "filePath",
-          import_zod3.z.string().min(1).max(this._config.maxFilePathLength).refine((path7) => !this.containsPathTraversal(path7), {
+          import_zod2.z.string().min(1).max(this._config.maxFilePathLength).refine((path7) => !this.containsPathTraversal(path7), {
             message: "Path traversal detected"
           })
         );
-        this._schemas.set("url", import_zod3.z.string().url());
-        this._schemas.set("email", import_zod3.z.string().email());
+        this._schemas.set("url", import_zod2.z.string().url());
+        this._schemas.set("email", import_zod2.z.string().email());
         this._schemas.set(
           "configValue",
-          import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.record(import_zod3.z.any())])
+          import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean(), import_zod2.z.record(import_zod2.z.any())])
         );
       }
       /**
@@ -16201,11 +15445,11 @@ var init_ValidationService = __esm({
             valid: true,
             value: result
           };
-        } catch (error2) {
-          if (error2 instanceof import_zod3.z.ZodError) {
+        } catch (error) {
+          if (error instanceof import_zod2.z.ZodError) {
             return {
               valid: false,
-              errors: error2.errors.map((e2) => ({
+              errors: error.errors.map((e2) => ({
                 field: e2.path.join("."),
                 message: e2.message,
                 code: e2.code,
@@ -16250,11 +15494,11 @@ var init_ValidationService = __esm({
             valid: true,
             value: result
           };
-        } catch (error2) {
-          if (error2 instanceof import_zod3.z.ZodError) {
+        } catch (error) {
+          if (error instanceof import_zod2.z.ZodError) {
             return {
               valid: false,
-              errors: error2.errors.map((e2) => ({
+              errors: error.errors.map((e2) => ({
                 field: "path",
                 message: e2.message,
                 code: e2.code,
@@ -16301,7 +15545,7 @@ var init_ValidationService = __esm({
             valid: true,
             value: result
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             valid: false,
             errors: [
@@ -16326,7 +15570,7 @@ var init_ValidationService = __esm({
             valid: true,
             value: result
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             valid: false,
             errors: [
@@ -19164,9 +18408,9 @@ var init_CommandRegistry = __esm({
             });
             clearTimeout(timer);
             return result;
-          } catch (error2) {
+          } catch (error) {
             clearTimeout(timer);
-            throw error2;
+            throw error;
           }
         }
         return registration.handler.execute(context2);
@@ -19405,9 +18649,9 @@ var init_SpinnerManager = __esm({
           const result = await fn();
           this.stop(spinnerId, "success");
           return result;
-        } catch (error2) {
+        } catch (error) {
           this.stop(spinnerId, "fail");
-          throw error2;
+          throw error;
         }
       }
       /**
@@ -19799,9 +19043,9 @@ var init_DisplayManager = __esm({
         process.on("exit", cleanup);
         process.on("SIGINT", cleanup);
         process.on("SIGTERM", cleanup);
-        process.on("uncaughtException", (error2) => {
+        process.on("uncaughtException", (error) => {
           cleanup();
-          console.error("Uncaught exception:", error2);
+          console.error("Uncaught exception:", error);
           process.exit(1);
         });
       }
@@ -20349,10 +19593,10 @@ export { generated };`;
             requiresInput: false
             // Important: prevent re-dispatch
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             ok: false,
-            message: import_chalk11.default.red(`Code generation failed: ${error2}`)
+            message: import_chalk11.default.red(`Code generation failed: ${error}`)
           };
         }
       }
@@ -21079,9 +20323,9 @@ var init_SessionOrchestrator = __esm({
           await this.setupCommandRegistry();
           await this.initializeSessionManager();
           this._initialized = true;
-        } catch (error2) {
+        } catch (error) {
           await this.cleanup();
-          throw new Error(`SessionOrchestrator initialization failed: ${error2}`);
+          throw new Error(`SessionOrchestrator initialization failed: ${error}`);
         }
       }
       /**
@@ -21225,9 +20469,9 @@ var init_SessionOrchestrator = __esm({
           if (this._sessionManager) {
             await this._sessionManager.start();
           }
-        } catch (error2) {
+        } catch (error) {
           this._running = false;
-          throw error2;
+          throw error;
         }
       }
       /**
@@ -21244,8 +20488,8 @@ var init_SessionOrchestrator = __esm({
           }
           await this.showGoodbye();
           await this.cleanup();
-        } catch (error2) {
-          console.error("Error during session stop:", error2);
+        } catch (error) {
+          console.error("Error during session stop:", error);
         }
       }
       /**
@@ -21429,10 +20673,10 @@ var init_interactive_session = __esm({
                 message: `Command ${command} is being migrated to the new system`
               };
           }
-        } catch (error2) {
+        } catch (error) {
           return {
             ok: false,
-            message: `Error executing command: ${error2}`
+            message: `Error executing command: ${error}`
           };
         }
       }
@@ -21516,7 +20760,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "3.6.1",
+      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",
@@ -21950,8 +21194,8 @@ var init_conversation_persistence = __esm({
         try {
           const configDir = path3.dirname(this.sessionFile);
           await import_fs2.promises.mkdir(configDir, { recursive: true });
-        } catch (error2) {
-          console.warn("Failed to create config directory:", error2);
+        } catch (error) {
+          console.warn("Failed to create config directory:", error);
         }
       }
       /**
@@ -21998,8 +21242,8 @@ var init_conversation_persistence = __esm({
             }
           };
           await import_fs2.promises.writeFile(this.sessionFile, JSON.stringify(session, null, 2));
-        } catch (error2) {
-          console.warn("Failed to save conversation history:", error2);
+        } catch (error) {
+          console.warn("Failed to save conversation history:", error);
         }
       }
       /**
@@ -22025,7 +21269,7 @@ var init_conversation_persistence = __esm({
             newestMessage: messages[messages.length - 1]?.timestamp,
             fileSize: stats.size
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             totalMessages: 0
           };
@@ -22228,10 +21472,10 @@ var init_chat_context_service = __esm({
           };
           await fs4.writeFile(sessionFile, JSON.stringify(sessionData, null, 2));
           this.emit("session-persisted", sessionFile);
-        } catch (error2) {
+        } catch (error) {
           this.emit(
             "persist-error",
-            error2 instanceof Error ? error2 : new Error(String(error2))
+            error instanceof Error ? error : new Error(String(error))
           );
         }
       }
@@ -22931,14 +22175,14 @@ var init_telemetry_collector = __esm({
       /**
        * Track errors
        */
-      trackError(error2, context2) {
+      trackError(error, context2) {
         this.addEvent({
           timestamp: Date.now(),
           eventType: "error_occurred",
           sessionId: this.sessionId,
           data: {
-            message: error2.message,
-            stack: error2.stack,
+            message: error.message,
+            stack: error.stack,
             ...context2
           }
         });
@@ -22965,8 +22209,8 @@ var init_telemetry_collector = __esm({
           } else {
             this.storeLocally(eventsToFlush);
           }
-        } catch (error2) {
-          console.error("[Telemetry] Failed to flush events:", error2);
+        } catch (error) {
+          console.error("[Telemetry] Failed to flush events:", error);
           this.events.unshift(...eventsToFlush);
         }
       }
@@ -23995,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);
       }
       /**
@@ -24013,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 (error2) {
-          try {
-            await this.legacyProviderFactory.initializeFromEnvironment();
-            this.initialized = true;
-          } catch (fallbackError) {
-          }
+        } catch (error) {
         }
       }
       /**
@@ -24035,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 (error2) {
-            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"}`);
         }
       }
       /**
@@ -24324,7 +23553,7 @@ I'm here to assist you effectively!`;
 });
 
 // src/shared/adapters/LegacySlashCommandAdapter.ts
-var LegacySlashCommandAdapter, SlashCommandHandler;
+var LegacySlashCommandAdapter, SlashCommandHandler2;
 var init_LegacySlashCommandAdapter = __esm({
   "src/shared/adapters/LegacySlashCommandAdapter.ts"() {
     "use strict";
@@ -24365,10 +23594,10 @@ var init_LegacySlashCommandAdapter = __esm({
             error: result.error,
             messages: result.messages || []
           };
-        } catch (error2) {
+        } catch (error) {
           return {
             success: false,
-            error: error2 instanceof Error ? error2.message : "Unknown error",
+            error: error instanceof Error ? error.message : "Unknown error",
             messages: []
           };
         }
@@ -24388,10 +23617,10 @@ var init_LegacySlashCommandAdapter = __esm({
                 success: true,
                 messages: [{ role: "assistant", content: result }]
               };
-            } catch (error2) {
+            } catch (error) {
               return {
                 success: false,
-                error: error2 instanceof Error ? error2.message : "Command execution failed",
+                error: error instanceof Error ? error.message : "Command execution failed",
                 messages: []
               };
             }
@@ -24406,7 +23635,7 @@ var init_LegacySlashCommandAdapter = __esm({
         return this.handler;
       }
     };
-    SlashCommandHandler = LegacySlashCommandAdapter;
+    SlashCommandHandler2 = LegacySlashCommandAdapter;
   }
 });
 
@@ -27309,7 +26538,7 @@ async function readConfig() {
   return _config;
 }
 var import_fs3, import_path2, import_toml, import_os, _CONFIG_FILE, _GLOBAL_CONFIG_PATH;
-var init_config2 = __esm({
+var init_config3 = __esm({
   "src/utils/config.ts"() {
     "use strict";
     import_fs3 = require("fs");
@@ -27336,7 +26565,7 @@ var init_code_generation_service = __esm({
     init_google_ai_provider();
     init_lmstudio_provider();
     init_default_provider();
-    init_config2();
+    init_config3();
     fs6 = __toESM(require("fs/promises"), 1);
     path6 = __toESM(require("path"), 1);
     logger2 = logger;
@@ -27984,7 +27213,7 @@ async function initializeServices() {
     conversationPersistence = new ConversationPersistence();
     chatContext = ChatContextService.getInstance();
     aiResponseService = new AIResponseService();
-    slashCommandHandler = SlashCommandHandler.getInstance();
+    slashCommandHandler = SlashCommandHandler2.getInstance();
     providerManager = new UnifiedAIProviderManager2();
     try {
       await providerManager.initialize();
@@ -28034,8 +27263,8 @@ async function initializeServices() {
       sessionMemory.push(msg);
     }
     return true;
-  } catch (error2) {
-    console.error(import_chalk15.default.red("\u274C Service initialization failed:"), error2);
+  } catch (error) {
+    console.error(import_chalk15.default.red("\u274C Service initialization failed:"), error);
     return false;
   }
 }
@@ -28156,10 +27385,10 @@ async function startInteractiveSession() {
             const errorMessage = result.message || result._message || "Command failed";
             console.log(import_chalk15.default.red(`\u274C ${errorMessage}`));
           }
-        } catch (error2) {
+        } catch (error) {
           console.error(
             import_chalk15.default.red("\u274C Command error:"),
-            error2?.message || error2
+            error?.message || error
           );
         }
       }
@@ -28245,10 +27474,10 @@ async function startInteractiveSession() {
               console.log();
               continue;
             }
-          } catch (error2) {
+          } catch (error) {
             console.error(
               import_chalk15.default.red("\u274C SlashCommand error:"),
-              error2?.message || error2
+              error?.message || error
             );
             console.log();
             continue;
@@ -28290,7 +27519,7 @@ async function startInteractiveSession() {
           if (conversationPersistence) {
             await conversationPersistence.addMessage(assistantMessage);
           }
-        } catch (error2) {
+        } catch (error) {
           console.log(
             import_chalk15.default.gray(
               "\u26A0\uFE0F  Persistent memory save failed, using session memory only"
@@ -28299,22 +27528,22 @@ async function startInteractiveSession() {
         }
       }
       console.log();
-    } catch (error2) {
-      if (error2?.code === "ABORT_ERR" || error2?.name === "AbortError") {
+    } catch (error) {
+      if (error?.code === "ABORT_ERR" || error?.name === "AbortError") {
         console.log(import_chalk15.default.cyan("\n\nGoodbye! \u{1F44B}"));
         await stopAll();
         return;
       }
       console.error(
         import_chalk15.default.red("\u274C An error occurred:"),
-        error2?.message || error2
+        error?.message || error
       );
     }
   }
 }
 function createCLI() {
   const program2 = new import_commander.Command();
-  program2.name("maria").description("\u{1F680} MARIA v3.0.0 - Intelligent AI Assistant").version(packageJson.version).option("--v3-session", "Use v3 session architecture").option("--no-interactive", "Disable interactive mode for CI/CD").action(async (options) => {
+  program2.name("maria").description(`\u{1F680} MARIA v${packageJson.version} - Intelligent AI Assistant`).version(packageJson.version).option("--v3-session", "Use v3 session architecture").option("--no-interactive", "Disable interactive mode for CI/CD").action(async (options) => {
     const { displayFinalStartupScreen: displayFinalStartupScreen2 } = await Promise.resolve().then(() => (init_startup_display(), startup_display_exports));
     displayFinalStartupScreen2();
     const useV3 = options.v3Session || process.env.MARIA_USE_V3_SESSION === "1";
@@ -28386,7 +27615,7 @@ var init_cli = __esm({
     init_ai_response_service();
     init_LegacySlashCommandAdapter();
     init_interactive_cli();
-    init_manager();
+    init_providers();
     init_env_loader();
     init_version();
     packageJson = { version: getVersion() };
@@ -28441,7 +27670,7 @@ var init_maria_ai = __esm({
     import_commander2 = require("commander");
     init_startup_display();
     init_provider_selector();
-    init_config_manager();
+    init_config2();
     init_IntelligentRouterService();
     init_interactive_session();
     init_package();
@@ -28451,7 +27680,7 @@ var init_maria_ai = __esm({
       router;
       session;
       constructor() {
-        this.config = new ConfigManagerV2();
+        this.config = new ConfigManager();
         this.providerSelector = new ProviderSelector(this.config);
       }
       async initialize() {
@@ -28478,8 +27707,8 @@ var init_maria_ai = __esm({
           );
           this.session = createInteractiveSession(this);
           await this.session.start();
-        } catch (error2) {
-          console.error(import_chalk16.default.red("\n\u274C Initialization failed:"), error2);
+        } catch (error) {
+          console.error(import_chalk16.default.red("\n\u274C Initialization failed:"), error);
           process.exit(1);
         }
       }
@@ -28528,52 +27757,16 @@ function checkNodeVersion() {
   }
 }
 
-// src/config/loader.ts
-var environmentLoaded = false;
-async function loadEnvironmentConfig() {
-  if (environmentLoaded) {
-    return;
-  }
-  try {
-    const { importNodeBuiltin: importNodeBuiltin2, safeDynamicImport: safeDynamicImport2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-    const fs7 = await safeDynamicImport2("fs-extra").catch(
-      () => importNodeBuiltin2("fs")
-    );
-    const _path = await importNodeBuiltin2("_path");
-    const _envPath = _path.join(process.cwd(), ".env.local");
-    if (await fs7.pathExists(_envPath)) {
-      const _envContent = await fs7.readFile(_envPath, "utf-8");
-      console.log("Loading environment from:", _envPath);
-      environmentLoaded = true;
-      const _lines = _envContent.split("\n");
-      for (const line of _lines) {
-        const _trimmed = line.trim();
-        if (_trimmed && !_trimmed.startsWith("#")) {
-          const _equalIndex = _trimmed.indexOf("=");
-          if (_equalIndex > 0) {
-            const _key = _trimmed.substring(0, _equalIndex).trim();
-            const _value = _trimmed.substring(_equalIndex + 1).trim();
-            if (_key && _value && !process.env[_key]) {
-              const _cleanValue = _value.replace(/^["']|["']$/g, "");
-              process.env[_key] = _cleanValue;
-            }
-          }
-        }
-      }
-    }
-  } catch (_error) {
-  }
-}
-
 // src/bin/maria.ts
+init_loader();
 async function main() {
   await loadEnvironmentConfig();
   checkNodeVersion();
   const program2 = createCLI2();
   program2.parse(process.argv);
 }
-process.on("uncaughtException", (error2) => {
-  console.error("\u274C Uncaught Exception:", error2.message);
+process.on("uncaughtException", (error) => {
+  console.error("\u274C Uncaught Exception:", error.message);
   process.exit(1);
 });
 process.on("unhandledRejection", (reason, promise) => {
@@ -28588,8 +27781,8 @@ process.on("SIGTERM", () => {
   console.log("\n\u{1F44B} Goodbye!");
   process.exit(0);
 });
-main().catch((error2) => {
-  console.error("\u274C Failed to start:", error2);
+main().catch((error) => {
+  console.error("\u274C Failed to start:", error);
   process.exit(1);
 });
 //# sourceMappingURL=maria.cjs.map