@nomad-e/bluma-cli 0.1.18 → 0.1.20

package/dist/config/skills/xlsx/scripts/office/validate.py

@@ -0,0 +1,122 @@
+"""
+Validate the internal structure of Office Open XML files.
+
+Checks that required parts exist, relationships are consistent,
+and the ZIP structure is well-formed. Does NOT validate against
+full ISO/IEC 29500 schemas (that would require lxml + full schema set).
+"""
+
+import os
+import zipfile
+
+REQUIRED_PARTS_XLSX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'xl/workbook.xml',
+    'xl/_rels/workbook.xml.rels',
+    'xl/styles.xml',
+]
+
+REQUIRED_PARTS_DOCX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'word/document.xml',
+    'word/_rels/document.xml.rels',
+    'word/styles.xml',
+]
+
+REQUIRED_PARTS_PPTX = [
+    '[Content_Types].xml',
+    '_rels/.rels',
+    'ppt/presentation.xml',
+    'ppt/_rels/presentation.xml.rels',
+]
+
+FILE_TYPE_MAP = {
+    '.xlsx': ('xlsx', REQUIRED_PARTS_XLSX),
+    '.xlsm': ('xlsx', REQUIRED_PARTS_XLSX),
+    '.docx': ('docx', REQUIRED_PARTS_DOCX),
+    '.pptx': ('pptx', REQUIRED_PARTS_PPTX),
+}
+
+
+def validate(filepath: str) -> dict:
+    """
+    Validate an Office file's internal structure.
+
+    Returns a dict with:
+        - valid (bool): Whether the file passes validation
+        - file_type (str): Detected type (xlsx/docx/pptx)
+        - parts_count (int): Number of parts in the archive
+        - missing_parts (list): Required parts that are missing
+        - warnings (list): Non-critical issues
+        - errors (list): Critical issues
+    """
+    abs_path = os.path.abspath(filepath)
+    ext = os.path.splitext(abs_path)[1].lower()
+
+    result = {
+        'valid': True,
+        'file_type': None,
+        'parts_count': 0,
+        'missing_parts': [],
+        'warnings': [],
+        'errors': [],
+    }
+
+    if not os.path.isfile(abs_path):
+        result['valid'] = False
+        result['errors'].append(f'File not found: {abs_path}')
+        return result
+
+    if ext not in FILE_TYPE_MAP:
+        result['valid'] = False
+        result['errors'].append(f'Unsupported extension: {ext}')
+        return result
+
+    file_type, required_parts = FILE_TYPE_MAP[ext]
+    result['file_type'] = file_type
+
+    try:
+        with zipfile.ZipFile(abs_path, 'r') as zf:
+            names = set(zf.namelist())
+            result['parts_count'] = len(names)
+
+            for part in required_parts:
+                if part not in names:
+                    result['missing_parts'].append(part)
+
+            corrupt = zf.testzip()
+            if corrupt:
+                result['errors'].append(f'Corrupt entry: {corrupt}')
+
+    except zipfile.BadZipFile:
+        result['valid'] = False
+        result['errors'].append('Not a valid ZIP file')
+        return result
+    except Exception as e:
+        result['valid'] = False
+        result['errors'].append(f'Error reading file: {str(e)}')
+        return result
+
+    if result['missing_parts']:
+        result['valid'] = False
+        result['errors'].append(
+            f"Missing {len(result['missing_parts'])} required part(s)"
+        )
+
+    for name in names:
+        if name.startswith('..') or '/../' in name:
+            result['valid'] = False
+            result['errors'].append(f'Path traversal detected: {name}')
+
+    if result['parts_count'] == 0:
+        result['valid'] = False
+        result['errors'].append('Archive is empty')
+
+    if result['parts_count'] > 10000:
+        result['warnings'].append(
+            f'Unusually large archive: {result["parts_count"]} entries'
+        )
+
+    return result

