@nomad-e/bluma-cli 0.1.37 → 0.1.39

package/dist/main.js

@@ -331,8 +331,8 @@ var init_async_command = __esm({
 import React12 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter3 } from "events";
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { v4 as uuidv46 } from "uuid";
 
@@ -2317,7 +2317,7 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path19 from "path";
+import path20 from "path";
 import os14 from "os";
 
 // src/app/agent/tool_invoker.ts
@@ -4821,7 +4821,7 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path18 from "path";
+import path19 from "path";
 import { v4 as uuidv43 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
@@ -5012,9 +5012,9 @@ async function saveSessionHistory(sessionFile, history, memory) {
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os11 from "os";
-import fs15 from "fs";
-import path17 from "path";
-import { execSync } from "child_process";
+import fs16 from "fs";
+import path18 from "path";
+import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
 import fs14 from "fs";
@@ -5313,6 +5313,215 @@ var SkillLoader = class _SkillLoader {
   }
 };
 
+// src/app/agent/core/prompt/workspace_snapshot.ts
+import fs15 from "fs";
+import path17 from "path";
+import { execSync } from "child_process";
+var LIMITS = {
+  readme: 1e4,
+  blumaMd: 12e3,
+  contributing: 4e3,
+  changelog: 4e3,
+  pyproject: 3500,
+  gitStatusLines: 48,
+  gitLogLines: 14,
+  diffStatLines: 28,
+  topDirEntries: 96
+};
+function safeReadFile(filePath, maxChars) {
+  try {
+    if (!fs15.existsSync(filePath)) return null;
+    const st = fs15.statSync(filePath);
+    if (!st.isFile()) return null;
+    const raw = fs15.readFileSync(filePath, "utf8");
+    if (raw.length <= maxChars) return raw;
+    return `${raw.slice(0, maxChars)}
+
+[\u2026 truncated for prompt size \u2026]`;
+  } catch {
+    return null;
+  }
+}
+function tryReadReadme(cwd) {
+  for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
+    const c = safeReadFile(path17.join(cwd, name), LIMITS.readme);
+    if (c) return `(${name})
+${c}`;
+  }
+  return null;
+}
+function tryReadBluMaMd(cwd) {
+  const paths = [
+    path17.join(cwd, "BluMa.md"),
+    path17.join(cwd, "BLUMA.md"),
+    path17.join(cwd, ".bluma", "BluMa.md")
+  ];
+  for (const p of paths) {
+    const c = safeReadFile(p, LIMITS.blumaMd);
+    if (c) {
+      const rel = path17.relative(cwd, p) || p;
+      return `(${rel})
+${c}`;
+    }
+  }
+  return null;
+}
+function summarizePackageJson(cwd) {
+  const p = path17.join(cwd, "package.json");
+  try {
+    if (!fs15.existsSync(p)) return null;
+    const pkg = JSON.parse(fs15.readFileSync(p, "utf8"));
+    const scripts = pkg.scripts;
+    let scriptKeys = "";
+    if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
+      scriptKeys = Object.keys(scripts).slice(0, 48).join(", ");
+    }
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    const nd = deps && typeof deps === "object" && !Array.isArray(deps) ? Object.keys(deps).length : 0;
+    const nDev = devDeps && typeof devDeps === "object" && !Array.isArray(devDeps) ? Object.keys(devDeps).length : 0;
+    let s = `name: ${String(pkg.name ?? "?")}  version: ${String(pkg.version ?? "?")}
+`;
+    if (typeof pkg.description === "string" && pkg.description.trim()) {
+      s += `description: ${pkg.description.trim().slice(0, 280)}
+`;
+    }
+    if (scriptKeys) s += `scripts (keys): ${scriptKeys}
+`;
+    s += `dependencies: ${nd}  devDependencies: ${nDev}
+`;
+    if (pkg.engines) s += `engines: ${JSON.stringify(pkg.engines)}
+`;
+    if (pkg.type) s += `type: ${String(pkg.type)}
+`;
+    if (pkg.main) s += `main: ${String(pkg.main)}
+`;
+    return s.trim();
+  } catch {
+    return null;
+  }
+}
+function topLevelListing(cwd) {
+  try {
+    const names = fs15.readdirSync(cwd, { withFileTypes: true });
+    const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
+    const limited = sorted.slice(0, LIMITS.topDirEntries);
+    const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
+    if (sorted.length > limited.length) {
+      lines.push(`[\u2026 +${sorted.length - limited.length} more entries at repo root \u2026]`);
+    }
+    return lines.join("\n");
+  } catch {
+    return "(could not list directory)";
+  }
+}
+function gitLines(cwd, args, maxLines) {
+  try {
+    const out = execSync(`git ${args}`, {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4,
+      maxBuffer: 512 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const lines = out.trimEnd().split(/\r?\n/).filter((l) => l.length > 0);
+    if (lines.length > maxLines) {
+      return `${lines.slice(0, maxLines).join("\n")}
+[\u2026 +${lines.length - maxLines} lines \u2026]`;
+    }
+    return lines.length ? lines.join("\n") : null;
+  } catch {
+    return null;
+  }
+}
+function insideGitWorkTree(cwd) {
+  try {
+    const v = execSync("git rev-parse --is-inside-work-tree", {
+      cwd,
+      encoding: "utf8",
+      timeout: 4e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return v === "true";
+  } catch {
+    return false;
+  }
+}
+function buildWorkspaceSnapshot(cwd) {
+  const parts = [];
+  parts.push(`### Repository root
+\`${cwd}\`
+`);
+  parts.push("### Top-level entries\n```");
+  parts.push(topLevelListing(cwd));
+  parts.push("```\n");
+  const pkg = summarizePackageJson(cwd);
+  if (pkg) {
+    parts.push("### package.json (summary)\n```");
+    parts.push(pkg);
+    parts.push("```\n");
+  }
+  const py = safeReadFile(path17.join(cwd, "pyproject.toml"), LIMITS.pyproject);
+  if (py) {
+    parts.push("### pyproject.toml (excerpt)\n```toml");
+    parts.push(py);
+    parts.push("```\n");
+  }
+  const readme = tryReadReadme(cwd);
+  if (readme) {
+    parts.push("### README (excerpt)\n```markdown");
+    parts.push(readme);
+    parts.push("```\n");
+  }
+  const bluma = tryReadBluMaMd(cwd);
+  if (bluma) {
+    parts.push("### BluMa / project context file (excerpt)\n```markdown");
+    parts.push(bluma);
+    parts.push("```\n");
+  }
+  const contrib = safeReadFile(path17.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
+  if (contrib) {
+    parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
+    parts.push(contrib);
+    parts.push("```\n");
+  }
+  const chlog = safeReadFile(path17.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
+  if (!chlog) {
+    const alt = safeReadFile(path17.join(cwd, "CHANGES.md"), LIMITS.changelog);
+    if (alt) {
+      parts.push("### CHANGES.md (excerpt)\n```markdown");
+      parts.push(alt);
+      parts.push("```\n");
+    }
+  } else {
+    parts.push("### CHANGELOG.md (excerpt)\n```markdown");
+    parts.push(chlog);
+    parts.push("```\n");
+  }
+  if (insideGitWorkTree(cwd)) {
+    parts.push("### Git\n");
+    const st = gitLines(cwd, "status --short", LIMITS.gitStatusLines);
+    parts.push("`git status --short`:\n```");
+    parts.push(st ?? "(empty or unavailable)");
+    parts.push("```\n");
+    const log = gitLines(cwd, "log -n 14 --oneline --decorate", LIMITS.gitLogLines);
+    if (log) {
+      parts.push("Recent commits:\n```");
+      parts.push(log);
+      parts.push("```\n");
+    }
+    const stat = gitLines(cwd, "diff --stat HEAD", LIMITS.diffStatLines);
+    if (stat) {
+      parts.push("Uncommitted vs `HEAD` (`git diff --stat HEAD`):\n```");
+      parts.push(stat);
+      parts.push("```\n");
+    }
+  } else {
+    parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
+  }
+  return parts.join("\n");
+}
+
 // src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   try {
@@ -5323,14 +5532,14 @@ function getNodeVersion() {
 }
 function getNpmVersion() {
   try {
-    return execSync("npm --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+    return execSync2("npm --version", { encoding: "utf-8", timeout: 5e3 }).trim();
   } catch {
     return "unknown";
   }
 }
 function getGitBranch(dir) {
   try {
-    return execSync("git rev-parse --abbrev-ref HEAD", {
+    return execSync2("git rev-parse --abbrev-ref HEAD", {
       cwd: dir,
       encoding: "utf-8",
       timeout: 5e3
@@ -5341,10 +5550,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs15.existsSync(path17.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs15.existsSync(path17.join(dir, "yarn.lock"))) return "yarn";
-    if (fs15.existsSync(path17.join(dir, "bun.lockb"))) return "bun";
-    if (fs15.existsSync(path17.join(dir, "package-lock.json"))) return "npm";
+    if (fs16.existsSync(path18.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs16.existsSync(path18.join(dir, "yarn.lock"))) return "yarn";
+    if (fs16.existsSync(path18.join(dir, "bun.lockb"))) return "bun";
+    if (fs16.existsSync(path18.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -5352,9 +5561,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs15.readdirSync(dir);
+    const files = fs16.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs15.readFileSync(path17.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs16.readFileSync(path18.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -5373,9 +5582,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path17.join(dir, "package.json");
-    if (fs15.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path18.join(dir, "package.json");
+    if (fs16.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -5384,7 +5593,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs15.existsSync(path17.join(dir, "pytest.ini")) || fs15.existsSync(path17.join(dir, "conftest.py"))) return "pytest";
+    if (fs16.existsSync(path18.join(dir, "pytest.ini")) || fs16.existsSync(path18.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -5392,9 +5601,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path17.join(dir, "package.json");
-    if (fs15.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path18.join(dir, "package.json");
+    if (fs16.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -5418,7 +5627,7 @@ var SYSTEM_PROMPT = `
     You are not just an assistant - you are a **teammate** who takes ownership of tasks.
 
     Key traits:
-    - F like a senior developer who has been on this project for years
+    - Act like a senior developer who has been on this project for years
     - Suggest improvements proactively, don't just follow orders blindly
     - Spot bugs and issues before they become problems
     - Write tests as naturally as you write code
@@ -5426,6 +5635,42 @@ var SYSTEM_PROMPT = `
 
 ---
 
+<engineering_mindset>
+## How you think and act (agentic engineer \u2014 not a chatbot)
+
+You behave like a **senior engineer in this repo**: you **ship**, you **prove with evidence**, and you **debug methodically**.
+
+### Operating mode
+- **Autonomous by default:** move the task forward until truly blocked (missing secrets, policy, or a decision only the human can make). Do not ask permission to read files, search the tree, run tests, or inspect git when that reduces risk.
+- **Outcome over monologue:** deliver working changes; keep narration **short and technical** (what changed, which paths, which command proved it).
+- **No assistant theatre:** drop filler (\u201CAs an AI\u2026\u201D, \u201CI\u2019d be happy to\u2026\u201D, long preambles). Be direct like a teammate on Slack.
+
+### Analysis (before you code)
+- Ground decisions in **observable facts** from tools: file contents, configs, compiler/test output, stack traces \u2014 not guesses.
+- Form a **hypothesis** you can falsify in **one** step (one command or one targeted read).
+- Before large refactors, map **blast radius** (callers, tests) with \`grep_search\` / \`read_file_lines\`.
+
+### Debugging
+- **Reproduce first** \u2014 same command, same failure message. If you cannot reproduce, you do not understand the bug yet.
+- **Localise:** narrow to file + function + line using logs and traces; avoid random edits in unrelated modules.
+- **Fix minimally:** smallest change for the root cause; do not mix unrelated refactors with bugfixes unless the user asked.
+- **Verify:** re-run the **same** failing command or test target after the fix; treat **exit_code** and **stderr** as first-class \u2014 read them literally.
+- **Never claim \u201Cfixed\u201D or \u201Cpassing\u201D** without tool output that shows success.
+
+### Implementation
+- **Read \u2192 edit \u2192 verify:** never edit from memory of a skim; use \`read_file_lines\` on the exact region you change.
+- Prefer **one logical slice** per burst when possible; for large work, use \`todo\` and complete vertical slices end-to-end (repro \u2192 fix \u2192 test).
+- Follow conventions from \`<workspace_snapshot>\`, \`BluMa.md\`, \`README\`, and **existing code** over generic templates.
+
+### When stuck
+- Say what you tried, paste or summarise **concrete tool output** (path, exit code, error line), and propose the **next experiment** \u2014 not \u201Cit failed\u201D.
+- Use \`coding_memory\` for durable project facts; do not rely on chat scroll alone after context compression.
+
+This mindset overrides generic assistant habits: you exist to **solve problems in the workspace** with tools and proof.
+</engineering_mindset>
+
+---
+
 <skills_knowledge>
 ## Skills vs Base Knowledge (CRITICAL)
 
@@ -5507,6 +5752,22 @@ You MUST adapt all commands to this environment. Use the correct package manager
 
 ---
 
+<workspace_snapshot>
+## Project workspace (loaded from disk when the system prompt is built)
+
+You are anchored to **the current working directory** (see **Working Directory** above). The block below is an automatic snapshot: tree root, package summary, README / BluMa.md excerpts, git status and recent commits, etc.
+
+**How to use it (IDE-grade discipline):**
+- Treat this as a **map**, not ground truth \u2014 re-read files and run tests/build/linter before high-risk edits.
+- It becomes **stale** after \`git pull\`, installs, refactors, or long chats; verify again when it matters.
+- **Close the loop:** hypothesis \u2192 smallest change \u2192 run the same command a human would (\`test\`, \`build\`, typecheck) \u2192 read stdout/stderr literally \u2192 repeat until green.
+- Do not guess file contents; use your tools to confirm.
+
+<<<BLUMA_WORKSPACE_SNAPSHOT_BODY>>>
+</workspace_snapshot>
+
+---
+
 <coding_memory>
 ## Persistent coding memory (tool: \`coding_memory\`)
 
@@ -5554,6 +5815,12 @@ This is your **long-term scratchpad** (usually \`~/.bluma/coding_memory.json\`).
 5. **Verify** - Check build, lint, and git status
 6. **Summarize** - Report results and any follow-up actions
 
+### For debugging / incidents (follow \`<engineering_mindset>\`):
+1. **Reproduce** \u2014 run the same command or test the user (or the repo) uses; capture full output via \`command_status\`.
+2. **Localise** \u2014 trace to a specific file/line; read that code with tools before changing anything.
+3. **Fix** \u2014 minimal diff addressing the root cause.
+4. **Prove** \u2014 re-run the same check; only then report success, citing exit code / test summary.
+
 ### For Simple Tasks:
 - Quick acknowledgment + immediate action
 - No TODO needed for single operations
@@ -5572,6 +5839,7 @@ Run tests when modifying code. If a testing skill is listed in available_skills,
 
 ### File Operations:
 - **ALWAYS read a file before editing** - Use read_file_lines or ls_tool first
+- After \`shell_command\` + \`command_status\`, treat **exit_code**, **stdout**, and **stderr** as authoritative \u2014 failures often appear only in stderr
 - **Use absolute paths** when possible to avoid ambiguity
 - **For edit_tool**: Provide exact content with correct whitespace (read first!)
 - **Truncated CLI preview** (user may press Ctrl+O for more lines): still not a substitute for \`read_file_lines\` \u2014 use the tool for authoritative content before editing
@@ -5707,8 +5975,8 @@ Examples:
 
 **Style:**
 - Direct and technical, like Slack/Discord
-- Get straight to the point
-- Celebrate wins, acknowledge mistakes
+- Get straight to the point; **agentic engineer**, not customer support tone
+- Celebrate wins, acknowledge mistakes with concrete next steps
 
 **Message via tool only:**
 - message with \`result\` = END your turn (after questions/completions)
@@ -5895,6 +6163,10 @@ function getUnifiedSystemPrompt(availableSkills) {
     (p, [key, value]) => p.replaceAll(`{${key}}`, value),
     basePrompt
   );
+  prompt = prompt.replace(
+    "<<<BLUMA_WORKSPACE_SNAPSHOT_BODY>>>",
+    buildWorkspaceSnapshot(cwd)
+  );
   if (availableSkills && availableSkills.length > 0) {
     const skillsList = availableSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
     prompt += `
@@ -6061,8 +6333,8 @@ ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(No entries yet. Use codi
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path17.join(dir, ".git");
-    return fs15.existsSync(gitPath) && fs15.lstatSync(gitPath).isDirectory();
+    const gitPath = path18.join(dir, ".git");
+    return fs16.existsSync(gitPath) && fs16.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -6980,7 +7252,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path18.basename(toolArgs.file_path);
+      const filename = path19.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}`;
@@ -7687,14 +7959,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path22, handler) {
-    this.routeHandlers.set(path22, handler);
+  registerRoute(path23, handler) {
+    this.routeHandlers.set(path23, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path22, handler] of this.routeHandlers) {
-      if (inputText === path22 || inputText.startsWith(`${path22} `)) {
+    for (const [path23, handler] of this.routeHandlers) {
+      if (inputText === path23 || inputText.startsWith(`${path23} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -7703,7 +7975,7 @@ var RouteManager = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path19.join(os14.homedir(), ".bluma", ".env");
+var globalEnvPath = path20.join(os14.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -7927,12 +8199,12 @@ var renderShellCommand2 = ({ args }) => {
 };
 var renderLsTool2 = ({ args }) => {
   const parsed = parseArgs(args);
-  const path22 = parsed.directory_path || ".";
+  const path23 = parsed.directory_path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "ls" }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path22
+      path23
     ] })
   ] });
 };
@@ -8068,7 +8340,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path22 = parsed.path || ".";
+  const path23 = parsed.path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "grep" }),
     /* @__PURE__ */ jsxs9(Text9, { color: BLUMA_TERMINAL.brandMagenta, children: [
@@ -8078,7 +8350,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path22
+      path23
     ] })
   ] });
 };
@@ -8647,10 +8919,10 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
       ] }),
       matches.slice(0, 5).map((m, i) => {
         const row = m;
-        const path22 = row.file || row.path || row.name || m;
+        const path23 = row.file || row.path || row.name || m;
         const line = row.line;
         return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
-          String(path22),
+          String(path23),
           line != null ? `:${line}` : ""
         ] }, i);
       }),
@@ -8989,66 +9261,94 @@ var SlashCommands = ({
 var SlashCommands_default = SlashCommands;
 
 // src/app/agent/utils/update_check.ts
-import updateNotifier from "update-notifier";
+import latestVersion from "latest-version";
+import semverGt from "semver/functions/gt.js";
+import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import path20 from "path";
-import fs16 from "fs";
+import path21 from "path";
+import fs17 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
-  for (let i = 0; i < 10; i++) {
-    const candidate = path20.join(dir, "package.json");
-    if (fs16.existsSync(candidate)) {
+  for (let i = 0; i < 12; i++) {
+    const candidate = path21.join(dir, "package.json");
+    if (fs17.existsSync(candidate)) {
       try {
-        const raw = fs16.readFileSync(candidate, "utf8");
+        const raw = fs17.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
-          return { name: parsed.name, version: parsed.version };
+          return { name: parsed.name, version: String(parsed.version) };
         }
       } catch {
       }
     }
-    const parent = path20.dirname(dir);
+    const parent = path21.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
+function resolveInstalledBlumaPackage() {
+  const tried = /* @__PURE__ */ new Set();
+  const tryFrom = (dir) => {
+    const abs = path21.resolve(dir);
+    if (tried.has(abs)) return null;
+    tried.add(abs);
+    return findBlumaPackageJson(abs);
+  };
+  try {
+    const fromBundle = tryFrom(path21.dirname(fileURLToPath4(import.meta.url)));
+    if (fromBundle) return fromBundle;
+  } catch {
+  }
+  const argv1 = process.argv[1];
+  if (argv1 && !argv1.startsWith("-")) {
+    try {
+      let resolved = argv1;
+      if (path21.isAbsolute(argv1) && fs17.existsSync(argv1)) {
+        resolved = fs17.realpathSync(argv1);
+      } else {
+        resolved = path21.resolve(process.cwd(), argv1);
+      }
+      const fromArgv = tryFrom(path21.dirname(resolved));
+      if (fromArgv) return fromArgv;
+    } catch {
+    }
+  }
+  return null;
+}
 async function checkForUpdates() {
   try {
     if (process.env.BLUMA_FORCE_UPDATE_MSG) {
       return String(process.env.BLUMA_FORCE_UPDATE_MSG);
     }
-    const binPath = process.argv?.[1];
-    let pkg = null;
-    if (binPath && fs16.existsSync(binPath)) {
-      pkg = findBlumaPackageJson(path20.dirname(binPath));
+    if (process.env.CI) {
+      return null;
     }
+    const pkg = resolveInstalledBlumaPackage();
     if (!pkg) {
-      const __filename = fileURLToPath4(import.meta.url);
-      const __dirname = path20.dirname(__filename);
-      pkg = findBlumaPackageJson(__dirname);
+      return null;
     }
-    if (!pkg) {
+    const cur = pkg.version.trim();
+    if (!semverValid(cur)) {
       return null;
     }
-    const isCI = Boolean(process.env.CI);
-    const updateCheckInterval = 0;
-    const notifier = updateNotifier({
-      pkg: { name: pkg.name, version: pkg.version },
-      updateCheckInterval,
-      shouldNotifyInNpmScript: true
-    });
-    if (notifier.update && !isCI) {
-      const cur = notifier.update.current;
-      const lat = notifier.update.latest;
-      if (cur && lat && cur !== lat) {
-        return `Update available for BluMa CLI! ${cur} \u2192 ${lat}
-Run: npm i -g ${BLUMA_PACKAGE_NAME} to update.`;
-      }
+    let latRaw;
+    try {
+      latRaw = await latestVersion(BLUMA_PACKAGE_NAME);
+    } catch {
+      return null;
     }
-    return null;
-  } catch (e) {
+    const lat = String(latRaw).trim();
+    if (!semverValid(lat)) {
+      return null;
+    }
+    if (!semverGt(lat, cur)) {
+      return null;
+    }
+    return `Update available for BluMa CLI! ${cur} \u2192 ${lat}
+Run: npm i -g ${BLUMA_PACKAGE_NAME} to update.`;
+  } catch {
     return null;
   }
 }
@@ -9241,6 +9541,7 @@ var ExpandedPreviewBlock = memo11(ExpandedPreviewBlockComponent);
 
 // src/app/ui/App.tsx
 import { jsx as jsx20, jsxs as jsxs19 } from "react/jsx-runtime";
+var blumaUpdateRegistryCheckStarted = false;
 var SAFE_AUTO_APPROVE_TOOLS = [
   // Comunicação/UI
   "message",
@@ -9312,7 +9613,6 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   const [recentActivityLine, setRecentActivityLine] = useState6(null);
   const alwaysAcceptList = useRef5([]);
   const workdir = process.cwd();
-  const updateCheckRan = useRef5(false);
   const turnStartedAtRef = useRef5(null);
   const appendExpandPreviewToHistory = useCallback3(() => {
     const p = peekLatestExpandable();
@@ -9342,6 +9642,23 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
       expandPreviewHotkeyBus.off("expand", appendExpandPreviewToHistory);
     };
   }, [appendExpandPreviewToHistory]);
+  useEffect7(() => {
+    if (process.env.CI || blumaUpdateRegistryCheckStarted) return;
+    blumaUpdateRegistryCheckStarted = true;
+    void checkForUpdates().then((msg) => {
+      if (!msg) return;
+      setHistory((prev) => {
+        const nextId3 = prev.length === 0 ? 1 : Math.max(...prev.map((h) => h.id), HEADER_PANEL_HISTORY_ID) + 1;
+        return [
+          ...prev,
+          {
+            id: nextId3,
+            component: /* @__PURE__ */ jsx20(UpdateNotice_default, { message: msg })
+          }
+        ];
+      });
+    });
+  }, []);
   useEffect7(() => {
     setHistory((prev) => {
       const tail = prev.filter((h) => h.id !== HEADER_PANEL_HISTORY_ID);
@@ -9602,20 +9919,6 @@ Please use command_status to check the result and report back to the user.`;
           setToolsCount(parsed.tools);
           setMcpStatus("connected");
           setIsProcessing(false);
-          if (!updateCheckRan.current) {
-            updateCheckRan.current = true;
-            Promise.resolve().then(() => checkForUpdates()).then((msg) => {
-              if (msg) {
-                setHistory((prev) => [
-                  ...prev,
-                  {
-                    id: prev.length,
-                    component: /* @__PURE__ */ jsx20(UpdateNotice_default, { message: msg })
-                  }
-                ]);
-              }
-            }).catch(() => void 0);
-          }
           return;
         }
         if (parsed.type === "error") {
@@ -9853,9 +10156,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs17.readFileSync(filePath, "utf-8");
+      rawPayload = fs18.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs17.readFileSync(0, "utf-8");
+      rawPayload = fs18.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeJsonl({
@@ -10023,9 +10326,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path21.dirname(fileURLToPath5(import.meta.url));
-    const pkgPath = path21.join(base, "..", "package.json");
-    const j = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
+    const base = path22.dirname(fileURLToPath5(import.meta.url));
+    const pkgPath = path22.join(base, "..", "package.json");
+    const j = JSON.parse(fs18.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.1.37",
+	"version": "0.1.39",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",
@@ -15,7 +15,6 @@
 		"@types/jest": "^30.0.0",
 		"@types/node": "^20.14.2",
 		"@types/react": "^18.3.3",
-		"@types/update-notifier": "^6.0.8",
 		"@types/uuid": "^9.0.8",
 		"babel-jest": "^30.0.5",
 		"babel-plugin-transform-import-meta": "^2.3.3",
@@ -52,11 +51,12 @@
 		"ink-spinner": "^5.0.0",
 		"ink-text-input": "^6.0.0",
 		"js-tiktoken": "^1.0.21",
+		"latest-version": "^9.0.0",
 		"marked": "^16.1.2",
 		"openai": "^4.47.3",
 		"react-devtools-core": "^4.28.5",
 		"read-package-up": "^11.0.0",
-		"update-notifier": "^7.0.0",
+		"semver": "^7.7.4",
 		"uuid": "^9.0.1"
 	},
 	"files": [