@nomad-e/bluma-cli 0.1.1 → 0.1.4

package/dist/main.js

@@ -328,14 +328,14 @@ var init_async_command = __esm({
 });
 
 // src/main.ts
-import React10 from "react";
+import React11 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter2 } from "events";
 import { v4 as uuidv43 } from "uuid";
 
 // src/app/ui/App.tsx
-import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo10 } from "react";
-import { Box as Box16, Text as Text15, Static } from "ink";
+import { useState as useState7, useEffect as useEffect6, useRef as useRef5, useCallback as useCallback2, memo as memo11 } from "react";
+import { Box as Box17, Text as Text16, Static as Static2 } from "ink";
 
 // src/app/ui/layout.tsx
 import { Box, Text } from "ink";
@@ -3374,9 +3374,17 @@ async function loadSkill(args) {
       message: `Skill "${skill_name}" not found. Available skills: ${availableNames}`
     };
   }
+  if (globalContext.history) {
+    globalContext.history.push({
+      role: "user",
+      content: `[SKILL:${skill.name}]
+
+${skill.content}`
+    });
+  }
   return {
     success: true,
-    message: `Skill "${skill_name}" loaded.`,
+    message: `Skill "${skill_name}" loaded successfully. Follow the instructions in the skill content above.`,
     skill_name: skill.name,
     description: skill.description
   };
