@nomad-e/bluma-cli 0.1.0 → 0.1.2

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 } from "ink";
 
 // src/app/ui/layout.tsx
 import { Box, Text } from "ink";
@@ -3071,8 +3071,9 @@ async function readArtifact(args) {
 import https from "https";
 import http from "http";
 var DEFAULT_SOURCES = ["reddit", "github", "stackoverflow"];
-var MAX_RESULTS_DEFAULT = 10;
-var REQUEST_TIMEOUT = 1e4;
+var MAX_RESULTS_DEFAULT = 5;
+var REQUEST_TIMEOUT = 15e3;
+var MAX_CONTENT_LENGTH = 4e3;
 function httpGet(url, customHeaders) {
   return new Promise((resolve, reject) => {
     const protocol = url.startsWith("https") ? https : http;
@@ -3081,7 +3082,6 @@ function httpGet(url, customHeaders) {
       "Accept": "application/json, text/html, */*",
       "Accept-Language": "en-US,en;q=0.9",
       "Accept-Encoding": "identity",
-      // Não usar gzip para simplificar
       "Cache-Control": "no-cache",
       "Connection": "keep-alive",
       ...customHeaders
@@ -3111,10 +3111,18 @@ function httpGet(url, customHeaders) {
     });
   });
 }
+function cleanContent(text, maxLength = MAX_CONTENT_LENGTH) {
+  if (!text) return "";
+  let cleaned = text.replace(/```[\s\S]*?```/g, (match) => match.substring(0, 500) + (match.length > 500 ? "\n[...code truncated...]" : "")).replace(/\n{3,}/g, "\n\n").trim();
+  if (cleaned.length > maxLength) {
+    cleaned = cleaned.substring(0, maxLength) + "\n\n[...content truncated...]";
+  }
+  return cleaned;
+}
 async function searchReddit(query, limit) {
   const results = [];
   try {
-    const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming";
+    const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming+rust+golang+devops";
     const encodedQuery = encodeURIComponent(query);
     const url = `https://www.reddit.com/r/${subreddits}/search.json?q=${encodedQuery}&sort=relevance&limit=${limit}&restrict_sr=on`;
     const response = await httpGet(url);
@@ -3122,12 +3130,46 @@ async function searchReddit(query, limit) {
     if (data.data?.children) {
       for (const child of data.data.children.slice(0, limit)) {
         const post = child.data;
+        let content = `# ${post.title}
+
+`;
+        content += `**Subreddit:** r/${post.subreddit} | **Score:** ${post.score} | **Comments:** ${post.num_comments}
+
+`;
+        if (post.selftext) {
+          content += `## Post Content:
+${cleanContent(post.selftext, 2e3)}
+
+`;
+        }
+        try {
+          const commentsUrl = `https://www.reddit.com${post.permalink}.json?limit=3&depth=1`;
+          const commentsResponse = await httpGet(commentsUrl);
+          const commentsData = JSON.parse(commentsResponse);
+          if (commentsData[1]?.data?.children) {
+            content += `## Top Comments:
+`;
+            for (const comment of commentsData[1].data.children.slice(0, 3)) {
+              if (comment.data?.body) {
+                content += `
+**[${comment.data.score || 0} pts]** ${cleanContent(comment.data.body, 500)}
+`;
+              }
+            }
+          }
+        } catch {
+        }
         results.push({
           title: post.title || "",
           url: `https://reddit.com${post.permalink}`,
           source: "reddit",
-          snippet: post.selftext?.substring(0, 200) || `r/${post.subreddit} - ${post.score} upvotes`,
-          score: post.score
+          content: cleanContent(content),
+          score: post.score,
+          metadata: {
+            author: post.author,
+            date: new Date(post.created_utc * 1e3).toISOString().split("T")[0],
+            comments_count: post.num_comments
+          }
         });
       }
     }
@@ -3145,12 +3187,35 @@ async function searchGitHub(query, limit) {
     const data = JSON.parse(response);
     if (data.items) {
       for (const item of data.items.slice(0, limit)) {
+        let content = `# ${item.title}
+
+`;
+        content += `**Repo:** ${item.repository_url?.split("/").slice(-2).join("/") || "unknown"}
+`;
+        content += `**State:** ${item.state} | **Comments:** ${item.comments} | **Reactions:** ${item.reactions?.total_count || 0}
+
+`;
+        if (item.body) {
+          content += `## Issue Description:
+${cleanContent(item.body, 2500)}
+`;
+        }
+        if (item.labels?.length > 0) {
+          content += `
+**Labels:** ${item.labels.map((l) => l.name).join(", ")}
+`;
+        }
         results.push({
           title: item.title || "",
           url: item.html_url || "",
           source: "github",
-          snippet: item.body?.substring(0, 200) || `${item.comments} comments`,
-          score: item.reactions?.total_count || 0
+          content: cleanContent(content),
+          score: item.reactions?.total_count || 0,
+          metadata: {
+            author: item.user?.login,
+            date: item.created_at?.split("T")[0],
+            comments_count: item.comments
+          }
         });
       }
     }
@@ -3163,17 +3228,56 @@ async function searchStackOverflow(query, limit) {
   const results = [];
   try {
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://api.stackexchange.com/2.3/search?order=desc&sort=relevance&intitle=${encodedQuery}&site=stackoverflow&pagesize=${limit}`;
+    const url = `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&q=${encodedQuery}&site=stackoverflow&pagesize=${limit}&filter=withbody`;
     const response = await httpGet(url);
     const data = JSON.parse(response);
     if (data.items) {
       for (const item of data.items.slice(0, limit)) {
+        let content = `# ${item.title}
+
+`;
+        content += `**Score:** ${item.score} | **Answers:** ${item.answer_count} | **Views:** ${item.view_count}`;
+        content += item.is_answered ? " | \u2705 Answered" : "";
+        content += `
+
+`;
+        if (item.body) {
+          const cleanBody = item.body.replace(/<code>/g, "`").replace(/<\/code>/g, "`").replace(/<pre>/g, "```\n").replace(/<\/pre>/g, "\n```").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+          content += `## Question:
+${cleanContent(cleanBody, 1500)}
+
+`;
+        }
+        if (item.tags?.length > 0) {
+          content += `**Tags:** ${item.tags.join(", ")}
+
+`;
+        }
+        if (item.accepted_answer_id) {
+          try {
+            const answerUrl = `https://api.stackexchange.com/2.3/answers/${item.accepted_answer_id}?site=stackoverflow&filter=withbody`;
+            const answerResponse = await httpGet(answerUrl);
+            const answerData = JSON.parse(answerResponse);
+            if (answerData.items?.[0]?.body) {
+              const cleanAnswer = answerData.items[0].body.replace(/<code>/g, "`").replace(/<\/code>/g, "`").replace(/<pre>/g, "```\n").replace(/<\/pre>/g, "\n```").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"');
+              content += `## \u2705 Accepted Answer (${answerData.items[0].score} pts):
+${cleanContent(cleanAnswer, 2e3)}
+`;
+            }
+          } catch {
+          }
+        }
         results.push({
           title: item.title || "",
           url: item.link || "",
           source: "stackoverflow",
-          snippet: `${item.score} votes, ${item.answer_count} answers${item.is_answered ? " \u2713" : ""}`,
-          score: item.score
+          content: cleanContent(content),
+          score: item.score,
+          metadata: {
+            author: item.owner?.display_name,
+            date: item.creation_date ? new Date(item.creation_date * 1e3).toISOString().split("T")[0] : void 0,
+            is_answered: item.is_answered
+          }
         });
       }
     }
@@ -3182,15 +3286,6 @@ async function searchStackOverflow(query, limit) {
   }
   return results;
 }
-function getXSearchUrl(query) {
-  const encodedQuery = encodeURIComponent(query);
-  return {
-    title: `Search X for: "${query}"`,
-    url: `https://twitter.com/search?q=${encodedQuery}&src=typed_query&f=live`,
-    source: "x",
-    snippet: "X/Twitter requires authentication. Click the link to search manually."
-  };
-}
 async function searchWeb(args) {
   try {
     const {
@@ -3224,9 +3319,6 @@ async function searchWeb(args) {
         case "stackoverflow":
           searches.push(searchStackOverflow(query, resultsPerSource));
           break;
-        case "x":
-          allResults.push(getXSearchUrl(query));
-          break;
       }
     }
     const searchResults = await Promise.all(searches);
@@ -3240,8 +3332,7 @@ async function searchWeb(args) {
       query,
       results: limitedResults,
       sources_searched: sourcesSearched,
-      total_results: limitedResults.length,
-      note: sources.includes("x") ? "X/Twitter requires manual search due to API restrictions" : void 0
+      total_results: limitedResults.length
     };
   } catch (error) {
     return {
@@ -3283,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
   };
@@ -3732,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
@@ -4644,8 +4749,8 @@ var ToolCallNormalizer = class {
    */
   static extractFromContent(content) {
     const results = [];
-    const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
-    const jsonMatches = this.extractJsonObjects(cleanContent);
+    const cleanContent2 = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
+    const jsonMatches = this.extractJsonObjects(cleanContent2);
     for (const jsonStr of jsonMatches) {
       try {
         const parsed = JSON.parse(jsonStr);
@@ -4849,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") {
@@ -4915,81 +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"
-        ];
-        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();
     }
   }
 };
@@ -5006,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,
@@ -5018,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
    */
@@ -5599,41 +5897,52 @@ var Agent = class {
 import { 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 shineTimer = setInterval(() => {
+      setShinePosition((prev) => (prev + 1) % 30);
+    }, 75);
+    return () => clearInterval(shineTimer);
   }, []);
   useEffect4(() => {
-    const animator = setInterval(() => {
-      setFrame((prev) => (prev + 1) % 4);
-    }, 150);
-    return () => clearInterval(animator);
+    const dotsTimer = setInterval(() => {
+      setDots((prev) => prev.length >= 3 ? "" : prev + ".");
+    }, 500);
+    return () => clearInterval(dotsTimer);
   }, []);
-  const spinners = ["|", "/", "-", "\\"];
-  const spinner = spinners[frame];
-  const formatTime = (s) => {
-    if (s < 60) return `${s}s`;
-    return `${Math.floor(s / 60)}m${s % 60}s`;
+  const displayAction = taskStatus || currentAction;
+  const renderShineText = (text) => {
+    const chars = text.split("");
+    const textLen = text.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);
+      }
+    });
   };
   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: renderShineText(displayAction) }),
     taskName && /* @__PURE__ */ jsx7(Box7, { paddingLeft: 2, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-      "^ ",
+      "\u203A ",
       taskName
     ] }) })
   ] });
