@alcyone-labs/arg-parser 2.10.2 → 2.11.0

package/dist/index.cjs

@@ -55,6 +55,7 @@ const RESET$1 = "\x1B[0m";
 const BOLD$1 = "\x1B[1m";
 const DIM$1 = "\x1B[2m";
 const UNDERLINE$1 = "\x1B[4m";
+const CLEAR$1 = "\x1B[2J\x1B[3J\x1B[H";
 const BLACK$1 = "\x1B[30m";
 const RED$1 = "\x1B[31m";
 const GREEN$1 = "\x1B[32m";
@@ -96,7 +97,7 @@ function addChalkProperty(fn, name, code, codes) {
   });
 }
 function createColorFunction(codes) {
-  const fn = (text) => colorize(text, ...codes);
+  const fn = ((text) => colorize(text, ...codes));
   addChalkProperty(fn, "bold", BOLD$1, codes);
   addChalkProperty(fn, "dim", DIM$1, codes);
   addChalkProperty(fn, "underline", UNDERLINE$1, codes);
@@ -111,6 +112,10 @@ function createColorFunction(codes) {
   addChalkProperty(fn, "gray", GRAY$1, codes);
   addChalkProperty(fn, "grey", GRAY$1, codes);
   addChalkProperty(fn, "blueBright", CYAN$1, codes);
+  Object.defineProperty(fn, "clear", {
+    get: () => colorEnabled$1 ? CLEAR$1 : "",
+    configurable: true
+  });
   return fn;
 }
 const simpleChalk = createColorFunction([]);
@@ -118,6 +123,7 @@ const RESET = "\x1B[0m";
 const BOLD = "\x1B[1m";
 const DIM = "\x1B[2m";
 const UNDERLINE = "\x1B[4m";
+const CLEAR = "\x1B[2J\x1B[3J\x1B[H";
 const BLACK = "\x1B[30m";
 const RED = "\x1B[31m";
 const GREEN = "\x1B[32m";
@@ -166,6 +172,16 @@ const simpleChalkFast = {
   bold: format$2(BOLD),
   dim: format$2(DIM),
   underline: format$2(UNDERLINE),
+  /**
+   * [NON-CHALK EXTENSION] Returns an ANSI escape sequence that clears the screen
+   * and the scrollback buffer (equivalent to CMD+K).
+   *
+   * @example
+   * ```javascript
+   * process.stdout.write(fast.clear);
+   * ```
+   */
+  clear: colorEnabled ? CLEAR : "",
   // Pre-created common combinations for some chaining support
   redBold: format$2(RED + BOLD),
   greenBold: format$2(GREEN + BOLD),
@@ -269,6 +285,28 @@ const simpleChalkBrowser = {
   bold: format$1("bold"),
   dim: format$1("dim"),
   underline: format$1("underline"),
+  /**
+   * [NON-CHALK EXTENSION] Clears the screen and scrollback buffer.
+   * In a browser environment, this calls console.clear().
+   * In a Node environment, it returns the ANSI clear/scrollback sequence.
+   *
+   * @example
+   * ```javascript
+   * // In browser: console.clear() will be called immediately
+   * // In node: will return ANSI string
+   * console.log(...browser.clear);
+   * ```
+   */
+  clear: (() => {
+    if (!supportsColor())
+      return "";
+    if (isBrowser) {
+      console.clear();
+      return "";
+    } else {
+      return "\x1B[2J\x1B[3J\x1B[H";
+    }
+  })(),
   // Browser-specific combinations (CSS can combine styles)
   redBold: (text) => {
     if (isBrowser) {
@@ -779,6 +817,30 @@ class ConfigurationManager {
     }
     return config;
   }
+  /**
+   * Discovers .env files in a specified directory
+   * Searches in priority order: .env.local, .env.dev/.env.test, .env
+   *
+   * @param searchDir - The directory to search for .env files
+   * @returns Path to found .env file, or null if none is found
+   */
+  discoverEnvFile(searchDir) {
+    const envFilesToCheck = [".env.local"];
+    const nodeEnv = process.env["NODE_ENV"]?.toLowerCase();
+    if (nodeEnv === "development" || nodeEnv === "dev") {
+      envFilesToCheck.push(".env.dev");
+    } else if (nodeEnv === "test") {
+      envFilesToCheck.push(".env.test");
+    }
+    envFilesToCheck.push(".env");
+    for (const envFile of envFilesToCheck) {
+      const envPath = path__namespace.join(searchDir, envFile);
+      if (fs__namespace.existsSync(envPath)) {
+        return envPath;
+      }
+    }
+    return null;
+  }
   /**
    * Parses JSON file content
    */
@@ -1412,6 +1474,22 @@ const _DxtPathResolver = class _DxtPathResolver {
 };
 _DxtPathResolver._cachedContext = null;
 let DxtPathResolver = _DxtPathResolver;
+const FlagInheritance = {
+  /**
+   * No flags are inherited from the parent.
+   */
+  NONE: "none",
+  /**
+   * Inherits flags only from the direct parent at the time of attachment (Snapshot behavior).
+   * Equivalent to `true` in legacy boolean config.
+   */
+  DirectParentOnly: "direct-parent-only",
+  /**
+   * Inherits flags from the entire parent chain, ensuring grandchildren receive root flags
+   * even in bottom-up construction scenarios.
+   */
+  AllParents: "all-parents"
+};
 const zodDxtOptionsSchema = zod.z.object({
   sensitive: zod.z.boolean().optional().describe(
     "Whether this field should be marked as sensitive in DXT user_config"
@@ -1517,6 +1595,9 @@ const zodFlagSchema = zod.z.object({
   ),
   dynamicRegister: zod.z.custom((val) => typeof val === "function").optional().describe(
     "Optional callback that can register additional flags dynamically when this flag is present."
+  ),
+  setWorkingDirectory: zod.z.boolean().optional().describe(
+    "If true, this flag's value becomes the effective working directory for file operations."
   )
 }).transform((obj) => {
   const newObj = { ...obj };
@@ -3083,6 +3164,7 @@ export default ${JSON.stringify(buildConfig, null, 2)};
     return null;
   }
 }
+const logger$5 = simpleMcpLogger.createMcpLogger("MCP Notifications");
 class McpNotificationsManager {
   constructor() {
     this.clients = /* @__PURE__ */ new Map();
@@ -3172,7 +3254,7 @@ class McpNotificationsManager {
       try {
         listener(event);
       } catch (error) {
-        console.error("Error in global change listener:", error);
+        logger$5.error("Error in global change listener:", error);
       }
     }
     for (const client of this.clients.values()) {
@@ -3240,7 +3322,7 @@ class McpNotificationsManager {
         );
       }
     } catch (error) {
-      console.error(
+      logger$5.error(
         `Error sending notification to client ${client.clientId}:`,
         error
       );
@@ -3274,6 +3356,7 @@ class McpNotificationsManager {
     this.changeHistory = [];
   }
 }
+const logger$4 = simpleMcpLogger.createMcpLogger("MCP Prompts");
 class McpPromptsManager {
   constructor() {
     this.prompts = /* @__PURE__ */ new Map();
@@ -3391,11 +3474,12 @@ class McpPromptsManager {
       try {
         listener();
       } catch (error) {
-        console.error("Error in prompt change listener:", error);
+        logger$4.error("Error in prompt change listener:", error);
       }
     }
   }
 }
+const logger$3 = simpleMcpLogger.createMcpLogger("MCP Resources");
 class ResourceTemplateParser {
   constructor(template) {
     const paramMatches = template.match(/\{([^}]+)\}/g) || [];
@@ -3545,7 +3629,7 @@ class McpResourcesManager {
       try {
         listener();
       } catch (error) {
-        console.error("Error in resource change listener:", error);
+        logger$3.error("Error in resource change listener:", error);
       }
     }
   }
@@ -3557,13 +3641,15 @@ const isDebugEnabled = () => {
     return false;
   }
 };
+const logger$2 = simpleMcpLogger.createMcpLogger("DEBUG");
 const debug = {
   /**
    * Log a debug message to stderr (only when DEBUG=true)
    */
   log: (...args) => {
     if (isDebugEnabled()) {
-      console.error("[DEBUG]", ...args);
+      const [msg, ...rest] = args;
+      logger$2.error(typeof msg === "string" ? msg : String(msg), ...rest);
     }
   },
   /**
@@ -3571,7 +3657,8 @@ const debug = {
    */
   error: (...args) => {
     if (isDebugEnabled()) {
-      console.error("[DEBUG ERROR]", ...args);
+      const [msg, ...rest] = args;
+      logger$2.error(typeof msg === "string" ? msg : String(msg), ...rest);
     }
   },
   /**
@@ -3579,7 +3666,8 @@ const debug = {
    */
   warn: (...args) => {
     if (isDebugEnabled()) {
-      console.error("[DEBUG WARN]", ...args);
+      const [msg, ...rest] = args;
+      logger$2.warn(typeof msg === "string" ? msg : String(msg), ...rest);
     }
   },
   /**
@@ -3587,7 +3675,8 @@ const debug = {
    */
   info: (...args) => {
     if (isDebugEnabled()) {
-      console.error("[DEBUG INFO]", ...args);
+      const [msg, ...rest] = args;
+      logger$2.info(typeof msg === "string" ? msg : String(msg), ...rest);
     }
   },
   /**
@@ -3595,7 +3684,8 @@ const debug = {
    */
   prefixed: (prefix, ...args) => {
     if (isDebugEnabled()) {
-      console.error(`[DEBUG ${prefix}]`, ...args);
+      const [msg, ...rest] = args;
+      logger$2.info(`[${prefix}] ${typeof msg === "string" ? msg : String(msg)}`, ...rest);
     }
   },
   /**
@@ -3727,12 +3817,21 @@ class ArgParserBase {
   #dxtGenerator;
   #configurationManager;
   #fuzzyMode = false;
+  #triggerAutoHelpIfNoHandler = false;
+  #logger;
   // Track dynamically added flags so we can clean them between parses
   #dynamicFlagNames = /* @__PURE__ */ new Set();
   // MCP-related managers
   #mcpResourcesManager = new McpResourcesManager();
   #mcpPromptsManager = new McpPromptsManager();
   #mcpNotificationsManager = new McpNotificationsManager();
+  // Working directory management
+  /** The effective working directory for this parser instance */
+  #effectiveWorkingDirectory = null;
+  /** The original root path from user's CLI invocation */
+  #rootPath = null;
+  /** Tracks if effective working directory has been resolved */
+  #workingDirectoryResolved = false;
   constructor(options = {}, initialFlags) {
     this.#appName = options.appName || "app";
     if (options.blankSpaceWidth && !isNaN(Number(options.blankSpaceWidth)) && Number(options.blankSpaceWidth) > 20)
@@ -3754,9 +3853,14 @@ class ArgParserBase {
     this.#handleErrors = options.handleErrors ?? true;
     this.#autoExit = options.autoExit ?? true;
     this.#inheritParentFlags = options.inheritParentFlags ?? false;
+    this.#triggerAutoHelpIfNoHandler = options.triggerAutoHelpIfNoHandler ?? false;
     this.#description = options.description;
     this.#handler = options.handler;
     this.#appCommandName = options.appCommandName;
+    this.#logger = options.logger || simpleMcpLogger.createMcpLogger({
+      prefix: this.#appName,
+      mcpMode: false
+    });
     const helpFlag = {
       name: "help",
       description: "Display this help message and exits",
@@ -3792,6 +3896,12 @@ class ArgParserBase {
   getAppCommandName() {
     return this.#appCommandName;
   }
+  /**
+   * Access to the logger
+   */
+  get logger() {
+    return this.#logger;
+  }
   getSubCommandName() {
     return this.#subCommandName;
   }
@@ -3958,7 +4068,9 @@ class ArgParserBase {
       subParser.#appCommandName = this.#appCommandName;
     }
     subParser.#autoExit = this.#autoExit;
-    if (subParser.#inheritParentFlags) {
+    subParser.#triggerAutoHelpIfNoHandler = this.#triggerAutoHelpIfNoHandler;
+    const shouldInherit = subParser.#inheritParentFlags === true || subParser.#inheritParentFlags === FlagInheritance.DirectParentOnly || subParser.#inheritParentFlags === FlagInheritance.AllParents;
+    if (shouldInherit) {
       const parentFlags = this.#flagManager.flags;
       for (const parentFlag of parentFlags) {
         if (!subParser.#flagManager.hasFlag(parentFlag["name"])) {
@@ -3967,11 +4079,38 @@ class ArgParserBase {
       }
     }
     this.#subCommands.set(subCommandConfig.name, subCommandConfig);
+    this.#propagateFlagsRecursive(subParser);
     if (subCommandConfig.handler) {
       subParser.setHandler(subCommandConfig.handler);
     }
     return this;
   }
+  /**
+   * Propagates available flags from the current parser to its subcommands,
+   * if those subcommands are configured to inherit recursively (AllParents).
+   */
+  #propagateFlagsRecursive(parser) {
+    for (const [_, subConfig] of parser.getSubCommands()) {
+      const childParser = subConfig.parser;
+      if (!(childParser instanceof ArgParserBase)) continue;
+      const isAllParents = childParser.#inheritParentFlags === FlagInheritance.AllParents;
+      if (isAllParents) {
+        const parentFlags = parser.#flagManager.flags;
+        let flagsAdded = false;
+        for (const parentFlag of parentFlags) {
+          if (!childParser.#flagManager.hasFlag(parentFlag["name"])) {
+            childParser.#flagManager._setProcessedFlagForInheritance(
+              parentFlag
+            );
+            flagsAdded = true;
+          }
+        }
+        if (flagsAdded) {
+          this.#propagateFlagsRecursive(childParser);
+        }
+      }
+    }
+  }
   /**
    * Sets the handler function for this specific parser instance.
    * This handler will be executed if this parser is the final one
@@ -3995,7 +4134,7 @@ class ArgParserBase {
           const outputObject = this.#_buildRecursiveJson(this);
           const jsonString = JSON.stringify(outputObject, null, 2);
           fs__namespace.writeFileSync(filePath, jsonString);
-          console.log(`ArgParser configuration JSON dumped to: ${filePath}`);
+          this.#logger.info(`ArgParser configuration JSON dumped to: ${filePath}`);
         } else {
           const outputString = this.#_buildRecursiveString(this, 0);
           const plainText = outputString.replace(
@@ -4003,18 +4142,18 @@ class ArgParserBase {
             ""
           );
           fs__namespace.writeFileSync(filePath, plainText);
-          console.log(`ArgParser configuration text dumped to: ${filePath}`);
+          this.#logger.info(`ArgParser configuration text dumped to: ${filePath}`);
         }
       } catch (error) {
-        console.error(
+        this.#logger.error(
           `Error writing ArgParser configuration to file '${filePath}':`,
           error
         );
       }
     } else {
-      console.log("\n--- ArgParser Configuration Dump ---");
+      this.#logger.info("\n--- ArgParser Configuration Dump ---");
       this.#_printRecursiveToConsole(this, 0);
-      console.log("--- End Configuration Dump ---\\n");
+      this.#logger.info("--- End Configuration Dump ---\\n");
     }
   }
   #_identifyCommandChainAndParsers(argsToParse, currentParser, commandChainSoFar, parserChainSoFar) {
@@ -4053,10 +4192,85 @@ class ArgParserBase {
       nextParserChain
     );
   }
+  #_resolveWorkingDirectory(processArgs, parserChain) {
+    if (!this.#rootPath) {
+      this.#rootPath = process.cwd();
+    }
+    let foundCwd = null;
+    for (let i = parserChain.length - 1; i >= 0; i--) {
+      const parser = parserChain[i];
+      const chdirFlags = parser.#flagManager.flags.filter(
+        (flag) => flag["setWorkingDirectory"]
+      );
+      for (const flag of chdirFlags) {
+        for (const option of flag["options"]) {
+          const flagIndex = processArgs.indexOf(option);
+          if (flagIndex !== -1 && flagIndex + 1 < processArgs.length) {
+            const value = processArgs[flagIndex + 1];
+            if (!value || value.startsWith("-")) continue;
+            const resolvedPath = path__namespace.resolve(
+              this.#effectiveWorkingDirectory || this.#rootPath,
+              value
+            );
+            if (!fs__namespace.existsSync(resolvedPath)) {
+              console.warn(
+                simpleChalk.yellow(
+                  `Warning: Working directory '${resolvedPath}' specified by ${option} does not exist. Using current directory instead.`
+                )
+              );
+              continue;
+            }
+            if (!fs__namespace.statSync(resolvedPath).isDirectory()) {
+              console.warn(
+                simpleChalk.yellow(
+                  `Warning: Path '${resolvedPath}' specified by ${option} is not a directory. Using current directory instead.`
+                )
+              );
+              continue;
+            }
+            foundCwd = resolvedPath;
+            process.chdir(resolvedPath);
+            const allChdirIndices = [];
+            for (let j = 0; j < processArgs.length; j++) {
+              for (const p of parserChain) {
+                for (const f of p.#flagManager.flags) {
+                  if (f["setWorkingDirectory"] && f["options"].includes(processArgs[j])) {
+                    allChdirIndices.push({ index: j, flag: processArgs[j] });
+                  }
+                }
+              }
+            }
+            if (allChdirIndices.length > 1) {
+              this.#logger.warn(
+                simpleChalk.yellow(
+                  `Warning: Multiple working directory flags detected. Using '${option}' (last one in command chain).`
+                )
+              );
+            }
+            break;
+          }
+        }
+        if (foundCwd) break;
+      }
+      if (foundCwd) break;
+    }
+    return {
+      effectiveCwd: foundCwd || this.#rootPath,
+      rootPath: this.#rootPath
+    };
+  }
   async #_handleGlobalChecks(processArgs, options) {
+    const { finalParser: parserChainParser } = this.#_identifyCommandChainAndParsers(processArgs, this, [], [this]);
+    const { effectiveCwd, rootPath } = this.#_resolveWorkingDirectory(
+      processArgs,
+      parserChainParser ? [this, parserChainParser] : [this]
+    );
+    this.#effectiveWorkingDirectory = effectiveCwd;
+    this.#rootPath = rootPath;
+    this.#workingDirectoryResolved = true;
     const isRootCliParser = !this.#parentParser && !!this.#appCommandName;
     if (processArgs.length === 0 && isRootCliParser && !this.#handler && !options?.skipHelpHandling) {
-      console.log(this.helpText());
+      this.#logger.info(this.helpText());
       return this._handleExit(0, "Help displayed", "help");
     }
     if (processArgs.includes("--s-debug-print")) {
@@ -4070,66 +4284,101 @@ class ArgParserBase {
     }
     const withEnvIndex = processArgs.findIndex((arg) => arg === "--s-with-env");
     if (withEnvIndex !== -1) {
-      if (withEnvIndex + 1 >= processArgs.length) {
-        console.error(
-          simpleChalk.red("Error: --s-with-env requires a file path argument")
-        );
-        return this._handleExit(
-          1,
-          "--s-with-env requires a file path argument",
-          "error"
-        );
+      let envFilePath = null;
+      let shouldAutoDiscover;
+      shouldAutoDiscover = this.#workingDirectoryResolved && this.#effectiveWorkingDirectory !== this.#rootPath && withEnvIndex + 1 >= processArgs.length;
+      if (withEnvIndex + 1 < processArgs.length) {
+        const providedPath = processArgs[withEnvIndex + 1];
+        if (providedPath && !providedPath.startsWith("-")) {
+          const basePath = this.#effectiveWorkingDirectory || process.cwd();
+          envFilePath = path__namespace.resolve(basePath, providedPath);
+        } else {
+          const basePath = this.#effectiveWorkingDirectory || process.cwd();
+          envFilePath = this.#configurationManager.discoverEnvFile(basePath);
+          if (!envFilePath) {
+            this.#logger.warn(
+              simpleChalk.yellow(
+                "Warning: No .env file found in working directory. Continuing without environment configuration."
+              )
+            );
+            processArgs.splice(withEnvIndex, 1);
+          }
+        }
       }
-      const filePath = processArgs[withEnvIndex + 1];
-      if (!filePath || filePath.startsWith("-")) {
-        console.error(
-          simpleChalk.red("Error: --s-with-env requires a file path argument")
-        );
-        return this._handleExit(
-          1,
-          "--s-with-env requires a file path argument",
-          "error"
-        );
+      if (shouldAutoDiscover) {
+        const basePath = this.#effectiveWorkingDirectory || process.cwd();
+        envFilePath = this.#configurationManager.discoverEnvFile(basePath);
+        if (envFilePath) {
+          this.#logger.info(simpleChalk.dim(`Auto-discovered env file: ${envFilePath}`));
+        } else {
+          this.#logger.warn(
+            simpleChalk.yellow(
+              "Warning: No .env file found in working directory. Continuing without environment configuration."
+            )
+          );
+          processArgs.splice(withEnvIndex, 1);
+        }
       }
-      try {
-        const {
-          finalParser: identifiedFinalParser2,
-          parserChain: identifiedParserChain
-        } = this.#_identifyCommandChainAndParsers(
-          processArgs,
-          this,
-          [],
-          [this]
-        );
-        const envConfigArgs = identifiedFinalParser2.#configurationManager.loadEnvFile(
-          filePath,
-          identifiedParserChain
-        );
-        if (envConfigArgs) {
-          const mergedArgs = identifiedFinalParser2.#configurationManager.mergeEnvConfigWithArgs(
-            envConfigArgs,
-            processArgs
+      if (envFilePath) {
+        try {
+          const {
+            finalParser: identifiedFinalParser2,
+            parserChain: identifiedParserChain
+          } = this.#_identifyCommandChainAndParsers(
+            processArgs,
+            this,
+            [],
+            [this]
+          );
+          const envConfigArgs = identifiedFinalParser2.#configurationManager.loadEnvFile(
+            envFilePath,
+            identifiedParserChain
+          );
+          if (envConfigArgs) {
+            const mergedArgs = identifiedFinalParser2.#configurationManager.mergeEnvConfigWithArgs(
+              envConfigArgs,
+              processArgs
+            );
+            processArgs.length = 0;
+            processArgs.push(...mergedArgs);
+          }
+          const finalWithEnvIndex = processArgs.findIndex(
+            (arg) => arg === "--s-with-env"
+          );
+          if (finalWithEnvIndex !== -1) {
+            if (finalWithEnvIndex + 1 < processArgs.length && !processArgs[finalWithEnvIndex + 1].startsWith("-")) {
+              processArgs.splice(finalWithEnvIndex, 2);
+            } else {
+              processArgs.splice(finalWithEnvIndex, 1);
+            }
+          }
+        } catch (error) {
+          console.error(
+            simpleChalk.red(
+              `Error loading environment file: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+          return this._handleExit(
+            1,
+            `Error loading environment file: ${error instanceof Error ? error.message : String(error)}`,
+            "error"
           );
-          processArgs.length = 0;
-          processArgs.push(...mergedArgs);
         }
-        const finalWithEnvIndex = processArgs.findIndex(
-          (arg) => arg === "--s-with-env"
-        );
-        if (finalWithEnvIndex !== -1) {
-          processArgs.splice(finalWithEnvIndex, 2);
+      }
+      shouldAutoDiscover = this.#workingDirectoryResolved && this.#effectiveWorkingDirectory !== this.#rootPath && withEnvIndex + 1 >= processArgs.length;
+      if (shouldAutoDiscover) {
+        const basePath = this.#effectiveWorkingDirectory || process.cwd();
+        envFilePath = this.#configurationManager.discoverEnvFile(basePath);
+        if (envFilePath) {
+          console.warn(`Auto-discovered env file: ${envFilePath}`);
+        } else {
+          console.warn(
+            "Warning: No .env file found in working directory. Continuing without environment configuration."
+          );
+        }
+        if (!envFilePath) {
+          processArgs.splice(withEnvIndex, 1);
         }
-      } catch (error) {
-        console.error(
-          simpleChalk.red(
-            `Error loading environment file: ${error instanceof Error ? error.message : String(error)}`
-          )
-        );
-        return this._handleExit(
-          1,
-          `Error loading environment file: ${error instanceof Error ? error.message : String(error)}`,
-          "error"
-        );
       }
     }
     const { finalParser: identifiedFinalParser } = this.#_identifyCommandChainAndParsers(processArgs, this, [], [this]);
@@ -4205,7 +4454,9 @@ class ArgParserBase {
           });
           break;
         }
-        currentParser = currentParser.#subCommands.get(subCommandName)?.parser;
+        currentParser = currentParser.#subCommands.get(
+          subCommandName
+        )?.parser;
         remainingArgs = remainingArgs.slice(1);
         const nextSubCommandIndex = remainingArgs.findIndex(
           (arg) => currentParser.#subCommands.has(arg)
@@ -4227,43 +4478,43 @@ class ArgParserBase {
         }
         remainingArgs = nextSubCommandIndex === -1 ? [] : remainingArgs.slice(nextSubCommandIndex);
       }
-      console.log(simpleChalk.yellow("\nParsing Simulation Steps:"));
+      this.#logger.info(simpleChalk.yellow("\nParsing Simulation Steps:"));
       parsingSteps.forEach((step) => {
-        console.log(`  Level: ${simpleChalk.cyan(step.level)}`);
-        console.log(
+        this.#logger.info(`  Level: ${simpleChalk.cyan(step.level)}`);
+        this.#logger.info(
           `    Args Slice Considered: ${JSON.stringify(step.argsSlice)}`
         );
         if (step.parsed) {
-          console.log(
+          this.#logger.info(
             `    Parsed Args at this Level: ${JSON.stringify(step.parsed)}`
           );
         }
         if (step.error) {
-          console.log(
+          this.#logger.info(
             `    ${simpleChalk.red("Error during parse simulation:")} ${step.error}`
           );
         }
       });
-      console.log(
+      this.#logger.info(
         simpleChalk.yellow(
           "\nFinal Accumulated Args State (before final validation):"
         )
       );
-      console.log(JSON.stringify(accumulatedArgs, null, 2));
-      console.log(simpleChalk.yellow("\nArguments Remaining After Simulation:"));
-      console.log(JSON.stringify(remainingArgs, null, 2));
-      console.log(
+      this.#logger.info(JSON.stringify(accumulatedArgs, null, 2));
+      this.#logger.info(simpleChalk.yellow("\nArguments Remaining After Simulation:"));
+      this.#logger.info(JSON.stringify(remainingArgs, null, 2));
+      this.#logger.info(
         simpleChalk.yellow.bold(
           "\n--- ArgParser Static Configuration (Final Parser) ---"
         )
       );
       identifiedFinalParser.printAll();
-      console.log(simpleChalk.yellow.bold("--- End ArgParser --s-debug ---"));
+      this.#logger.info(simpleChalk.yellow.bold("--- End ArgParser --s-debug ---"));
       return this._handleExit(0, "Debug information displayed", "debug");
     }
     let parserNameForLog = "undefined_parser";
     if (identifiedFinalParser instanceof ArgParserBase) {
-      parserNameForLog = identifiedFinalParser["#subCommandName"] || identifiedFinalParser["#appName"];
+      parserNameForLog = identifiedFinalParser.getSubCommandName() || identifiedFinalParser.getAppName() || "unknown";
     } else if (identifiedFinalParser) {
       parserNameForLog = identifiedFinalParser.name || identifiedFinalParser.appName || "unknown_type";
     }
@@ -4372,14 +4623,21 @@ class ArgParserBase {
       }
       if (foundVal !== void 0) {
         try {
-          const typedVal = this.#configurationManager.convertValueToFlagType(foundVal, flag);
+          const typedVal = this.#configurationManager.convertValueToFlagType(
+            foundVal,
+            flag
+          );
           if (flag["allowMultiple"]) {
             finalArgs[flagName] = Array.isArray(typedVal) ? typedVal : [typedVal];
           } else {
             finalArgs[flagName] = typedVal;
           }
         } catch (e) {
-          console.warn(simpleChalk.yellow(`Warning: Failed to parse env var for flag '${flagName}': ${e}`));
+          console.warn(
+            simpleChalk.yellow(
+              `Warning: Failed to parse env var for flag '${flagName}': ${e}`
+            )
+          );
         }
       }
     }
@@ -4420,7 +4678,7 @@ class ArgParserBase {
       return;
     }
     const finalParserWhoseHandlerWillRun = handlerToExecute.context.parser;
-    const finalParserFlags = finalParserWhoseHandlerWillRun.#flagManager.flags;
+    const finalParserFlags = finalParserWhoseHandlerWillRun.flags;
     const handlerArgs = handlerToExecute.context.args;
     for (const flag of finalParserFlags) {
       const flagName = flag["name"];
@@ -4634,16 +4892,33 @@ class ArgParserBase {
         finalParseResultArgs["$commandChain"] = commandChainSoFar;
       }
       let handlerToExecute = void 0;
+      const handlerContext = {
+        args: currentLevelArgs,
+        parentArgs: accumulatedParentArgs,
+        commandChain: commandChainSoFar,
+        parser: currentParser,
+        parentParser,
+        // displayHelp implementation that respects autoExit setting
+        displayHelp: () => {
+          console.log(currentParser.helpText());
+          if (currentParser.getAutoExit() && typeof process === "object" && typeof process.exit === "function") {
+            process.exit(0);
+          }
+        },
+        // Add rootPath if working directory was resolved
+        rootPath: this.#rootPath || void 0,
+        logger: this.#logger,
+        isMcp: options?.isMcp || false
+      };
       if (currentParser.#handler) {
         handlerToExecute = {
           handler: currentParser.#handler,
-          context: {
-            args: currentLevelArgs,
-            parentArgs: accumulatedParentArgs,
-            commandChain: commandChainSoFar,
-            parser: currentParser,
-            parentParser
-          }
+          context: handlerContext
+        };
+      } else if (currentParser.#triggerAutoHelpIfNoHandler) {
+        handlerToExecute = {
+          handler: (ctx) => ctx.displayHelp(),
+          context: handlerContext
         };
       }
       return { finalArgs: finalParseResultArgs, handlerToExecute };
@@ -4948,8 +5223,8 @@ ${cyan("Flags:")}
             if (typeof flag["type"] === "function" && flag["type"].name === "Array") {
               isRepeatable = true;
             }
-            const anyType = flag["type"];
-            if (anyType && typeof anyType === "object" && anyType._def && anyType._def.typeName === "ZodArray") {
+            const maybeZodSchema = flag["type"];
+            if (maybeZodSchema && typeof maybeZodSchema === "object" && maybeZodSchema._def && maybeZodSchema._def.typeName === "ZodArray") {
               isRepeatable = true;
             }
             if (flag["allowMultiple"]) isRepeatable = true;
@@ -5055,9 +5330,9 @@ ${indent(2)}${white(line)}`).join("")}
       } catch {
       }
     }
-    console.error(`
+    this.#logger.error(`
 ${simpleChalk.red.bold("Error:")} ${error.message}`);
-    console.error(
+    this.#logger.error(
       `
 ${simpleChalk.dim(`Try '${commandNameToSuggest} --help' for usage details.`)}`
     );
@@ -5081,65 +5356,65 @@ ${simpleChalk.dim(`Try '${commandNameToSuggest} --help' for usage details.`)}`
     const indent = "  ".repeat(level);
     const subIndent = "  ".repeat(level + 1);
     const flagIndent = "  ".repeat(level + 2);
-    console.log(
+    this.#logger.info(
       `${indent}Parser: ${simpleChalk.blueBright(parser.#subCommandName || parser.#appName)}`
     );
     if (parser.#description) {
-      console.log(`${subIndent}Description: ${parser.#description}`);
+      this.#logger.info(`${subIndent}Description: ${parser.#description}`);
     }
-    console.log(`${subIndent}Options:`);
-    console.log(`${flagIndent}appName: ${parser.#appName}`);
-    console.log(
+    this.#logger.info(`${subIndent}Options:`);
+    this.#logger.info(`${flagIndent}appName: ${parser.#appName}`);
+    this.#logger.info(
       `${flagIndent}appCommandName: ${parser.#appCommandName ?? simpleChalk.dim("undefined")}`
     );
-    console.log(`${flagIndent}handleErrors: ${parser.#handleErrors}`);
-    console.log(
+    this.#logger.info(`${flagIndent}handleErrors: ${parser.#handleErrors}`);
+    this.#logger.info(
       `${flagIndent}throwForDuplicateFlags: ${parser.#throwForDuplicateFlags}`
     );
-    console.log(
+    this.#logger.info(
       `${flagIndent}inheritParentFlags: ${parser.#inheritParentFlags}`
     );
-    console.log(`${flagIndent}Handler Defined: ${!!parser.#handler}`);
-    console.log(
+    this.#logger.info(`${flagIndent}Handler Defined: ${!!parser.#handler}`);
+    this.#logger.info(
       `${subIndent}Internal Params: ${JSON.stringify(parser.#parameters)}`
     );
     const flags = parser.#flagManager.flags;
     if (flags.length > 0) {
-      console.log(`${subIndent}Flags (${flags.length}):`);
+      this.#logger.info(`${subIndent}Flags (${flags.length}):`);
       flags.forEach((flag) => {
-        console.log(`${flagIndent}* ${simpleChalk.green(flag["name"])}:`);
-        console.log(`${flagIndent}  Options: ${flag["options"].join(", ")}`);
-        console.log(
+        this.#logger.info(`${flagIndent}* ${simpleChalk.green(flag["name"])}:`);
+        this.#logger.info(`${flagIndent}  Options: ${flag["options"].join(", ")}`);
+        this.#logger.info(
           `${flagIndent}  Description: ${Array.isArray(flag["description"]) ? flag["description"].join(" | ") : flag["description"]}`
         );
-        console.log(
+        this.#logger.info(
           `${flagIndent}  Type: ${typeof flag["type"] === "function" ? flag["type"].name || "custom function" : flag["type"]}`
         );
-        console.log(
+        this.#logger.info(
           `${flagIndent}  Mandatory: ${typeof flag["mandatory"] === "function" ? "dynamic" : flag["mandatory"] ?? false}`
         );
-        console.log(
+        this.#logger.info(
           `${flagIndent}  Default: ${JSON.stringify(flag["defaultValue"])}`
         );
-        console.log(`${flagIndent}  Flag Only: ${flag["flagOnly"]}`);
-        console.log(`${flagIndent}  Allow Multiple: ${flag["allowMultiple"]}`);
-        console.log(`${flagIndent}  Allow Ligature: ${flag["allowLigature"]}`);
-        console.log(
+        this.#logger.info(`${flagIndent}  Flag Only: ${flag["flagOnly"]}`);
+        this.#logger.info(`${flagIndent}  Allow Multiple: ${flag["allowMultiple"]}`);
+        this.#logger.info(`${flagIndent}  Allow Ligature: ${flag["allowLigature"]}`);
+        this.#logger.info(
           `${flagIndent}  Enum: ${flag["enum"] && flag["enum"].length > 0 ? flag["enum"].join(", ") : "none"}`
         );
-        console.log(`${flagIndent}  Validator Defined: ${!!flag["validate"]}`);
+        this.#logger.info(`${flagIndent}  Validator Defined: ${!!flag["validate"]}`);
       });
     } else {
-      console.log(`${subIndent}Flags: ${simpleChalk.dim("none")}`);
+      this.#logger.info(`${subIndent}Flags: ${simpleChalk.dim("none")}`);
     }
     const subCommandParsers = Array.from(parser.#subCommands.values());
     if (subCommandParsers.length > 0) {
-      console.log(`${subIndent}Sub-Commands (${subCommandParsers.length}):`);
+      this.#logger.info(`${subIndent}Sub-Commands (${subCommandParsers.length}):`);
       subCommandParsers.forEach((subCommand) => {
         this.#_printRecursiveToConsole(subCommand.parser, level + 1, visited);
       });
     } else {
-      console.log(`${subIndent}Sub-Commands: ${simpleChalk.dim("none")}`);
+      this.#logger.info(`${subIndent}Sub-Commands: ${simpleChalk.dim("none")}`);
     }
   }
   #_buildRecursiveString(parser, level, visited = /* @__PURE__ */ new Set()) {
@@ -5446,6 +5721,7 @@ ${simpleChalk.dim(`Try '${commandNameToSuggest} --help' for usage details.`)}`
       }
       debug.log("Created MCP logger, about to hijack console");
       globalThis.console = mcpLogger;
+      this.#logger = mcpLogger;
       debug.log("Console hijacked successfully");
     } catch {
       debug.log("Failed to import simple-mcp-logger, using fallback");
@@ -5758,6 +6034,9 @@ ${simpleChalk.dim(`Try '${commandNameToSuggest} --help' for usage details.`)}`
     return options;
   }
 }
+const autoHelpHandler = async (ctx) => {
+  ctx.displayHelp();
+};
 function sanitizeMcpToolName(name) {
   if (!name || typeof name !== "string") {
     throw new Error("Tool name must be a non-empty string");
@@ -5778,6 +6057,7 @@ function isValidMcpToolName(name) {
   const mcpNamePattern = /^[a-zA-Z0-9_-]{1,64}$/;
   return mcpNamePattern.test(name);
 }
+const logger$1 = simpleMcpLogger.createMcpLogger("MCP Integration");
 function createMcpSuccessResponse(data2) {
   return {
     content: [
@@ -5813,7 +6093,7 @@ function convertFlagToJsonSchemaProperty(flag) {
       const isRequired2 = !!(flag.mandatory || flag.required);
       return { property: property2, isRequired: isRequired2 };
     } catch (error) {
-      console.warn(`Failed to convert Zod schema to JSON Schema for flag '${flag.name}':`, error);
+      logger$1.error(`Failed to convert Zod schema to JSON Schema for flag '${flag.name}':`, error);
       const property2 = {
         type: "object",
         description: flag.description || `${flag.name} parameter (Zod schema)`
@@ -6003,8 +6283,7 @@ function mapArgParserFlagToZodSchema(flag) {
         zodSchema = zod.z.record(zod.z.string(), zod.z.any());
         break;
       default:
-        const logger = simpleMcpLogger.createMcpLogger("MCP Integration");
-        logger.mcpError(
+        logger$1.error(
           `Flag '${flag["name"]}' has an unknown type '${typeName}'. Defaulting to z.string().`
         );
         zodSchema = zod.z.string();
@@ -6100,10 +6379,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
         outputSchema,
         async execute(mcpInputArgs) {
           if (process.env["MCP_DEBUG"]) {
-            console.error(
+            logger$1.error(
               `[MCP Execute] Starting execution for tool '${toolName}'`
             );
-            console.error(
+            logger$1.error(
               `[MCP Execute] Input args:`,
               JSON.stringify(mcpInputArgs, null, 2)
             );
@@ -6178,7 +6457,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
           }
           try {
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Starting try block for tool '${toolName}'`
               );
             }
@@ -6186,25 +6465,25 @@ function generateMcpToolsFromArgParser(rootParser, options) {
             const unifiedTools = rootParserTyped._tools;
             const isUnifiedTool = unifiedTools && unifiedTools.has(toolName);
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Tool Debug] Checking tool '${toolName}' for unified execution`
               );
-              console.error(`[MCP Tool Debug] Has _tools:`, !!unifiedTools);
-              console.error(
+              logger$1.error(`[MCP Tool Debug] Has _tools:`, !!unifiedTools);
+              logger$1.error(
                 `[MCP Tool Debug] Available tools:`,
                 unifiedTools ? Array.from(unifiedTools.keys()) : []
               );
-              console.error(`[MCP Tool Debug] Is unified tool:`, isUnifiedTool);
+              logger$1.error(`[MCP Tool Debug] Is unified tool:`, isUnifiedTool);
             }
             let parseResult;
             if (isUnifiedTool) {
               const toolConfig = unifiedTools.get(toolName);
               if (process.env["MCP_DEBUG"]) {
-                console.error(
+                logger$1.error(
                   `[MCP Tool Debug] Found unified tool config:`,
                   !!toolConfig
                 );
-                console.error(
+                logger$1.error(
                   `[MCP Tool Debug] Has handler:`,
                   !!(toolConfig && toolConfig.handler)
                 );
@@ -6212,10 +6491,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
               if (toolConfig && toolConfig.handler) {
                 try {
                   if (process.env["MCP_DEBUG"]) {
-                    console.error(
+                    logger$1.error(
                       `[MCP Tool Debug] Executing unified tool handler for '${toolName}'`
                     );
-                    console.error(
+                    logger$1.error(
                       `[MCP Tool Debug] Handler args:`,
                       JSON.stringify(mcpInputArgs, null, 2)
                     );
@@ -6245,11 +6524,18 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                     parser: rootParser,
                     parentArgs: void 0,
                     isMcp: true,
-                    getFlag
+                    getFlag,
+                    logger: logger$1,
+                    // Add logger to context
+                    displayHelp: () => {
+                      logger$1.error(
+                        "Help display is not supported in MCP mode."
+                      );
+                    }
                   };
                   const handlerResult = await toolConfig.handler(handlerContext);
                   if (process.env["MCP_DEBUG"]) {
-                    console.error(
+                    logger$1.error(
                       `[MCP Tool Debug] Handler result:`,
                       JSON.stringify(handlerResult, null, 2)
                     );
@@ -6261,7 +6547,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   };
                 } catch (handlerError) {
                   if (process.env["MCP_DEBUG"]) {
-                    console.error(
+                    logger$1.error(
                       `[MCP Tool Debug] Handler error:`,
                       handlerError
                     );
@@ -6287,10 +6573,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
               }
             } else {
               if (process.env["MCP_DEBUG"]) {
-                console.error(
+                logger$1.error(
                   `[MCP Tool Debug] Using CLI-generated tool parsing for '${toolName}'`
                 );
-                console.error(
+                logger$1.error(
                   `[MCP Tool Debug] Parse argv:`,
                   JSON.stringify(argv, null, 2)
                 );
@@ -6315,7 +6601,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   if (outputSchema && typeof outputSchema === "object" && outputSchema !== null && outputSchema._def) {
                     const zodSchema = outputSchema;
                     if (process.env["MCP_DEBUG"]) {
-                      console.error(
+                      logger$1.error(
                         `[MCP Debug] Output schema type:`,
                         zodSchema._def?.typeName || zodSchema._def?.type
                       );
@@ -6326,7 +6612,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                         const shape = typeof shapeGetter === "function" ? shapeGetter() : shapeGetter;
                         if (shape && typeof shape === "object") {
                           if (process.env["MCP_DEBUG"]) {
-                            console.error(
+                            logger$1.error(
                               `[MCP Debug] Schema shape keys:`,
                               Object.keys(shape)
                             );
@@ -6368,14 +6654,14 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   }
                 } catch (schemaError) {
                   if (process.env["MCP_DEBUG"]) {
-                    console.error(
+                    logger$1.error(
                       `[MCP Debug] Error processing output schema for structured error:`,
                       schemaError
                     );
                   }
                 }
                 if (process.env["MCP_DEBUG"]) {
-                  console.error(
+                  logger$1.error(
                     `[MCP Debug] Final structured error:`,
                     JSON.stringify(structuredError, null, 2)
                   );
@@ -6486,7 +6772,13 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   parser: finalParser,
                   parentArgs: resolvedParentArgs,
                   isMcp: true,
-                  getFlag
+                  getFlag,
+                  displayHelp: () => {
+                    logger$1.error(
+                      "Help display is not supported in MCP mode."
+                    );
+                  },
+                  logger: logger$1
                 };
                 try {
                   handlerResponse = await handlerToCall(handlerContext);
@@ -6496,10 +6788,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
               }
             }
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Formatting response for tool '${toolName}'`
               );
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Handler response:`,
                 JSON.stringify(handlerResponse, null, 2)
               );
@@ -6515,7 +6807,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   handlerResponse.structuredContent = handlerResponse;
                 }
                 if (process.env["MCP_DEBUG"]) {
-                  console.error(
+                  logger$1.error(
                     `[MCP Execute] Returning MCP format response for '${toolName}'`
                   );
                 }
@@ -6531,10 +6823,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   structuredContent: handlerResponse
                 };
                 if (process.env["MCP_DEBUG"]) {
-                  console.error(
+                  logger$1.error(
                     `[MCP Execute] Wrapping plain response in MCP format for '${toolName}'`
                   );
-                  console.error(
+                  logger$1.error(
                     `[MCP Execute] Final MCP response:`,
                     JSON.stringify(mcpResponse, null, 2)
                   );
@@ -6544,10 +6836,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
             }
             const defaultResponse = handlerResponse || { success: true };
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Using default response for tool '${toolName}'`
               );
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Default response:`,
                 JSON.stringify(defaultResponse, null, 2)
               );
@@ -6563,10 +6855,10 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                 structuredContent: defaultResponse
               };
               if (process.env["MCP_DEBUG"]) {
-                console.error(
+                logger$1.error(
                   `[MCP Execute] Returning structured default response for '${toolName}'`
                 );
-                console.error(
+                logger$1.error(
                   `[MCP Execute] Final response:`,
                   JSON.stringify(finalResponse, null, 2)
                 );
@@ -6574,14 +6866,14 @@ function generateMcpToolsFromArgParser(rootParser, options) {
               return finalResponse;
             }
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Returning success response for '${toolName}'`
               );
             }
             return createMcpSuccessResponse(defaultResponse);
           } catch (e) {
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              logger$1.error(
                 `[MCP Execute] Exception caught in tool '${toolName}':`,
                 e
               );
@@ -6695,41 +6987,42 @@ function compareVersions(v1, v2) {
   if (v1 === v2) return 0;
   return v1 < v2 ? -1 : 1;
 }
+const logger = simpleMcpLogger.createMcpLogger("Zod Compatibility");
 function debugSchemaStructure(schema, label = "Schema") {
   if (process.env["MCP_DEBUG"]) {
-    console.error(`[Zod Compatibility Debug] ${label} structure:`);
-    console.error(`  - Type: ${typeof schema}`);
-    console.error(`  - Constructor: ${schema?.constructor?.name}`);
-    console.error(`  - Has shape: ${!!schema?.shape}`);
-    console.error(`  - Has _def: ${!!schema?._def}`);
-    console.error(`  - _def.typeName: ${schema?._def?.typeName}`);
-    console.error(`  - _def.type: ${schema?._def?.type}`);
-    console.error(`  - Has parse: ${typeof schema?.parse}`);
-    console.error(`  - Has safeParse: ${typeof schema?.safeParse}`);
+    logger.error(`[Zod Compatibility Debug] ${label} structure:`);
+    logger.error(`  - Type: ${typeof schema}`);
+    logger.error(`  - Constructor: ${schema?.constructor?.name}`);
+    logger.error(`  - Has shape: ${!!schema?.shape}`);
+    logger.error(`  - Has _def: ${!!schema?._def}`);
+    logger.error(`  - _def.typeName: ${schema?._def?.typeName}`);
+    logger.error(`  - _def.type: ${schema?._def?.type}`);
+    logger.error(`  - Has parse: ${typeof schema?.parse}`);
+    logger.error(`  - Has safeParse: ${typeof schema?.safeParse}`);
     if (schema?.shape) {
-      console.error(`  - Shape keys: ${Object.keys(schema.shape)}`);
+      logger.error(`  - Shape keys: ${Object.keys(schema.shape)}`);
     }
   }
 }
 function validateMcpSchemaCompatibility(schema) {
   try {
     if (typeof schema?.parse !== "function") {
-      console.warn("[Zod Compatibility] Schema missing parse method");
+      logger.warn("[Zod Compatibility] Schema missing parse method");
       return false;
     }
     if (typeof schema?.safeParse !== "function") {
-      console.warn("[Zod Compatibility] Schema missing safeParse method");
+      logger.warn("[Zod Compatibility] Schema missing safeParse method");
       return false;
     }
     if ((schema?._def?.typeName === "ZodObject" || schema?._def?.type === "object") && !schema?.shape) {
-      console.warn(
+      logger.warn(
         "[Zod Compatibility] ZodObject schema missing shape property"
       );
       return false;
     }
     return true;
   } catch (error) {
-    console.error(
+    logger.error(
       "[Zod Compatibility] Error validating schema compatibility:",
       error
     );
@@ -6870,12 +7163,9 @@ class ArgParser extends ArgParserBase {
     }
     const sanitizedName = sanitizeMcpToolName(toolConfig.name);
     if (sanitizedName !== toolConfig.name) {
-      const isMcpMode = globalThis.console?.mcpError;
-      if (!isMcpMode) {
-        console.warn(
-          `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
-        );
-      }
+      console.warn(
+        `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
+      );
     }
     if (this._tools.has(sanitizedName)) {
       throw new Error(`Tool with name '${sanitizedName}' already exists`);
@@ -6918,30 +7208,14 @@ class ArgParser extends ArgParserBase {
    * @returns This ArgParser instance for chaining
    */
   addMcpTool(toolConfig) {
-    try {
-      if (typeof process !== "undefined" && process.stderr) {
-        process.stderr.write(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
-Please use addTool() instead for a unified CLI/MCP experience.
-Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md
-`);
-      } else {
-        console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
+    console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
 Please use addTool() instead for a unified CLI/MCP experience.
 Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md`);
-      }
-    } catch {
-      console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
-Please use addTool() instead for a unified CLI/MCP experience.
-Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md`);
-    }
     const sanitizedName = sanitizeMcpToolName(toolConfig.name);
     if (sanitizedName !== toolConfig.name) {
-      const isMcpMode = globalThis.console?.mcpError;
-      if (!isMcpMode) {
-        console.warn(
-          `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
-        );
-      }
+      console.warn(
+        `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
+      );
     }
     if (this._mcpTools.has(sanitizedName)) {
       throw new Error(`MCP tool with name '${sanitizedName}' already exists`);
@@ -7104,18 +7378,18 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         outputSchema = mergedOptions.outputSchemaMap[toolConfig.name];
       } else if (toolConfig.outputSchema) {
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Tool '${toolConfig.name}' has outputSchema:`,
             typeof toolConfig.outputSchema
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] outputSchema has _def:`,
             !!(toolConfig.outputSchema && typeof toolConfig.outputSchema === "object" && "_def" in toolConfig.outputSchema)
           );
         }
         outputSchema = createOutputSchema(toolConfig.outputSchema);
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Created output schema for '${toolConfig.name}':`,
             !!outputSchema
           );
@@ -7133,7 +7407,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
       }
       if (outputSchema && !this.supportsOutputSchemas()) {
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Output schema for '${toolConfig.name}' removed due to MCP version ${this._mcpProtocolVersion} not supporting output schemas`
           );
         }
@@ -7171,13 +7445,17 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
               parentArgs: {},
               commandChain: [toolConfig.name],
               parser: this,
-              isMcp: true
+              isMcp: true,
+              logger: this.logger,
+              displayHelp: () => {
+                this.logger.error("Help display is not supported in MCP mode.");
+              }
             };
             const startTime = Date.now();
             const result = await toolConfig.handler(context);
             const executionTime = Date.now() - startTime;
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              this.logger.error(
                 `[MCP Tool] '${toolConfig.name}' executed successfully in ${executionTime}ms`
               );
             }
@@ -7204,9 +7482,9 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           } catch (error) {
             const errorMessage = `Tool '${toolConfig.name}' execution failed: ${error instanceof Error ? error.message : String(error)}`;
             if (process.env["MCP_DEBUG"]) {
-              console.error(`[MCP Tool Error] ${errorMessage}`);
+              this.logger.error(`[MCP Tool Error] ${errorMessage}`);
               if (error instanceof Error && error.stack) {
-                console.error(`[MCP Tool Stack] ${error.stack}`);
+                this.logger.error(`[MCP Tool Stack] ${error.stack}`);
               }
             }
             return createMcpErrorResponse(errorMessage);
@@ -7229,7 +7507,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           const result = await toolConfig.handler(args);
           const executionTime = Date.now() - startTime;
           if (process.env["MCP_DEBUG"]) {
-            console.error(
+            this.logger.error(
               `[MCP Tool] '${toolConfig.name}' (legacy) executed successfully in ${executionTime}ms`
             );
           }
@@ -7256,7 +7534,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         } catch (error) {
           const errorMessage = `Tool '${toolConfig.name}' execution failed: ${error instanceof Error ? error.message : String(error)}`;
           if (process.env["MCP_DEBUG"]) {
-            console.error(`[MCP Tool Error] ${errorMessage}`);
+            this.logger.error(`[MCP Tool Error] ${errorMessage}`);
           }
           return createMcpErrorResponse(errorMessage);
         }
@@ -7286,7 +7564,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
    */
   async createMcpServer(serverInfo, toolOptions, logPath) {
     const loggerConfig = this.#_resolveLoggerConfig(logPath);
-    const logger = typeof loggerConfig === "string" ? simpleMcpLogger.createMcpLogger("MCP Server Creation", loggerConfig) : simpleMcpLogger.createMcpLogger(
+    const logger2 = typeof loggerConfig === "string" ? simpleMcpLogger.createMcpLogger("MCP Server Creation", loggerConfig) : simpleMcpLogger.createMcpLogger(
       loggerConfig.prefix || "MCP Server Creation",
       loggerConfig.logToFile
     );
@@ -7297,11 +7575,11 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           "No MCP server configuration found. Use withMcp() to configure server info or provide serverInfo parameter."
         );
       }
-      logger.mcpError(
+      logger2.mcpError(
         `Creating MCP server: ${effectiveServerInfo.name} v${effectiveServerInfo.version}`
       );
       const { McpServer: McpServer2, ResourceTemplate: ResourceTemplate2 } = await Promise.resolve().then(() => mcp);
-      logger.mcpError(
+      logger2.mcpError(
         "Successfully imported McpServer and ResourceTemplate from SDK"
       );
       const server = new McpServer2({
@@ -7310,13 +7588,13 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         name: effectiveServerInfo.name,
         description: effectiveServerInfo.description
       });
-      logger.mcpError("Successfully created McpServer instance");
+      logger2.mcpError("Successfully created McpServer instance");
       const isInMcpServeMode = process.argv.includes("--s-mcp-serve");
       if (this._mcpServerConfig?.lifecycle && !isInMcpServeMode) {
         const { McpLifecycleManager: McpLifecycleManager2 } = await Promise.resolve().then(() => mcpLifecycle);
         const lifecycleManager = new McpLifecycleManager2(
           this._mcpServerConfig.lifecycle,
-          logger,
+          logger2,
           effectiveServerInfo,
           this
         );
@@ -7330,17 +7608,17 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           });
           const parsedArgs = parsedResult?.args || parsedResult || {};
           lifecycleManager.setParsedArgs(parsedArgs);
-          logger.mcpError(
+          logger2.mcpError(
             `Lifecycle manager initialized with parsed args: ${Object.keys(parsedArgs).join(", ")}`
           );
         } catch (parseError) {
-          logger.mcpError(
+          logger2.mcpError(
             `Warning: Could not parse arguments for lifecycle manager: ${parseError instanceof Error ? parseError.message : String(parseError)}`
           );
         }
         const originalConnect = server.connect.bind(server);
         server.connect = async (transport) => {
-          logger.mcpError("MCP server connecting with lifecycle events...");
+          logger2.mcpError("MCP server connecting with lifecycle events...");
           const result = await originalConnect(transport);
           try {
             await lifecycleManager.handleInitialize(
@@ -7355,38 +7633,38 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
               try {
                 await lifecycleManager.handleInitialized();
               } catch (error) {
-                logger.mcpError(
+                logger2.mcpError(
                   `Lifecycle onInitialized error: ${error instanceof Error ? error.message : String(error)}`
                 );
               }
             }, 100);
           } catch (error) {
-            logger.mcpError(
+            logger2.mcpError(
               `Lifecycle onInitialize error: ${error instanceof Error ? error.message : String(error)}`
             );
           }
           return result;
         };
         server._lifecycleManager = lifecycleManager;
-        logger.mcpError("Successfully set up MCP lifecycle manager");
+        logger2.mcpError("Successfully set up MCP lifecycle manager");
       }
-      logger.mcpError(
+      logger2.mcpError(
         "MCP server will register actual resources and prompts for full capability support"
       );
-      logger.mcpError("Generating MCP tools from ArgParser");
+      logger2.mcpError("Generating MCP tools from ArgParser");
       const tools = this.toMcpTools(toolOptions);
-      logger.mcpError(`Generated ${tools.length} MCP tools`);
+      logger2.mcpError(`Generated ${tools.length} MCP tools`);
       const uniqueTools = tools.reduce((acc, tool) => {
         if (!acc.find((t) => t.name === tool.name)) {
           acc.push(tool);
         }
         return acc;
       }, []);
-      logger.mcpError(
+      logger2.mcpError(
         `After deduplication: ${uniqueTools.length} unique tools`
       );
       uniqueTools.forEach((tool) => {
-        logger.mcpError(`Registering tool: ${tool.name}`);
+        logger2.mcpError(`Registering tool: ${tool.name}`);
         let zodSchema;
         const toolFromUnified = Array.from(this._tools.values()).find(
           (t) => t.name === tool.name
@@ -7404,58 +7682,58 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         let mcpCompatibleSchema;
         try {
           if (process.env["MCP_DEBUG"]) {
-            console.error(`[MCP Debug] Preparing schema for tool ${tool.name}`);
-            console.error(`[MCP Debug] Input zodSchema:`, zodSchema);
+            this.logger.error(`[MCP Debug] Preparing schema for tool ${tool.name}`);
+            this.logger.error(`[MCP Debug] Input zodSchema:`, zodSchema);
           }
           mcpCompatibleSchema = zodSchema;
           if (process.env["MCP_DEBUG"]) {
-            console.error(
+            this.logger.error(
               `[MCP Debug] Successfully prepared schema for tool ${tool.name}`
             );
           }
         } catch (schemaError) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Error preparing schema for tool ${tool.name}:`,
             schemaError
           );
           throw schemaError;
         }
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Prepared mcpCompatibleSchema for tool ${tool.name}:`,
             JSON.stringify(mcpCompatibleSchema, null, 2)
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] Schema properties:`,
             Object.keys(mcpCompatibleSchema || {})
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] Schema def:`,
             mcpCompatibleSchema?.def
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] Schema shape:`,
             mcpCompatibleSchema?.shape
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] Schema parse function:`,
             typeof mcpCompatibleSchema?.parse
           );
         }
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] About to prepare schema for tool ${tool.name}`
           );
-          console.error(`[MCP Debug] zodSchema type:`, typeof zodSchema);
-          console.error(`[MCP Debug] zodSchema:`, zodSchema);
-          console.error(
+          this.logger.error(`[MCP Debug] zodSchema type:`, typeof zodSchema);
+          this.logger.error(`[MCP Debug] zodSchema:`, zodSchema);
+          this.logger.error(
             `[MCP Debug] zodSchema constructor:`,
             zodSchema?.constructor?.name
           );
         }
         debugSchemaStructure(mcpCompatibleSchema, `Tool ${tool.name} schema`);
         if (!validateMcpSchemaCompatibility(mcpCompatibleSchema)) {
-          logger.mcpError(
+          logger2.mcpError(
             `Warning: Schema for tool ${tool.name} may not be fully compatible with MCP SDK`
           );
         }
@@ -7467,35 +7745,35 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           // Use Zod v3 compatible schema for MCP SDK
         };
         if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] Final toolConfig for ${tool.name}:`,
             JSON.stringify(toolConfig, null, 2)
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] toolConfig.inputSchema type:`,
             typeof toolConfig.inputSchema
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] toolConfig.inputSchema constructor:`,
             toolConfig.inputSchema?.constructor?.name
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] toolConfig.inputSchema._def:`,
             toolConfig.inputSchema?._def
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] toolConfig.inputSchema.shape:`,
             toolConfig.inputSchema?.shape
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] toolConfig.inputSchema._zod:`,
             toolConfig.inputSchema?._zod
           );
-          console.error(
+          this.logger.error(
             `[MCP Debug] Schema keys:`,
             Object.keys(mcpCompatibleSchema || {})
           );
-          console.error(`[MCP Debug] About to call server.registerTool with:`, {
+          this.logger.error(`[MCP Debug] About to call server.registerTool with:`, {
             name: tool.name,
             description: tool.description,
             inputSchema: mcpCompatibleSchema
@@ -7505,28 +7783,28 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           const convertedOutputSchema = createOutputSchema(tool.outputSchema);
           toolConfig.outputSchema = convertedOutputSchema;
           if (process.env["MCP_DEBUG"]) {
-            console.error(
+            this.logger.error(
               `[MCP Debug] Including outputSchema for tool '${tool.name}':`,
               typeof tool.outputSchema
             );
-            console.error(
+            this.logger.error(
               `[MCP Debug] Converted outputSchema constructor:`,
               convertedOutputSchema?.constructor?.name
             );
-            console.error(
+            this.logger.error(
               `[MCP Debug] supportsOutputSchemas():`,
               this.supportsOutputSchemas()
             );
           }
         } else if (process.env["MCP_DEBUG"]) {
-          console.error(
+          this.logger.error(
             `[MCP Debug] NOT including outputSchema for tool '${tool.name}':`,
             `hasOutputSchema=${!!tool.outputSchema}, supportsOutputSchemas=${this.supportsOutputSchemas()}`
           );
         }
         const simpleExecute = async (args) => {
           if (process.env["MCP_DEBUG"]) {
-            console.error(
+            this.logger.error(
               `[MCP Simple Execute] 🎯 TOOL CALLED: '${tool.name}' with args:`,
               JSON.stringify(args, null, 2)
             );
@@ -7534,7 +7812,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           try {
             const result = await tool.execute(args);
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              this.logger.error(
                 `[MCP Simple Execute] Tool '${tool.name}' returned:`,
                 JSON.stringify(result, null, 2)
               );
@@ -7553,7 +7831,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              this.logger.error(
                 `[MCP Simple Execute] Tool '${tool.name}' error:`,
                 errorMessage
               );
@@ -7571,9 +7849,9 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         };
         server.registerTool(tool.name, toolConfig, simpleExecute);
       });
-      logger.mcpError("Successfully registered all tools with MCP server");
+      logger2.mcpError("Successfully registered all tools with MCP server");
       const resources = this.getMcpResources();
-      logger.mcpError(`Registering ${resources.length} MCP resources`);
+      logger2.mcpError(`Registering ${resources.length} MCP resources`);
       resources.forEach((resource) => {
         try {
           const resourceConfig = {
@@ -7610,7 +7888,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
                   })
                 };
               } catch (error) {
-                logger.mcpError(
+                logger2.mcpError(
                   `Resource template handler error for ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
                 );
                 throw error;
@@ -7647,7 +7925,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
                   })
                 };
               } catch (error) {
-                logger.mcpError(
+                logger2.mcpError(
                   `Resource handler error for ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
                 );
                 throw error;
@@ -7660,34 +7938,34 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
               resourceHandler
             );
           }
-          logger.mcpError(`Successfully registered resource: ${resource.name}`);
+          logger2.mcpError(`Successfully registered resource: ${resource.name}`);
         } catch (error) {
-          logger.mcpError(
+          logger2.mcpError(
             `Failed to register resource ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       });
-      logger.mcpError("Successfully registered all resources with MCP server");
+      logger2.mcpError("Successfully registered all resources with MCP server");
       const prompts = this.getMcpPrompts();
-      logger.mcpError(`Registering ${prompts.length} MCP prompts`);
+      logger2.mcpError(`Registering ${prompts.length} MCP prompts`);
       prompts.forEach((prompt) => {
         try {
           let mcpCompatibleSchema;
           try {
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              this.logger.error(
                 `[MCP Debug] Preparing schema for prompt ${prompt.name}`
               );
-              console.error(`[MCP Debug] Input argsSchema:`, prompt.argsSchema);
+              this.logger.error(`[MCP Debug] Input argsSchema:`, prompt.argsSchema);
             }
             mcpCompatibleSchema = prompt.argsSchema;
             if (process.env["MCP_DEBUG"]) {
-              console.error(
+              this.logger.error(
                 `[MCP Debug] Successfully prepared schema for prompt ${prompt.name}`
               );
             }
           } catch (schemaError) {
-            console.error(
+            this.logger.error(
               `[MCP Debug] Error preparing schema for prompt ${prompt.name}:`,
               schemaError
             );
@@ -7713,14 +7991,14 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
               const validatedArgs = prompt.argsSchema.parse(args);
               const result = await prompt.handler(validatedArgs);
               if (process.env["MCP_DEBUG"]) {
-                console.error(
+                this.logger.error(
                   `[MCP Debug] Prompt '${prompt.name}' executed successfully`
                 );
               }
               return result;
             } catch (error) {
               if (process.env["MCP_DEBUG"]) {
-                console.error(
+                this.logger.error(
                   `[MCP Debug] Prompt '${prompt.name}' execution error:`,
                   error
                 );
@@ -7733,26 +8011,26 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
             promptConfig,
             promptHandler
           );
-          logger.mcpError(`Successfully registered prompt: ${prompt.name}`);
+          logger2.mcpError(`Successfully registered prompt: ${prompt.name}`);
         } catch (error) {
-          logger.mcpError(
+          logger2.mcpError(
             `Failed to register prompt ${prompt.name}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       });
-      logger.mcpError("Successfully registered all prompts with MCP server");
+      logger2.mcpError("Successfully registered all prompts with MCP server");
       this.setupMcpChangeNotifications(server);
-      logger.mcpError("Successfully set up MCP change notifications");
+      logger2.mcpError("Successfully set up MCP change notifications");
       if (server._lifecycleManager) {
         const originalClose = server.close?.bind(server);
         server.close = async () => {
-          logger.mcpError("MCP server shutdown initiated");
+          logger2.mcpError("MCP server shutdown initiated");
           try {
             await server._lifecycleManager.handleShutdown(
               "server_shutdown"
             );
           } catch (error) {
-            logger.mcpError(
+            logger2.mcpError(
               `Error during lifecycle shutdown: ${error instanceof Error ? error.message : String(error)}`
             );
           }
@@ -7763,11 +8041,11 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
       }
       return server;
     } catch (error) {
-      logger.mcpError(
+      logger2.mcpError(
         `Error creating MCP server: ${error instanceof Error ? error.message : String(error)}`
       );
       if (error instanceof Error && error.stack) {
-        logger.mcpError(`Stack trace: ${error.stack}`);
+        logger2.mcpError(`Stack trace: ${error.stack}`);
       }
       throw error;
     }
@@ -7778,8 +8056,8 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
    */
   setupMcpChangeNotifications(_server) {
     this.onMcpChange((event) => {
-      const logger = simpleMcpLogger.createMcpLogger("MCP Change Notifications");
-      logger.mcpError(
+      const logger2 = simpleMcpLogger.createMcpLogger("MCP Change Notifications");
+      logger2.mcpError(
         `MCP ${event.type} ${event.action}: ${event.entityName || "unknown"}`
       );
     });
@@ -7844,20 +8122,20 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
    */
   async #_startSingleTransport(server, serverInfo, transportConfig, logPath) {
     const resolvedLogPath = resolveLogPath(logPath || "./logs/mcp.log");
-    const logger = simpleMcpLogger.createMcpLogger("MCP Transport", resolvedLogPath);
+    const logger2 = simpleMcpLogger.createMcpLogger("MCP Transport", resolvedLogPath);
     try {
-      logger.mcpError(
+      logger2.mcpError(
         `Starting ${transportConfig.type} transport for server: ${serverInfo.name}`
       );
       switch (transportConfig.type) {
         case "stdio": {
-          logger.mcpError("Importing StdioServerTransport from SDK");
+          logger2.mcpError("Importing StdioServerTransport from SDK");
           const { StdioServerTransport: StdioServerTransport2 } = await Promise.resolve().then(() => stdio);
-          logger.mcpError("Creating StdioServerTransport instance");
+          logger2.mcpError("Creating StdioServerTransport instance");
           const transport = new StdioServerTransport2();
-          logger.mcpError("Connecting server to stdio transport");
+          logger2.mcpError("Connecting server to stdio transport");
           await server.connect(transport);
-          logger.mcpError("Successfully connected to stdio transport");
+          logger2.mcpError("Successfully connected to stdio transport");
           break;
         }
         case "sse": {
@@ -7873,7 +8151,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           });
           await new Promise((resolve) => {
             app.listen(port, transportConfig.host || "localhost", () => {
-              console.error(
+              this.logger.error(
                 `[${serverInfo.name}] MCP Server listening on http://${transportConfig.host || "localhost"}:${port}${path2} (SSE)`
               );
               resolve();
@@ -8055,20 +8333,20 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
           break;
         }
         default:
-          logger.mcpError(
+          logger2.mcpError(
             `Unsupported transport type: ${transportConfig.type}`
           );
           throw new Error(
             `Unsupported transport type: ${transportConfig.type}`
           );
       }
-      logger.mcpError(`Successfully started ${transportConfig.type} transport`);
+      logger2.mcpError(`Successfully started ${transportConfig.type} transport`);
     } catch (error) {
-      logger.mcpError(
+      logger2.mcpError(
         `Error starting ${transportConfig.type} transport: ${error instanceof Error ? error.message : String(error)}`
       );
       if (error instanceof Error && error.stack) {
-        logger.mcpError(`Stack trace: ${error.stack}`);
+        logger2.mcpError(`Stack trace: ${error.stack}`);
       }
       throw error;
     }
@@ -8132,7 +8410,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
    *
    * // With error handling:
    * await cli.parseIfExecutedDirectly(import.meta.url).catch((error) => {
-   *   console.error("Fatal error:", error instanceof Error ? error.message : String(error));
+   *   this.logger.error("Fatal error:", error instanceof Error ? error.message : String(error));
    *   process.exit(1);
    * });
    * ```
@@ -8191,30 +8469,30 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
       };
     }
     const mcpHandler = async (ctx) => {
-      const logger = simpleMcpLogger.createMcpLogger("MCP Handler");
-      globalThis.console = logger;
+      const logger2 = simpleMcpLogger.createMcpLogger("MCP Handler");
+      globalThis.console = logger2;
       try {
-        logger.mcpError(
+        logger2.mcpError(
           "MCP handler started - console hijacked for MCP safety"
         );
-        logger.mcpError(`Handler context args: ${JSON.stringify(ctx.args)}`);
+        logger2.mcpError(`Handler context args: ${JSON.stringify(ctx.args)}`);
         if (!ctx.parentParser) {
-          logger.mcpError(
+          logger2.mcpError(
             "Critical: MCP server handler called without a parent parser context."
           );
           process.exit(1);
         }
-        logger.mcpError("Parent parser found, casting to ArgParser");
+        logger2.mcpError("Parent parser found, casting to ArgParser");
         const mcpParser = ctx.parentParser;
-        logger.mcpError("Checking transport configuration");
+        logger2.mcpError("Checking transport configuration");
         const transports = ctx.args["transports"];
         if (transports) {
-          logger.mcpError(
+          logger2.mcpError(
             `Multiple transports specified via CLI: ${transports}`
           );
           try {
             const transportConfigs = JSON.parse(transports);
-            logger.mcpError(
+            logger2.mcpError(
               `Parsed transport configs: ${JSON.stringify(transportConfigs)}`
             );
             await mcpParser.startMcpServerWithMultipleTransports(
@@ -8223,16 +8501,16 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
               toolOptions
             );
           } catch (error) {
-            logger.mcpError(
+            logger2.mcpError(
               `Error parsing transports configuration: ${error.message}`
             );
-            logger.mcpError(
+            logger2.mcpError(
               `Expected JSON format: '[{"type":"stdio"},{"type":"sse","port":3001}]'`
             );
             process.exit(1);
           }
         } else if (defaultTransports && defaultTransports.length > 0) {
-          logger.mcpError(
+          logger2.mcpError(
             `Using preset multiple transports: ${JSON.stringify(defaultTransports)}`
           );
           await mcpParser.startMcpServerWithMultipleTransports(
@@ -8241,7 +8519,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
             toolOptions
           );
         } else if (defaultTransport) {
-          logger.mcpError(
+          logger2.mcpError(
             `Using preset single transport: ${JSON.stringify(defaultTransport)}`
           );
           await mcpParser.startMcpServerWithTransport(
@@ -8262,7 +8540,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
             host: ctx.args["host"],
             path: ctx.args["path"]
           };
-          logger.mcpError(
+          logger2.mcpError(
             `Using single transport mode: ${transportType} with options: ${JSON.stringify(transportOptions)}`
           );
           await mcpParser.startMcpServerWithTransport(
@@ -8272,15 +8550,15 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
             toolOptions
           );
         }
-        logger.mcpError("MCP server setup completed, keeping process alive");
+        logger2.mcpError("MCP server setup completed, keeping process alive");
         return new Promise(() => {
         });
       } catch (error) {
-        logger.mcpError(
+        logger2.mcpError(
           `Error in MCP handler: ${error instanceof Error ? error.message : String(error)}`
         );
         if (error instanceof Error && error.stack) {
-          logger.mcpError(`Stack trace: ${error.stack}`);
+          logger2.mcpError(`Stack trace: ${error.stack}`);
         }
         process.exit(1);
       }
@@ -8692,9 +8970,9 @@ class ArgParserFuzzyTester {
     const commandPaths = this.discoverCommandPaths();
     const results = [];
     if (this.options.verbose) {
-      console.log(`Discovered ${commandPaths.length} command paths:`);
+      this.parser.logger.info(`Discovered ${commandPaths.length} command paths:`);
       commandPaths.forEach(
-        (path2) => console.log(`  ${path2.join(" ") || "(root)"}`)
+        (path2) => this.parser.logger.info(`  ${path2.join(" ") || "(root)"}`)
       );
     }
     for (const commandPath of commandPaths) {
@@ -8749,7 +9027,7 @@ class ArgParserFuzzyTester {
     const targetParser = this.getParserForPath(commandPath);
     const flags = this.getFlags(targetParser);
     if (this.options.verbose) {
-      console.log(`Testing command path: ${commandPath.join(" ") || "(root)"}`);
+      this.parser.logger.info(`Testing command path: ${commandPath.join(" ") || "(root)"}`);
     }
     const validCombinations = this.generateValidFlagCombinations(flags);
     for (const flagArgs of validCombinations) {
@@ -8990,585 +9268,6 @@ class ArgParserFuzzyTester {
     };
   }
 }
-class Terminal {
-  constructor() {
-  }
-  static getInstance() {
-    if (!Terminal.instance) {
-      Terminal.instance = new Terminal();
-    }
-    return Terminal.instance;
-  }
-  get width() {
-    return process.stdout.columns || 80;
-  }
-  get height() {
-    return process.stdout.rows || 24;
-  }
-  write(text) {
-    process.stdout.write(text);
-  }
-  clear() {
-    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
-  }
-  hideCursor() {
-    process.stdout.write("\x1B[?25l");
-  }
-  showCursor() {
-    process.stdout.write("\x1B[?25h");
-  }
-  moveCursor(x, y) {
-    process.stdout.write(`\x1B[${y + 1};${x + 1}H`);
-  }
-  enableRawMode() {
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding("utf8");
-    }
-  }
-  enableMouse() {
-    process.stdout.write("\x1B[?1000h\x1B[?1002h\x1B[?1006h");
-  }
-  disableMouse() {
-    process.stdout.write("\x1B[?1000l\x1B[?1002l\x1B[?1006l");
-  }
-  disableRawMode() {
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-    }
-  }
-  onKey(callback) {
-    process.stdin.on("data", (data2) => {
-      const char = data2.toString();
-      if (char === "") {
-        this.cleanup();
-        process.exit(0);
-      }
-      callback(char, false);
-    });
-  }
-  cleanup() {
-    this.showCursor();
-    this.disableMouse();
-    this.disableRawMode();
-  }
-}
-class Component {
-  constructor(config = {}) {
-    this.x = 0;
-    this.y = 0;
-    this.width = 0;
-    this.height = 0;
-    this.config = config;
-    this.id = config.id || `component_${Math.random().toString(36).substr(2, 9)}`;
-  }
-  resize(x, y, width, height) {
-    this.x = x;
-    this.y = y;
-    this.width = width;
-    this.height = height;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  handleInput(_key) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  handleMouse(_event) {
-  }
-}
-class SplitLayout extends Component {
-  constructor(config) {
-    super(config);
-    this.direction = config.direction;
-    this.first = config.first;
-    this.second = config.second;
-    this.splitRatio = config.splitRatio ?? 0.5;
-  }
-  resize(x, y, width, height) {
-    super.resize(x, y, width, height);
-    if (this.direction === "horizontal") {
-      const splitX = Math.floor(width * this.splitRatio);
-      this.first.resize(x, y, splitX, height);
-      this.second.resize(x + splitX, y, width - splitX, height);
-    } else {
-      const splitY = Math.floor(height * this.splitRatio);
-      this.first.resize(x, y, width, splitY);
-      this.second.resize(x, y + splitY, width, height - splitY);
-    }
-  }
-  render() {
-    const lines = [];
-    const firstLines = this.first.render();
-    const secondLines = this.second.render();
-    if (this.direction === "horizontal") {
-      const maxHeight = Math.max(firstLines.length, secondLines.length);
-      for (let i = 0; i < maxHeight; i++) {
-        const line1 = firstLines[i] || " ".repeat(this.first["width"]);
-        const line2 = secondLines[i] || " ".repeat(this.second["width"]);
-        lines.push(line1 + line2);
-      }
-    } else {
-      lines.push(...firstLines);
-      lines.push(...secondLines);
-    }
-    return lines;
-  }
-  handleInput(key) {
-    this.first.handleInput(key);
-    this.second.handleInput(key);
-  }
-  handleMouse(event) {
-    this.first.handleMouse(event);
-    this.second.handleMouse(event);
-  }
-}
-class App {
-  constructor() {
-    this.isRunning = false;
-    this.lastRenderedLines = [];
-    this.terminal = Terminal.getInstance();
-  }
-  run(root) {
-    this.root = root;
-    this.isRunning = true;
-    this.terminal.enableRawMode();
-    this.terminal.enableMouse();
-    this.terminal.hideCursor();
-    this.terminal.clear();
-    this.render();
-    const cleanup = () => this.terminal.cleanup();
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => {
-      cleanup();
-      process.exit(0);
-    });
-    process.on("uncaughtException", (err) => {
-      cleanup();
-      console.error(err);
-      process.exit(1);
-    });
-    this.terminal.onKey((key) => {
-      if (key.startsWith("\x1B[<")) {
-        const parts = key.substring(3).split(";");
-        if (parts.length === 3) {
-          let buttonCode = parseInt(parts[0]);
-          const x = parseInt(parts[1]) - 1;
-          const lastPart = parts[2];
-          const y = parseInt(lastPart.substring(0, lastPart.length - 1)) - 1;
-          const type2 = lastPart.charAt(lastPart.length - 1);
-          let action = "press";
-          let button = 0;
-          if (type2 === "m") {
-            action = "release";
-          } else {
-            if (buttonCode >= 64) {
-              action = buttonCode === 64 ? "scroll_up" : "scroll_down";
-              buttonCode -= 64;
-            } else {
-              if (buttonCode === 0) button = 0;
-              else if (buttonCode === 1) button = 1;
-              else if (buttonCode === 2) button = 2;
-              if ((buttonCode & 32) === 32) {
-                action = "drag";
-                buttonCode -= 32;
-                if (buttonCode === 0) button = 0;
-              }
-            }
-          }
-          const event = { x, y, button, action };
-          if (this.root) {
-            this.root.handleMouse(event);
-            this.render();
-          }
-          return;
-        }
-      }
-      if (key === "\x1B" || key === "") {
-        this.stop();
-        return;
-      }
-      if (this.root) {
-        this.root.handleInput(key);
-        this.render();
-      }
-    });
-    process.stdout.on("resize", () => {
-      this.render();
-    });
-  }
-  stop() {
-    this.isRunning = false;
-    this.terminal.cleanup();
-    process.exit(0);
-  }
-  render() {
-    if (!this.root || !this.isRunning) return;
-    const width = this.terminal.width;
-    const height = this.terminal.height;
-    this.root.resize(0, 0, width, height);
-    const lines = this.root.render();
-    const maxLines = Math.min(lines.length, height - 1);
-    this.terminal.write("\x1B[H");
-    for (let i = 0; i < maxLines; i++) {
-      const line = lines[i];
-      const lastLine = this.lastRenderedLines[i];
-      if (line !== lastLine) {
-        this.terminal.moveCursor(0, i);
-        this.terminal.write(line);
-        this.terminal.write("\x1B[K");
-      }
-    }
-    this.lastRenderedLines = [...lines];
-  }
-}
-const Themes = {
-  Default: {
-    // Dark Mode
-    base: simpleChalk.white,
-    muted: simpleChalk.gray,
-    accent: simpleChalk.cyan,
-    highlight: simpleChalk.cyan,
-    // Was bgBlue.white
-    success: simpleChalk.green,
-    warning: simpleChalk.yellow,
-    error: simpleChalk.red,
-    border: simpleChalk.gray,
-    scrollbarThumb: simpleChalk.white,
-    scrollbarTrack: simpleChalk.gray
-  },
-  Light: {
-    // "Ocean" theme (High contrast on dark)
-    base: simpleChalk.white,
-    muted: simpleChalk.gray,
-    accent: simpleChalk.cyan,
-    highlight: simpleChalk.cyan,
-    // Fallback since bgCyan not supported
-    success: simpleChalk.green,
-    warning: simpleChalk.yellow,
-    error: simpleChalk.red,
-    border: simpleChalk.cyan,
-    scrollbarThumb: simpleChalk.cyan,
-    scrollbarTrack: simpleChalk.gray
-  },
-  Monokai: {
-    base: simpleChalk.white,
-    muted: simpleChalk.gray,
-    accent: simpleChalk.magenta,
-    highlight: simpleChalk.magenta,
-    // Was bgMagenta.white
-    success: simpleChalk.green,
-    warning: simpleChalk.yellow,
-    error: simpleChalk.red,
-    border: simpleChalk.gray,
-    scrollbarThumb: simpleChalk.magenta,
-    scrollbarTrack: simpleChalk.gray
-  }
-};
-const _ThemeManager = class _ThemeManager {
-  static get current() {
-    return this._current;
-  }
-  static setTheme(name) {
-    if (Themes[name]) {
-      this._current = Themes[name];
-    }
-  }
-  static setCustomTheme(theme) {
-    this._current = theme;
-  }
-};
-_ThemeManager._current = Themes["Default"];
-let ThemeManager = _ThemeManager;
-class List extends Component {
-  constructor(config) {
-    super(config);
-    this.selectedIndex = 0;
-    this.scrollOffset = 0;
-    this.items = config.items;
-    this.onSelect = config.onSelect;
-    this.onSubmit = config.onSubmit;
-  }
-  setItems(items2) {
-    this.items = items2;
-    if (this.selectedIndex >= this.items.length) {
-      this.selectedIndex = Math.max(0, this.items.length - 1);
-    }
-  }
-  render() {
-    const lines = [];
-    const visibleCount = this.height;
-    if (this.selectedIndex < this.scrollOffset) {
-      this.scrollOffset = this.selectedIndex;
-    } else if (this.selectedIndex >= this.scrollOffset + visibleCount) {
-      this.scrollOffset = this.selectedIndex - visibleCount + 1;
-    }
-    const visibleItems = this.items.slice(this.scrollOffset, this.scrollOffset + visibleCount);
-    for (let i = 0; i < this.height; i++) {
-      const itemIndex = this.scrollOffset + i;
-      const item = visibleItems[i];
-      if (!item) {
-        lines.push(" ".repeat(this.width));
-        continue;
-      }
-      const isSelected = itemIndex === this.selectedIndex;
-      const theme = ThemeManager.current;
-      let line = "";
-      if (isSelected) {
-        line = theme.highlight("> " + item.label);
-      } else {
-        line = theme.base("  " + item.label);
-      }
-      const rawLabelLength = item.label.length + 2;
-      const padding = Math.max(0, this.width - rawLabelLength);
-      if (isSelected) {
-        line = theme.highlight("> " + item.label + " ".repeat(padding));
-      } else {
-        line = theme.base("  " + item.label + " ".repeat(padding));
-      }
-      lines.push(line);
-    }
-    return lines;
-  }
-  handleInput(key) {
-    if (this.items.length === 0) return;
-    if (key === "\x1B[A") {
-      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
-      if (this.onSelect) this.onSelect(this.items[this.selectedIndex]);
-    } else if (key === "\x1B[B") {
-      this.selectedIndex = Math.min(this.items.length - 1, this.selectedIndex + 1);
-      if (this.onSelect) this.onSelect(this.items[this.selectedIndex]);
-    } else if (key === "\r" || key === "\x1B[C") {
-      if (this.onSubmit) this.onSubmit(this.items[this.selectedIndex]);
-    }
-  }
-}
-function stripAnsi(str) {
-  return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
-}
-function visualLength(str) {
-  return stripAnsi(str).length;
-}
-function wrapText(text, width) {
-  if (width <= 0) return [text];
-  const result = [];
-  const lines = text.split("\n");
-  for (const line of lines) {
-    if (visualLength(line) <= width) {
-      result.push(line);
-      continue;
-    }
-    let currentLine = "";
-    let currentVisibleLength = 0;
-    let activeAnsiCodes = [];
-    const tokenRegex = /(\u001b\[(?:\d{1,3}(?:;\d{1,3})*)?[mK])|([\s\S])/g;
-    let match;
-    while ((match = tokenRegex.exec(line)) !== null) {
-      const ansiCode = match[1];
-      const char = match[2];
-      if (ansiCode) {
-        currentLine += ansiCode;
-        if (ansiCode === "\x1B[0m") {
-          activeAnsiCodes = [];
-        } else if (ansiCode.endsWith("m")) {
-          activeAnsiCodes.push(ansiCode);
-        }
-      } else if (char) {
-        if (currentVisibleLength >= width) {
-          result.push(currentLine + "\x1B[0m");
-          currentLine = activeAnsiCodes.join("") + char;
-          currentVisibleLength = 1;
-        } else {
-          currentLine += char;
-          currentVisibleLength++;
-        }
-      }
-    }
-    if (currentLine.length > 0) {
-      result.push(currentLine + "\x1B[0m");
-    }
-  }
-  return result;
-}
-class ScrollArea extends Component {
-  constructor(config) {
-    super(config);
-    this.contentLines = [];
-    this.scrollOffset = 0;
-    this.wrapText = false;
-    this.content = config.content;
-    this.wrapText = !!config.wrapText;
-    this.updateContentLines();
-  }
-  setContent(content) {
-    this.content = typeof content === "string" ? content : String(content || "");
-    this.scrollOffset = 0;
-    this.updateContentLines();
-  }
-  resize(x, y, width, height) {
-    super.resize(x, y, width, height);
-    if (this.wrapText) {
-      this.updateContentLines();
-    }
-  }
-  updateContentLines() {
-    if (this.wrapText && this.width > 0) {
-      this.contentLines = wrapText(this.content, Math.max(1, this.width - 2));
-    } else {
-      this.contentLines = this.content.split("\n");
-    }
-  }
-  render() {
-    const lines = [];
-    const visibleLines = this.contentLines.slice(this.scrollOffset, this.scrollOffset + this.height);
-    const showScrollbar = this.contentLines.length > this.height;
-    let scrollbarHeight = 0;
-    let scrollbarTop = 0;
-    if (showScrollbar) {
-      const ratio = this.height / this.contentLines.length;
-      scrollbarHeight = Math.max(1, Math.floor(this.height * ratio));
-      const scrollPercent = this.scrollOffset / (this.contentLines.length - this.height);
-      const maxTop = this.height - scrollbarHeight;
-      scrollbarTop = Math.floor(scrollPercent * maxTop);
-    }
-    for (let i = 0; i < this.height; i++) {
-      const lineContent = visibleLines[i] || "";
-      let prefix = "";
-      if (showScrollbar) {
-        const isThumb = i >= scrollbarTop && i < scrollbarTop + scrollbarHeight;
-        const theme = ThemeManager.current;
-        prefix = isThumb ? theme.scrollbarThumb("█") : theme.scrollbarTrack("│");
-        prefix += " ";
-      }
-      const visibleWidth = showScrollbar ? this.width - 2 : this.width;
-      const visibleLength = stripAnsi(lineContent).length;
-      const rawLength = lineContent.length;
-      const invisibleLength = rawLength - visibleLength;
-      let renderedContent = "";
-      if (visibleLength > visibleWidth) {
-        renderedContent = lineContent.substring(0, visibleWidth + invisibleLength);
-      } else {
-        const padding = Math.max(0, visibleWidth - visibleLength);
-        renderedContent = lineContent + " ".repeat(padding);
-      }
-      lines.push(prefix + renderedContent);
-    }
-    return lines;
-  }
-  handleMouse(event) {
-    if (event.x >= this.x && event.x < this.x + this.width && event.y >= this.y && event.y < this.y + this.height) {
-      if (event.action === "scroll_up") {
-        this.scrollOffset = Math.max(0, this.scrollOffset - 3);
-      } else if (event.action === "scroll_down") {
-        const maxScroll = Math.max(0, this.contentLines.length - this.height);
-        this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 3);
-      }
-    }
-  }
-  handleInput(key) {
-    if (key === "\x1B[A") {
-      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
-    } else if (key === "\x1B[B") {
-      const maxScroll = Math.max(0, this.contentLines.length - this.height);
-      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
-    } else if (key === "\x1B[5~") {
-      this.scrollOffset = Math.max(0, this.scrollOffset - this.height);
-    } else if (key === "\x1B[6~") {
-      const maxScroll = Math.max(0, this.contentLines.length - this.height);
-      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + this.height);
-    }
-  }
-}
-class Input extends Component {
-  constructor(config) {
-    super(config);
-    this.prefix = config.prefix || "";
-    this.placeholder = config.placeholder || "";
-    this.value = config.value || "";
-    this.onChange = config.onChange;
-    this.onSubmit = config.onSubmit;
-  }
-  setValue(value) {
-    this.value = value;
-    if (this.onChange) this.onChange(this.value);
-  }
-  getValue() {
-    return this.value;
-  }
-  render() {
-    const lines = [];
-    const theme = ThemeManager.current;
-    let text = this.prefix + (this.value || theme.muted(this.placeholder));
-    if (text.length > this.width) {
-      text = text.substring(0, this.width - 1) + "…";
-    }
-    lines.push((text + " ".repeat(Math.max(0, this.width - text.length))).substring(0, this.width));
-    return lines;
-  }
-  handleInput(key) {
-    if (key === "\r") {
-      if (this.onSubmit) this.onSubmit(this.value);
-    } else if (key === "" || key === "\b") {
-      if (this.value.length > 0) {
-        this.value = this.value.substring(0, this.value.length - 1);
-        if (this.onChange) this.onChange(this.value);
-      }
-    } else if (key.length === 1 && key >= " " && key <= "~") {
-      this.value += key;
-      if (this.onChange) this.onChange(this.value);
-    }
-  }
-}
-class StackNavigator extends Component {
-  constructor(config) {
-    super(config);
-    this.stack = [];
-    this.stack.push(config.initialComponent);
-  }
-  push(component) {
-    this.stack.push(component);
-    component.resize(this.x, this.y, this.width, this.height);
-  }
-  pop() {
-    if (this.stack.length > 1) {
-      this.stack.pop();
-    }
-  }
-  get currentComponent() {
-    return this.stack[this.stack.length - 1];
-  }
-  resize(x, y, width, height) {
-    super.resize(x, y, width, height);
-    this.currentComponent.resize(x, y, width, height);
-  }
-  render() {
-    return this.currentComponent.render();
-  }
-  handleInput(key) {
-    if ((key === "\x1B" || key === "\x1B[D") && this.stack.length > 1) {
-      this.pop();
-      this.currentComponent.resize(this.x, this.y, this.width, this.height);
-      return;
-    }
-    this.currentComponent.handleInput(key);
-  }
-  handleMouse(event) {
-    this.currentComponent.handleMouse(event);
-  }
-}
-const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  App,
-  Component,
-  Input,
-  List,
-  ScrollArea,
-  SplitLayout,
-  StackNavigator,
-  Terminal,
-  ThemeManager,
-  Themes
-}, Symbol.toStringTag, { value: "Module" }));
 const LATEST_PROTOCOL_VERSION = "2025-06-18";
 const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 const SUPPORTED_PROTOCOL_VERSIONS = [
@@ -10942,7 +10641,7 @@ function requireUri_all() {
   (function(module2, exports2) {
     (function(global2, factory) {
       factory(exports2);
-    })(uri_all, function(exports3) {
+    })(uri_all, (function(exports3) {
       function merge() {
         for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
           sets[_key] = arguments[_key];
@@ -11009,7 +10708,7 @@ function requireUri_all() {
       }
       var URI_PROTOCOL = buildExps(false);
       var IRI_PROTOCOL = buildExps(true);
-      var slicedToArray = /* @__PURE__ */ function() {
+      var slicedToArray = /* @__PURE__ */ (function() {
         function sliceIterator(arr, i) {
           var _arr = [];
           var _n = true;
@@ -11041,7 +10740,7 @@ function requireUri_all() {
             throw new TypeError("Invalid attempt to destructure non-iterable instance");
           }
         };
-      }();
+      })();
       var toConsumableArray = function(arr) {
         if (Array.isArray(arr)) {
           for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
@@ -11956,7 +11655,7 @@ function requireUri_all() {
       exports3.escapeComponent = escapeComponent;
       exports3.unescapeComponent = unescapeComponent;
       Object.defineProperty(exports3, "__esModule", { value: true });
-    });
+    }));
   })(uri_all$1, uri_all$1.exports);
   return uri_all$1.exports;
 }
@@ -12550,7 +12249,7 @@ function requireFastJsonStableStringify() {
     if (!opts) opts = {};
     if (typeof opts === "function") opts = { cmp: opts };
     var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
-    var cmp = opts.cmp && /* @__PURE__ */ function(f) {
+    var cmp = opts.cmp && /* @__PURE__ */ (function(f) {
       return function(node) {
         return function(a, b) {
           var aobj = { key: a, value: node[a] };
@@ -12558,9 +12257,9 @@ function requireFastJsonStableStringify() {
           return f(aobj, bobj);
         };
       };
-    }(opts.cmp);
+    })(opts.cmp);
     var seen = [];
-    return function stringify2(node) {
+    return (function stringify2(node) {
       if (node && node.toJSON && typeof node.toJSON === "function") {
         node = node.toJSON();
       }
@@ -12593,7 +12292,7 @@ function requireFastJsonStableStringify() {
       }
       seen.splice(seenIndex, 1);
       return "{" + out + "}";
-    }(data2);
+    })(data2);
   };
   return fastJsonStableStringify;
 }
@@ -16954,14 +16653,14 @@ function requireAjv() {
     return metaOpts;
   }
   function setLogger(self2) {
-    var logger = self2._opts.logger;
-    if (logger === false) {
+    var logger2 = self2._opts.logger;
+    if (logger2 === false) {
       self2.logger = { log: noop, warn: noop, error: noop };
     } else {
-      if (logger === void 0) logger = console;
-      if (!(typeof logger == "object" && logger.log && logger.warn && logger.error))
+      if (logger2 === void 0) logger2 = console;
+      if (!(typeof logger2 == "object" && logger2.log && logger2.warn && logger2.error))
         throw new Error("logger must implement log, warn and error methods");
-      self2.logger = logger;
+      self2.logger = logger2;
     }
   }
   function noop() {
@@ -18152,9 +17851,9 @@ const mcp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty(
   ResourceTemplate
 }, Symbol.toStringTag, { value: "Module" }));
 class McpLifecycleManager {
-  constructor(events, logger, serverInfo, argParser) {
+  constructor(events, logger2, serverInfo, argParser) {
     this.events = events;
-    this.logger = logger;
+    this.logger = logger2;
     this.serverInfo = serverInfo;
     this.argParser = argParser;
     this.state = {
@@ -20428,7 +20127,7 @@ function requireBuffer() {
     function numberIsNaN(obj) {
       return obj !== obj;
     }
-    var hexSliceLookupTable = function() {
+    var hexSliceLookupTable = (function() {
       var alphabet = "0123456789abcdef";
       var table = new Array(256);
       for (var i = 0; i < 16; ++i) {
@@ -20438,7 +20137,7 @@ function requireBuffer() {
         }
       }
       return table;
-    }();
+    })();
   })(buffer);
   return buffer;
 }
@@ -25524,7 +25223,7 @@ function getStringEnd(str, seek) {
   }
   return seek;
 }
-let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}:\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
 class TomlDate extends Date {
   #hasDate = false;
   #hasTime = false;
@@ -25617,13 +25316,14 @@ class TomlDate extends Date {
 let INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
 let FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
 let LEADING_ZERO = /^[+-]?0[0-9_]/;
-let ESCAPE_REGEX = /^[0-9a-f]{4,8}$/i;
+let ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
 let ESC_MAP = {
   b: "\b",
   t: "	",
   n: "\n",
   f: "\f",
   r: "\r",
+  e: "\x1B",
   '"': '"',
   "\\": "\\"
 };
@@ -25658,8 +25358,8 @@ function parseString(str, ptr = 0, endPtr = str.length) {
     }
     if (isEscape) {
       isEscape = false;
-      if (c === "u" || c === "U") {
-        let code = str.slice(ptr, ptr += c === "u" ? 4 : 8);
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
         if (!ESCAPE_REGEX.test(code)) {
           throw new TomlError("invalid unicode escape", {
             toml: str,
@@ -25750,24 +25450,14 @@ function parseValue(value, toml, ptr, integersAsBigInt) {
   }
   return date;
 }
-function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
   let value = str.slice(startPtr, endPtr);
   let commentIdx = value.indexOf("#");
   if (commentIdx > -1) {
     skipComment(str, commentIdx);
     value = value.slice(0, commentIdx);
   }
-  let trimmed = value.trimEnd();
-  if (!allowNewLines) {
-    let newlineIdx = value.indexOf("\n", trimmed.length);
-    if (newlineIdx > -1) {
-      throw new TomlError("newlines are not allowed in inline tables", {
-        toml: str,
-        ptr: startPtr + newlineIdx
-      });
-    }
-  }
-  return [trimmed, commentIdx];
+  return [value.trimEnd(), commentIdx];
 }
 function extractValue(str, ptr, end, depth, integersAsBigInt) {
   if (depth === 0) {
@@ -25779,24 +25469,25 @@ function extractValue(str, ptr, end, depth, integersAsBigInt) {
   let c = str[ptr];
   if (c === "[" || c === "{") {
     let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
-    let newPtr = end ? skipUntil(str, endPtr2, ",", end) : endPtr2;
-    if (endPtr2 - newPtr && end === "}") {
-      let nextNewLine = indexOfNewline(str, endPtr2, newPtr);
-      if (nextNewLine > -1) {
-        throw new TomlError("newlines are not allowed in inline tables", {
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
           toml: str,
-          ptr: nextNewLine
+          ptr: endPtr2
         });
       }
     }
-    return [value, newPtr];
+    return [value, endPtr2];
   }
   let endPtr;
   if (c === '"' || c === "'") {
     endPtr = getStringEnd(str, ptr);
     let parsed = parseString(str, ptr, endPtr);
     if (end) {
-      endPtr = skipVoid(str, endPtr, end !== "]");
+      endPtr = skipVoid(str, endPtr);
       if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
         throw new TomlError("unexpected character encountered", {
           toml: str,
@@ -25808,7 +25499,7 @@ function extractValue(str, ptr, end, depth, integersAsBigInt) {
     return [parsed, endPtr];
   }
   endPtr = skipUntil(str, ptr, ",", end);
-  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","), end === "]");
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
   if (!slice[0]) {
     throw new TomlError("incomplete key-value declaration: no value specified", {
       toml: str,
@@ -25896,17 +25587,16 @@ function parseInlineTable(str, ptr, depth, integersAsBigInt) {
   let res = {};
   let seen = /* @__PURE__ */ new Set();
   let c;
-  let comma = 0;
   ptr++;
   while ((c = str[ptr++]) !== "}" && c) {
-    let err = { toml: str, ptr: ptr - 1 };
-    if (c === "\n") {
-      throw new TomlError("newlines are not allowed in inline tables", err);
-    } else if (c === "#") {
-      throw new TomlError("inline tables cannot contain comments", err);
-    } else if (c === ",") {
-      throw new TomlError("expected key-value, found comma", err);
-    } else if (c !== " " && c !== "	") {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
       let k;
       let t = res;
       let hasOwn = false;
@@ -25935,15 +25625,8 @@ function parseInlineTable(str, ptr, depth, integersAsBigInt) {
       seen.add(value);
       t[k] = value;
       ptr = valueEndPtr;
-      comma = str[ptr - 1] === "," ? ptr - 1 : 0;
     }
   }
-  if (comma) {
-    throw new TomlError("trailing commas are not allowed in inline tables", {
-      toml: str,
-      ptr: comma
-    });
-  }
   if (!c) {
     throw new TomlError("unfinished table encountered", {
       toml: str,
@@ -26274,13 +25957,14 @@ exports.ConfigPlugin = ConfigPlugin;
 exports.ConfigPluginRegistry = ConfigPluginRegistry;
 exports.DxtPathResolver = DxtPathResolver;
 exports.EnvConfigPlugin = EnvConfigPlugin;
+exports.FlagInheritance = FlagInheritance;
 exports.JsonConfigPlugin = JsonConfigPlugin;
 exports.OutputSchemaPatterns = OutputSchemaPatterns;
 exports.SimpleChalk = simpleChalk;
 exports.TomlConfigPlugin = TomlConfigPlugin;
-exports.UI = index$2;
 exports.YamlConfigPlugin = YamlConfigPlugin;
 exports.absolutePath = absolutePath;
+exports.autoHelpHandler = autoHelpHandler;
 exports.convertFlagToJsonSchemaProperty = convertFlagToJsonSchemaProperty;
 exports.convertFlagsToJsonSchema = convertFlagsToJsonSchema;
 exports.convertFlagsToZodSchema = convertFlagsToZodSchema;