@bonginkan/maria 3.0.9 → 3.1.0

package/dist/bin/maria.cjs

@@ -28,7 +28,6 @@ var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__
   isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/services/startup-display.ts
 var startup_display_exports = {};
@@ -166,10 +165,6 @@ function displayFinalStartupScreen(_selectedProvider, _selectedModel) {
   console.log(import_chalk.default.magentaBright("\u2551                                                          \u2551"));
   console.log(import_chalk.default.magentaBright("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
   console.log("");
-  console.log("");
-  console.log(import_chalk.default.gray("AI-Powered Development Platform"));
-  console.log(import_chalk.default.gray(" (c) 2025 Bonginkan Inc."));
-  console.log("");
   console.log(import_chalk.default.cyan.bold(`MARIA CODE v${version}`) + import_chalk.default.gray(" \u2014 Ready"));
   console.log(import_chalk.default.yellow("/help for commands") + import_chalk.default.gray(" | Providers: 8/8 OK"));
   console.log("");
@@ -11411,14 +11406,7 @@ var init_ai_response_service = __esm({
       async callAIProvider(context2, _options) {
         const userInput2 = context2.currentInput.toLowerCase();
         const hasContext = context2.messages.length > 0;
-        console.log("\u{1F9E0} AI Provider Debug:", {
-          userInput: userInput2,
-          hasContext,
-          messagesCount: context2.messages.length,
-          contextStats: context2.contextStats
-        });
         const intent2 = this.analyzeIntent(userInput2, context2);
-        console.log("\u{1F3AF} Intent Analysis:", intent2);
         switch (intent2.type) {
           case "TETRIS_REQUEST":
             return this.generateTetrisGame(userInput2);
@@ -11442,11 +11430,6 @@ var init_ai_response_service = __esm({
         const messages2 = context2.messages || [];
         const recentMessages2 = messages2.slice(-3);
         const contextString = recentMessages2.map((m2) => m2.content).join(" ").toLowerCase();
-        console.log("\u{1F50D} Context Analysis:", {
-          userInput: userInput2,
-          contextString: contextString.substring(0, 100) + "...",
-          recentMessagesCount: recentMessages2.length
-        });
         if (userInput2.includes("tetris") || contextString.includes("tetris") && (userInput2.includes("html") || userInput2.includes("game") || userInput2.includes("whole code") || userInput2.includes("start") || userInput2.includes("black") || userInput2.includes("background"))) {
           return {
             type: "TETRIS_REQUEST",
@@ -14030,13 +14013,350 @@ var init_template_manager = __esm({
   }
 });
 
+// src/services/batch-execution.ts
+var import_chalk10, BatchExecutionEngine;
+var init_batch_execution = __esm({
+  "src/services/batch-execution.ts"() {
+    import_chalk10 = __toESM(require("chalk"), 1);
+    BatchExecutionEngine = class _BatchExecutionEngine {
+      static instance;
+      commandHandler = null;
+      variables = {};
+      isExecuting = false;
+      constructor() {
+      }
+      /**
+       * Set command handler via dependency injection
+       */
+      setCommandHandler(handler) {
+        this.commandHandler = handler;
+      }
+      getCommandHandler() {
+        if (!this.commandHandler) {
+          throw new Error("CommandHandler not injected. Call setCommandHandler() first.");
+        }
+        return this.commandHandler;
+      }
+      static getInstance() {
+        if (!_BatchExecutionEngine.instance) {
+          _BatchExecutionEngine.instance = new _BatchExecutionEngine();
+        }
+        return _BatchExecutionEngine.instance;
+      }
+      /**
+       * Parse _batch command string
+       */
+      parseBatchString(batchString) {
+        const _lines = batchString.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
+        const commands2 = [];
+        lines.forEach((line) => {
+          const _ifMatch = line.match(/^IF\s+(.+)\s+THEN\s+(.+)(?:\s+ELSE\s+(.+))?$/i);
+          if (_ifMatch) {
+            const [, condition, thenCmd, elseCmd] = _ifMatch;
+            if (condition && thenCmd) {
+              commands2.push({
+                command: thenCmd.split(" ")[0] || "",
+                args: thenCmd.split(" ").slice(1),
+                condition
+              });
+              if (elseCmd) {
+                commands2.push({
+                  command: elseCmd.split(" ")[0] || "",
+                  args: elseCmd.split(" ").slice(1),
+                  condition: `!${condition}`
+                });
+              }
+            }
+            return;
+          }
+          if (line.startsWith("PARALLEL:")) {
+            const _parallelCommands = line.substring(9).split("&&").map((cmd2) => cmd2.trim());
+            parallelCommands.forEach((cmd2) => {
+              const _parts2 = cmd2.split(" ");
+              if (_parts2[0]) {
+                commands2.push({
+                  command: _parts2[0],
+                  args: parts.slice(1),
+                  parallel: true
+                });
+              }
+            });
+            return;
+          }
+          const _parts = line.split(" ");
+          if (_parts[0]) {
+            commands2.push({
+              command: _parts[0],
+              args: parts.slice(1)
+            });
+          }
+        });
+        return commands2;
+      }
+      /**
+       * Execute a _batch of commands
+       */
+      async executeBatch(commands2, context2, options2 = {}) {
+        if (this.isExecuting) {
+          throw new Error("Batch execution already in progress");
+        }
+        this.isExecuting = true;
+        const _startTime = Date.now();
+        this.variables = { ...options2.variables };
+        const result2 = {
+          success: true,
+          totalCommands: commands2.length,
+          executed: 0,
+          succeeded: 0,
+          failed: 0,
+          skipped: 0,
+          _duration: 0,
+          results: [],
+          variables: this.variables
+        };
+        console.log(import_chalk10.default.blue("\n\u{1F680} Starting _batch execution\n"));
+        if (options2.dryRun) {
+          console.log(import_chalk10.default.yellow("DRY RUN MODE - Commands will not be executed\n"));
+          commands2.forEach((cmd2, _i) => {
+            console.log(import_chalk10.default.gray(`${i + 1}. ${cmd2.command} ${cmd2.args.join(" ")}`));
+            if (cmd2.condition) {
+              console.log(import_chalk10.default.gray(`   IF: ${cmd2.condition}`));
+            }
+          });
+          this.isExecuting = false;
+          return result2;
+        }
+        try {
+          const _commandGroups = this.groupCommands(commands2);
+          for (const group of _commandGroups) {
+            if (options2.stopOnError && result2.failed > 0) {
+              console.log(import_chalk10.default.yellow("\n\u23F9\uFE0F  Stopping due to _error (stopOnError=true)"));
+              break;
+            }
+            if (group.length === 1 && group[0]) {
+              await this.executeSingleCommand(group[0], context2, result2);
+            } else {
+              await this.executeParallelCommands(group, context2, result2, options2.maxParallel || 3);
+            }
+          }
+          result2.duration = Date.now() - _startTime;
+          result2.success = result2.failed === 0;
+          this.printSummary(result2);
+        } finally {
+          this.isExecuting = false;
+        }
+        return result2;
+      }
+      /**
+       * Execute a single command
+       */
+      async executeSingleCommand(cmd2, context2, result2) {
+        if (cmd2.condition && !this.evaluateCondition(cmd2.condition)) {
+          result2.skipped++;
+          console.log(import_chalk10.default.gray(`\u23ED\uFE0F  Skipping ${cmd2.command} (condition not met)`));
+          return;
+        }
+        console.log(import_chalk10.default.cyan(`
+\u25B6\uFE0F  Executing: ${cmd2.command} ${cmd2.args.join(" ")}`));
+        const _startTime = Date.now();
+        let attempts = 0;
+        const _maxAttempts = cmd2.retries ? cmd2.retries + 1 : 1;
+        while (attempts < _maxAttempts) {
+          attempts++;
+          try {
+            const _cmdResult = await this.executeWithTimeout(
+              () => this.getCommandHandler().handleCommand(cmd2.command, cmd2.args, context2),
+              cmd2.timeout || 3e4
+            );
+            const _duration = Date.now() - _startTime;
+            result2.executed++;
+            if (cmdResult.success) {
+              result2.succeeded++;
+              console.log(import_chalk10.default.green(`\u2705 Success (${_duration}ms)`));
+              result2.results.push({
+                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                success: true,
+                output: cmdResult.message,
+                _duration
+              });
+              if (cmdResult.data && typeof cmdResult.data === "object" && "variable" in cmdResult.data && "_value" in cmdResult.data) {
+                const _resultData = cmdResult.data;
+                this.variables[resultData.variable] = resultData.value;
+              }
+              break;
+            } else {
+              if (attempts < _maxAttempts) {
+                console.log(import_chalk10.default.yellow(`\u26A0\uFE0F  Failed, retrying (${attempts}/${_maxAttempts})...`));
+                await this.delay(1e3);
+              } else {
+                result2.failed++;
+                console.log(import_chalk10.default.red(`\u274C Failed: ${cmdResult.message}`));
+                result2.results.push({
+                  command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                  success: false,
+                  _error: cmdResult.message,
+                  _duration
+                });
+              }
+            }
+          } catch (_error) {
+            const _duration = Date.now() - _startTime;
+            if (attempts < _maxAttempts) {
+              console.log(import_chalk10.default.yellow(`\u26A0\uFE0F  Error, retrying (${attempts}/${_maxAttempts})...`));
+              await this.delay(1e3);
+            } else {
+              result2.failed++;
+              result2.executed++;
+              const _errorMsg = _error instanceof Error ? error.message : "Unknown _error";
+              console.log(import_chalk10.default.red(`\u274C Error: ${_errorMsg}`));
+              result2.results.push({
+                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                success: false,
+                _error: _errorMsg,
+                _duration
+              });
+            }
+          }
+        }
+      }
+      /**
+       * Execute commands in parallel
+       */
+      async executeParallelCommands(commands2, context2, result2, maxParallel) {
+        console.log(import_chalk10.default.cyan(`
+\u26A1 Executing ${commands2.length} commands in parallel`));
+        const _promises = commands2.map(
+          (cmd2) => this.executeSingleCommand(cmd2, context2, {
+            ...result2,
+            executed: 0,
+            succeeded: 0,
+            failed: 0,
+            skipped: 0,
+            results: []
+          })
+        );
+        for (let i2 = 0; i2 < promises.length; i2 += maxParallel) {
+          const _batch = promises.slice(i2, i2 + maxParallel);
+          const _batchResults = await Promise.allSettled(_batch);
+          batchResults.forEach((batchResult) => {
+            if (batchResult.status === "rejected") {
+              result2.failed++;
+              result2.executed++;
+            }
+          });
+        }
+      }
+      /**
+       * Group commands for execution
+       */
+      groupCommands(commands2) {
+        const groups = [];
+        let currentGroup = [];
+        commands2.forEach((cmd2) => {
+          if (cmd2.parallel && currentGroup.length > 0) {
+            currentGroup.push(cmd2);
+          } else {
+            if (currentGroup.length > 0) {
+              groups.push(currentGroup);
+            }
+            currentGroup = [cmd2];
+          }
+        });
+        if (currentGroup.length > 0) {
+          groups.push(currentGroup);
+        }
+        return groups;
+      }
+      /**
+       * Evaluate condition
+       */
+      evaluateCondition(condition) {
+        if (condition.startsWith("!")) {
+          return !this.evaluateCondition(condition.substring(1));
+        }
+        if (condition.startsWith("$")) {
+          const _varName = condition.substring(1);
+          return this.variables[_varName] !== void 0;
+        }
+        const _eqMatch = condition.match(/^\$(\w+)\s*==\s*(.+)$/);
+        if (_eqMatch && _eqMatch[1] && _eqMatch[2] !== void 0) {
+          const _varName = _eqMatch[1];
+          const _value = _eqMatch[2];
+          return String(this.variables[_varName] || "") === _value;
+        }
+        switch (condition) {
+          case "hasErrors":
+            return this.variables["hasErrors"] === true;
+          case "testsPass":
+            return this.variables["testsPass"] === true;
+          default:
+            return true;
+        }
+      }
+      /**
+       * Execute with timeout
+       */
+      async executeWithTimeout(fn, timeout) {
+        return Promise.race([
+          fn(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Command timeout")), timeout)
+          )
+        ]);
+      }
+      /**
+       * Print execution summary
+       */
+      printSummary(result2) {
+        console.log(import_chalk10.default.blue("\n\u{1F4CA} Batch Execution Summary\n"));
+        const _successRate = result2.executed > 0 ? Math.round(result2.succeeded / result2.executed * 100) : 0;
+        console.log(`Total Commands: ${result2.totalCommands}`);
+        console.log(`Executed: ${result2.executed}`);
+        console.log(import_chalk10.default.green(`Succeeded: ${result2.succeeded}`));
+        if (result2.failed > 0) {
+          console.log(import_chalk10.default.red(`Failed: ${result2.failed}`));
+        }
+        if (result2.skipped > 0) {
+          console.log(import_chalk10.default.gray(`Skipped: ${result2.skipped}`));
+        }
+        console.log(`Success Rate: ${_successRate}%`);
+        console.log(`Duration: ${(result2.duration / 1e3).toFixed(2)}s`);
+        if (Object.keys(result2.variables).length > 0) {
+          console.log("\nVariables Set:");
+          Object.entries(result2.variables).forEach(([key2, _value]) => {
+            console.log(`  ${key2} = ${JSON.stringify(_value)}`);
+          });
+        }
+      }
+      /**
+       * Helper to add delay
+       */
+      delay(ms) {
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
+      }
+      /**
+       * Check if _batch is executing
+       */
+      getExecutionStatus() {
+        return this.isExecuting;
+      }
+      /**
+       * Get current variables
+       */
+      getVariables() {
+        return { ...this.variables };
+      }
+    };
+  }
+});
+
 // src/services/hotkey-manager.ts
-var import_chalk10, import_fs4, import_path3, import_os3, logger4, HotkeyManager;
+var import_chalk11, import_fs4, import_path3, import_os3, logger4, HotkeyManager;
 var init_hotkey_manager = __esm({
   "src/services/hotkey-manager.ts"() {
     init_slash_command_handler();
     init_logger();
-    import_chalk10 = __toESM(require("chalk"), 1);
+    import_chalk11 = __toESM(require("chalk"), 1);
     import_fs4 = require("fs");
     import_path3 = require("path");
     import_os3 = require("os");
@@ -14437,19 +14757,19 @@ var init_hotkey_manager = __esm({
         if (_bindings.length === 0) {
           return "No hotkeys configured.";
         }
-        let help = import_chalk10.default.bold("\nAvailable Hotkeys:\n\n");
+        let help = import_chalk11.default.bold("\nAvailable Hotkeys:\n\n");
         _bindings.forEach((raw) => {
           const _binding = this.normalize(raw);
-          const _hotkey = import_chalk10.default.cyan(this.formatHotkey(raw));
-          const _command = import_chalk10.default.yellow(_binding.command);
-          const _args = _binding.args ? import_chalk10.default.gray(` ${_binding.args.join(" ")}`) : "";
-          const _desc = _binding.description ? import_chalk10.default.gray(` - ${_binding.description}`) : "";
-          const _status = !_binding.enabled ? import_chalk10.default.red(" [disabled]") : "";
+          const _hotkey = import_chalk11.default.cyan(this.formatHotkey(raw));
+          const _command = import_chalk11.default.yellow(_binding.command);
+          const _args = _binding.args ? import_chalk11.default.gray(` ${_binding.args.join(" ")}`) : "";
+          const _desc = _binding.description ? import_chalk11.default.gray(` - ${_binding.description}`) : "";
+          const _status = !_binding.enabled ? import_chalk11.default.red(" [disabled]") : "";
           help += `  ${_hotkey.padEnd(20)} \u2192 ${_command}${_args}${_desc}${_status}
 `;
         });
         help += `
-${import_chalk10.default.gray("Use /_hotkey to manage hotkeys")}
+${import_chalk11.default.gray("Use /_hotkey to manage hotkeys")}
 `;
         return help;
       }
@@ -16634,12 +16954,12 @@ var init_ReferentialResolver = __esm({
 });
 
 // src/services/conversation/ContextAwareSaveHandler.ts
-var fs6, path8, import_chalk11, ContextAwareSaveHandler;
+var fs6, path8, import_chalk12, ContextAwareSaveHandler;
 var init_ContextAwareSaveHandler = __esm({
   "src/services/conversation/ContextAwareSaveHandler.ts"() {
     fs6 = __toESM(require("fs/promises"), 1);
     path8 = __toESM(require("path"), 1);
-    import_chalk11 = __toESM(require("chalk"), 1);
+    import_chalk12 = __toESM(require("chalk"), 1);
     init_TurnManager();
     init_ReferentialResolver();
     ContextAwareSaveHandler = class _ContextAwareSaveHandler {
@@ -16873,7 +17193,7 @@ var init_ContextAwareSaveHandler = __esm({
           await fs6.access(this.mariaGeneratedDir);
         } catch (_error) {
           await fs6.mkdir(this.mariaGeneratedDir, { recursive: true });
-          console.log(import_chalk11.default.blue(`\u{1F4C1} Created '${this.mariaGeneratedDir}' folder for MARIA outputs`));
+          console.log(import_chalk12.default.blue(`\u{1F4C1} Created '${this.mariaGeneratedDir}' folder for MARIA outputs`));
         }
       }
       async ensureDirectoryExists(dirPath) {
@@ -17000,347 +17320,6 @@ ${dirName}/
   }
 });
 
-// src/services/batch-execution.ts
-var batch_execution_exports = {};
-__export(batch_execution_exports, {
-  BatchExecutionEngine: () => BatchExecutionEngine
-});
-var import_chalk12, BatchExecutionEngine;
-var init_batch_execution = __esm({
-  "src/services/batch-execution.ts"() {
-    import_chalk12 = __toESM(require("chalk"), 1);
-    BatchExecutionEngine = class _BatchExecutionEngine {
-      static instance;
-      commandHandler = null;
-      variables = {};
-      isExecuting = false;
-      constructor() {
-      }
-      /**
-       * Set command handler via dependency injection
-       */
-      setCommandHandler(handler) {
-        this.commandHandler = handler;
-      }
-      getCommandHandler() {
-        if (!this.commandHandler) {
-          throw new Error("CommandHandler not injected. Call setCommandHandler() first.");
-        }
-        return this.commandHandler;
-      }
-      static getInstance() {
-        if (!_BatchExecutionEngine.instance) {
-          _BatchExecutionEngine.instance = new _BatchExecutionEngine();
-        }
-        return _BatchExecutionEngine.instance;
-      }
-      /**
-       * Parse _batch command string
-       */
-      parseBatchString(batchString) {
-        const _lines = batchString.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
-        const commands2 = [];
-        lines.forEach((line) => {
-          const _ifMatch = line.match(/^IF\s+(.+)\s+THEN\s+(.+)(?:\s+ELSE\s+(.+))?$/i);
-          if (_ifMatch) {
-            const [, condition, thenCmd, elseCmd] = _ifMatch;
-            if (condition && thenCmd) {
-              commands2.push({
-                command: thenCmd.split(" ")[0] || "",
-                args: thenCmd.split(" ").slice(1),
-                condition
-              });
-              if (elseCmd) {
-                commands2.push({
-                  command: elseCmd.split(" ")[0] || "",
-                  args: elseCmd.split(" ").slice(1),
-                  condition: `!${condition}`
-                });
-              }
-            }
-            return;
-          }
-          if (line.startsWith("PARALLEL:")) {
-            const _parallelCommands = line.substring(9).split("&&").map((cmd2) => cmd2.trim());
-            parallelCommands.forEach((cmd2) => {
-              const _parts2 = cmd2.split(" ");
-              if (_parts2[0]) {
-                commands2.push({
-                  command: _parts2[0],
-                  args: parts.slice(1),
-                  parallel: true
-                });
-              }
-            });
-            return;
-          }
-          const _parts = line.split(" ");
-          if (_parts[0]) {
-            commands2.push({
-              command: _parts[0],
-              args: parts.slice(1)
-            });
-          }
-        });
-        return commands2;
-      }
-      /**
-       * Execute a _batch of commands
-       */
-      async executeBatch(commands2, context2, options2 = {}) {
-        if (this.isExecuting) {
-          throw new Error("Batch execution already in progress");
-        }
-        this.isExecuting = true;
-        const _startTime = Date.now();
-        this.variables = { ...options2.variables };
-        const result2 = {
-          success: true,
-          totalCommands: commands2.length,
-          executed: 0,
-          succeeded: 0,
-          failed: 0,
-          skipped: 0,
-          _duration: 0,
-          results: [],
-          variables: this.variables
-        };
-        console.log(import_chalk12.default.blue("\n\u{1F680} Starting _batch execution\n"));
-        if (options2.dryRun) {
-          console.log(import_chalk12.default.yellow("DRY RUN MODE - Commands will not be executed\n"));
-          commands2.forEach((cmd2, _i) => {
-            console.log(import_chalk12.default.gray(`${i + 1}. ${cmd2.command} ${cmd2.args.join(" ")}`));
-            if (cmd2.condition) {
-              console.log(import_chalk12.default.gray(`   IF: ${cmd2.condition}`));
-            }
-          });
-          this.isExecuting = false;
-          return result2;
-        }
-        try {
-          const _commandGroups = this.groupCommands(commands2);
-          for (const group of _commandGroups) {
-            if (options2.stopOnError && result2.failed > 0) {
-              console.log(import_chalk12.default.yellow("\n\u23F9\uFE0F  Stopping due to _error (stopOnError=true)"));
-              break;
-            }
-            if (group.length === 1 && group[0]) {
-              await this.executeSingleCommand(group[0], context2, result2);
-            } else {
-              await this.executeParallelCommands(group, context2, result2, options2.maxParallel || 3);
-            }
-          }
-          result2.duration = Date.now() - _startTime;
-          result2.success = result2.failed === 0;
-          this.printSummary(result2);
-        } finally {
-          this.isExecuting = false;
-        }
-        return result2;
-      }
-      /**
-       * Execute a single command
-       */
-      async executeSingleCommand(cmd2, context2, result2) {
-        if (cmd2.condition && !this.evaluateCondition(cmd2.condition)) {
-          result2.skipped++;
-          console.log(import_chalk12.default.gray(`\u23ED\uFE0F  Skipping ${cmd2.command} (condition not met)`));
-          return;
-        }
-        console.log(import_chalk12.default.cyan(`
-\u25B6\uFE0F  Executing: ${cmd2.command} ${cmd2.args.join(" ")}`));
-        const _startTime = Date.now();
-        let attempts = 0;
-        const _maxAttempts = cmd2.retries ? cmd2.retries + 1 : 1;
-        while (attempts < _maxAttempts) {
-          attempts++;
-          try {
-            const _cmdResult = await this.executeWithTimeout(
-              () => this.getCommandHandler().handleCommand(cmd2.command, cmd2.args, context2),
-              cmd2.timeout || 3e4
-            );
-            const _duration = Date.now() - _startTime;
-            result2.executed++;
-            if (cmdResult.success) {
-              result2.succeeded++;
-              console.log(import_chalk12.default.green(`\u2705 Success (${_duration}ms)`));
-              result2.results.push({
-                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                success: true,
-                output: cmdResult.message,
-                _duration
-              });
-              if (cmdResult.data && typeof cmdResult.data === "object" && "variable" in cmdResult.data && "_value" in cmdResult.data) {
-                const _resultData = cmdResult.data;
-                this.variables[resultData.variable] = resultData.value;
-              }
-              break;
-            } else {
-              if (attempts < _maxAttempts) {
-                console.log(import_chalk12.default.yellow(`\u26A0\uFE0F  Failed, retrying (${attempts}/${_maxAttempts})...`));
-                await this.delay(1e3);
-              } else {
-                result2.failed++;
-                console.log(import_chalk12.default.red(`\u274C Failed: ${cmdResult.message}`));
-                result2.results.push({
-                  command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                  success: false,
-                  _error: cmdResult.message,
-                  _duration
-                });
-              }
-            }
-          } catch (_error) {
-            const _duration = Date.now() - _startTime;
-            if (attempts < _maxAttempts) {
-              console.log(import_chalk12.default.yellow(`\u26A0\uFE0F  Error, retrying (${attempts}/${_maxAttempts})...`));
-              await this.delay(1e3);
-            } else {
-              result2.failed++;
-              result2.executed++;
-              const _errorMsg = _error instanceof Error ? error.message : "Unknown _error";
-              console.log(import_chalk12.default.red(`\u274C Error: ${_errorMsg}`));
-              result2.results.push({
-                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                success: false,
-                _error: _errorMsg,
-                _duration
-              });
-            }
-          }
-        }
-      }
-      /**
-       * Execute commands in parallel
-       */
-      async executeParallelCommands(commands2, context2, result2, maxParallel) {
-        console.log(import_chalk12.default.cyan(`
-\u26A1 Executing ${commands2.length} commands in parallel`));
-        const _promises = commands2.map(
-          (cmd2) => this.executeSingleCommand(cmd2, context2, {
-            ...result2,
-            executed: 0,
-            succeeded: 0,
-            failed: 0,
-            skipped: 0,
-            results: []
-          })
-        );
-        for (let i2 = 0; i2 < promises.length; i2 += maxParallel) {
-          const _batch = promises.slice(i2, i2 + maxParallel);
-          const _batchResults = await Promise.allSettled(_batch);
-          batchResults.forEach((batchResult) => {
-            if (batchResult.status === "rejected") {
-              result2.failed++;
-              result2.executed++;
-            }
-          });
-        }
-      }
-      /**
-       * Group commands for execution
-       */
-      groupCommands(commands2) {
-        const groups = [];
-        let currentGroup = [];
-        commands2.forEach((cmd2) => {
-          if (cmd2.parallel && currentGroup.length > 0) {
-            currentGroup.push(cmd2);
-          } else {
-            if (currentGroup.length > 0) {
-              groups.push(currentGroup);
-            }
-            currentGroup = [cmd2];
-          }
-        });
-        if (currentGroup.length > 0) {
-          groups.push(currentGroup);
-        }
-        return groups;
-      }
-      /**
-       * Evaluate condition
-       */
-      evaluateCondition(condition) {
-        if (condition.startsWith("!")) {
-          return !this.evaluateCondition(condition.substring(1));
-        }
-        if (condition.startsWith("$")) {
-          const _varName = condition.substring(1);
-          return this.variables[_varName] !== void 0;
-        }
-        const _eqMatch = condition.match(/^\$(\w+)\s*==\s*(.+)$/);
-        if (_eqMatch && _eqMatch[1] && _eqMatch[2] !== void 0) {
-          const _varName = _eqMatch[1];
-          const _value = _eqMatch[2];
-          return String(this.variables[_varName] || "") === _value;
-        }
-        switch (condition) {
-          case "hasErrors":
-            return this.variables["hasErrors"] === true;
-          case "testsPass":
-            return this.variables["testsPass"] === true;
-          default:
-            return true;
-        }
-      }
-      /**
-       * Execute with timeout
-       */
-      async executeWithTimeout(fn, timeout) {
-        return Promise.race([
-          fn(),
-          new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Command timeout")), timeout)
-          )
-        ]);
-      }
-      /**
-       * Print execution summary
-       */
-      printSummary(result2) {
-        console.log(import_chalk12.default.blue("\n\u{1F4CA} Batch Execution Summary\n"));
-        const _successRate = result2.executed > 0 ? Math.round(result2.succeeded / result2.executed * 100) : 0;
-        console.log(`Total Commands: ${result2.totalCommands}`);
-        console.log(`Executed: ${result2.executed}`);
-        console.log(import_chalk12.default.green(`Succeeded: ${result2.succeeded}`));
-        if (result2.failed > 0) {
-          console.log(import_chalk12.default.red(`Failed: ${result2.failed}`));
-        }
-        if (result2.skipped > 0) {
-          console.log(import_chalk12.default.gray(`Skipped: ${result2.skipped}`));
-        }
-        console.log(`Success Rate: ${_successRate}%`);
-        console.log(`Duration: ${(result2.duration / 1e3).toFixed(2)}s`);
-        if (Object.keys(result2.variables).length > 0) {
-          console.log("\nVariables Set:");
-          Object.entries(result2.variables).forEach(([key2, _value]) => {
-            console.log(`  ${key2} = ${JSON.stringify(_value)}`);
-          });
-        }
-      }
-      /**
-       * Helper to add delay
-       */
-      delay(ms) {
-        return new Promise((resolve6) => setTimeout(resolve6, ms));
-      }
-      /**
-       * Check if _batch is executing
-       */
-      getExecutionStatus() {
-        return this.isExecuting;
-      }
-      /**
-       * Get current variables
-       */
-      getVariables() {
-        return { ...this.variables };
-      }
-    };
-  }
-});
-
 // src/services/init/scanner.ts
 async function runWithBudget(tasks2, totalMs = 6e3, perStepMs = 600) {
   const started = Date.now();
@@ -22990,6 +22969,7 @@ var init_slash_command_handler = __esm({
     init_command_chain_service();
     init_alias_system();
     init_template_manager();
+    init_batch_execution();
     init_hotkey_manager();
     import_inquirer2 = __toESM(require("inquirer"), 1);
     init_chat_context_service();
@@ -23018,8 +22998,7 @@ var init_slash_command_handler = __esm({
         this.suggestionService = SuggestionService.getInstance();
         this.aliasSystem = AliasSystem.getInstance();
         this.templateManager = TemplateManager.getInstance();
-        const { BatchExecutionEngine: BatchExecutionEngine2 } = (init_batch_execution(), __toCommonJS(batch_execution_exports));
-        this.batchEngine = BatchExecutionEngine2.getInstance();
+        this.batchEngine = BatchExecutionEngine.getInstance();
         this.batchEngine.setCommandHandler(this);
         this.hotkeyManager = HotkeyManager.getInstance();
         this.chatContextService = ChatContextService2.getInstance();
@@ -27574,13 +27553,11 @@ __export(cli_exports, {
 });
 async function initializeServices() {
   try {
-    console.log(import_chalk18.default.cyan("Initializing conversation memory..."));
     conversationPersistence = new ConversationPersistence();
     chatContext = ChatContextService.getInstance();
     aiResponseService = new AIResponseService();
     slashCommandHandler = SlashCommandHandler.getInstance();
     const previousHistory = await conversationPersistence.loadHistory();
-    console.log(import_chalk18.default.green(`\u2705 Memory loaded: ${previousHistory.length} previous messages`));
     for (const msg2 of previousHistory) {
       await chatContext.addMessage({
         role: msg2.role,
@@ -27596,15 +27573,6 @@ async function initializeServices() {
 }
 async function generateAIResponse(input3) {
   try {
-    if (process.env.NODE_ENV !== "production") {
-      console.log("\u{1F527} CLI Debug - Session Memory:", {
-        sessionMemoryLength: sessionMemory.length,
-        lastFewMessages: sessionMemory.slice(-3).map((m2) => ({
-          role: m2.role,
-          content: m2.content.substring(0, 50) + "..."
-        }))
-      });
-    }
     const response2 = await aiResponseService.generateResponse({
       userInput: input3,
       sessionMemory,
@@ -27799,7 +27767,7 @@ var init_cli = __esm({
     init_chat_context_fixed_service();
     init_ai_response_service();
     init_slash_command_handler();
-    packageJson2 = { version: "3.0.9" };
+    packageJson2 = { version: "3.1.0" };
     sessionMemory = [];
     program = createCLI();
     program.parse(process.argv);
@@ -37747,8 +37715,8 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "3.0.9",
-      description: "\u{1F680} MARIA v3.0.9 - Minimal API, Maximum Power. Intelligent Router + Dual Memory + File System. Enterprise-ready AI development platform with enhanced /help command and stability improvements.",
+      version: "3.1.0",
+      description: "\u{1F680} MARIA v3.1.0 - Minimal API, Maximum Power. Intelligent Router + Dual Memory + File System. Enterprise-ready AI development platform with CLI cleanup and production-ready improvements.",
       keywords: [
         "ai",
         "cli",