@@ -6566,14 +6875,60 @@ 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/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 } from "ink";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var StreamingTextComponent = ({ eventBus: eventBus2, onReasoningComplete }) => {
+  const [reasoning, setReasoning] = useState6("");
+  const [isStreaming, setIsStreaming] = useState6(false);
+  const reasoningRef = useRef4("");
+  useEffect5(() => {
+    const handleStart = () => {
+      setReasoning("");
+      reasoningRef.current = "";
+      setIsStreaming(true);
+    };
+    const handleReasoningChunk = (data) => {
+      if (data.delta) {
+        reasoningRef.current += data.delta;
+        setReasoning(reasoningRef.current);
+      }
+    };
+    const handleEnd = () => {
+      setIsStreaming(false);
+      const finalReasoning = reasoningRef.current;
+      if (finalReasoning && onReasoningComplete) {
+        onReasoningComplete(finalReasoning);
+      }
+      setReasoning("");
+      reasoningRef.current = "";
+    };
+    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 || !reasoning) {
+    return null;
+  }
+  const lines = reasoning.split("\n");
+  return /* @__PURE__ */ jsx16(Box16, { flexDirection: "column", paddingX: 1, marginBottom: 1, marginTop: 1, children: /* @__PURE__ */ jsx16(Box16, { paddingLeft: 2, flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx16(Text15, { color: "gray", dimColor: true, children: line }, i)) }) });
+};
+var StreamingText = memo10(StreamingTextComponent);
+
 // src/app/ui/App.tsx