@@ -3823,7 +3831,13 @@ async function doSaveSessionHistory(sessionFile, history) {
   });
 }
 async function saveSessionHistory(sessionFile, history) {
-  debouncedSave(sessionFile, history);
+  const cleanHistory = history.filter((msg) => {
+    if (msg.role === "user" && typeof msg.content === "string") {
+      return !msg.content.startsWith("[SKILL:");
+    }
+    return true;
+  });
+  debouncedSave(sessionFile, cleanHistory);
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
@@ -4940,6 +4954,19 @@ var BluMaAgent = class {
           this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled before tool execution." });
           return;
         }
+        const actionMap = {
+          "edit_tool": "Editing",
+          "shell_command": "Executing",
+          "command_status": "Waiting",
+          "ls_tool": "Reading",
+          "read_file_lines": "Reading",
+          "message": "Responding",
+          "load_skill": "Loading skill",
+          "search_web": "Searching",
+          "todo": "Planning"
+        };
+        const action = actionMap[toolName] || "Processing";
+        this.eventBus.emit("action_status", { action });
         const result = await this.mcpClient.invoke(toolName, toolArgs);
         let finalResult = result;
         if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
@@ -5006,82 +5033,200 @@ ${editData.error.display}`;
         return;
       }
       const contextWindow = createApiContextWindow(this.history, this.maxContextTurns);
-      const response = await this.llm.chatCompletion({
-        model: "x-ai/grok-code-fast-1",
-        // model: "openrouter/polaris-alpha", //OpenRouter Openai training model
-        messages: contextWindow,
-        temperature: 0.3,
-        tools: this.mcpClient.getAvailableTools(),
-        tool_choice: "required",
-        parallel_tool_calls: false
-      });
+      const llmService = this.llm;
+      if (typeof llmService.chatCompletionStream === "function") {
+        await this._handleStreamingResponse(contextWindow);
+      } else {
+        await this._handleNonStreamingResponse(contextWindow);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "An unknown API error occurred.";
+      this.eventBus.emit("backend_message", { type: "error", message: errorMessage });
+    } finally {
+      await saveSessionHistory(this.sessionFile, this.history);
+    }
+  }
+  async _handleStreamingResponse(contextWindow) {
+    const llmService = this.llm;
+    this.eventBus.emit("action_status", { action: "Thinking" });
+    let accumulatedContent = "";
+    let toolCalls;
+    let hasEmittedStart = false;
+    let reasoningContent = "";
+    const stream = llmService.chatCompletionStream({
+      model: "x-ai/grok-code-fast-1",
+      messages: contextWindow,
+      temperature: 0.3,
+      tools: this.mcpClient.getAvailableTools(),
+      tool_choice: "required",
+      parallel_tool_calls: false
+    });
+    for await (const chunk of stream) {
       if (this.isInterrupted) {
+        this.eventBus.emit("stream_end", {});
         this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
         return;
       }
-      let message2 = response.choices[0].message;
-      message2 = ToolCallNormalizer.normalizeAssistantMessage(message2);
-      if (message2.reasoning_content || message2.reasoning) {
-        const reasoningText = message2.reasoning_content || message2.reasoning;
+      if (chunk.reasoning) {
+        if (!hasEmittedStart) {
+          this.eventBus.emit("stream_start", {});
+          hasEmittedStart = true;
+        }
+        reasoningContent += chunk.reasoning;
+        this.eventBus.emit("stream_reasoning_chunk", { delta: chunk.reasoning });
+      }
+      if (chunk.delta) {
+        if (!hasEmittedStart) {
+          this.eventBus.emit("stream_start", {});
+          hasEmittedStart = true;
+        }
+        accumulatedContent += chunk.delta;
+        this.eventBus.emit("stream_chunk", { delta: chunk.delta });
+      }
+      if (chunk.tool_calls) {
+        toolCalls = chunk.tool_calls;
+      }
+      if (chunk.finish_reason) {
+        if (hasEmittedStart) {
+          this.eventBus.emit("stream_end", {});
+        }
+      }
+    }
+    const message2 = {
+      role: "assistant",
+      content: accumulatedContent || null
+    };
+    if (toolCalls && toolCalls.length > 0) {
+      message2.tool_calls = toolCalls;
+    }
+    const normalizedMessage = ToolCallNormalizer.normalizeAssistantMessage(message2);
+    if (normalizedMessage.reasoning_content || normalizedMessage.reasoning) {
+      const reasoningText = normalizedMessage.reasoning_content || normalizedMessage.reasoning;
+      this.eventBus.emit("backend_message", {
+        type: "reasoning",
+        content: typeof reasoningText === "string" ? reasoningText : JSON.stringify(reasoningText)
+      });
+    }
+    this.history.push(normalizedMessage);
+    if (normalizedMessage.tool_calls && normalizedMessage.tool_calls.length > 0) {
+      const validToolCalls = normalizedMessage.tool_calls.filter(
+        (call) => ToolCallNormalizer.isValidToolCall(call)
+      );
+      if (validToolCalls.length === 0) {
         this.eventBus.emit("backend_message", {
-          type: "reasoning",
-          content: typeof reasoningText === "string" ? reasoningText : JSON.stringify(reasoningText)
+          type: "error",
+          message: "Model returned invalid tool calls. Retrying..."
         });
+        await this._continueConversation();
+        return;
       }
-      this.history.push(message2);
-      if (message2.tool_calls && message2.tool_calls.length > 0) {
-        const validToolCalls = message2.tool_calls.filter(
-          (call) => ToolCallNormalizer.isValidToolCall(call)
-        );
-        if (validToolCalls.length === 0) {
-          this.eventBus.emit("backend_message", {
-            type: "error",
-            message: "Model returned invalid tool calls. Retrying..."
-          });
-          await this._continueConversation();
-          return;
-        }
-        const autoApprovedTools = [
-          "message",
-          "ls_tool",
-          "count_file_lines",
-          "read_file_lines",
-          "todo",
-          "load_skill",
-          "search_web"
-        ];
-        const toolToCall = validToolCalls[0];
-        const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
-        if (isSafeTool) {
-          await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
+      const autoApprovedTools = [
+        "message",
+        "ls_tool",
+        "count_file_lines",
+        "read_file_lines",
+        "todo",
+        "load_skill",
+        "search_web"
+      ];
+      const toolToCall = validToolCalls[0];
+      const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+      if (isSafeTool) {
+        await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
+      } else {
+        const toolName = toolToCall.function.name;
+        if (toolName === "edit_tool") {
+          const args = JSON.parse(toolToCall.function.arguments);
+          const previewContent = await this._generateEditPreview(args);
+          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls, preview: previewContent });
         } else {
-          const toolName = toolToCall.function.name;
-          if (toolName === "edit_tool") {
-            const args = JSON.parse(toolToCall.function.arguments);
-            const previewContent = await this._generateEditPreview(args);
-            this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls, preview: previewContent });
-          } else {
-            this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
-          }
+          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
         }
-      } else if (message2.content) {
-        this.eventBus.emit("backend_message", { type: "assistant_message", content: message2.content });
-        const feedback = this.feedbackSystem.generateFeedback({
-          event: "protocol_violation_direct_text",
-          details: { violationContent: message2.content }
+      }
+    } else if (accumulatedContent) {
+      this.eventBus.emit("backend_message", { type: "assistant_message", content: accumulatedContent });
+      const feedback = this.feedbackSystem.generateFeedback({
+        event: "protocol_violation_direct_text",
+        details: { violationContent: accumulatedContent }
+      });
+      this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: accumulatedContent });
+      this.history.push({ role: "system", content: feedback.correction });
+      await this._continueConversation();
+    } else {
+      this.eventBus.emit("backend_message", { type: "info", message: "Agent is thinking... continuing reasoning cycle." });
+      await this._continueConversation();
+    }
+  }
+  async _handleNonStreamingResponse(contextWindow) {
+    const response = await this.llm.chatCompletion({
+      model: "x-ai/grok-code-fast-1",
+      messages: contextWindow,
+      temperature: 0.3,
+      tools: this.mcpClient.getAvailableTools(),
+      tool_choice: "required",
+      parallel_tool_calls: false
+    });
+    if (this.isInterrupted) {
+      this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+      return;
+    }
+    let message2 = response.choices[0].message;
+    message2 = ToolCallNormalizer.normalizeAssistantMessage(message2);
+    if (message2.reasoning_content || message2.reasoning) {
+      const reasoningText = message2.reasoning_content || message2.reasoning;
+      this.eventBus.emit("backend_message", {
+        type: "reasoning",
+        content: typeof reasoningText === "string" ? reasoningText : JSON.stringify(reasoningText)
+      });
+    }
+    this.history.push(message2);
+    if (message2.tool_calls && message2.tool_calls.length > 0) {
+      const validToolCalls = message2.tool_calls.filter(
+        (call) => ToolCallNormalizer.isValidToolCall(call)
+      );
+      if (validToolCalls.length === 0) {
+        this.eventBus.emit("backend_message", {
+          type: "error",
+          message: "Model returned invalid tool calls. Retrying..."
         });
-        this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message2.content });
-        this.history.push({ role: "system", content: feedback.correction });
         await this._continueConversation();
+        return;
+      }
+      const autoApprovedTools = [
+        "message",
+        "ls_tool",
+        "count_file_lines",
+        "read_file_lines",
+        "todo",
+        "load_skill",
+        "search_web"
+      ];
+      const toolToCall = validToolCalls[0];
+      const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+      if (isSafeTool) {
+        await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
       } else {
-        this.eventBus.emit("backend_message", { type: "info", message: "Agent is thinking... continuing reasoning cycle." });
-        await this._continueConversation();
+        const toolName = toolToCall.function.name;
+        if (toolName === "edit_tool") {
+          const args = JSON.parse(toolToCall.function.arguments);
+          const previewContent = await this._generateEditPreview(args);
+          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls, preview: previewContent });
+        } else {
+          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
+        }
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "An unknown API error occurred.";
-      this.eventBus.emit("backend_message", { type: "error", message: errorMessage });
-    } finally {
-      await saveSessionHistory(this.sessionFile, this.history);
+    } else if (message2.content) {
+      this.eventBus.emit("backend_message", { type: "assistant_message", content: message2.content });
+      const feedback = this.feedbackSystem.generateFeedback({
+        event: "protocol_violation_direct_text",
+        details: { violationContent: message2.content }
+      });
+      this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message2.content });
+      this.history.push({ role: "system", content: feedback.correction });
+      await this._continueConversation();
+    } else {
+      this.eventBus.emit("backend_message", { type: "info", message: "Agent is thinking... continuing reasoning cycle." });
+      await this._continueConversation();
     }
   }
 };
@@ -5098,6 +5243,9 @@ var LLMService = class {
     });
     this.defaultModel = config2.model || "";
   }
+  /**
+   * Chamada tradicional (não-streaming) - retorna resposta completa
+   */
   async chatCompletion(params) {
     const resp = await this.client.chat.completions.create({
       model: params.model || this.defaultModel,
@@ -5110,6 +5258,64 @@ var LLMService = class {
     });
     return resp;
   }
+  /**
+   * Chamada com streaming - retorna chunks em tempo real
+   * 
+   * Uso:
+   * ```
+   * for await (const chunk of llm.chatCompletionStream(params)) {
+   *   process.stdout.write(chunk.delta);
+   * }
+   * ```
+   */
+  async *chatCompletionStream(params) {
+    const stream = await this.client.chat.completions.create({
+      model: params.model || this.defaultModel,
+      messages: params.messages,
+      tools: params.tools,
+      tool_choice: params.tool_choice,
+      parallel_tool_calls: params.parallel_tool_calls,
+      temperature: params.temperature,
+      max_tokens: params.max_tokens,
+      stream: true
+    });
+    const toolCallsAccumulator = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      const choice = chunk.choices[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCallsAccumulator.has(idx)) {
+            toolCallsAccumulator.set(idx, {
+              id: tc.id || "",
+              type: tc.type || "function",
+              function: { name: "", arguments: "" }
+            });
+          }
+          const acc = toolCallsAccumulator.get(idx);
+          if (tc.id) acc.id = tc.id;
+          if (tc.function?.name) acc.function.name = tc.function.name;
+          if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
+        }
+      }
+      const reasoning = delta?.reasoning_content || delta?.reasoning || "";
+      yield {
+        delta: delta?.content || "",
+        reasoning,
+        tool_calls: choice.finish_reason === "tool_calls" ? Array.from(toolCallsAccumulator.values()) : void 0,
+        finish_reason: choice.finish_reason
+      };
+    }
+    if (toolCallsAccumulator.size > 0) {
+      yield {
+        delta: "",
+        tool_calls: Array.from(toolCallsAccumulator.values()),
+        finish_reason: "tool_calls"
+      };
+    }
+  }
   /**
    * Retorna o modelo padrão configurado
    */
@@ -5688,44 +5894,55 @@ var Agent = class {
 };
 
 // src/app/ui/WorkingTimer.tsx
-import { useState as useState4, useEffect as useEffect4, memo as memo5 } from "react";
+import React4, { useState as useState4, useEffect as useEffect4, memo as memo5 } from "react";
 import { Box as Box7, Text as Text7 } from "ink";
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-var WorkingTimerComponent = ({ taskName, taskStatus }) => {
-  const [seconds, setSeconds] = useState4(0);
-  const [frame, setFrame] = useState4(0);
+var WorkingTimerComponent = ({ eventBus: eventBus2, taskName, taskStatus }) => {
+  const [currentAction, setCurrentAction] = useState4("Thinking...");
+  const [shinePosition, setShinePosition] = useState4(0);
+  const [dots, setDots] = useState4("");
   useEffect4(() => {
-    const timer = setInterval(() => {
-      setSeconds((prev) => prev + 1);
-    }, 1e3);
-    return () => clearInterval(timer);
-  }, []);
+    if (!eventBus2) return;
+    const handleActionStatus = (data) => {
+      if (data.action) {
+        setCurrentAction(data.action);
+      }
+    };
+    eventBus2.on("action_status", handleActionStatus);
+    return () => {
+      eventBus2.off("action_status", handleActionStatus);
+    };
+  }, [eventBus2]);
   useEffect4(() => {
-    const animator = setInterval(() => {
-      setFrame((prev) => (prev + 1) % 4);
+    const shineTimer = setInterval(() => {
+      setShinePosition((prev) => (prev + 1) % 30);
     }, 150);
-    return () => clearInterval(animator);
+    return () => clearInterval(shineTimer);
   }, []);
-  const spinners = ["|", "/", "-", "\\"];
-  const spinner = spinners[frame];
-  const formatTime = (s) => {
-    if (s < 60) return `${s}s`;
-    return `${Math.floor(s / 60)}m${s % 60}s`;
-  };
+  useEffect4(() => {
+    const dotsTimer = setInterval(() => {
+      setDots((prev) => prev.length >= 3 ? "" : prev + ".");
+    }, 500);
+    return () => clearInterval(dotsTimer);
+  }, []);
+  const displayAction = taskStatus || currentAction;
+  const shineText = React4.useMemo(() => {
+    const chars = displayAction.split("");
+    const textLen = displayAction.length;
+    const shineIdx = shinePosition % (textLen + 6);
+    return chars.map((char, i) => {
+      const distance = Math.abs(i - shineIdx);
+      if (distance <= 1) {
+        return /* @__PURE__ */ jsx7(Text7, { color: "white", dimColor: true, children: char }, i);
+      } else {
+        return /* @__PURE__ */ jsx7(Text7, { color: "gray", dimColor: true, children: char }, i);
+      }
+    });
+  }, [displayAction, shinePosition]);
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs7(Box7, { children: [
-      /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: spinner }),
-      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-        " ",
-        taskStatus || "thinking"
-      ] }),
-      /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
-        " ",
-        formatTime(seconds)
-      ] })
-    ] }),
+    /* @__PURE__ */ jsx7(Box7, { children: shineText }),
     taskName && /* @__PURE__ */ jsx7(Box7, { paddingLeft: 2, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      "^ ",
+      "\u203A ",
       taskName
     ] }) })
   ] });
@@ -6658,14 +6875,79 @@ var ReasoningDisplayComponent = ({
   const lines = reasoning.split("\n");
   const displayText = isExpanded ? reasoning : lines.slice(0, maxLines).join("\n") + (lines.length > maxLines ? "..." : "");
   return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", paddingX: 1, marginBottom: 1, marginTop: 1, children: [
-    /* @__PURE__ */ jsx15(Box15, { children: /* @__PURE__ */ jsx15(Text14, { color: "white", bold: true, children: "Thinking" }) }),
+    /* @__PURE__ */ jsx15(Box15, {}),
     /* @__PURE__ */ jsx15(Box15, { paddingLeft: 2, flexDirection: "column", children: displayText.split("\n").map((line, i) => /* @__PURE__ */ jsx15(Text14, { color: "gray", dimColor: true, children: line }, i)) })
   ] });
 };
 var ReasoningDisplay = memo9(ReasoningDisplayComponent);
 
-// src/app/ui/App.tsx
+// src/app/ui/components/StreamingText.tsx
+import { useState as useState6, useEffect as useEffect5, useRef as useRef4, memo as memo10 } from "react";
+import { Box as Box16, Text as Text15, Static } from "ink";
 import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+var StreamingTextComponent = ({ eventBus: eventBus2, onReasoningComplete }) => {
+  const [completedLines, setCompletedLines] = useState6([]);
+  const [currentLine, setCurrentLine] = useState6("");
+  const [isStreaming, setIsStreaming] = useState6(false);
+  const reasoningRef = useRef4("");
+  const lastProcessedLength = useRef4(0);
+  useEffect5(() => {
+    const handleStart = () => {
+      setCompletedLines([]);
+      setCurrentLine("");
+      reasoningRef.current = "";
+      lastProcessedLength.current = 0;
+      setIsStreaming(true);
+    };
+    const handleReasoningChunk = (data) => {
+      if (data.delta) {
+        reasoningRef.current += data.delta;
+        const fullText = reasoningRef.current;
+        const lastNewlineIndex = fullText.lastIndexOf("\n");
+        if (lastNewlineIndex > lastProcessedLength.current) {
+          const newCompleteText = fullText.substring(0, lastNewlineIndex);
+          const lines = newCompleteText.split("\n");
+          setCompletedLines(lines.map((line, i) => ({ id: i, content: line })));
+          setCurrentLine(fullText.substring(lastNewlineIndex + 1));
+          lastProcessedLength.current = lastNewlineIndex + 1;
+        } else {
+          const startIdx = lastProcessedLength.current > 0 ? lastProcessedLength.current : fullText.lastIndexOf("\n") + 1;
+          setCurrentLine(fullText.substring(startIdx));
+        }
+      }
+    };
+    const handleEnd = () => {
+      setIsStreaming(false);
+      const finalReasoning = reasoningRef.current;
+      if (finalReasoning && onReasoningComplete) {
+        onReasoningComplete(finalReasoning);
+      }
+      setCompletedLines([]);
+      setCurrentLine("");
+      reasoningRef.current = "";
+      lastProcessedLength.current = 0;
+    };
+    eventBus2.on("stream_start", handleStart);
+    eventBus2.on("stream_reasoning_chunk", handleReasoningChunk);
+    eventBus2.on("stream_end", handleEnd);
+    return () => {
+      eventBus2.off("stream_start", handleStart);
+      eventBus2.off("stream_reasoning_chunk", handleReasoningChunk);
+      eventBus2.off("stream_end", handleEnd);
+    };
+  }, [eventBus2, onReasoningComplete]);
+  if (!isStreaming || completedLines.length === 0 && !currentLine) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx16(Box16, { flexDirection: "column", paddingX: 1, marginBottom: 1, marginTop: 1, children: /* @__PURE__ */ jsxs15(Box16, { paddingLeft: 2, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx16(Static, { items: completedLines, children: (item) => /* @__PURE__ */ jsx16(Text15, { color: "gray", dimColor: true, children: item.content }, item.id) }),
+    currentLine && /* @__PURE__ */ jsx16(Text15, { color: "gray", dimColor: true, children: currentLine })
+  ] }) });
+};
+var StreamingText = memo10(StreamingTextComponent);
+
+// src/app/ui/App.tsx
+import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
 var SAFE_AUTO_APPROVE_TOOLS = [
   // Comunicação/UI
   "message",
@@ -6683,28 +6965,28 @@ var SAFE_AUTO_APPROVE_TOOLS = [
   "command_status"
 ];
 var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
-  const agentInstance = useRef4(null);
-  const [history, setHistory] = useState6([]);
-  const [statusMessage, setStatusMessage] = useState6(
+  const agentInstance = useRef5(null);
+  const [history, setHistory] = useState7([]);
+  const [statusMessage, setStatusMessage] = useState7(
     "Initializing agent..."
   );
-  const [toolsCount, setToolsCount] = useState6(null);
-  const [mcpStatus, setMcpStatus] = useState6(
+  const [toolsCount, setToolsCount] = useState7(null);
+  const [mcpStatus, setMcpStatus] = useState7(
     "connecting"
   );
-  const [isProcessing, setIsProcessing] = useState6(true);
-  const [pendingConfirmation, setPendingConfirmation] = useState6(
+  const [isProcessing, setIsProcessing] = useState7(true);
+  const [pendingConfirmation, setPendingConfirmation] = useState7(
     null
   );
-  const [confirmationPreview, setConfirmationPreview] = useState6(
+  const [confirmationPreview, setConfirmationPreview] = useState7(
     null
   );
-  const [isInitAgentActive, setIsInitAgentActive] = useState6(false);
-  const alwaysAcceptList = useRef4([]);
+  const [isInitAgentActive, setIsInitAgentActive] = useState7(false);
+  const alwaysAcceptList = useRef5([]);
   const workdir = process.cwd();
-  const updateCheckRan = useRef4(false);
-  const sessionStartTime = useRef4(Date.now());
-  const [toolCallCount, setToolCallCount] = useState6(0);
+  const updateCheckRan = useRef5(false);
+  const sessionStartTime = useRef5(Date.now());
+  const [toolCallCount, setToolCallCount] = useState7(0);
   const handleInterrupt = useCallback2(() => {
     if (!isProcessing) return;
     eventBus2.emit("user_interrupt");
@@ -6713,7 +6995,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
       ...prev,
       {
         id: prev.length,
-        component: /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: "-- Task cancelled by dev. --" })
+        component: /* @__PURE__ */ jsx17(Text16, { color: "yellow", children: "-- Task cancelled by dev. --" })
       }
     ]);
   }, [isProcessing, eventBus2]);
@@ -6737,11 +7019,11 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           ...prev,
           {
             id: prev.length,
-            component: /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text15, { color: "white", dimColor: true, children: text }) })
+            component: /* @__PURE__ */ jsx17(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsx17(Text16, { color: "white", dimColor: true, children: text }) })
           },
           {
             id: prev.length + 1,
-            component: /* @__PURE__ */ jsx16(
+            component: /* @__PURE__ */ jsx17(
               SlashCommands_default,
               {
                 input: text,
@@ -6763,9 +7045,9 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           ...prev,
           {
             id: prev.length,
-            component: /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
-              /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "$ " }),
-              /* @__PURE__ */ jsx16(Text15, { color: "white", children: command })
+            component: /* @__PURE__ */ jsxs16(Box17, { marginBottom: 1, children: [
+              /* @__PURE__ */ jsx17(Text16, { color: "white", bold: true, children: "$ " }),
+              /* @__PURE__ */ jsx17(Text16, { color: "white", children: command })
             ] })
           }
         ]);
@@ -6784,7 +7066,7 @@ Please use command_status to check the result and report back to the user.`;
                 ...prev,
                 {
                   id: prev.length,
-                  component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                  component: /* @__PURE__ */ jsxs16(Text16, { color: "red", children: [
                     "Failed to execute: ",
                     result.error || result.message
                   ] })
@@ -6797,7 +7079,7 @@ Please use command_status to check the result and report back to the user.`;
               ...prev,
               {
                 id: prev.length,
-                component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                component: /* @__PURE__ */ jsxs16(Text16, { color: "red", children: [
                   "Error: ",
                   err.message
                 ] })
@@ -6816,8 +7098,8 @@ Please use command_status to check the result and report back to the user.`;
           id: prev.length,
           component: (
             // Uma única Box para o espaçamento
-            /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "white", dimColor: true, children: [
-              /* @__PURE__ */ jsxs15(Text15, { color: "white", children: [
+            /* @__PURE__ */ jsx17(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsxs16(Text16, { color: "white", dimColor: true, children: [
+              /* @__PURE__ */ jsxs16(Text16, { color: "white", children: [
                 ">",
                 " "
               ] }),
@@ -6851,8 +7133,8 @@ Please use command_status to check the result and report back to the user.`;
     },
     []
   );
-  useEffect5(() => {
-    setHistory([{ id: 0, component: /* @__PURE__ */ jsx16(Header, { sessionId: sessionId2, workdir }) }]);
+  useEffect6(() => {
+    setHistory([{ id: 0, component: /* @__PURE__ */ jsx17(Header, { sessionId: sessionId2, workdir }) }]);
     const initializeAgent = async () => {
       try {
         agentInstance.current = new Agent(sessionId2, eventBus2);
@@ -6918,7 +7200,7 @@ Please use command_status to check the result and report back to the user.`;
                   ...prev,
                   {
                     id: prev.length,
-                    component: /* @__PURE__ */ jsx16(UpdateNotice_default, { message: msg })
+                    component: /* @__PURE__ */ jsx17(UpdateNotice_default, { message: msg })
                   }
                 ]);
               }
@@ -6932,10 +7214,10 @@ Please use command_status to check the result and report back to the user.`;
         }
         let newComponent = null;
         if (parsed.type === "debug") {
-          newComponent = /* @__PURE__ */ jsx16(Text15, { color: "gray", children: parsed.message });
+          newComponent = /* @__PURE__ */ jsx17(Text16, { color: "gray", children: parsed.message });
         } else if (parsed.type === "protocol_violation") {
-          newComponent = /* @__PURE__ */ jsxs15(
-            Box16,
+          newComponent = /* @__PURE__ */ jsxs16(
+            Box17,
             {
               borderStyle: "round",
               borderColor: "yellow",
@@ -6943,14 +7225,14 @@ Please use command_status to check the result and report back to the user.`;
               marginBottom: 1,
               paddingX: 1,
               children: [
-                /* @__PURE__ */ jsx16(Text15, { color: "yellow", bold: true, children: "Protocol Violation" }),
-                /* @__PURE__ */ jsx16(Text15, { color: "gray", children: parsed.content }),
-                /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: parsed.message })
+                /* @__PURE__ */ jsx17(Text16, { color: "yellow", bold: true, children: "Protocol Violation" }),
+                /* @__PURE__ */ jsx17(Text16, { color: "gray", children: parsed.content }),
+                /* @__PURE__ */ jsx17(Text16, { color: "yellow", children: parsed.message })
               ]
             }
           );
         } else if (parsed.type === "error") {
-          newComponent = /* @__PURE__ */ jsx16(
+          newComponent = /* @__PURE__ */ jsx17(
             ErrorMessage_default,
             {
               message: parsed.message,
@@ -6960,7 +7242,7 @@ Please use command_status to check the result and report back to the user.`;
           );
         } else if (parsed.type === "tool_call") {
           const nextId2 = history.length;
-          newComponent = /* @__PURE__ */ jsx16(
+          newComponent = /* @__PURE__ */ jsx17(
             ToolCallDisplay,
             {
               toolName: parsed.tool_name,
@@ -6969,7 +7251,7 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "tool_result") {
-          newComponent = /* @__PURE__ */ jsx16(
+          newComponent = /* @__PURE__ */ jsx17(
             ToolResultDisplay,
             {
               toolName: parsed.tool_name,
@@ -6977,17 +7259,17 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "user_overlay") {
-          newComponent = /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "gray", children: [
-            /* @__PURE__ */ jsxs15(Text15, { color: "magenta", children: [
+          newComponent = /* @__PURE__ */ jsx17(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsxs16(Text16, { color: "gray", children: [
+            /* @__PURE__ */ jsxs16(Text16, { color: "magenta", children: [
               ">",
               " "
             ] }),
             parsed.payload
           ] }) });
         } else if (parsed.type === "reasoning") {
-          newComponent = /* @__PURE__ */ jsx16(ReasoningDisplay, { reasoning: parsed.content });
+          newComponent = /* @__PURE__ */ jsx17(ReasoningDisplay, { reasoning: parsed.content });
         } else if (parsed.type === "log") {
-          newComponent = /* @__PURE__ */ jsxs15(Text15, { color: "gray", children: [
+          newComponent = /* @__PURE__ */ jsxs16(Text16, { color: "gray", children: [
             "\u2139\uFE0F ",
             parsed.message,
             parsed.payload ? `: ${parsed.payload}` : ""
@@ -7020,7 +7302,7 @@ Please use command_status to check the result and report back to the user.`;
       return;
     }
     if (pendingConfirmation) {
-      return /* @__PURE__ */ jsx16(
+      return /* @__PURE__ */ jsx17(
         ConfirmationPrompt,
         {
           toolCalls: pendingConfirmation,
@@ -7032,9 +7314,9 @@ Please use command_status to check the result and report back to the user.`;
         }
       );
     }
-    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
-      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx16(WorkingTimer, {}),
-      /* @__PURE__ */ jsx16(
+    return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", children: [
+      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx17(WorkingTimer, { eventBus: eventBus2 }),
+      /* @__PURE__ */ jsx17(
         InputPrompt,
         {
           onSubmit: handleSubmit,
@@ -7045,12 +7327,29 @@ Please use command_status to check the result and report back to the user.`;
       )
     ] });
   };
-  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx16(Static, { items: history, children: (item) => /* @__PURE__ */ jsx16(Box16, { children: item.component }, item.id) }),
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx17(Static2, { items: history, children: (item) => /* @__PURE__ */ jsx17(Box17, { children: item.component }, item.id) }),
+    /* @__PURE__ */ jsx17(
+      StreamingText,
+      {
+        eventBus: eventBus2,
+        onReasoningComplete: (reasoning) => {
+          if (reasoning) {
+            setHistory((prev) => [
+              ...prev,
+              {
+                id: prev.length,
+                component: /* @__PURE__ */ jsx17(ReasoningDisplay, { reasoning })
+              }
+            ]);
+          }
+        }
+      }
+    ),
     renderInteractiveComponent()
   ] });
 };
-var App = memo10(AppComponent);
+var App = memo11(AppComponent);
 var App_default = App;
 
 // src/app/ui/utils/terminalTitle.ts
@@ -7117,4 +7416,4 @@ var props = {
   eventBus,
   sessionId
 };
-render(React10.createElement(App_default, props));
+render(React11.createElement(App_default, props));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.1.1",
+	"version": "0.1.4",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",