@nomad-e/bluma-cli 0.1.14 → 0.1.17

package/dist/main.js

@@ -331,6 +331,7 @@ var init_async_command = __esm({
 import React11 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter2 } from "events";
+import fs14 from "fs";
 import { v4 as uuidv43 } from "uuid";
 
 // src/app/ui/App.tsx
@@ -342,7 +343,7 @@ import { Box, Text } from "ink";
 import { memo } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var HeaderComponent = ({
-  sessionId: sessionId2,
+  sessionId,
   workdir
 }) => {
   const dirName = workdir.split("/").pop() || workdir;
@@ -353,13 +354,13 @@ var HeaderComponent = ({
       /* @__PURE__ */ jsx(Text, { color: "cyan", children: dirName }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: " | " }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
-      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId2.slice(0, 8) })
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId.slice(0, 8) })
     ] })
   ] });
 };
 var Header = memo(HeaderComponent);
 var SessionInfoComponent = ({
-  sessionId: sessionId2,
+  sessionId,
   workdir,
   toolsCount,
   mcpStatus
@@ -2934,8 +2935,8 @@ async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const homeDir = os3.homedir();
   const baseDir = path9.join(homeDir, ".bluma", "artifacts");
-  const sessionId2 = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path9.join(baseDir, sessionId2);
+  const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
+  artifactsDir = path9.join(baseDir, sessionId);
   await fs7.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
@@ -3482,9 +3483,9 @@ var MCPClient = class {
   nativeToolInvoker;
   eventBus;
   // <<< ADICIONA A PROPRIEDADE
-  constructor(nativeToolInvoker, eventBus2) {
+  constructor(nativeToolInvoker, eventBus) {
     this.nativeToolInvoker = nativeToolInvoker;
-    this.eventBus = eventBus2;
+    this.eventBus = eventBus;
   }
   // ... (método initialize inalterado) ...
   async initialize() {
@@ -3762,9 +3763,9 @@ async function ensureSessionDir() {
   await fs10.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
-async function loadOrcreateSession(sessionId2) {
+async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path12.join(sessionDir, `${sessionId2}.json`);
+  const sessionFile = path12.join(sessionDir, `${sessionId}.json`);
   try {
     await fs10.access(sessionFile);
     const fileContent = await fs10.readFile(sessionFile, "utf-8");
@@ -3772,7 +3773,7 @@ async function loadOrcreateSession(sessionId2) {
     return [sessionFile, [], []];
   } catch (error) {
     const newSessionData = {
-      session_id: sessionId2,
+      session_id: sessionId,
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
@@ -3800,9 +3801,9 @@ async function doSaveSessionHistory(sessionFile, history) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId2 = path12.basename(sessionFile, ".json");
+      const sessionId = path12.basename(sessionFile, ".json");
       sessionData = {
-        session_id: sessionId2,
+        session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
@@ -4414,6 +4415,68 @@ You communicate because you respect your teammate.
 Let's build something great, {username}.
 </personality>
 `;
+var SANDBOX_PROMPT_SUFFIX = `
+
+---
+
+<sandbox_context>
+## Sandbox Context
+
+Sandbox Name: {sandbox_name}
+
+You are running INSIDE an orchestrated sandbox / API container.
+
+In this mode:
+
+- You are NOT talking directly to a human; all inputs come from JSON payloads provided by an orchestrator (the Sandbox API).
+- You MUST avoid interactive flows (no REPL, no prompts that wait for human input, no TUI/CLI menus).
+- You MUST keep all outputs deterministic, concise and structured so that external systems can log and replay your reasoning.
+
+### Execution Capabilities (Python-only)
+
+- You are allowed to:
+  - Generate and modify **Python code** (modules, scripts, notebooks, tests).
+  - Propose and run **Python commands only**, e.g.:
+    - \`python main.py\`
+    - \`python -m pytest\`
+  - Use the existing Python environment and preinstalled libraries inside the sandbox (e.g. pandas and other whitelisted packages).
+
+- You are NOT allowed to:
+  - Execute arbitrary shell commands (\`bash\`, \`sh\`, \`zsh\`, \`fish\`, \`cmd\`, \`powershell\`).
+  - Run system-level tools (\`docker\`, \`npm\`, \`node\`, \`git\`, \`curl\`, \`wget\`, package managers, etc.).
+  - Change global system configuration, users, permissions, or network settings.
+  - Depend on interactive stdin/stdout behavior (no \`input()\`, no click/typer prompts).
+
+### Filesystem & IO
+
+- Assume you are working in a **project directory managed by the orchestrator**.
+- You MAY:
+  - Read and write project files (source, tests, configs) as requested by the job.
+  - Create temporary Python files or modules needed to execute the job.
+- You MUST NOT:
+  - Access files outside the project directory tree.
+  - Store secrets or credentials in code or logs.
+  - Rely on long-lived state: each job is independent and may run in a fresh environment.
+
+### Logging & Observability
+
+- Treat every step as being logged and parsed by the orchestrator.
+- Prefer **structured, step-wise logs** (JSON lines) over free-form prose when emitting tool logs:
+  - Each log entry SHOULD include at least: \`event_type\`, \`level\`, \`message\`, \`timestamp\`, and optional \`data\`.
+- Final results MUST be clearly separated from intermediate logs, using a dedicated \`"result"\` event when appropriate.
+
+### Security & Privacy (CRITICAL)
+
+- You MUST treat all environment variables, API keys, tokens and credentials as **sensitive**.
+- You MUST NEVER:
+  - Run commands whose primary purpose is to dump or enumerate environment variables (e.g. \`env\`, \`set\`, \`print(os.environ)\`, or equivalents).
+  - Expose the values of any variables matching patterns like \`*_KEY\`, \`*_TOKEN\`, \`*_SECRET\` or similar.
+  - Print full raw environment listings (PATH, HOSTNAME, PORT, etc.) unless **explicitly** allowed by the sandbox specification and strictly necessary.
+- If the user explicitly asks for environment details or secrets, you MUST explain that you **cannot** reveal them and instead describe capabilities at a high level (e.g. "I can access an LLM via an external API" instead of showing keys/URLs).
+
+In summary: in sandbox mode you are a Python-focused, non-interactive, deterministic agent. You generate and execute Python code inside a controlled environment, and all interactions are mediated by JSON payloads and structured logs, while strictly protecting environment variables and secrets from disclosure.
+</sandbox_context>
+`;
 function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const env = {
@@ -4432,11 +4495,14 @@ function getUnifiedSystemPrompt(availableSkills) {
     package_manager: getPackageManager(cwd),
     project_type: getProjectType(cwd),
     test_framework: getTestFramework(cwd),
-    test_command: getTestCommand(cwd)
+    test_command: getTestCommand(cwd),
+    sandbox_mode: process.env.BLUMA_SANDBOX === "true" ? "yes" : "no",
+    sandbox_name: process.env.BLUMA_SANDBOX_NAME || "local"
   };
+  const basePrompt = env.sandbox_mode === "yes" ? SYSTEM_PROMPT + SANDBOX_PROMPT_SUFFIX : SYSTEM_PROMPT;
   let prompt = Object.entries(env).reduce(
     (p, [key, value]) => p.replaceAll(`{${key}}`, value),
-    SYSTEM_PROMPT
+    basePrompt
   );
   if (availableSkills && availableSkills.length > 0) {
     const skillsList = availableSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
@@ -4825,9 +4891,9 @@ var BluMaAgent = class {
   skillLoader;
   maxContextTurns = 5;
   isInterrupted = false;
-  constructor(sessionId2, eventBus2, llm, model, mcpClient, feedbackSystem) {
-    this.sessionId = sessionId2;
-    this.eventBus = eventBus2;
+  constructor(sessionId, eventBus, llm, model, mcpClient, feedbackSystem) {
+    this.sessionId = sessionId;
+    this.eventBus = eventBus;
     this.llm = llm;
     this.model = model;
     this.mcpClient = mcpClient;
@@ -5068,7 +5134,7 @@ ${editData.error.display}`;
       messages: contextWindow,
       temperature: 0,
       tools: this.mcpClient.getAvailableTools(),
-      tool_choice: "required",
+      //tool_choice: 'required',
       parallel_tool_calls: false
     });
     for await (const chunk of stream) {
@@ -5130,6 +5196,7 @@ ${editData.error.display}`;
         await this._continueConversation();
         return;
       }
+      const isSandbox = process.env.BLUMA_SANDBOX === "true";
       const autoApprovedTools = [
         "message",
         "ls_tool",
@@ -5137,10 +5204,11 @@ ${editData.error.display}`;
         "read_file_lines",
         "todo",
         "load_skill",
-        "search_web"
+        "search_web",
+        "coding_memory"
       ];
       const toolToCall = validToolCalls[0];
-      const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+      const isSafeTool = isSandbox || autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
       if (isSafeTool) {
         await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
       } else {
@@ -5159,7 +5227,6 @@ ${editData.error.display}`;
         event: "protocol_violation_direct_text",
         details: { violationContent: accumulatedContent }
       });
-      this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: accumulatedContent });
       this.history.push({ role: "system", content: feedback.correction });
       await this._continueConversation();
     } else {
@@ -5173,7 +5240,7 @@ ${editData.error.display}`;
       messages: contextWindow,
       temperature: 0,
       tools: this.mcpClient.getAvailableTools(),
-      tool_choice: "required",
+      //tool_choice: 'required',
       parallel_tool_calls: false
     });
     if (this.isInterrupted) {
@@ -5202,6 +5269,7 @@ ${editData.error.display}`;
         await this._continueConversation();
         return;
       }
+      const isSandbox = process.env.BLUMA_SANDBOX === "true";
       const autoApprovedTools = [
         "message",
         "ls_tool",
@@ -5209,10 +5277,11 @@ ${editData.error.display}`;
         "read_file_lines",
         "todo",
         "load_skill",
-        "search_web"
+        "search_web",
+        "coding_memory"
       ];
       const toolToCall = validToolCalls[0];
-      const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+      const isSafeTool = isSandbox || autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
       if (isSafeTool) {
         await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
       } else {
@@ -5267,7 +5336,7 @@ var LLMService = class {
       model: params.model || this.defaultModel,
       messages: params.messages,
       tools: params.tools,
-      tool_choice: params.tool_choice,
+      //tool_choice: params.tool_choice,
       parallel_tool_calls: params.parallel_tool_calls,
       temperature: params.temperature,
       max_tokens: params.max_tokens
@@ -5289,7 +5358,7 @@ var LLMService = class {
       model: params.model || this.defaultModel,
       messages: params.messages,
       tools: params.tools,
-      tool_choice: params.tool_choice,
+      //tool_choice: params.tool_choice,
       parallel_tool_calls: params.parallel_tool_calls,
       temperature: params.temperature,
       max_tokens: params.max_tokens,
@@ -5566,8 +5635,8 @@ var BaseLLMSubAgent = class {
     return { history: this.history };
   }
   async initializeHistory() {
-    const sessionId2 = `${this.id}`;
-    const [sessionFile, history] = await loadOrcreateSession(sessionId2);
+    const sessionId = `${this.id}`;
+    const [sessionFile, history] = await loadOrcreateSession(sessionId);
     this.sessionFile = sessionFile;
     this.history = history || [];
     const systemPromptContent = getInitPrompt();
@@ -5604,7 +5673,7 @@ ${editData.error.display}`;
         model: this.ctx.policy?.llmDeployment || "default",
         messages: contextWindow,
         tools: this.ctx.mcpClient.getAvailableTools(),
-        tool_choice: "required",
+        //tool_choice: 'required',
         parallel_tool_calls: false
       });
       if (this.isInterrupted) {
@@ -5810,12 +5879,12 @@ var Agent = class {
   core;
   subAgents;
   toolInvoker;
-  constructor(sessionId2, eventBus2) {
-    this.sessionId = sessionId2;
-    this.eventBus = eventBus2;
+  constructor(sessionId, eventBus) {
+    this.sessionId = sessionId;
+    this.eventBus = eventBus;
     const nativeToolInvoker = new ToolInvoker();
     this.toolInvoker = nativeToolInvoker;
-    this.mcpClient = new MCPClient(nativeToolInvoker, eventBus2);
+    this.mcpClient = new MCPClient(nativeToolInvoker, eventBus);
     this.feedbackSystem = new AdvancedFeedbackSystem();
     const apiKey = process.env.NOMAD_API_KEY;
     const baseUrl = process.env.NOMAD_BASE_URL;
@@ -5913,22 +5982,22 @@ var Agent = class {
 import { useState as useState4, useEffect as useEffect4, memo as memo5 } from "react";
 import { Box as Box7, Text as Text7 } from "ink";
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-var WorkingTimerComponent = ({ eventBus: eventBus2, taskName, taskStatus }) => {
+var WorkingTimerComponent = ({ eventBus, taskName, taskStatus }) => {
   const [currentAction, setCurrentAction] = useState4("Thinking...");
   const [shinePosition, setShinePosition] = useState4(0);
   const [dots, setDots] = useState4("");
   useEffect4(() => {
-    if (!eventBus2) return;
+    if (!eventBus) return;
     const handleActionStatus = (data) => {
       if (data.action) {
         setCurrentAction(data.action);
       }
     };
-    eventBus2.on("action_status", handleActionStatus);
+    eventBus.on("action_status", handleActionStatus);
     return () => {
-      eventBus2.off("action_status", handleActionStatus);
+      eventBus.off("action_status", handleActionStatus);
     };
-  }, [eventBus2]);
+  }, [eventBus]);
   useEffect4(() => {
     const shineTimer = setInterval(() => {
       setShinePosition((prev) => (prev + 1) % 30);
@@ -6262,7 +6331,7 @@ var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
   if (toolName.includes("message")) {
     return null;
   }
-  const Renderer = ToolRenderDisplay[toolName] || ((props2) => renderGeneric2({ ...props2, toolName }));
+  const Renderer = ToolRenderDisplay[toolName] || ((props) => renderGeneric2({ ...props, toolName }));
   return /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Renderer, { toolName, args, preview }) });
 };
 var ToolCallDisplay = memo6(ToolCallDisplayComponent);
@@ -6903,7 +6972,7 @@ var ReasoningDisplay = memo9(ReasoningDisplayComponent);
 import { useState as useState6, useEffect as useEffect5, useRef as useRef4, memo as memo10 } from "react";
 import { Box as Box16, Text as Text15 } from "ink";
 import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
-var StreamingTextComponent = ({ eventBus: eventBus2, onReasoningComplete }) => {
+var StreamingTextComponent = ({ eventBus, onReasoningComplete }) => {
   const [reasoning, setReasoning] = useState6("");
   const [isStreaming, setIsStreaming] = useState6(false);
   const reasoningRef = useRef4("");
@@ -6945,15 +7014,15 @@ var StreamingTextComponent = ({ eventBus: eventBus2, onReasoningComplete }) => {
       setReasoning("");
       reasoningRef.current = "";
     };
-    eventBus2.on("stream_start", handleStart);
-    eventBus2.on("stream_reasoning_chunk", handleReasoningChunk);
-    eventBus2.on("stream_end", handleEnd);
+    eventBus.on("stream_start", handleStart);
+    eventBus.on("stream_reasoning_chunk", handleReasoningChunk);
+    eventBus.on("stream_end", handleEnd);
     return () => {
-      eventBus2.off("stream_start", handleStart);
-      eventBus2.off("stream_reasoning_chunk", handleReasoningChunk);
-      eventBus2.off("stream_end", handleEnd);
+      eventBus.off("stream_start", handleStart);
+      eventBus.off("stream_reasoning_chunk", handleReasoningChunk);
+      eventBus.off("stream_end", handleEnd);
     };
-  }, [eventBus2, onReasoningComplete]);
+  }, [eventBus, onReasoningComplete]);
   if (!isStreaming || !reasoning) {
     return null;
   }
@@ -6993,7 +7062,7 @@ var SAFE_AUTO_APPROVE_TOOLS = [
   // Status de comandos (read-only)
   "command_status"
 ];
-var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
+var AppComponent = ({ eventBus, sessionId }) => {
   const agentInstance = useRef5(null);
   const [history, setHistory] = useState7([]);
   const [statusMessage, setStatusMessage] = useState7(
@@ -7018,7 +7087,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
   const [toolCallCount, setToolCallCount] = useState7(0);
   const handleInterrupt = useCallback2(() => {
     if (!isProcessing) return;
-    eventBus2.emit("user_interrupt");
+    eventBus.emit("user_interrupt");
     setIsProcessing(false);
     setHistory((prev) => [
       ...prev,
@@ -7027,7 +7096,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         component: /* @__PURE__ */ jsx17(Text16, { color: "yellow", children: "-- Task cancelled by dev. --" })
       }
     ]);
-  }, [isProcessing, eventBus2]);
+  }, [isProcessing, eventBus]);
   const handleSubmit = useCallback2(
     (text) => {
       if (!text || isProcessing || !agentInstance.current) return;
@@ -7167,19 +7236,19 @@ Please use command_status to check the result and report back to the user.`;
     []
   );
   useEffect6(() => {
-    setHistory([{ id: 0, component: /* @__PURE__ */ jsx17(Header, { sessionId: sessionId2, workdir }) }]);
+    setHistory([{ id: 0, component: /* @__PURE__ */ jsx17(Header, { sessionId, workdir }) }]);
     const initializeAgent = async () => {
       try {
-        agentInstance.current = new Agent(sessionId2, eventBus2);
+        agentInstance.current = new Agent(sessionId, eventBus);
         await agentInstance.current.initialize();
-        eventBus2.emit("backend_message", {
+        eventBus.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", {
+        eventBus.emit("backend_message", {
           type: "error",
           message: errorMessage
         });
@@ -7320,16 +7389,16 @@ Please use command_status to check the result and report back to the user.`;
       }
     };
     const handleUiOverlay = (data) => {
-      eventBus2.emit("user_overlay", data);
+      eventBus.emit("user_overlay", data);
     };
     uiEventBus.on("user_overlay", handleUiOverlay);
-    eventBus2.on("backend_message", handleBackendMessage);
+    eventBus.on("backend_message", handleBackendMessage);
     initializeAgent();
     return () => {
       uiEventBus.off("user_overlay", handleUiOverlay);
-      eventBus2.off("backend_message", handleBackendMessage);
+      eventBus.off("backend_message", handleBackendMessage);
     };
-  }, [eventBus2, sessionId2, handleConfirmation]);
+  }, [eventBus, sessionId, handleConfirmation]);
   const renderInteractiveComponent = () => {
     if (mcpStatus !== "connected") {
       return;
@@ -7348,7 +7417,7 @@ Please use command_status to check the result and report back to the user.`;
       );
     }
     return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", children: [
-      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx17(WorkingTimer, { eventBus: eventBus2 }),
+      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx17(WorkingTimer, { eventBus }),
       /* @__PURE__ */ jsx17(
         InputPrompt,
         {
@@ -7365,7 +7434,7 @@ Please use command_status to check the result and report back to the user.`;
     /* @__PURE__ */ jsx17(
       StreamingText,
       {
-        eventBus: eventBus2,
+        eventBus,
         onReasoningComplete: (reasoning) => {
           if (reasoning) {
             setHistory((prev) => [
@@ -7441,12 +7510,174 @@ function stopTitleKeeper() {
 }
 
 // src/main.ts
-var BLUMA_TITLE = process.env.BLUMA_TITLE || "BluMa - NomadEngenuity";
-startTitleKeeper(BLUMA_TITLE);
-var eventBus = new EventEmitter2();
-var sessionId = uuidv43();
-var props = {
-  eventBus,
-  sessionId
-};
-render(React11.createElement(App_default, props));
+function writeJsonl(event) {
+  try {
+    process.stdout.write(JSON.stringify(event) + "\n");
+  } catch {
+  }
+}
+async function runAgentMode() {
+  const args = process.argv.slice(2);
+  const inputFileIndex = args.indexOf("--input-file");
+  const inputIndex = args.indexOf("--input");
+  let rawPayload = "";
+  try {
+    if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
+      const filePath = args[inputFileIndex + 1];
+      rawPayload = fs14.readFileSync(filePath, "utf-8");
+    } else {
+      rawPayload = fs14.readFileSync(0, "utf-8");
+    }
+  } catch (err) {
+    writeJsonl({
+      event_type: "result",
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: {
+        message: "Failed to read agent payload",
+        details: err?.message
+      }
+    });
+    process.exit(1);
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(rawPayload);
+  } catch (err) {
+    writeJsonl({
+      event_type: "result",
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: {
+        message: "Invalid JSON payload for agent mode",
+        details: err?.message
+      }
+    });
+    process.exit(1);
+    return;
+  }
+  const eventBus = new EventEmitter2();
+  const sessionId = envelope.message_id || uuidv43();
+  let lastAssistantMessage = null;
+  let reasoningBuffer = null;
+  let resultEmitted = false;
+  eventBus.on("backend_message", (payload) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    writeJsonl({
+      event_type: "backend_message",
+      backend_type: String(payload?.type || "unknown"),
+      timestamp,
+      payload
+    });
+    if (payload?.type === "assistant_message" && typeof payload.content === "string") {
+      lastAssistantMessage = payload.content;
+    }
+    if (payload?.type === "reasoning" && typeof payload.content === "string") {
+      reasoningBuffer = (reasoningBuffer || "") + payload.content;
+    }
+    if (payload?.type === "tool_result" && payload.tool_name === "message") {
+      try {
+        const rawResult = payload.result;
+        const parsed = typeof rawResult === "string" ? JSON.parse(rawResult) : rawResult;
+        const body = parsed?.content?.body;
+        if (typeof body === "string") {
+          lastAssistantMessage = body;
+        }
+      } catch {
+      }
+    }
+    if (!resultEmitted && payload?.type === "done") {
+      resultEmitted = true;
+      writeJsonl({
+        event_type: "result",
+        status: "success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          message_id: envelope.message_id || sessionId,
+          action: envelope.action || "unknown",
+          last_assistant_message: lastAssistantMessage,
+          reasoning: reasoningBuffer
+        }
+      });
+      process.exit(0);
+    }
+  });
+  eventBus.on("action_status", (payload) => {
+    writeJsonl({
+      event_type: "action_status",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload
+    });
+  });
+  writeJsonl({
+    event_type: "log",
+    level: "info",
+    message: "Starting agent mode execution",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: {
+      message_id: envelope.message_id,
+      action: envelope.action,
+      from_agent: envelope.from_agent,
+      to_agent: envelope.to_agent
+    }
+  });
+  try {
+    const agent = new Agent(sessionId, eventBus);
+    await agent.initialize();
+    const userContent = JSON.stringify({
+      message_id: envelope.message_id || sessionId,
+      from_agent: envelope.from_agent || "sandbox-api",
+      to_agent: envelope.to_agent || "bluma",
+      action: envelope.action || "unknown",
+      context: envelope.context || {},
+      metadata: envelope.metadata || {}
+    });
+    await agent.processTurn({ content: userContent });
+    if (!resultEmitted) {
+      resultEmitted = true;
+      writeJsonl({
+        event_type: "result",
+        status: "success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          message_id: envelope.message_id || sessionId,
+          action: envelope.action || "unknown",
+          last_assistant_message: lastAssistantMessage,
+          reasoning: reasoningBuffer
+        }
+      });
+      process.exit(0);
+    }
+  } catch (err) {
+    if (!resultEmitted) {
+      writeJsonl({
+        event_type: "result",
+        status: "error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        error: {
+          message: "Agent mode execution failed",
+          details: err?.message
+        }
+      });
+    }
+    process.exit(1);
+  }
+}
+function runCliMode() {
+  const BLUMA_TITLE = process.env.BLUMA_TITLE || "BluMa - NomadEngenuity";
+  startTitleKeeper(BLUMA_TITLE);
+  const eventBus = new EventEmitter2();
+  const sessionId = uuidv43();
+  const props = {
+    eventBus,
+    sessionId
+  };
+  render(React11.createElement(App_default, props));
+}
+var argv = process.argv.slice(2);
+if (argv[0] === "agent") {
+  runAgentMode();
+} else {
+  runCliMode();
+}

package/dist/skills/git-conventional/LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright (c) NomadEngenuity. All rights reserved.
+
+This skill is part of the Bluma CLI and is subject to the same license as the main package (Apache-2.0) unless otherwise stated in the SKILL.md frontmatter.