-import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
 var SAFE_AUTO_APPROVE_TOOLS = [
   // Comunicação/UI
   "message",
@@ -6591,28 +6946,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");
@@ -6621,7 +6976,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]);
@@ -6645,11 +7000,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,
@@ -6671,9 +7026,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__ */ jsxs15(Box17, { marginBottom: 1, children: [
+              /* @__PURE__ */ jsx17(Text16, { color: "white", bold: true, children: "$ " }),
+              /* @__PURE__ */ jsx17(Text16, { color: "white", children: command })
             ] })
           }
         ]);
@@ -6692,7 +7047,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__ */ jsxs15(Text16, { color: "red", children: [
                     "Failed to execute: ",
                     result.error || result.message
                   ] })
@@ -6705,7 +7060,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__ */ jsxs15(Text16, { color: "red", children: [
                   "Error: ",
                   err.message
                 ] })
@@ -6724,8 +7079,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__ */ jsxs15(Text16, { color: "white", dimColor: true, children: [
+              /* @__PURE__ */ jsxs15(Text16, { color: "white", children: [
                 ">",
                 " "
               ] }),
@@ -6759,8 +7114,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);
@@ -6826,7 +7181,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 })
                   }
                 ]);
               }
@@ -6840,10 +7195,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,
+            Box17,
             {
               borderStyle: "round",
               borderColor: "yellow",
@@ -6851,14 +7206,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,
@@ -6868,7 +7223,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,
@@ -6877,7 +7232,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,
@@ -6885,17 +7240,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__ */ jsxs15(Text16, { color: "gray", children: [
+            /* @__PURE__ */ jsxs15(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__ */ jsxs15(Text16, { color: "gray", children: [
             "\u2139\uFE0F ",
             parsed.message,
             parsed.payload ? `: ${parsed.payload}` : ""
@@ -6928,7 +7283,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,
@@ -6940,9 +7295,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__ */ jsxs15(Box17, { flexDirection: "column", children: [
+      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx17(WorkingTimer, { eventBus: eventBus2 }),
+      /* @__PURE__ */ jsx17(
         InputPrompt,
         {
           onSubmit: handleSubmit,
@@ -6953,12 +7308,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__ */ jsxs15(Box17, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx17(Static, { 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
@@ -7025,4 +7397,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.0",
+	"version": "0.1.2",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",