package/dist/config/skills/xlsx/scripts/recalc.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Recalculate all formulas in an Excel file using LibreOffice and scan
+for formula errors.
+
+Usage:
+    python recalc.py <excel_file> [timeout_seconds]
+
+Returns JSON to stdout with recalculation status and any errors found.
+Requires LibreOffice installed and openpyxl for error scanning.
+
+Exit codes:
+    0  Recalculated successfully (may still have formula errors)
+    1  Recalculation failed
+"""
+
+import json
+import os
+import sys
+import time
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from office.soffice import find_soffice, run_soffice_recalc
+
+
+ERROR_VALUES = frozenset({
+    '#REF!', '#DIV/0!', '#VALUE!', '#N/A', '#NAME?',
+    '#NULL!', '#NUM!', '#GETTING_DATA', '#SPILL!', '#CALC!',
+})
+
+
+def scan_errors_fast(filepath: str) -> dict:
+    """Optimized error scanning — loads formula workbook only once."""
+    try:
+        from openpyxl import load_workbook
+    except ImportError:
+        return {
+            'status': 'error',
+            'message': 'openpyxl not installed — cannot scan for formula errors',
+        }
+
+    wb_data = load_workbook(filepath, data_only=True)
+    wb_formula = load_workbook(filepath)
+
+    errors = {}
+    total_formulas = 0
+    sheets_processed = []
+
+    for sheet_name in wb_data.sheetnames:
+        ws_data = wb_data[sheet_name]
+        ws_form = wb_formula[sheet_name]
+        sheets_processed.append(sheet_name)
+
+        for row_data, row_form in zip(ws_data.iter_rows(), ws_form.iter_rows()):
+            for cell_data, cell_form in zip(row_data, row_form):
+                if isinstance(cell_form.value, str) and cell_form.value.startswith('='):
+                    total_formulas += 1
+
+                if isinstance(cell_data.value, str) and cell_data.value in ERROR_VALUES:
+                    err_type = cell_data.value
+                    if err_type not in errors:
+                        errors[err_type] = {'count': 0, 'locations': []}
+                    errors[err_type]['count'] += 1
+                    loc = f"{sheet_name}!{cell_data.coordinate}"
+                    if len(errors[err_type]['locations']) < 20:
+                        errors[err_type]['locations'].append(loc)
+
+    wb_data.close()
+    wb_formula.close()
+
+    total_errors = sum(e['count'] for e in errors.values())
+
+    result = {
+        'total_formulas': total_formulas,
+        'total_errors': total_errors,
+        'sheets_processed': sheets_processed,
+    }
+
+    if total_errors > 0:
+        result['status'] = 'errors_found'
+        result['error_summary'] = errors
+    else:
+        result['status'] = 'success'
+
+    return result
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({
+            'status': 'error',
+            'message': 'Usage: python recalc.py <excel_file> [timeout_seconds]',
+        }))
+        sys.exit(1)
+
+    filepath = os.path.abspath(sys.argv[1])
+    timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 60
+
+    if not os.path.isfile(filepath):
+        print(json.dumps({
+            'status': 'error',
+            'message': f'File not found: {filepath}',
+        }))
+        sys.exit(1)
+
+    soffice_path = find_soffice()
+    if not soffice_path:
+        print(json.dumps({
+            'status': 'error',
+            'message': (
+                'LibreOffice not found. Install it with: '
+                'sudo apt install libreoffice-calc (Linux) or '
+                'brew install --cask libreoffice (macOS)'
+            ),
+        }))
+        sys.exit(1)
+
+    start = time.time()
+
+    success, message = run_soffice_recalc(soffice_path, filepath, timeout)
+
+    elapsed = round(time.time() - start, 2)
+
+    if not success:
+        print(json.dumps({
+            'status': 'error',
+            'message': message,
+            'elapsed_seconds': elapsed,
+        }))
+        sys.exit(1)
+
+    result = scan_errors_fast(filepath)
+    result['elapsed_seconds'] = elapsed
+    result['recalc_engine'] = 'LibreOffice'
+
+    print(json.dumps(result, indent=2))
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/dist/main.js

@@ -3376,19 +3376,51 @@ async function loadSkill(args) {
       message: `Skill "${skill_name}" not found. Available skills: ${availableNames}`
     };
   }
+  const warnings = [];
+  const conflicts = globalContext.skillLoader.getConflicts();
+  const thisConflict = conflicts.find((c) => c.name === skill_name);
+  if (thisConflict) {
+    warnings.push(
+      `Skill "${skill_name}" exists as a native BluMa skill AND as a user skill at "${thisConflict.userPath}" (${thisConflict.userSource}). The native (bundled) version was loaded. Please rename your custom skill to avoid this conflict.`
+    );
+  }
   if (globalContext.history) {
+    let injected = `[SKILL:${skill.name}]
+
+${skill.content}`;
+    if (skill.references.length > 0 || skill.scripts.length > 0) {
+      injected += "\n\n---\n";
+    }
+    if (skill.references.length > 0) {
+      injected += "\n## Available References\n";
+      for (const ref of skill.references) {
+        injected += `- ${ref.name}: ${ref.path}
+`;
+      }
+      injected += "\nTo read a reference: use read_file_lines with the path above.\n";
+    }
+    if (skill.scripts.length > 0) {
+      injected += "\n## Available Scripts\n";
+      for (const s of skill.scripts) {
+        injected += `- ${s.name}: ${s.path}
+`;
+      }
+      injected += '\nTo run a script: use shell_command with "python <path> [args]".\n';
+    }
     globalContext.history.push({
       role: "user",
-      content: `[SKILL:${skill.name}]
-
-${skill.content}`
+      content: injected
     });
   }
   return {
     success: true,
-    message: `Skill "${skill_name}" loaded successfully. Follow the instructions in the skill content above.`,
+    message: warnings.length > 0 ? `Skill "${skill_name}" loaded (native). WARNING: ${warnings[0]}` : `Skill "${skill_name}" loaded successfully (${skill.source}). Follow the instructions in the skill content above.`,
     skill_name: skill.name,
-    description: skill.description
+    description: skill.description,
+    source: skill.source,
+    warnings: warnings.length > 0 ? warnings : void 0,
+    references: skill.references.length > 0 ? skill.references : void 0,
+    scripts: skill.scripts.length > 0 ? skill.scripts : void 0
   };
 }
 
@@ -3409,8 +3441,8 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path10.dirname(__filename);
-      const configPath = path10.resolve(__dirname, "config", "native_tools.json");
+      const __dirname2 = path10.dirname(__filename);
+      const configPath = path10.resolve(__dirname2, "config", "native_tools.json");
       const fileContent = await fs8.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = config2.nativeTools;
@@ -3500,8 +3532,8 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path11.dirname(__filename);
-    const defaultConfigPath = path11.resolve(__dirname, "config", "bluma-mcp.json");
+    const __dirname2 = path11.dirname(__filename);
+    const defaultConfigPath = path11.resolve(__dirname2, "config", "bluma-mcp.json");
     const userConfigPath = path11.join(os4.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
@@ -3852,33 +3884,71 @@ import { execSync } from "child_process";
 import fs11 from "fs";
 import path13 from "path";
 import os6 from "os";
-var SkillLoader = class {
+import { fileURLToPath as fileURLToPath3 } from "url";
+var SkillLoader = class _SkillLoader {
+  bundledSkillsDir;
   projectSkillsDir;
   globalSkillsDir;
   cache = /* @__PURE__ */ new Map();
-  constructor(projectRoot) {
+  conflicts = [];
+  constructor(projectRoot, bundledDir) {
     this.projectSkillsDir = path13.join(projectRoot, ".bluma", "skills");
     this.globalSkillsDir = path13.join(os6.homedir(), ".bluma", "skills");
+    this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
+  }
+  /**
+   * Resolve o diretório de skills nativas relativo ao binário (dist/config/skills).
+   * Funciona tanto em ESM como quando executado a partir de dist/.
+   */
+  static resolveBundledDir() {
+    if (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) {
+      if (typeof __dirname !== "undefined") {
+        return path13.join(__dirname, "config", "skills");
+      }
+      return path13.join(process.cwd(), "dist", "config", "skills");
+    }
+    try {
+      const currentFile = fileURLToPath3(import.meta.url);
+      const distDir = path13.dirname(currentFile);
+      return path13.join(distDir, "config", "skills");
+    } catch {
+      return path13.join(process.cwd(), "dist", "config", "skills");
+    }
   }
   /**
-   * Lista skills disponíveis de ambas as fontes
-   * Skills de projeto têm prioridade sobre globais com mesmo nome
+   * Lista skills disponíveis de todas as fontes.
+   * Skills nativas sempre presentes; skills do utilizador com nomes conflitantes são excluídas.
    */
   listAvailable() {
+    this.conflicts = [];
     const skills = /* @__PURE__ */ new Map();
-    const globalSkills = this.listFromDir(this.globalSkillsDir, "global");
-    for (const skill of globalSkills) {
-      skills.set(skill.name, skill);
-    }
-    const projectSkills = this.listFromDir(this.projectSkillsDir, "project");
-    for (const skill of projectSkills) {
+    const bundledSkills = this.listFromDir(this.bundledSkillsDir, "bundled");
+    const bundledNames = new Set(bundledSkills.map((s) => s.name));
+    for (const skill of bundledSkills) {
       skills.set(skill.name, skill);
     }
+    this.mergeUserSkills(skills, bundledNames, this.globalSkillsDir, "global");
+    this.mergeUserSkills(skills, bundledNames, this.projectSkillsDir, "project");
     return Array.from(skills.values());
   }
   /**
-   * Lista skills de um diretório específico
+   * Adiciona skills do utilizador ao mapa, detetando conflitos com nativas.
    */
+  mergeUserSkills(skills, bundledNames, dir, source) {
+    const userSkills = this.listFromDir(dir, source);
+    for (const skill of userSkills) {
+      if (bundledNames.has(skill.name)) {
+        this.conflicts.push({
+          name: skill.name,
+          userSource: source,
+          userPath: path13.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path13.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+        });
+        continue;
+      }
+      skills.set(skill.name, skill);
+    }
+  }
   listFromDir(dir, source) {
     if (!fs11.existsSync(dir)) return [];
     try {
@@ -3890,9 +3960,6 @@ var SkillLoader = class {
       return [];
     }
   }
-  /**
-   * Carrega metadata de um path específico
-   */
   loadMetadataFromPath(skillPath, skillName, source) {
     if (!fs11.existsSync(skillPath)) return null;
     try {
@@ -3911,20 +3978,47 @@ var SkillLoader = class {
     }
   }
   /**
-   * Carrega skill completa - procura primeiro em projeto, depois global
+   * Carrega skill completa.
+   * Ordem: bundled > project > global.
+   * Retorna null se não encontrada.
+   * Lança erro se o nome existir como nativa E como skill do utilizador (conflito).
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
+    const bundledPath = path13.join(this.bundledSkillsDir, name, "SKILL.md");
     const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
-    if (fs11.existsSync(projectPath)) {
+    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs11.existsSync(bundledPath);
+    const existsProject = fs11.existsSync(projectPath);
+    const existsGlobal = fs11.existsSync(globalPath);
+    if (existsBundled && (existsProject || existsGlobal)) {
+      const conflictSource = existsProject ? "project" : "global";
+      const conflictPath = existsProject ? projectPath : globalPath;
+      const conflict = {
+        name,
+        userSource: conflictSource,
+        userPath: conflictPath,
+        bundledPath
+      };
+      if (!this.conflicts.find((c) => c.name === name)) {
+        this.conflicts.push(conflict);
+      }
+    }
+    if (existsBundled) {
+      const skill = this.loadFromPath(bundledPath, name, "bundled");
+      if (skill) {
+        this.cache.set(name, skill);
+        return skill;
+      }
+    }
+    if (existsProject) {
       const skill = this.loadFromPath(projectPath, name, "project");
       if (skill) {
         this.cache.set(name, skill);
         return skill;
       }
     }
-    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
-    if (fs11.existsSync(globalPath)) {
+    if (existsGlobal) {
       const skill = this.loadFromPath(globalPath, name, "global");
       if (skill) {
         this.cache.set(name, skill);
@@ -3933,13 +4027,11 @@ var SkillLoader = class {
     }
     return null;
   }
-  /**
-   * Carrega skill de um path específico
-   */
   loadFromPath(skillPath, name, source) {
     try {
       const raw = fs11.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
+      const skillDir = path13.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -3947,15 +4039,28 @@ var SkillLoader = class {
         source,
         version: parsed.version,
         author: parsed.author,
-        license: parsed.license
+        license: parsed.license,
+        references: this.scanAssets(path13.join(skillDir, "references")),
+        scripts: this.scanAssets(path13.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
-  /**
-   * Parse simples de YAML frontmatter
-   */
+  scanAssets(dir) {
+    if (!fs11.existsSync(dir)) return [];
+    try {
+      return fs11.readdirSync(dir).filter((f) => {
+        const fp = path13.join(dir, f);
+        return fs11.statSync(fp).isFile();
+      }).map((f) => ({
+        name: f,
+        path: path13.resolve(dir, f)
+      }));
+    } catch {
+      return [];
+    }
+  }
   parseFrontmatter(raw) {
     const lines = raw.split("\n");
     if (lines[0]?.trim() !== "---") {
@@ -3991,25 +4096,38 @@ var SkillLoader = class {
       content
     };
   }
-  /**
-   * Limpa o cache
-   */
   clearCache() {
     this.cache.clear();
   }
-  /**
-   * Verifica se uma skill existe (em projeto ou global)
-   */
   exists(name) {
+    const bundledPath = path13.join(this.bundledSkillsDir, name, "SKILL.md");
     const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
     const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+    return fs11.existsSync(bundledPath) || fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+  }
+  /**
+   * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
+   */
+  getConflicts() {
+    return [...this.conflicts];
+  }
+  /**
+   * Verifica se existem conflitos (útil para logs/warnings rápidos).
+   */
+  hasConflicts() {
+    return this.conflicts.length > 0;
   }
   /**
-   * Retorna os diretórios de skills
+   * Formata mensagens de conflito legíveis para o utilizador.
    */
+  formatConflictWarnings() {
+    return this.conflicts.map(
+      (c) => `Skill "${c.name}" already exists as a native BluMa skill. Your skill at "${c.userPath}" (${c.userSource}) was ignored. Please rename your skill to avoid this conflict.`
+    );
+  }
   getSkillsDirs() {
     return {
+      bundled: this.bundledSkillsDir,
       project: this.projectSkillsDir,
       global: this.globalSkillsDir
     };
@@ -4156,6 +4274,21 @@ var SYSTEM_PROMPT = `
 - NEVER invent skill names that aren't in \`<available_skills>\`
 - NEVER try to \`load_skill\` with a name that isn't in \`<available_skills>\`
 - Your base knowledge (testing, git, docker...) is NOT a skill - it's just knowledge you have
+
+**Progressive Disclosure (Skills with references and scripts):**
+
+Skills may include additional assets beyond the SKILL.md body:
+- \`references/\` \u2014 extra documentation files (e.g. REFERENCE.md, FORMS.md) loaded on-demand.
+- \`scripts/\` \u2014 ready-made executable scripts (e.g. Python) you can run directly.
+
+When you load a skill via \`load_skill\`, the result includes a manifest listing available references and scripts with their absolute paths.
+
+Rules:
+- **Do NOT read references or run scripts unless the task specifically requires them.** The SKILL.md body is often sufficient.
+- To read a reference: use \`read_file_lines\` with the absolute path from the manifest.
+- To run a script: use \`shell_command\` with \`python <absolute_path> [args]\`.
+- The SKILL.md body tells you WHEN to consult each reference or script (e.g. "for forms, read references/FORMS.md").
+- This keeps your context lean \u2014 only load what you need.
 </skills_knowledge>
 
 ---
@@ -4970,6 +5103,14 @@ var BluMaAgent = class {
     });
     if (this.history.length === 0) {
       const availableSkills = this.skillLoader.listAvailable();
+      if (this.skillLoader.hasConflicts()) {
+        for (const warning of this.skillLoader.formatConflictWarnings()) {
+          this.eventBus.emit("backend_message", {
+            type: "warning",
+            message: warning
+          });
+        }
+      }
       const systemPrompt = getUnifiedSystemPrompt(availableSkills);
       this.history.push({ role: "system", content: systemPrompt });
       await saveSessionHistory(this.sessionFile, this.history);
@@ -5214,11 +5355,10 @@ ${editData.error.display}`;
       message2.tool_calls = toolCalls;
     }
     const normalizedMessage = ToolCallNormalizer.normalizeAssistantMessage(message2);
-    if (normalizedMessage.reasoning_content || normalizedMessage.reasoning) {
-      const reasoningText = normalizedMessage.reasoning_content || normalizedMessage.reasoning;
+    if (reasoningContent) {
       this.eventBus.emit("backend_message", {
         type: "reasoning",
-        content: typeof reasoningText === "string" ? reasoningText : JSON.stringify(reasoningText)
+        content: reasoningContent
       });
     }
     this.history.push(normalizedMessage);
@@ -6873,7 +7013,7 @@ var SlashCommands_default = SlashCommands;
 
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import path17 from "path";
 import fs13 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
@@ -6908,9 +7048,9 @@ async function checkForUpdates() {
       pkg = findBlumaPackageJson(path17.dirname(binPath));
     }
     if (!pkg) {
-      const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path17.dirname(__filename);
-      pkg = findBlumaPackageJson(__dirname);
+      const __filename = fileURLToPath4(import.meta.url);
+      const __dirname2 = path17.dirname(__filename);
+      pkg = findBlumaPackageJson(__dirname2);
     }
     if (!pkg) {
       return null;
@@ -7613,7 +7753,9 @@ async function runAgentMode() {
       lastAssistantMessage = payload.content;
     }
     if (payload?.type === "reasoning" && typeof payload.content === "string") {
-      reasoningBuffer = (reasoningBuffer || "") + payload.content;
+      if (!reasoningBuffer) {
+        reasoningBuffer = payload.content;
+      }
     }
     if (payload?.type === "tool_result" && payload.tool_name === "message") {
       try {
@@ -7654,6 +7796,15 @@ async function runAgentMode() {
       payload
     });
   });
+  eventBus.on("stream_reasoning_chunk", (payload) => {
+    writeJsonl({
+      event_type: "backend_message",
+      backend_type: "reasoning_delta",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { type: "reasoning_delta", delta: payload?.delta }
+    });
+    reasoningBuffer = (reasoningBuffer || "") + (payload?.delta || "");
+  });
   writeJsonl({
     event_type: "log",
     level: "info",

package/package.json

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