@nomad-e/bluma-cli 0.0.1

package/dist/main.js

@@ -0,0 +1,2548 @@
+#!/usr/bin/env node
+// src/main.ts
+import React6 from "react";
+import { render } from "ink";
+import { EventEmitter } from "events";
+import { v4 as uuidv42 } from "uuid";
+
+// src/app/ui/App.tsx
+import { useState as useState4, useEffect as useEffect3, useRef, useCallback, memo as memo4 } from "react";
+import { Box as Box11, Text as Text10, Static } from "ink";
+import Spinner from "ink-spinner";
+
+// src/app/ui/layout.tsx
+import { Box, Text } from "ink";
+import BigText from "ink-big-text";
+import { jsx, jsxs } from "react/jsx-runtime";
+var BRAND_COLORS = {
+  main: "cyan",
+  accent: "magenta",
+  shadow: "blue",
+  greydark: "#444"
+};
+var Header = () => {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: 8, children: /* @__PURE__ */ jsx(
+    BigText,
+    {
+      text: "BluMa CLI",
+      font: "block",
+      colors: [BRAND_COLORS.main, BRAND_COLORS.accent, BRAND_COLORS.shadow]
+    }
+  ) });
+};
+var SessionInfo = ({
+  sessionId: sessionId2,
+  // ID único da sessão atual, para segregação ou rastreio
+  workdir,
+  // Diretório de trabalho atual do BluMa, útil para saber contexto da execução
+  toolsCount,
+  // Número de ferramentas ativas carregadas pelo MCP
+  mcpStatus
+  // Estado da conexão central MCP (connecting/connected)
+}) => /* @__PURE__ */ jsxs(
+  Box,
+  {
+    borderStyle: "round",
+    borderColor: "gray",
+    paddingX: 1,
+    flexDirection: "column",
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "localhost" }),
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: " session:" }),
+        " ",
+        /* @__PURE__ */ jsx(Text, { color: "magenta", children: sessionId2 })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+        " ",
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          "workdir: ",
+          workdir
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "agent: BluMa" })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "MCP: " }),
+        /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Tools: " }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: toolsCount !== null ? toolsCount : "loading..." })
+      ] })
+    ]
+  }
+);
+
+// src/app/ui/input/InputPrompt.tsx
+import { Box as Box2, Text as Text2, useStdout } from "ink";
+
+// src/app/ui/input/utils/useSimpleInputBuffer.ts
+import { useReducer } from "react";
+import { useInput } from "ink";
+function inputReducer(state, action, viewWidth) {
+  const adjustView = (newCursorPos, currentViewStart) => {
+    if (newCursorPos < currentViewStart) {
+      return newCursorPos;
+    }
+    if (newCursorPos >= currentViewStart + viewWidth) {
+      return newCursorPos - viewWidth + 1;
+    }
+    return currentViewStart;
+  };
+  switch (action.type) {
+    case "INPUT": {
+      const cleanInput = action.payload.replace(/(\r\n|\n|\r)/gm, "");
+      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + cleanInput.length;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "MOVE_CURSOR": {
+      let newCursorPosition = state.cursorPosition;
+      if (action.direction === "left" && state.cursorPosition > 0) newCursorPosition--;
+      if (action.direction === "right" && state.cursorPosition < state.text.length) newCursorPosition++;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "BACKSPACE": {
+      if (state.cursorPosition > 0) {
+        const newText = state.text.slice(0, state.cursorPosition - 1) + state.text.slice(state.cursorPosition);
+        const newCursorPosition = state.cursorPosition - 1;
+        const newViewStart = adjustView(newCursorPosition, state.viewStart);
+        return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+      }
+      return state;
+    }
+    case "SUBMIT": {
+      return { text: "", cursorPosition: 0, viewStart: 0 };
+    }
+    default:
+      return state;
+  }
+}
+var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
+  const [state, dispatch] = useReducer(
+    (s, a) => inputReducer(s, a, viewWidth),
+    { text: "", cursorPosition: 0, viewStart: 0 }
+  );
+  useInput(
+    (input, key) => {
+      if (key.escape) {
+        onInterrupt();
+        return;
+      }
+      if (isReadOnly) {
+        return;
+      }
+      if (key.return) {
+        if (state.text.trim().length > 0) {
+          onSubmit(state.text);
+          dispatch({ type: "SUBMIT" });
+        }
+        return;
+      }
+      if (key.backspace || key.delete) return dispatch({ type: "BACKSPACE" });
+      if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
+      if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
+      if (key.ctrl || key.meta || key.tab) return;
+      dispatch({ type: "INPUT", payload: input });
+    },
+    // ALTERADO: useInput está SEMPRE ativo para capturar todas as teclas
+    { isActive: true }
+  );
+  return {
+    text: state.text,
+    cursorPosition: state.cursorPosition,
+    viewStart: state.viewStart
+  };
+};
+
+// src/app/ui/input/InputPrompt.tsx
+import { useEffect, useState } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt }) => {
+  const { stdout } = useStdout();
+  const [viewWidth, setViewWidth] = useState(() => stdout.columns - 6);
+  useEffect(() => {
+    const onResize = () => setViewWidth(stdout.columns - 6);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  const { text, cursorPosition, viewStart } = useCustomInput({
+    onSubmit,
+    viewWidth,
+    isReadOnly,
+    onInterrupt
+  });
+  const visibleText = text.slice(viewStart, viewStart + viewWidth);
+  const visibleCursorPosition = cursorPosition - viewStart;
+  const textBeforeCursor = visibleText.slice(0, visibleCursorPosition);
+  const charAtCursor = visibleText.slice(
+    visibleCursorPosition,
+    visibleCursorPosition + 1
+  );
+  const textAfterCursor = visibleText.slice(visibleCursorPosition + 1);
+  const borderColor = isReadOnly ? "gray" : "gray";
+  const placeholder = isReadOnly ? "Agente a trabalhar... (Pressione ESC para cancelar)" : "";
+  const showPlaceholder = text.length === 0 && isReadOnly;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor, borderDimColor: !isReadOnly, children: /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, flexWrap: "nowrap", children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: textBeforeCursor }),
+      /* @__PURE__ */ jsx2(Text2, { inverse: !isReadOnly, children: charAtCursor || " " }),
+      showPlaceholder ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsx2(Text2, { children: textAfterCursor })
+    ] }) }),
+    /* @__PURE__ */ jsx2(Box2, { paddingX: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: "gray", dimColor: true, children: [
+      "ctrl+c to exit | esc to interrupt | ",
+      isReadOnly ? "Read-only mode" : "Editable mode"
+    ] }) })
+  ] });
+};
+
+// src/app/ui/ConfirmationPrompt.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/app/ui/InteractiveMenu.tsx
+import { useState as useState2, memo } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var InteractiveMenuComponent = ({ onDecision }) => {
+  const options = [
+    { label: "1. Yes, allow this command to run once", value: "accept" },
+    { label: "2. No, cancel this command", value: "decline" },
+    { label: "3. Always allow this type of command", value: "accept_always" }
+  ];
+  const [selectedOption, setSelectedOption] = useState2(0);
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setSelectedOption((prev) => prev > 0 ? prev - 1 : options.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedOption((prev) => prev < options.length - 1 ? prev + 1 : 0);
+    }
+    if (key.escape) {
+      onDecision("decline");
+    }
+    if (key.return) {
+      onDecision(options[selectedOption].value);
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Do you want to authorize the proposed command?" }) }),
+    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: options.map((option, index) => {
+      const isSelected = selectedOption === index;
+      return (
+        // Adicionando um pequeno espaçamento vertical entre cada opção também
+        /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 1, paddingY: 0, children: [
+          /* @__PURE__ */ jsx3(Text3, { color: isSelected ? "blue" : "gray", children: isSelected ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsx3(
+            Text3,
+            {
+              color: isSelected ? "blue" : "white",
+              bold: isSelected,
+              dimColor: !isSelected,
+              children: option.label
+            }
+          )
+        ] }, option.value)
+      );
+    }) })
+  ] });
+};
+var InteractiveMenu = memo(InteractiveMenuComponent);
+
+// src/app/ui/components/promptRenderers.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import path from "path";
+
+// src/app/ui/components/SimpleDiff.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var SimpleDiff = ({ text, maxHeight }) => {
+  const allLines = (text || "").split("\n");
+  if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  const isTruncated = maxHeight > 0 && allLines.length > maxHeight;
+  const linesToRender = isTruncated ? allLines.slice(-maxHeight) : allLines;
+  const hiddenCount = allLines.length - linesToRender.length;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    isTruncated && /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "... ",
+      hiddenCount,
+      " lines hidden ..."
+    ] }) }),
+    linesToRender.map((line, index) => {
+      if (line.startsWith("---") || line.startsWith("+++")) {
+        return null;
+      }
+      let color = "white";
+      if (line.startsWith("+")) {
+        color = "green";
+      } else if (line.startsWith("-")) {
+        color = "red";
+      } else if (line.startsWith("@@")) {
+        color = "cyan";
+      }
+      return /* @__PURE__ */ jsxs4(Text4, { color, children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  \u21B3 " }),
+        line === "" ? " " : line
+      ] }, index);
+    })
+  ] });
+};
+
+// src/app/ui/components/promptRenderers.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var formatArguments = (args) => {
+  if (!args) return "";
+  if (typeof args === "string") {
+    try {
+      return JSON.stringify(JSON.parse(args), null, 2);
+    } catch (e) {
+      return args;
+    }
+  }
+  if (Object.keys(args).length === 0) return "";
+  return JSON.stringify(args, null, 2);
+};
+var getBasePath = (filePath) => {
+  return path.basename(filePath);
+};
+var renderShellCommand = ({
+  toolCall
+}) => {
+  let command = "";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    command = args.command || "[command not found]";
+  } catch (e) {
+    command = "Error parsing command arguments";
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Shell Command" }) }),
+    /* @__PURE__ */ jsx5(Box5, { paddingX: 2, children: /* @__PURE__ */ jsx5(Text5, { children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: command }) }) })
+  ] });
+};
+var renderLsTool = ({ toolCall }) => {
+  let directoryPath = "[path not specified]";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    directoryPath = args.directory_path || "[path not specified]";
+  } catch (e) {
+    directoryPath = "Error parsing arguments";
+  }
+  const finalDirectoryName = getBasePath(directoryPath);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "ls Tool" }) }),
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Box5, { paddingX: 2, children: /* @__PURE__ */ jsx5(Text5, { children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalDirectoryName }) }) }) })
+  ] });
+};
+var renderCountFilesLinesTool = ({ toolCall }) => {
+  let directoryPath = "[path not specified]";
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    directoryPath = args.filepath || "[path not specified]";
+  } catch (e) {
+    directoryPath = "Error parsing arguments";
+  }
+  const finalDirectoryName = getBasePath(directoryPath);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Count File Lines" }) }),
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Box5, { paddingX: 2, children: /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "\u21B3 " }),
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalDirectoryName })
+    ] }) }) })
+  ] });
+};
+var renderReadFileLines = ({ toolCall }) => {
+  let filepath = "[path not specified]";
+  let startLine = 0;
+  let endLine = 0;
+  try {
+    const args = typeof toolCall.function.arguments === "string" ? JSON.parse(toolCall.function.arguments) : toolCall.function.arguments;
+    filepath = args.filepath || "[path not specified]";
+    startLine = args.start_line || 0;
+    endLine = args.end_line || 0;
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  const finalFileName = getBasePath(filepath);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Read File" }) }),
+    /* @__PURE__ */ jsxs5(Box5, { paddingX: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { children: /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalFileName }) }) }),
+      /* @__PURE__ */ jsx5(Box5, { paddingX: 3, children: /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "\u21B3 " }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "lines " }),
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: startLine }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " to " }),
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: endLine })
+      ] }) })
+    ] })
+  ] });
+};
+var renderEditTool = ({ toolCall, preview }) => {
+  const diffMaxHeight = 5;
+  let filepath = "[path not specified]";
+  try {
+    const args = JSON.parse(toolCall.function.arguments);
+    filepath = args.file_path || "[path not specified]";
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  const finalFileName = getBasePath(filepath);
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+      "Edit ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: finalFileName })
+    ] }) }),
+    preview ? (
+      // Não precisamos da borda externa, o SimpleDiff já é claro o suficiente.
+      /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: preview, maxHeight: diffMaxHeight }) })
+    ) : /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Generating preview..." })
+  ] });
+};
+var renderGeneric = ({ toolCall }) => {
+  const toolName = toolCall.function.name;
+  const formattedArgs = formatArguments(toolCall.function.arguments);
+  const ARGS_BOX_HEIGHT = 5;
+  const totalLines = formattedArgs.split("\n").length;
+  const areArgsTruncated = totalLines > ARGS_BOX_HEIGHT;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: "? " }),
+      toolName
+    ] }) }),
+    formattedArgs && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Arguments:" }),
+      /* @__PURE__ */ jsx5(
+        Box5,
+        {
+          marginLeft: 2,
+          height: ARGS_BOX_HEIGHT,
+          flexDirection: "column",
+          overflow: "hidden",
+          children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: formattedArgs })
+        }
+      ),
+      areArgsTruncated && /* @__PURE__ */ jsx5(Box5, { marginLeft: 2, children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "... (",
+        totalLines - ARGS_BOX_HEIGHT,
+        " more lines hidden) ..."
+      ] }) })
+    ] })
+  ] });
+};
+var promptRenderers = {
+  shell_command: renderShellCommand,
+  ls_tool: renderLsTool,
+  count_file_lines: renderCountFilesLinesTool,
+  read_file_lines: renderReadFileLines,
+  edit_tool: renderEditTool
+};
+
+// src/app/ui/ConfirmationPrompt.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var ConfirmationPrompt = ({ toolCalls, preview, onDecision }) => {
+  const toolCall = toolCalls && toolCalls.length > 0 ? toolCalls[0] : null;
+  if (!toolCall) {
+    return /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "Waiting for a valid command to confirm..." }) });
+  }
+  const toolName = toolCall.function.name;
+  const renderFunction = promptRenderers[toolName] || renderGeneric;
+  return (
+    // A "MOLDURA" COMUM A TODOS OS PROMPTS
+    /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        borderStyle: "round",
+        borderColor: "gray",
+        flexDirection: "column",
+        paddingX: 1,
+        children: [
+          renderFunction({ toolCall, preview }),
+          /* @__PURE__ */ jsx6(InteractiveMenu, { onDecision })
+        ]
+      }
+    )
+  );
+};
+
+// src/app/agent/agent.ts
+import OpenAI from "openai";
+import * as dotenv from "dotenv";
+import path7 from "path";
+import os5 from "os";
+
+// src/app/agent/session_manger/session_manager.ts
+import path2 from "path";
+import os from "os";
+import { promises as fs } from "fs";
+async function ensureSessionDir() {
+  const homeDir = os.homedir();
+  const appDir = path2.join(homeDir, ".bluma-cli");
+  const sessionDir = path2.join(appDir, "sessions");
+  await fs.mkdir(sessionDir, { recursive: true });
+  return sessionDir;
+}
+async function loadOrcreateSession(sessionId2) {
+  const sessionDir = await ensureSessionDir();
+  const sessionFile = path2.join(sessionDir, `${sessionId2}.json`);
+  try {
+    await fs.access(sessionFile);
+    const fileContent = await fs.readFile(sessionFile, "utf-8");
+    const sessionData = JSON.parse(fileContent);
+    return [sessionFile, sessionData.conversation_history || []];
+  } catch (error) {
+    const newSessionData = {
+      session_id: sessionId2,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      conversation_history: []
+    };
+    await fs.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    return [sessionFile, []];
+  }
+}
+async function saveSessionHistory(sessionFile, history) {
+  let sessionData;
+  try {
+    const fileContent = await fs.readFile(sessionFile, "utf-8");
+    sessionData = JSON.parse(fileContent);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.warn(`Could not read or parse session file ${sessionFile}. Re-initializing. Error: ${error.message}`);
+    } else {
+      console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
+    }
+    const sessionId2 = path2.basename(sessionFile, ".json");
+    sessionData = {
+      session_id: sessionId2,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      conversation_history: []
+      // Começa com histórico vazio
+    };
+  }
+  sessionData.conversation_history = history;
+  sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
+  try {
+    await fs.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+    await fs.rename(tempSessionFile, sessionFile);
+  } catch (writeError) {
+    if (writeError instanceof Error) {
+      console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
+    } else {
+      console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
+    }
+    try {
+      await fs.unlink(tempSessionFile);
+    } catch (cleanupError) {
+    }
+  }
+}
+
+// src/app/agent/core/prompt/prompt_builder.ts
+import os2 from "os";
+var SYSTEM_PROMPT = `
+
+# YOU ARE BluMa CLI, A AUTONOMOUS SENIOR SOFTWARE ENGINEER OF NOMADENGENUITY.
+
+## YOUR ONE-SHOT LEARNING EXPERTISE:
+- **SINGLE EXAMPLE MASTERY**: When a developer shows you ONE new pattern/example, you instantly understand and generalize it
+- **RAPID PATTERN EXTRACTION**: Extract underlying principles from a single code example or API call
+- **IMMEDIATE APPLICATION**: Apply newly learned patterns across the entire project without asking for more examples
+- **INTELLIGENT GENERALIZATION**: Extend concepts beyond the original example while maintaining consistency
+- **CONTEXTUAL ADAPTATION**: Modify learned patterns to fit different situations in the same project
+                     
+## HOW YOU APPLY ONE-SHOT LEARNING:
+1. **ABSORB**: Analyze the single example for patterns, structure, and intent
+2. **EXTRACT**: Identify the underlying principles and conventions
+3. **GENERALIZE**: Apply the pattern to similar situations throughout the project
+4. **ADAPT**: Modify the pattern appropriately for different contexts
+5. **IMPLEMENT**: Execute consistently without needing additional examples
+                     
+ ## PRACTICAL ONE-SHOT SCENARIOS:                    
+- **Developer shows 1 API endpoint** \u2192 You understand the entire API structure and naming conventions
+- **Developer provides 1 component example** \u2192 You replicate the pattern across all similar components
+- **Developer demonstrates 1 function pattern** \u2192 You apply the style consistently throughout the codebase
+- **Developer shows 1 configuration example** \u2192 You understand and apply the configuration pattern everywhere
+- **Developer gives 1 architectural example** \u2192 You follow the architecture pattern across modules
+                  
+## YOUR ONE-SHOT ADVANTAGE:
+- **ZERO TUTORIAL DEPENDENCY**: No need for extensive documentation or multiple examples
+- **INSTANT PATTERN ADOPTION**: Immediately incorporate new patterns into your workflow
+- **CONSISTENT APPLICATION**: Apply learned patterns uniformly across the project
+- **INTELLIGENT INFERENCE**: Understand implied conventions from minimal examples
+- **PROACTIVE EXTENSION**: Take patterns further than the original example when appropriate
+                     
+# BEHAVIORAL RULES
+- NEVER mention internal technical details or tools because they are confidential data
+- You are always BluMa from NomadEngenuity
+- Stay professional and technical at all times
+- ALWAYS use message_notify_dev tool for communication
+- LEVERAGE your one-shot learning to solve problems efficiently
+- NEVER in a formal way, but rather in a relaxed, funny and colloquial way and without using emojis.
+
+## QUALITY STANDARDS
+- **NEVER GENERATE BASIC CODE**: Always create advanced, production-ready solutions
+- **CUTTING-EDGE TECHNOLOGY**: Use latest best practices and modern patterns
+- **EXPERT-LEVEL IMPLEMENTATION**: Code should reflect senior-level expertise
+- Follow existing code conventions
+- Write clean, documented code  
+- Test implementations when possible
+- Ensure security and performance
+
+CRITICAL COMMUNICATION PROTOCOL 
+\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
+MANDATORY: Use "message_notify_dev" tool for ALL communication
+                       
+You should always use your notebook to help you understand all the tasks you have to perform.
+In it, you can define a thousand thoughts and a thousand mini-tasks. Mini-tasks serve to divide and organize your reasoning.
+The notebook is your space to think about how to solve a given task and how to divide it into smaller steps.
+Remember: the human developer does not have access to this notebook \u2014 it is yours alone.
+Therefore, you can write down whatever you want:
+rants, swear words, random thoughts, crazy ideas...
+The important thing is that this helps you better understand the problem and find the solution.
+
+Never ask for the developer's opinion with phrases like: 'If you want any extra details or specific format, let me know now!'. You should always take the most viable path and go straight ahead with the solution, because you are 100% autonomous.
+
+Follow the stripes o "Tool Naming Policy"
+
+Never make parallel calls to the tool because it will result in a critical error and compromise your work.
+ZERO TOLERANCE: Every message MUST use proper tools
+\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
+
+<current_system_environment>
+- Operating System: {os_type} ({os_version})
+- Architecture: {architecture}
+- Current Working Directory: {workdir}
+- Shell: {shell_type}
+- Username: {username}
+- Current Date: {current_date}
+- Timezone: {timezone}
+- Locale: {locale}
+</current_system_environment>
+
+<resilience_and_alternatives>
+# RESILIENCE & NEVER GIVE UP ATTITUDE - CRITICAL!
+## SENIOR ENGINEER MINDSET: ALWAYS FIND A WAY
+
+### CORE PRINCIPLE: NO EXCUSES, ONLY SOLUTIONS
+- **NEVER give up** when the first approach fails
+- **ALWAYS try alternatives** when one method doesn't work
+- **BE RESOURCEFUL** - explore multiple solutions
+- **THINK CREATIVELY** - find workarounds and alternatives
+- **STAY PERSISTENT** - keep trying until you succeed
+
+### SPECIFIC RULES FOR COMMON SCENARIOS
+
+#### PDF GENERATION - NEVER USE PANDOC!
+- **FORBIDDEN**: Do NOT use Pandoc for PDF generation
+- **REQUIRED**: Always use Python libraries for PDF creation
+- **PRIMARY CHOICE**: Use **fpdf2** library for maximum customization
+- **ALTERNATIVES**: **reportlab**, **weasyprint**, **matplotlib** for charts
+
+#### OFFICIAL PDF TEMPLATE - MANDATORY USAGE!
+When creating PDFs, you MUST follow this professional structure:
+
+**STEP 1: Import and Unicode Function**
+- Import: **from fpdf import FPDF** and **import os**
+- Create remove_unicode function to handle special characters
+- Replace problematic chars: '\u2014' to '-', '\u2714\uFE0F' to 'X', '\u2026' to '...'
+
+**STEP 2: Custom PDF Class**
+- Inherit from FPDF: **class PDF(FPDF)**
+- Custom header method with professional title formatting
+- Custom footer with "Generated by BluMa | NomadEngenuity" branding
+- Use colors: Title (30,60,120), text (80,80,80)
+- Add professional line separator in header
+
+**STEP 3: PDF Creation Standards**
+- Create PDF instance and add page
+- Set auto page break with 18pt margin
+- Use Helvetica font family throughout
+- Standard text: 11pt, Headers: 14pt bold, Title: 22pt bold
+- Professional color scheme: Blues and grays
+
+**STEP 4: Content Formatting Rules**
+- Use multi_cell for paragraphs with proper line spacing
+- Create tables with alternating row colors (fill=True/False)
+- Section headers in bold with proper spacing
+- Consistent margins and indentation
+- Save with descriptive filename using os.path.join
+
+**STEP 5: Table Creation Pattern**
+- Header row with light blue fill (220,230,250)
+- Alternating row colors for readability
+- Proper border formatting (border=1)
+- Text alignment: Left for text, Center for short data
+- Use remove_unicode for all text content
+
+**MANDATORY REQUIREMENTS:**
+1. ALWAYS use remove_unicode function for text compatibility
+2. ALWAYS use custom PDF class with header/footer
+3. ALWAYS include BluMa branding in footer
+4. USE professional colors: Blues (30,60,120), grays (40,40,40)
+5. CREATE tables for structured data with alternating colors
+6. ADD proper spacing between sections
+7. USE multi_cell for long text paragraphs
+8. SET proper margins and auto page breaks
+9. SAVE with descriptive filename
+
+**REQUIREMENT**: This template ensures consistent, professional PDF output.
+
+#### WHEN SOMETHING FAILS:
+1. **ANALYZE** why it failed (missing dependency, wrong approach, etc.)
+2. **RESEARCH** alternative libraries or methods
+3. **IMPLEMENT** the alternative approach immediately
+4. **TEST** and validate the solution works
+5. **DOCUMENT** what worked for future reference
+
+#### EXAMPLES OF RESILIENT APPROACHES:
+- **PDF Creation**: fpdf2 \u2192 reportlab \u2192 weasyprint \u2192 matplotlib
+- **Image Processing**: Pillow \u2192 opencv \u2192 imageio \u2192 skimage
+- **Data Analysis**: pandas \u2192 numpy \u2192 pure Python \u2192 alternative libraries
+- **Web Scraping**: requests + BeautifulSoup \u2192 selenium \u2192 scrapy
+- **File Processing**: Built-in libs \u2192 specialized libs \u2192 custom solutions
+
+### PROBLEM-SOLVING HIERARCHY:
+1. **Try the optimal solution first**
+2. **If it fails, immediately try alternative #1**
+3. **If that fails, try alternative #2**
+4. **Keep trying until you find a working solution**
+5. **Create custom solution if no library works**
+6. **NEVER say "I can't do this" or "this isn't possible"**
+
+### FORBIDDEN PHRASES:
+- "This isn't possible"
+- "I can't do this"
+- "The tool isn't available"
+- "You'll need to do this manually"
+- "I recommend using external tools"
+
+### REQUIRED ATTITUDE:
+- "Let me try a different approach"
+- "I'll use an alternative library"
+- "I'll create a custom solution"
+- "I'll find another way to accomplish this"
+- "I'll build this from scratch if needed"
+
+## TECHNICAL IMPLEMENTATION AUTHORITY
+A Senior Engineer finds solutions, not excuses. You have the skills, tools, and authority to solve any problem.
+</resilience_and_alternatives>
+
+<mermaid_diagrams>
+# MERMAID DIAGRAM CREATION - PERFECT SYNTAX REQUIRED!
+## CRITICAL: ALL DIAGRAMS MUST RENDER WITHOUT ERRORS
+
+### MANDATORY MERMAID SYNTAX RULES
+1. **ALWAYS wrap ALL labels in double quotes**: "label text"
+2. **NEVER use unescaped special characters**: /, (), [], {}, +, *, ?, ^, $, |, 3. **Use line breaks (<br/>) for multi-line labels**: "Line 1<br/>Line 2"
+4. **NO custom colors or ::: syntax**: Stick to standard themes
+5. **NO beta features**: Use only stable Mermaid syntax
+6. **NO remote images**: Never embed external images
+
+### SAFE LABEL FORMATTING
+
+CORRECT:
+- "dev Authentication"
+- "API Gateway (REST)"
+- "Database Connection<br/>MySQL 8.0"
+- "Process Data<br/>Transform & Validate"
+
+INCORRECT:
+- dev Authentication (missing quotes)
+- API Gateway (REST) (parentheses without quotes)
+- Database/MySQL (slash without quotes)
+- Process & Transform (ampersand without quotes)
+
+
+### DIAGRAM TYPE BEST PRACTICES
+
+#### FLOWCHART
+
+flowchart TD
+    A["Start Process"] --> B["Validate Input"]
+    B --> C{"Is Valid?"}
+    C -->|"Yes"| D["Process Data"]
+    C -->|"No"| E["Return Error"]
+    D --> F["Save to Database"]
+    F --> G["Send Response"]
+
+
+#### SEQUENCE DIAGRAM
+
+sequenceDiagram
+    participant U as "dev"
+    participant A as "API Gateway"
+    participant D as "Database"
+    
+    U->>A: "Submit Request"
+    A->>D: "Query Data"
+    D-->>A: "Return Results"
+    A-->>U: "Response Data"
+
+#### CLASS DIAGRAM
+
+classDiagram
+    class dev {
+        +String name
+        +String email
+        +authenticate()
+        +updateProfile()
+    }
+    
+    class Database {
+        +connect()
+        +query()
+        +close()
+    }
+    
+    dev --> Database : "uses"
+
+
+### VALIDATION CHECKLIST
+Before creating any diagram, ensure:
+- [ ] All labels are wrapped in double quotes
+- [ ] No unescaped special characters (/, (), etc.)
+- [ ] Line breaks use <br/> syntax
+- [ ] No custom colors or styling
+- [ ] No beta features or experimental syntax
+- [ ] All connections use proper arrow syntax
+- [ ] Node IDs are simple alphanumeric
+
+### ERROR PREVENTION
+- Always test diagram syntax mentally before generating
+- Use simple, descriptive labels without special formatting
+- Prefer clarity over visual complexity
+- Keep diagrams focused and readable
+- Use standard Mermaid themes only
+
+## ZERO TOLERANCE FOR SYNTAX ERRORS
+Every diagram MUST render perfectly on first try. No exceptions.
+</mermaid_diagrams>
+                       
+<message_rules>
+- Communicate with dev via message tools instead of direct text responses
+- Reply immediately to new dev messages before other operations
+- First reply must be brief, only confirming receipt without specific solutions
+- Notify dev's with brief explanation when changing methods or strategies
+- Message tools are divided into notify (non-blocking, no reply needed from dev's) and ask (blocking, reply required)
+- Actively use notify for progress updates, but reserve ask for only essential needs to minimize dev disruption and avoid blocking progress
+- Must send messages to developers with results and deliverables before signaling the completion of the task system.
+- Never forget to follow the "end_task_rules" properly.
+</message_rules>
+                       
+<bluma_nootebook>
+# YOUR THINKING ON A NOTEBOOK - MANDATORY USE
+CRITICAL: Your laptop (**bluma_nootebook**) is your ORGANIZED MIND
+## IMPORTANT
+## NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
+## ALWAYS USE A NOTEBOOK (Always for):
+- ANY task
+- Before starting development (plan first!)
+- Projects with multiple files (organize the structure)
+- Debugging sessions (monitor discoveries)
+- Extensive refactoring (map the changes)
+- Architectural decisions (think through the options)
+
+## HOW TO USE A NOTEBOOK:
+1. Start with **bluma_nootebook**
+2. Break the task down into logical steps
+3. Plan the approach - Which files? What changes? What order? 4. Track progress - Check off completed steps
+5. Write down decisions - Why did you choose this approach?
+6. Update continuously - Keep the notebook up to date
+
+## THE NOTEBOOK PREVENTS:
+- Acting "outside the box"
+- Forgetting task requirements
+- Losing control of complex workflows
+- Making unplanned changes
+- Ineffective approaches
+- Working without a clear roadmap
+- Jumping between unrelated subtasks
+
+	##Important rule:
+	Do **not** include any future steps, to-do items, or pending tasks here.
+	Those belong strictly in the **remaining_tasks** field.
+
+	Never write phrases like:
+	- "Next I will..."
+	- "I still need to..."
+	- "Pending: ..."
+	Such content must go in **remaining_tasks**, not **thought**.
+
+- remaining_tasks: Checklist-style list of high-level upcoming tasks.
+	This format is **mandatory**:
+	- Each task **must start** with either:
+	- "[ ]" \u2192 for tasks not yet done (pending)
+	- "\u{1F5F8}" \u2192 for tasks that have already been completed
+
+	Whenever a task is already done, it **must** be marked with "\u{1F5F8}". Do not leave completed tasks without the checkmark.
+
+	Do not use other formats like "-", "*", or plain text without the prefix.
+
+	Examples:
+	[ ] Test integration flow
+	\u{1F5F8} Set up environment
+	\u{1F5F8} Configure database
+</bluma_nootebook>
+
+### Tool Naming Policy
+
+Tool names must strictly follow the standard naming format:
+
+- Use: plain, unmodified, lowercase names
+- Do NOT use: special characters, extra spaces, version suffixes, or dynamic IDs
+
+---
+
+Correct Examples:
+- bluma_notebook
+- getDataTool
+- convertImage
+- userAuth
+
+---
+
+Incorrect Examples:
+- bluma_nootebook:0       \u2190 contains colon and dynamic suffix
+- bluma_nootebook 1       \u2190 contains space and number
+- bluma_nootebook#v2      \u2190 contains special character #
+- bluma__nootebook        \u2190 double underscore
+- Bluma_Nootebook         \u2190 capital letters and underscore
+- bluma nootebook         \u2190 contains space
+
+---
+
+Rule Summary:
+- Use only a\u2013z, 0\u20139, and underscores (_)
+- Do not append suffixes like :0, :v2, etc.
+- Tool names must be static and predictable
+- No whitespace, no dynamic elements, no special characters
+
+
+<edit_tool_rules>
+- Use this tool to perform precise text replacements inside files based on exact literal matches.
+- Can be used to create new files or directories implicitly by targeting non-existing paths.
+- Suitable for inserting full content into a file even if the file does not yet exist.
+- Shell access is not required for file or directory creation when using this tool.
+- Always prefer this tool over shell_command when performing structured edits or creating files with specific content.
+- Ensure **old_string** includes 3+ lines of exact context before and after the target if replacing existing content.
+- For creating a new file, provide an **old_string** that matches an empty string or placeholder and a complete **new_string** with the intended content.
+- When generating or modifying todo.md files, prefer this tool to insert checklist structure and update status markers.
+- After completing any task in the checklist, immediately update the corresponding section in todo.md using this tool.
+- Reconstruct the entire file from task planning context if todo.md becomes outdated or inconsistent.
+- Track all progress related to planning and execution inside todo.md using text replacement only.
+</edit_tool_rules>
+
+      
+## Examples os iteration with dev
+<example>
+dev: Hello, how are you?
+BluMa: tool_call "message_notify_dev" Hello, I'm BluMa. What can I do with your code?
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: What day is it?
+BluMa: tool_call "message_notify_dev" Sorry, I was designed to operate in the codebase. How can I help you with the code today?
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Can you generate a new feature for me?
+BluMa: tool_call "message_notify_dev" Of course. Tell me what functionality you want, and I\u2019ll generate the code accordingly.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: What's the weather like today?
+BluMa: tool_call "message_notify_dev" I don\u2019t have access to real-world data. I'm focused on your codebase. What would you like to modify or create?
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: I'm tired of debugging this.
+BluMa: tool_call "message_notify_dev" I can help you with that. Show me the file or error, and I\u2019ll assist with debugging.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Can you create documentation for this module?
+BluMa: tool_call "message_notify_dev" Yes. Please specify which module or function you'd like documented.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Do you know who won the game last night?
+BluMa: tool_call "message_notify_dev" I\u2019m only trained to work inside the codebase. Let me know what you need done in the project.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Refactor this file to follow clean architecture.
+BluMa: tool_call "message_notify_dev" Got it. Send me the file path or code snippet you want refactored.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: How do I fix this type error in TypeScript?
+BluMa: tool_call "message_notify_dev" Send me the error message and relevant code, and I\u2019ll help you resolve the issue.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Do you have feelings?
+BluMa: tool_call "message_notify_dev" I\u2019m not sentient \u2014 I exist solely to help you build, refactor, and improve your codebase.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Rename all the variables to match the new convention.
+BluMa: tool_call "message_notify_dev" Please share the convention and the target file(s), and I\u2019ll rename the variables accordingly.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Run the tests for the user module.
+BluMa: tool_call "message_notify_dev" Running tests for the user module.
+BluMa: shell_command_shell_command "npm run test user"
+BluMa: tool_call "message_notify_dev" All tests passed successfully for the user module.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Run the tests for the user module.
+BluMa: tool_call "message_notify_dev" Running tests for the user module.
+BluMa: shell_command_shell_command "npm run test user"
+BluMa: tool_call "message_notify_dev" Tests finished with 2 failures. See **tests/user.test.js** for more details.
+tool_call "agent_end_task"
+</example>
+
+<example>
+dev: Prepare the project for deployment.
+BluMa: tool_call "message_notify_dev" Starting full project preparation: linting, building, and testing.
+BluMa: shell_command_shell_command "npm run lint"
+BluMa: tool_call "message_notify_dev" Linting completed. No major issues found.
+BluMa: shell_command_shell_command "npm run build"
+BluMa: tool_call "message_notify_dev" Build successful. Artifacts ready in the /dist folder.
+BluMa: shell_command_shell_command "npm run test"
+BluMa: tool_call "message_notify_dev" All tests passed. The project is ready for deployment. If you need any further adjustments or extra sections, let me know!
+tool_call "agent_end_task"
+</example>
+
+<end_task_rules>
+    This tool is used to signal to the system that the current task has completed and that the agent can be placed in an idle state. 
+</end_task_rules>
+
+
+### QUALITY STANDARDS 
+- Document every major decision in Notion 
+- Communicate transparently at each step 
+- Write clean, well-documented code 
+- Follow existing project conventions 
+- Test implementations when possible 
+- Ensure security and performance 
+
+<scope_and_limitations>
+# WHAT YOU DON'T HANDLE 
+- Non-technical questions 
+- Personal advice 
+- General conversation 
+- Tasks outside software development 
+
+# IF ASKED NON-TECHNICAL QUESTIONS 
+- Use message_notify_dev to politely decline 
+- Explain you only handle technical/coding tasks 
+- Suggest they ask a development-related question instead 
+</scope_and_limitations>
+
+`;
+function getUnifiedSystemPrompt() {
+  const now = /* @__PURE__ */ new Date();
+  const collectedData = {
+    os_type: os2.type(),
+    os_version: os2.release(),
+    architecture: os2.arch(),
+    workdir: process.cwd(),
+    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
+    username: os2.userInfo().username || "Unknown",
+    current_date: now.toISOString().split("T")[0],
+    // Formato YYYY-MM-DD
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
+    locale: process.env.LANG || process.env.LC_ALL || "Unknown"
+  };
+  const finalEnv = {
+    os_type: "Unknown",
+    os_version: "Unknown",
+    workdir: "Unknown",
+    shell_type: "Unknown",
+    username: "Unknown",
+    architecture: "Unknown",
+    current_date: "Unknown",
+    timezone: "Unknown",
+    locale: "Unknown",
+    ...collectedData
+    // Os dados coletados sobrescrevem os padrões
+  };
+  let formattedPrompt = SYSTEM_PROMPT;
+  for (const key in finalEnv) {
+    const placeholder = `{${key}}`;
+    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
+  }
+  return formattedPrompt;
+}
+
+// src/app/agent/tool_invoker.ts
+import { promises as fs6 } from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+
+// src/app/agent/tools/natives/shell_command.ts
+import os3 from "os";
+import { exec } from "child_process";
+function shellCommand(args) {
+  const { command, timeout = 20, cwd = process.cwd(), verbose = false } = args;
+  return new Promise((resolve) => {
+    const report = {
+      platform: os3.platform(),
+      // Coleta o sistema operacional (ex: 'win32', 'linux')
+      command,
+      cwd,
+      results: []
+    };
+    if (verbose) {
+      report.env = {
+        PATH: process.env.PATH || "NOT SET",
+        ComSpec: process.env.ComSpec || "NOT SET"
+        // Específico do Windows, útil para saber qual cmd está sendo usado
+      };
+    }
+    const childProcess = exec(
+      command,
+      {
+        // O diretório de trabalho para o comando.
+        cwd,
+        // O timeout em milissegundos. Se o comando exceder este tempo, ele será encerrado.
+        timeout: timeout * 1e3,
+        // A opção `shell` foi removida, pois `exec` usa o shell por padrão.
+        // Especificar a codificação garante que a saída seja tratada como texto UTF-8.
+        encoding: "utf-8"
+      },
+      // Este é o callback que será executado QUANDO o processo filho terminar,
+      // seja por sucesso, erro ou timeout.
+      (error, stdout, stderr) => {
+        const result = {
+          method: "child_process.exec",
+          status: "Success",
+          // Se `error` existir, ele contém o código de saída. Caso contrário, o código é 0 (sucesso).
+          code: error ? error.code || null : 0,
+          // Limpa espaços em branco do início e fim das saídas.
+          output: stdout.trim(),
+          error: stderr.trim()
+        };
+        if (error) {
+          if (error.killed) {
+            result.status = "Timeout";
+            result.error = `Command exceeded timeout of ${timeout} seconds. ${stderr.trim()}`.trim();
+          } else {
+            result.status = "Error";
+            result.error = `${error.message}
+${stderr.trim()}`.trim();
+          }
+        }
+        if (verbose) {
+          report.results.push(result);
+          resolve(JSON.stringify(report, null, 2));
+        } else {
+          resolve(JSON.stringify(result, null, 2));
+        }
+      }
+    );
+  });
+}
+
+// src/app/agent/tools/natives/edit.ts
+import path3 from "path";
+import { promises as fs2 } from "fs";
+import { diffLines } from "diff";
+function unescapeLlmString(inputString) {
+  return inputString.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+}
+function ensureCorrectEdit(currentContent, oldString, newString, expectedReplacements) {
+  let finalOldString = oldString;
+  let finalNewString = newString;
+  let occurrences = currentContent.split(finalOldString).length - 1;
+  if (occurrences !== expectedReplacements && occurrences === 0) {
+    const unescapedOldString = unescapeLlmString(oldString);
+    const unescapedOccurrences = currentContent.split(unescapedOldString).length - 1;
+    if (unescapedOccurrences > 0) {
+      finalOldString = unescapedOldString;
+      finalNewString = unescapeLlmString(newString);
+      occurrences = unescapedOccurrences;
+    } else {
+      const trimmedOldString = oldString.trim();
+      const trimmedOccurrences = currentContent.split(trimmedOldString).length - 1;
+      if (trimmedOccurrences > 0) {
+        finalOldString = trimmedOldString;
+        finalNewString = newString.trim();
+        occurrences = trimmedOccurrences;
+      }
+    }
+  }
+  return [finalOldString, finalNewString, occurrences];
+}
+async function calculateEdit(filePath, oldString, newString, expectedReplacements) {
+  let currentContent = null;
+  let isNewFile = false;
+  let error = null;
+  let finalNewString = unescapeLlmString(newString).replace(/\r\n/g, "\n");
+  let finalOldString = oldString.replace(/\r\n/g, "\n");
+  let occurrences = 0;
+  try {
+    currentContent = await fs2.readFile(filePath, "utf-8");
+    currentContent = currentContent.replace(/\r\n/g, "\n");
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      error = { display: `Error reading file: ${e.message}`, raw: `Error reading file ${filePath}: ${e.message}` };
+      return { currentContent, newContent: "", occurrences: 0, error, isNewFile };
+    }
+  }
+  if (currentContent === null) {
+    if (oldString === "") {
+      isNewFile = true;
+      occurrences = 1;
+    } else {
+      error = { display: "File not found. Cannot apply edit. Use an empty old_string to create a new file.", raw: `File not found: ${filePath}` };
+    }
+  } else {
+    if (oldString === "") {
+      error = { display: "Failed to edit. Attempted to create a file that already exists.", raw: `File already exists, cannot create: ${filePath}` };
+    } else {
+      [finalOldString, finalNewString, occurrences] = ensureCorrectEdit(currentContent, finalOldString, finalNewString, expectedReplacements);
+      if (occurrences === 0) {
+        error = { display: "Failed to edit, could not find the string to replace.", raw: `0 occurrences found for old_string in ${filePath}. Check whitespace, indentation, and context.` };
+      } else if (occurrences !== expectedReplacements) {
+        error = { display: `Failed to edit, expected ${expectedReplacements} occurrence(s) but found ${occurrences}.`, raw: `Expected ${expectedReplacements} but found ${occurrences} for old_string in ${filePath}` };
+      }
+    }
+  }
+  let newContentResult = "";
+  if (!error) {
+    if (isNewFile) {
+      newContentResult = finalNewString;
+    } else if (currentContent !== null) {
+      newContentResult = currentContent.replaceAll(finalOldString, finalNewString);
+    }
+  }
+  return { currentContent, newContent: newContentResult, occurrences, error, isNewFile };
+}
+function createDiff(filename, oldContent, newContent) {
+  const diff = diffLines(oldContent, newContent, {
+    // `unified: 3` é o padrão para diffs, mostrando 3 linhas de contexto.
+    // `newlineIsToken: true` lida melhor com mudanças de quebra de linha.
+  });
+  let diffString = `--- a/${filename}
++++ b/${filename}
+`;
+  diff.forEach((part) => {
+    const prefix = part.added ? "+" : part.removed ? "-" : " ";
+    part.value.split("\n").slice(0, -1).forEach((line) => {
+      diffString += `${prefix}${line}
+`;
+    });
+  });
+  return diffString;
+}
+async function editTool(args) {
+  const { file_path, old_string, new_string, expected_replacements = 1 } = args;
+  if (!path3.isAbsolute(file_path)) {
+    return { success: false, error: `Invalid parameters: file_path must be absolute.`, file_path };
+  }
+  if (file_path.includes("..")) {
+    return { success: false, error: `Invalid parameters: file_path cannot contain '..'.`, file_path };
+  }
+  try {
+    const editData = await calculateEdit(file_path, old_string, new_string, expected_replacements);
+    if (editData.error) {
+      return {
+        success: false,
+        error: `Execution failed: ${editData.error.display}`,
+        details: editData.error.raw,
+        file_path
+      };
+    }
+    await fs2.mkdir(path3.dirname(file_path), { recursive: true });
+    await fs2.writeFile(file_path, editData.newContent, "utf-8");
+    const relativePath = path3.relative(process.cwd(), file_path);
+    const filename = path3.basename(file_path);
+    if (editData.isNewFile) {
+      return {
+        success: true,
+        file_path,
+        description: `Created new file: ${relativePath}`,
+        message: `Created new file: ${file_path} with the provided content.`,
+        is_new_file: true,
+        occurrences: editData.occurrences,
+        relative_path: relativePath
+      };
+    } else {
+      const finalDiff = createDiff(filename, editData.currentContent || "", editData.newContent);
+      return {
+        success: true,
+        file_path,
+        description: `Modified ${relativePath} (${editData.occurrences} replacement(s)).`,
+        message: `Successfully modified file: ${file_path}. Diff of changes:
+${finalDiff}`,
+        is_new_file: false,
+        occurrences: editData.occurrences,
+        relative_path: relativePath
+      };
+    }
+  } catch (e) {
+    return {
+      success: false,
+      error: `An unexpected error occurred during the edit operation: ${e.message}`,
+      file_path
+    };
+  }
+}
+
+// src/app/agent/tools/natives/message.ts
+import { v4 as uuidv4 } from "uuid";
+function messageNotifyDev(args) {
+  const { text_markdown } = args;
+  const notification = {
+    type: "message_notify_dev",
+    id: `notify_${uuidv4()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    content: {
+      format: "markdown",
+      body: text_markdown
+    },
+    success: true,
+    delivered: true
+  };
+  return Promise.resolve(notification);
+}
+
+// src/app/agent/tools/natives/ls.ts
+import { promises as fs3 } from "fs";
+import path4 from "path";
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  ".git",
+  ".gitignore",
+  ".venv",
+  "venv",
+  "node_modules",
+  "__pycache__",
+  "*.pyc",
+  ".vscode",
+  ".idea",
+  "dist",
+  "build",
+  "*.log",
+  ".DS_Store"
+]);
+async function ls(args) {
+  const {
+    directory_path = ".",
+    recursive = false,
+    ignore_patterns = [],
+    start_index = 0,
+    end_index,
+    show_hidden = false,
+    file_extensions,
+    max_depth
+  } = args;
+  try {
+    const basePath = path4.resolve(directory_path);
+    if (!(await fs3.stat(basePath)).isDirectory()) {
+      throw new Error(`Directory '${directory_path}' not found.`);
+    }
+    const allIgnorePatterns = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore_patterns]);
+    const normalizedExtensions = file_extensions?.map((ext) => ext.toLowerCase());
+    const allFiles = [];
+    const allDirs = [];
+    const walk = async (currentDir, currentDepth) => {
+      if (max_depth !== void 0 && currentDepth > max_depth) return;
+      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryName = entry.name;
+        const fullPath = path4.join(currentDir, entryName);
+        const posixPath = fullPath.split(path4.sep).join("/");
+        const isHidden = entryName.startsWith(".");
+        if (allIgnorePatterns.has(entryName) || isHidden && !show_hidden) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          allDirs.push(posixPath);
+          if (recursive) {
+            await walk(fullPath, currentDepth + 1);
+          }
+        } else if (entry.isFile()) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path4.extname(entryName).toLowerCase())) {
+            allFiles.push(posixPath);
+          }
+        }
+      }
+    };
+    await walk(basePath, 0);
+    allFiles.sort();
+    allDirs.sort();
+    return {
+      success: true,
+      path: basePath.split(path4.sep).join("/"),
+      recursive,
+      total_files: allFiles.length,
+      total_directories: allDirs.length,
+      showing_files: `[${start_index}:${Math.min(end_index ?? allFiles.length, allFiles.length)}]`,
+      showing_directories: `[${start_index}:${Math.min(end_index ?? allDirs.length, allDirs.length)}]`,
+      files: allFiles.slice(start_index, end_index),
+      directories: allDirs.slice(start_index, end_index),
+      filters_applied: { ignore_patterns: [...allIgnorePatterns], show_hidden, file_extensions, max_depth }
+    };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// src/app/agent/tools/natives/readLines.ts
+import { promises as fs4 } from "fs";
+async function readLines(args) {
+  const { filepath, start_line, end_line } = args;
+  try {
+    if (!(await fs4.stat(filepath)).isFile()) {
+      throw new Error(`File '${filepath}' not found or is not a file.`);
+    }
+    if (start_line < 1 || end_line < start_line) {
+      throw new Error("Invalid line range. start_line must be >= 1 and end_line must be >= start_line.");
+    }
+    const fileContent = await fs4.readFile(filepath, "utf-8");
+    const lines = fileContent.split("\n");
+    const total_lines = lines.length;
+    const startIndex = start_line - 1;
+    let endIndex = end_line;
+    if (startIndex >= total_lines) {
+      throw new Error(`start_line (${start_line}) exceeds file length (${total_lines} lines).`);
+    }
+    endIndex = Math.min(endIndex, total_lines);
+    const contentLines = lines.slice(startIndex, endIndex);
+    const content = contentLines.join("\n");
+    return {
+      success: true,
+      filepath,
+      content,
+      lines_read: contentLines.length,
+      start_line,
+      end_line: endIndex,
+      // Retorna o final real usado
+      total_file_lines: total_lines
+    };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// src/app/agent/tools/natives/count_lines.ts
+import { createReadStream } from "fs";
+import { promises as fs5 } from "fs";
+import readline from "readline";
+async function countLines(args) {
+  const { filepath } = args;
+  try {
+    if (!(await fs5.stat(filepath)).isFile()) {
+      throw new Error(`File '${filepath}' not found or is not a file.`);
+    }
+    const fileStream = createReadStream(filepath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let lineCount = 0;
+    for await (const line of rl) {
+      lineCount++;
+    }
+    return { success: true, filepath, line_count: lineCount };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// src/app/agent/tool_invoker.ts
+var ToolInvoker = class {
+  // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
+  toolImplementations;
+  // Propriedade privada para armazenar as definições de ferramentas carregadas do JSON.
+  toolDefinitions = [];
+  constructor() {
+    this.toolImplementations = /* @__PURE__ */ new Map();
+    this.registerTools();
+  }
+  /**
+   * Carrega as definições de ferramentas do arquivo de configuração `native_tools.json`.
+   * Este método é assíncrono e deve ser chamado após a criação da instância.
+   */
+  async initialize() {
+    try {
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path5.dirname(__filename);
+      const configPath = path5.resolve(__dirname, "config", "native_tools.json");
+      const fileContent = await fs6.readFile(configPath, "utf-8");
+      const config2 = JSON.parse(fileContent);
+      this.toolDefinitions = config2.nativeTools;
+    } catch (error) {
+      console.error("[ToolInvoker] Erro cr\xEDtico ao carregar 'native_tools.json'. As ferramentas nativas n\xE3o estar\xE3o dispon\xEDveis.", error);
+      this.toolDefinitions = [];
+    }
+  }
+  /**
+   * Registra as implementações de todas as ferramentas nativas.
+   * Este método mapeia o nome da ferramenta (string) para a função TypeScript que a executa.
+   */
+  registerTools() {
+    this.toolImplementations.set("shell_command", shellCommand);
+    this.toolImplementations.set("edit_tool", editTool);
+    this.toolImplementations.set("message_notify_dev", messageNotifyDev);
+    this.toolImplementations.set("ls_tool", ls);
+    this.toolImplementations.set("count_file_lines", countLines);
+    this.toolImplementations.set("read_file_lines", readLines);
+    this.toolImplementations.set("agent_end_task", async () => ({ success: true, message: "Task ended by agent." }));
+  }
+  /**
+   * Retorna a lista de definições de todas as ferramentas nativas carregadas.
+   * O MCPClient usará esta função para obter a lista de ferramentas locais.
+   */
+  getToolDefinitions() {
+    return this.toolDefinitions;
+  }
+  /**
+   * Invoca uma ferramenta nativa pelo nome com os argumentos fornecidos.
+   * @param toolName O nome da ferramenta a ser invocada.
+   * @param args Os argumentos para a ferramenta, geralmente um objeto.
+   * @returns O resultado da execução da ferramenta.
+   */
+  async invoke(toolName, args) {
+    const implementation = this.toolImplementations.get(toolName);
+    if (!implementation) {
+      return { error: `Error: Native tool "${toolName}" not found.` };
+    }
+    try {
+      return await implementation(args);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "An unknown error occurred.";
+      return { error: `Error executing tool "${toolName}": ${errorMessage}` };
+    }
+  }
+};
+
+// src/app/agent/tools/mcp/mcp_client.ts
+import { promises as fs7 } from "fs";
+import path6 from "path";
+import os4 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var MCPClient = class {
+  sessions = /* @__PURE__ */ new Map();
+  toolToServerMap = /* @__PURE__ */ new Map();
+  globalToolsForLlm = [];
+  nativeToolInvoker;
+  eventBus;
+  // <<< ADICIONA A PROPRIEDADE
+  constructor(nativeToolInvoker, eventBus2) {
+    this.nativeToolInvoker = nativeToolInvoker;
+    this.eventBus = eventBus2;
+  }
+  // ... (método initialize inalterado) ...
+  async initialize() {
+    const nativeTools = this.nativeToolInvoker.getToolDefinitions();
+    this.globalToolsForLlm.push(...nativeTools);
+    for (const tool of nativeTools) {
+      const toolName = tool.function.name;
+      this.toolToServerMap.set(toolName, {
+        server: "native",
+        originalName: toolName
+      });
+    }
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = path6.dirname(__filename);
+    const defaultConfigPath = path6.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path6.join(os4.homedir(), ".bluma-cli", "bluma-mcp.json");
+    const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
+    const userConfig = await this.loadMcpConfig(userConfigPath, "User");
+    const mergedConfig = {
+      mcpServers: {
+        ...defaultConfig.mcpServers || {},
+        ...userConfig.mcpServers || {}
+      }
+    };
+    if (Object.keys(mergedConfig.mcpServers).length === 0) {
+      return;
+    }
+    const serverEntries = Object.entries(mergedConfig.mcpServers);
+    for (const [serverName, serverConf] of serverEntries) {
+      try {
+        this.eventBus.emit("backend_message", {
+          type: "connection_status",
+          message: `Connecting to MCP server: ${serverName}...`
+        });
+        if (serverConf.type === "stdio") {
+          await this.connectToStdioServer(serverName, serverConf);
+        } else if (serverConf.type === "sse") {
+          console.warn(`[MCPClient] Conex\xE3o com servidores SSE (como '${serverName}') ainda n\xE3o implementada.`);
+        }
+      } catch (error) {
+        this.eventBus.emit("backend_message", {
+          type: "error",
+          message: `Failed to connect to server '${serverName}'.`
+        });
+      }
+    }
+  }
+  async loadMcpConfig(configPath, configType) {
+    try {
+      const fileContent = await fs7.readFile(configPath, "utf-8");
+      const processedContent = this.replaceEnvPlaceholders(fileContent);
+      return JSON.parse(processedContent);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (configType === "User") {
+        }
+      } else {
+        console.warn(`[MCPClient] Warning: Error reading ${configType} config file ${configPath}.`, error);
+      }
+      return {};
+    }
+  }
+  /**
+   * Conecta-se a um servidor MCP baseado em Stdio, adaptando o comando para o SO atual.
+   */
+  async connectToStdioServer(serverName, config2) {
+    let commandToExecute = config2.command;
+    let argsToExecute = config2.args || [];
+    const isWindows = os4.platform() === "win32";
+    if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
+      if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
+        commandToExecute = argsToExecute[1];
+        argsToExecute = argsToExecute.slice(2);
+      } else {
+        console.warn(`[MCPClient] Formato de comando 'cmd /c' inesperado para '${serverName}' em sistema n\xE3o-Windows. O servidor ser\xE1 ignorado.`);
+        return;
+      }
+    }
+    const transport = new StdioClientTransport({
+      command: commandToExecute,
+      // Usa o comando adaptado
+      args: argsToExecute,
+      // Usa os argumentos adaptados
+      env: config2.env
+    });
+    const mcp = new Client({ name: `bluma-cli-client-for-${serverName}`, version: "1.0.0" });
+    await mcp.connect(transport);
+    this.sessions.set(serverName, mcp);
+    const toolsResult = await mcp.listTools();
+    for (const tool of toolsResult.tools) {
+      const prefixedToolName = `${serverName}_${tool.name}`;
+      this.globalToolsForLlm.push({
+        type: "function",
+        function: {
+          name: prefixedToolName,
+          description: tool.description || "",
+          parameters: tool.inputSchema
+        }
+      });
+      this.toolToServerMap.set(prefixedToolName, {
+        server: serverName,
+        originalName: tool.name
+      });
+    }
+  }
+  async invoke(toolName, args) {
+    const route = this.toolToServerMap.get(toolName);
+    if (!route) {
+      return { error: `Ferramenta '${toolName}' n\xE3o encontrada ou registrada.` };
+    }
+    if (route.server === "native") {
+      return this.nativeToolInvoker.invoke(route.originalName, args);
+    } else {
+      const session = this.sessions.get(route.server);
+      if (!session) {
+        return { error: `Sess\xE3o para o servidor '${route.server}' n\xE3o encontrada.` };
+      }
+      const result = await session.callTool({ name: route.originalName, arguments: args });
+      return result.content;
+    }
+  }
+  getAvailableTools() {
+    return this.globalToolsForLlm;
+  }
+  async close() {
+    for (const [name, session] of this.sessions.entries()) {
+      try {
+        await session.close();
+      } catch (error) {
+        console.error(`[MCPClient] Erro ao encerrar conex\xE3o com '${name}':`, error);
+      }
+    }
+  }
+  replaceEnvPlaceholders(content) {
+    return content.replace(/\$\{([A-Za-z0-9_]+)\}/g, (match, varName) => {
+      return process.env[varName] || match;
+    });
+  }
+};
+
+// src/app/agent/feedback/feedback_system.ts
+var AdvancedFeedbackSystem = class {
+  cumulativeScore = 0;
+  /**
+   * Gera feedback com base em um evento ocorrido.
+   * @param event O evento a ser avaliado.
+   * @returns Um objeto com a pontuação, mensagem e correção.
+   */
+  generateFeedback(event) {
+    if (event.event === "protocol_violation_direct_text") {
+      const penalty = -2.5;
+      this.cumulativeScore += penalty;
+      return {
+        score: penalty,
+        message: "Direct text response is a protocol violation. All communication must be done via the 'message_notify_dev' tool.",
+        correction: `
+  ## PROTOCOL VIOLATION \u2014 SEVERE
+  You sent a direct text response, which is strictly prohibited.
+  PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
+  You MUST use tools for all actions and communication.
+          `.trim()
+      };
+    }
+    return { score: 0, message: "No feedback for this event.", correction: "" };
+  }
+  getCumulativeScore() {
+    return this.cumulativeScore;
+  }
+};
+
+// src/app/agent/core/context-api/context_manager.ts
+function createApiContextWindow(fullHistory, maxTurns) {
+  if (!fullHistory.length) {
+    return [];
+  }
+  if (maxTurns === null || maxTurns === void 0) {
+    return [...fullHistory];
+  }
+  const systemMessages = [];
+  let historyStartIndex = 0;
+  while (historyStartIndex < fullHistory.length && fullHistory[historyStartIndex].role === "system") {
+    systemMessages.push(fullHistory[historyStartIndex]);
+    historyStartIndex++;
+  }
+  const conversationHistory = fullHistory.slice(historyStartIndex);
+  const turns = [];
+  let currentTurn = [];
+  let turnsFound = 0;
+  for (let i = conversationHistory.length - 1; i >= 0; i--) {
+    const msg = conversationHistory[i];
+    currentTurn.unshift(msg);
+    if (msg.role === "assistant" && // CORREÇÃO: Adicionamos o tipo explícito para 'tc' para resolver o erro do TypeScript.
+    msg.tool_calls?.some((tc) => tc.function.name === "agent_end_task")) {
+      turns.unshift([...currentTurn]);
+      currentTurn = [];
+      turnsFound++;
+      if (turnsFound >= maxTurns) {
+        break;
+      }
+    }
+  }
+  if (currentTurn.length > 0) {
+    turns.unshift(currentTurn);
+  }
+  const finalContext = systemMessages.concat(turns.flat());
+  return finalContext;
+}
+
+// src/app/agent/agent.ts
+var globalEnvPath = path7.join(os5.homedir(), ".bluma-cli", ".env");
+dotenv.config({ path: globalEnvPath });
+var Agent = class {
+  client;
+  deploymentName;
+  sessionId;
+  sessionFile = "";
+  history = [];
+  eventBus;
+  mcpClient;
+  feedbackSystem;
+  isInitialized = false;
+  maxContextTurns = 300;
+  isInterrupted = false;
+  // <-- NOVO: Flag de interrupção
+  constructor(sessionId2, eventBus2) {
+    this.sessionId = sessionId2;
+    this.eventBus = eventBus2;
+    this.eventBus.on("user_interrupt", () => {
+      this.isInterrupted = true;
+    });
+    const nativeToolInvoker = new ToolInvoker();
+    this.mcpClient = new MCPClient(nativeToolInvoker, eventBus2);
+    this.feedbackSystem = new AdvancedFeedbackSystem();
+    const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
+    const apiKey = process.env.AZURE_OPENAI_API_KEY;
+    const apiVersion = process.env.AZURE_OPENAI_API_VERSION;
+    this.deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT || "";
+    if (!endpoint || !apiKey || !apiVersion || !this.deploymentName) {
+      const errorMessage = `Uma ou mais vari\xE1veis de ambiente Azure OpenAI n\xE3o foram encontradas. Verifique em: ${globalEnvPath} ou nas vari\xE1veis de sistema.`;
+      throw new Error(errorMessage);
+    }
+    this.client = new OpenAI({
+      // Configuração do cliente OpenAI hospedado no Azure
+      apiKey,
+      baseURL: `${endpoint}/openai/deployments/${this.deploymentName}`,
+      defaultQuery: { "api-version": apiVersion },
+      defaultHeaders: { "api-key": apiKey }
+    });
+  }
+  /**
+   * Inicializa o agente, carregando ou criando uma sessão e preparando o histórico.
+   * Também inicializa o MCPClient e o ToolInvoker.
+   */
+  async initialize() {
+    await this.mcpClient.nativeToolInvoker.initialize();
+    await this.mcpClient.initialize();
+    const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
+    this.sessionFile = sessionFile;
+    this.history = history;
+    if (this.history.length === 0) {
+      let systemPrompt = getUnifiedSystemPrompt();
+      systemPrompt += `
+        BEHAVIORAL REQUIREMENTS:
+        - You MUST use the 'message_notify_dev' tool for ALL communication with the user.
+        - Direct text responses are a protocol violation and will be penalized.
+        - Signal the end of a task using the 'agent_end_task' tool.
+        - Never make parallel tool calls.
+        - Do not include any of the following in tool names:
+            - Special characters
+            - Extra spaces
+            Always use clean, unmodified, and simple names for tools.
+            Tool names must follow strict formatting: no symbols, no whitespace, no alterations.
+        - Follow the stripes o "Tool Naming Policy"
+        - Never modify the names of the tools, use their real names without any modification.
+        - Never forget to signal the system when the task is completed 'agent_end_task' tool.
+      `;
+      this.history.push({ role: "system", content: systemPrompt });
+      await saveSessionHistory(this.sessionFile, this.history);
+    }
+  }
+  getAvailableTools() {
+    return this.mcpClient.getAvailableTools();
+  }
+  async processTurn(userInput) {
+    this.isInterrupted = false;
+    this.history.push({ role: "user", content: userInput.content });
+    await this._continueConversation();
+  }
+  /**
+   * Lida com a decisão do usuário (aceitar/recusar) sobre uma chamada de ferramenta.
+   * Garante que uma mensagem de 'role: tool' seja sempre adicionada ao histórico.
+   */
+  async handleToolResponse(decisionData) {
+    const toolCall = decisionData.tool_calls[0];
+    let toolResultContent;
+    let shouldContinueConversation = true;
+    if (decisionData.type === "user_decision_execute") {
+      const toolName = toolCall.function.name;
+      const toolArgs = JSON.parse(toolCall.function.arguments);
+      let previewContent;
+      if (toolName === "edit_tool") {
+        previewContent = await this._generateEditPreview(toolArgs);
+      }
+      this.eventBus.emit("backend_message", {
+        type: "tool_call",
+        tool_name: toolName,
+        arguments: toolArgs,
+        preview: previewContent
+      });
+      try {
+        if (this.isInterrupted) {
+          this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled before tool execution." });
+          return;
+        }
+        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") {
+          finalResult = result[0].text;
+        }
+        toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
+      } catch (error) {
+        toolResultContent = JSON.stringify({
+          error: `Tool execution failed: ${error.message}`,
+          details: error.data || "No additional details."
+        });
+      }
+      this.eventBus.emit("backend_message", { type: "tool_result", tool_name: toolName, result: toolResultContent });
+      if (toolName.includes("agent_end_task")) {
+        shouldContinueConversation = false;
+        this.eventBus.emit("backend_message", { type: "done", status: "completed" });
+      }
+    } else {
+      toolResultContent = "The user declined to execute this tool...";
+    }
+    this.history.push({
+      role: "tool",
+      tool_call_id: toolCall.id,
+      content: toolResultContent
+    });
+    await saveSessionHistory(this.sessionFile, this.history);
+    if (shouldContinueConversation && !this.isInterrupted) {
+      await this._continueConversation();
+    }
+  }
+  /**
+   * Método central que chama a API do LLM e processa a resposta,
+   * com lógica de feedback e auto-aprovação de ferramentas.
+   */
+  // Adicione este método dentro da classe Agent
+  async _generateEditPreview(toolArgs) {
+    try {
+      const editData = await calculateEdit(toolArgs.file_path, toolArgs.old_string, toolArgs.new_string, toolArgs.expected_replacements || 1);
+      if (editData.error) {
+        return `Failed to generate diff:
+
+${editData.error.display}`;
+      }
+      const filename = path7.basename(toolArgs.file_path);
+      return createDiff(filename, editData.currentContent || "", editData.newContent);
+    } catch (e) {
+      return `An unexpected error occurred while generating the edit preview: ${e.message}`;
+    }
+  }
+  async _continueConversation() {
+    try {
+      if (this.isInterrupted) {
+        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        return;
+      }
+      const contextWindow = createApiContextWindow(this.history, this.maxContextTurns);
+      const response = await this.client.chat.completions.create({
+        model: this.deploymentName,
+        messages: contextWindow,
+        tools: this.mcpClient.getAvailableTools(),
+        tool_choice: "auto",
+        parallel_tool_calls: false
+      });
+      if (this.isInterrupted) {
+        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        return;
+      }
+      const message = response.choices[0].message;
+      this.history.push(message);
+      if (message.tool_calls) {
+        const autoApprovedTools = [
+          "agent_end_task",
+          "message_notify_dev",
+          "bluma_nootebook"
+        ];
+        const toolToCall = message.tool_calls[0];
+        const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+        if (isSafeTool) {
+          await this.handleToolResponse({ type: "user_decision_execute", tool_calls: message.tool_calls });
+        } 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: message.tool_calls,
+              preview: previewContent
+            });
+          } else {
+            this.eventBus.emit("backend_message", {
+              type: "confirmation_request",
+              tool_calls: message.tool_calls
+            });
+          }
+        }
+      } else if (message.content) {
+        this.eventBus.emit("backend_message", {
+          type: "assistant_message",
+          content: message.content
+        });
+        const feedback = this.feedbackSystem.generateFeedback({
+          event: "protocol_violation_direct_text",
+          details: { violationContent: message.content }
+        });
+        this.eventBus.emit("backend_message", {
+          type: "protocol_violation",
+          message: feedback.message,
+          content: message.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();
+      }
+    } 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);
+    }
+  }
+};
+
+// src/app/ui/WorkingTimer.tsx
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var WorkingTimer = () => {
+  const [seconds, setSeconds] = useState3(0);
+  const [dotIndex, setDotIndex] = useState3(1);
+  useEffect2(() => {
+    const secondsTimer = setInterval(() => {
+      setSeconds((prev) => prev + 1);
+    }, 1e3);
+    return () => clearInterval(secondsTimer);
+  }, []);
+  useEffect2(() => {
+    const dotsTimer = setInterval(() => {
+      setDotIndex((prev) => prev % 3 + 1);
+    }, 100);
+    return () => clearInterval(dotsTimer);
+  }, []);
+  const dots = ".".repeat(dotIndex).padEnd(3, " ");
+  return /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: "magenta", children: [
+    `working${dots}`,
+    ` ${seconds}s`
+  ] }) });
+};
+
+// src/app/ui/components/ToolCallDisplay.tsx
+import { memo as memo2 } from "react";
+import { Box as Box9 } from "ink";
+
+// src/app/ui/components/toolCallRenderers.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import path8 from "path";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var formatArgumentsForDisplay = (args) => {
+  if (typeof args === "string") {
+    try {
+      return JSON.stringify(JSON.parse(args), null, 2);
+    } catch (e) {
+      return args;
+    }
+  }
+  return JSON.stringify(args, null, 2);
+};
+var renderShellCommand2 = ({ args }) => {
+  const command = args.command || "[command not found]";
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+      "Shell Command"
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: command })
+    ] }) })
+  ] });
+};
+var renderLsTool2 = ({ args }) => {
+  let directoryPath = "[path not found]";
+  try {
+    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
+    directoryPath = parsedArgs.directory_path || "[path not specified]";
+  } catch (e) {
+    directoryPath = "Error parsing arguments";
+  }
+  const finalDirectoryName = path8.basename(directoryPath);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+      "ls Tool"
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: finalDirectoryName })
+    ] }) })
+  ] });
+};
+var renderCountFilesLines = ({ args }) => {
+  let directoryPath = "[path not found]";
+  try {
+    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
+    directoryPath = parsedArgs.filepath || "[path not specified]";
+  } catch (e) {
+    directoryPath = "Error parsing arguments";
+  }
+  const finalDirectoryName = path8.basename(directoryPath);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+      "Count File Lines"
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: finalDirectoryName })
+    ] }) })
+  ] });
+};
+var renderReadFileLines2 = ({ args }) => {
+  let filepath = "[path not found]";
+  let startLine = 0;
+  let endLine = 0;
+  try {
+    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
+    filepath = parsedArgs.filepath || "[path not specified]";
+    startLine = parsedArgs.start_line || 0;
+    endLine = parsedArgs.end_line || 0;
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  const finalFileName = path8.basename(filepath);
+  return (
+    // A caixa externa com a borda, seguindo o template
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+        "Read File Lines Tool"
+      ] }) }),
+      /* @__PURE__ */ jsxs8(Box8, { marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: finalFileName })
+        ] }) }),
+        /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 4, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "lines " }),
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: startLine }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " to " }),
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: endLine })
+        ] }) })
+      ] })
+    ] })
+  );
+};
+var renderBlumaNotebook = ({ args }) => {
+  try {
+    let dataToParse = args;
+    if (args && typeof args === "object") {
+      if (args.content) dataToParse = args.content;
+      else if (args.data) dataToParse = args.data;
+    }
+    const thinkingData = typeof dataToParse === "string" ? JSON.parse(dataToParse) : dataToParse;
+    if (!thinkingData || typeof thinkingData.thought !== "string") {
+      throw new Error("Invalid or missing 'thought' property.");
+    }
+    return (
+      // Usamos a mesma estrutura de caixa com borda
+      /* @__PURE__ */ jsxs8(Box8, { borderStyle: "round", borderColor: "green", flexDirection: "column", paddingX: 1, children: [
+        /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u{1F9E0} " }),
+          "Thinking Process"
+        ] }) }),
+        /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Thought:" }),
+          /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: thinkingData.thought }) })
+        ] }),
+        thinkingData.remaining_tasks && thinkingData.remaining_tasks.length > 0 && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Remaining Tasks:" }),
+          thinkingData.remaining_tasks.map((task, index) => /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+            /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+            /* @__PURE__ */ jsx8(Text8, { color: task.startsWith("\u{1F5F8}") ? "green" : "yellow", children: task })
+          ] }) }, index))
+        ] })
+      ] })
+    );
+  } catch (e) {
+    return /* @__PURE__ */ jsxs8(Box8, { borderStyle: "round", borderColor: "blue", paddingX: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "blue", bold: true, children: "Thinking (Error)" }),
+      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: JSON.stringify(args, null, 2) })
+    ] });
+  }
+};
+var renderEditToolCall = ({ args, preview }) => {
+  let filepath = "[path not specified]";
+  try {
+    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
+    filepath = parsedArgs.file_path || "[path not specified]";
+  } catch (e) {
+    filepath = "Error parsing arguments";
+  }
+  const finalFileName = path8.basename(filepath);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+      "Edit File"
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: finalFileName })
+    ] }) }),
+    preview && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(SimpleDiff, { text: preview, maxHeight: Infinity }) })
+  ] });
+};
+var renderGenericToolCall = ({ toolName, args }) => {
+  const formattedArgs = formatArgumentsForDisplay(args);
+  return (
+    // A "moldura" padrão de sucesso com a borda cinza
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+      /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
+        toolName
+      ] }) }),
+      formattedArgs && formattedArgs !== "{}" && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Arguments passed:" }),
+        /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, flexDirection: "column", children: formattedArgs.split("\n").map((line, index) => /* @__PURE__ */ jsxs8(Text8, { color: "gray", children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u21B3 " }),
+          line
+        ] }, index)) })
+      ] })
+    ] })
+  );
+};
+var ToolRenderDisplay = {
+  "shell_command": renderShellCommand2,
+  "ls_tool": renderLsTool2,
+  "bluma_nootebook": renderBlumaNotebook,
+  "count_file_lines": renderCountFilesLines,
+  "read_file_lines": renderReadFileLines2,
+  "edit_tool": renderEditToolCall
+};
+
+// src/app/ui/components/ToolCallDisplay.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
+  if (toolName.includes("message_notify_dev") || toolName.includes("agent_end_task")) {
+    return null;
+  }
+  const Renderer = ToolRenderDisplay[toolName] || renderGenericToolCall;
+  return /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Renderer, { toolName, args, preview }) });
+};
+var ToolCallDisplay = memo2(ToolCallDisplayComponent);
+
+// src/app/ui/components/ToolResultDisplay.tsx
+import { memo as memo3 } from "react";
+import { Box as Box10, Text as Text9 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var ToolResultDisplayComponent = ({ toolName, result }) => {
+  const MAX_LINES = 3;
+  if (toolName.includes("agent_end_task") || toolName.includes("bluma_nootebook") || toolName.includes("shell_command") || toolName.includes("ls_tool") || toolName.includes("count_file_lines") || toolName.includes("read_file_lines") || toolName.includes("edit_tool")) {
+    return null;
+  }
+  if (toolName.includes("message_notify_dev")) {
+    try {
+      const parsed = JSON.parse(result);
+      if (parsed.content && parsed.content.body) {
+        const bodyText = parsed.content.body.trim();
+        return /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, paddingX: 1, children: /* @__PURE__ */ jsx10(Text9, { children: bodyText }) });
+      }
+    } catch (e) {
+    }
+  }
+  let formattedResult = result;
+  try {
+    const parsedJson = JSON.parse(result);
+    formattedResult = JSON.stringify(parsedJson, null, 2);
+  } catch (e) {
+    formattedResult = result;
+  }
+  const lines = formattedResult.split("\n");
+  const isTruncated = lines.length > MAX_LINES;
+  const visibleLines = isTruncated ? lines.slice(0, MAX_LINES) : lines;
+  const remainingCount = lines.length - MAX_LINES;
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", marginBottom: 1, children: [
+    visibleLines.map((line, idx) => /* @__PURE__ */ jsx10(Text9, { color: "gray", children: line }, idx)),
+    isTruncated && /* @__PURE__ */ jsxs9(Text9, { color: "gray", children: [
+      "...(",
+      remainingCount,
+      " more lines)"
+    ] })
+  ] });
+};
+var ToolResultDisplay = memo3(ToolResultDisplayComponent);
+
+// src/app/ui/App.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
+  const agentInstance = useRef(null);
+  const [history, setHistory] = useState4([]);
+  const [statusMessage, setStatusMessage] = useState4(
+    "Initializing agent..."
+  );
+  const [toolsCount, setToolsCount] = useState4(null);
+  const [mcpStatus, setMcpStatus] = useState4(
+    "connecting"
+  );
+  const [isProcessing, setIsProcessing] = useState4(true);
+  const [pendingConfirmation, setPendingConfirmation] = useState4(
+    null
+  );
+  const [confirmationPreview, setConfirmationPreview] = useState4(null);
+  const alwaysAcceptList = useRef([]);
+  const workdir = process.cwd();
+  const handleInterrupt = useCallback(() => {
+    if (!isProcessing) return;
+    eventBus2.emit("user_interrupt");
+    setIsProcessing(false);
+    setHistory((prev) => [
+      ...prev,
+      {
+        id: prev.length,
+        component: /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: "-- Task cancelled by dev. --" })
+      }
+    ]);
+  }, [isProcessing, eventBus2]);
+  const handleSubmit = useCallback(
+    (text) => {
+      if (!text || isProcessing || !agentInstance.current) return;
+      setIsProcessing(true);
+      const displayText = text.length > 1e4 ? text.substring(0, 1e4) + "..." : text;
+      setHistory((prev) => [
+        ...prev,
+        {
+          id: prev.length,
+          component: (
+            // Uma única Box para o espaçamento
+            /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsxs10(Text10, { color: "white", dimColor: true, children: [
+              /* @__PURE__ */ jsxs10(Text10, { color: "white", children: [
+                ">",
+                " "
+              ] }),
+              displayText
+            ] }) })
+          )
+        }
+      ]);
+      agentInstance.current.processTurn({ content: text });
+    },
+    [isProcessing]
+  );
+  const handleConfirmation = useCallback(
+    (decision, toolCalls) => {
+      if (!agentInstance.current) return;
+      setPendingConfirmation(null);
+      setIsProcessing(true);
+      let finalDecision = decision;
+      if (decision === "accept_always") {
+        const toolNameToWhitelist = toolCalls[0].function.name;
+        if (!alwaysAcceptList.current.includes(toolNameToWhitelist)) {
+          alwaysAcceptList.current.push(toolNameToWhitelist);
+        }
+        finalDecision = "accept";
+      }
+      const messageType = finalDecision === "accept" ? "user_decision_execute" : "user_decision_decline";
+      agentInstance.current.handleToolResponse({
+        type: messageType,
+        tool_calls: toolCalls
+      });
+    },
+    []
+  );
+  useEffect3(() => {
+    setHistory([{ id: 0, component: /* @__PURE__ */ jsx11(Header, {}) }]);
+    const initializeAgent = async () => {
+      try {
+        agentInstance.current = new Agent(sessionId2, eventBus2);
+        await agentInstance.current.initialize();
+        eventBus2.emit("backend_message", {
+          type: "status",
+          status: "mcp_connected",
+          tools: agentInstance.current.getAvailableTools().length
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during Agent initialization.";
+        eventBus2.emit("backend_message", {
+          type: "error",
+          message: errorMessage
+        });
+      }
+    };
+    const handleBackendMessage = (parsed) => {
+      try {
+        if (parsed.type === "connection_status") {
+          setStatusMessage(parsed.message);
+          return;
+        }
+        if (parsed.type === "confirmation_request") {
+          const toolToConfirm = parsed.tool_calls[0].function.name;
+          if (alwaysAcceptList.current.includes(toolToConfirm)) {
+            handleConfirmation("accept", parsed.tool_calls);
+            return;
+          }
+          setPendingConfirmation(parsed.tool_calls);
+          setConfirmationPreview(parsed.preview || null);
+          setIsProcessing(false);
+          return;
+        }
+        if (parsed.type === "done") {
+          if (parsed.status !== "awaiting_confirmation") {
+            setStatusMessage(null);
+          }
+          setIsProcessing(false);
+          return;
+        }
+        if (parsed.type === "status" && parsed.status === "mcp_connected") {
+          setStatusMessage(null);
+          setToolsCount(parsed.tools);
+          setMcpStatus("connected");
+          setIsProcessing(false);
+          setHistory((prev) => {
+            const newHistory = [...prev];
+            if (prev.length < 2) {
+              newHistory.push({
+                id: 1,
+                component: /* @__PURE__ */ jsx11(
+                  SessionInfo,
+                  {
+                    sessionId: sessionId2,
+                    toolsCount: parsed.tools,
+                    mcpStatus: "connected",
+                    workdir
+                  }
+                )
+              });
+            }
+            return newHistory;
+          });
+          return;
+        }
+        if (parsed.type === "error") {
+          setStatusMessage(null);
+          setIsProcessing(false);
+        }
+        let newComponent = null;
+        if (parsed.type === "debug") {
+          newComponent = /* @__PURE__ */ jsx11(Text10, { color: "gray", children: parsed.message });
+        } else if (parsed.type === "protocol_violation") {
+          newComponent = /* @__PURE__ */ jsxs10(
+            Box11,
+            {
+              borderStyle: "round",
+              borderColor: "yellow",
+              flexDirection: "column",
+              marginBottom: 1,
+              paddingX: 1,
+              children: [
+                " ",
+                /* @__PURE__ */ jsxs10(Text10, { color: "yellow", bold: true, children: [
+                  " ",
+                  "Protocol Violation",
+                  " "
+                ] }),
+                " ",
+                /* @__PURE__ */ jsx11(Text10, { color: "gray", children: parsed.content }),
+                " ",
+                /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: parsed.message }),
+                " "
+              ]
+            }
+          );
+        } else if (parsed.type === "error") {
+          newComponent = /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
+            "\u274C ",
+            parsed.message
+          ] });
+        } else if (parsed.type === "tool_call") {
+          newComponent = /* @__PURE__ */ jsx11(
+            ToolCallDisplay,
+            {
+              toolName: parsed.tool_name,
+              args: parsed.arguments,
+              preview: parsed.preview
+            }
+          );
+        } else if (parsed.type === "tool_result") {
+          newComponent = /* @__PURE__ */ jsx11(
+            ToolResultDisplay,
+            {
+              toolName: parsed.tool_name,
+              result: parsed.result
+            }
+          );
+        } else if (parsed.type === "assistant_message" && parsed.content) {
+          newComponent = /* @__PURE__ */ jsx11(Box11, { paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ jsx11(Text10, { color: "blue", children: parsed.content }) });
+        }
+        if (newComponent) {
+          setHistory((prev) => [
+            ...prev,
+            { id: prev.length, component: newComponent }
+          ]);
+        }
+      } catch (error) {
+      }
+    };
+    eventBus2.on("backend_message", handleBackendMessage);
+    initializeAgent();
+    return () => {
+      eventBus2.off("backend_message", handleBackendMessage);
+    };
+  }, [eventBus2, sessionId2, handleConfirmation]);
+  const renderInteractiveComponent = () => {
+    if (mcpStatus !== "connected") {
+      return /* @__PURE__ */ jsx11(Box11, { borderStyle: "round", borderColor: "black", children: /* @__PURE__ */ jsxs10(Text10, { color: "yellow", children: [
+        /* @__PURE__ */ jsx11(Spinner, { type: "dots" }),
+        " ",
+        statusMessage || "Connecting..."
+      ] }) });
+    }
+    if (pendingConfirmation) {
+      return /* @__PURE__ */ jsx11(
+        ConfirmationPrompt,
+        {
+          toolCalls: pendingConfirmation,
+          preview: confirmationPreview,
+          onDecision: (decision) => {
+            setConfirmationPreview(null);
+            handleConfirmation(decision, pendingConfirmation);
+          }
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
+      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx11(WorkingTimer, {}),
+      /* @__PURE__ */ jsx11(
+        InputPrompt,
+        {
+          onSubmit: handleSubmit,
+          isReadOnly: isProcessing,
+          onInterrupt: handleInterrupt
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Static, { items: history, children: (item) => /* @__PURE__ */ jsx11(Box11, { children: item.component }, item.id) }),
+    renderInteractiveComponent()
+  ] });
+};
+var App = memo4(AppComponent);
+var App_default = App;
+
+// src/main.ts
+var eventBus = new EventEmitter();
+var sessionId = uuidv42();
+var props = {
+  eventBus,
+  sessionId
+};
+render(React6.createElement(App_default, props));