@nomad-e/bluma-cli 0.1.26 → 0.1.28

package/dist/main.js

@@ -178,16 +178,16 @@ async function commandStatus(args) {
     }
     const maxWait = Math.min(wait_seconds, 15);
     if (maxWait > 0 && entry.status === "running") {
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const checkInterval = setInterval(() => {
           if (entry.status !== "running") {
             clearInterval(checkInterval);
-            resolve();
+            resolve2();
           }
         }, 100);
         setTimeout(() => {
           clearInterval(checkInterval);
-          resolve();
+          resolve2();
         }, maxWait * 1e3);
       });
     }
@@ -331,7 +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 fs15 from "fs";
 import { v4 as uuidv46 } from "uuid";
 
 // src/app/ui/App.tsx
@@ -1484,12 +1484,12 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path16 from "path";
-import os10 from "os";
+import path17 from "path";
+import os11 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs8 } from "fs";
-import path10 from "path";
+import { promises as fs9 } from "fs";
+import path11 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/natives/edit.ts
@@ -3077,7 +3077,7 @@ var MAX_RESULTS_DEFAULT = 5;
 var REQUEST_TIMEOUT = 15e3;
 var MAX_CONTENT_LENGTH = 4e3;
 function httpGet(url, customHeaders) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const protocol = url.startsWith("https") ? https : http;
     const defaultHeaders = {
       "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
@@ -3093,14 +3093,14 @@ function httpGet(url, customHeaders) {
       timeout: REQUEST_TIMEOUT
     }, (res) => {
       if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        httpGet(res.headers.location, customHeaders).then(resolve).catch(reject);
+        httpGet(res.headers.location, customHeaders).then(resolve2).catch(reject);
         return;
       }
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-          resolve(data);
+          resolve2(data);
         } else {
           reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`));
         }
@@ -3424,6 +3424,218 @@ ${skill.content}`;
   };
 }
 
+// src/app/agent/tools/natives/coding_memory.ts
+import * as fs8 from "fs";
+import * as path10 from "path";
+import os4 from "os";
+var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
+var PROMPT_DEFAULT_MAX_NOTES = 25;
+var PROMPT_DEFAULT_PREVIEW = 500;
+function readCodingMemoryForPrompt(options) {
+  const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
+  const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
+  const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
+  const globalPath = path10.join(os4.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path10.join(process.cwd(), ".bluma", "coding_memory.json");
+  let raw = null;
+  try {
+    if (fs8.existsSync(globalPath)) {
+      raw = fs8.readFileSync(globalPath, "utf-8");
+    } else if (path10.resolve(globalPath) !== path10.resolve(legacyPath) && fs8.existsSync(legacyPath)) {
+      raw = fs8.readFileSync(legacyPath, "utf-8");
+    }
+  } catch {
+    return "";
+  }
+  if (!raw) return "";
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return "";
+  }
+  const entries = Array.isArray(data.entries) ? [...data.entries] : [];
+  if (entries.length === 0) return "";
+  entries.sort((a, b) => (b.id ?? 0) - (a.id ?? 0));
+  const parts = [];
+  let used = 0;
+  for (let i = 0; i < entries.length && i < maxNotes; i++) {
+    const e = entries[i];
+    const full = e.note || "";
+    const body = full.length > preview ? `${full.slice(0, preview)}\u2026` : full;
+    const block = `### id ${e.id} \xB7 tags: ${(e.tags || []).join(", ") || "(none)"}
+${body}`;
+    const piece = parts.length > 0 ? `
+
+---
+
+${block}` : block;
+    if (used + piece.length > maxTotal) break;
+    parts.push(piece);
+    used += piece.length;
+  }
+  return parts.join("");
+}
+var memoryStore = [];
+var nextId2 = 1;
+var loaded = false;
+function getMemoryFilePath() {
+  return path10.join(os4.homedir(), ".bluma", "coding_memory.json");
+}
+function getLegacyMemoryFilePath() {
+  return path10.join(process.cwd(), ".bluma", "coding_memory.json");
+}
+function loadMemoryFromFile() {
+  if (loaded) return;
+  loaded = true;
+  memoryStore = [];
+  nextId2 = 1;
+  try {
+    const filePath = getMemoryFilePath();
+    const legacy = getLegacyMemoryFilePath();
+    const legacyDistinct = path10.resolve(legacy) !== path10.resolve(filePath);
+    const readIntoStore = (p) => {
+      const raw = fs8.readFileSync(p, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed.entries)) {
+        memoryStore = parsed.entries;
+        nextId2 = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
+      }
+    };
+    if (fs8.existsSync(filePath)) {
+      readIntoStore(filePath);
+    }
+    if (memoryStore.length === 0 && legacyDistinct && fs8.existsSync(legacy)) {
+      readIntoStore(legacy);
+      if (memoryStore.length > 0) {
+        saveMemoryToFile();
+      }
+    }
+  } catch {
+    memoryStore = [];
+    nextId2 = 1;
+  }
+}
+function saveMemoryToFile() {
+  try {
+    const filePath = getMemoryFilePath();
+    const dir = path10.dirname(filePath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
+    }
+    const payload = {
+      entries: memoryStore,
+      nextId: nextId2,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs8.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+  } catch {
+  }
+}
+function normalizeTags(tags) {
+  if (!tags) return [];
+  return tags.map((t) => typeof t === "string" ? t.trim() : "").filter((t) => t.length > 0).slice(0, 10);
+}
+function addNote(args) {
+  loadMemoryFromFile();
+  const note = (args.note || "").trim();
+  if (!note) {
+    return {
+      success: false,
+      message: "note is required for action=add",
+      entries: memoryStore
+    };
+  }
+  if (note.length > 4e3) {
+    return {
+      success: false,
+      message: "note too long (max 4000 chars)",
+      entries: memoryStore
+    };
+  }
+  const entry = {
+    id: nextId2++,
+    note,
+    tags: normalizeTags(args.tags),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    usageCount: 0
+  };
+  memoryStore.push(entry);
+  saveMemoryToFile();
+  return {
+    success: true,
+    message: "Memory entry added",
+    entries: memoryStore
+  };
+}
+function listNotes() {
+  loadMemoryFromFile();
+  return {
+    success: true,
+    message: memoryStore.length === 0 ? "No coding memory entries yet" : `Listing ${memoryStore.length} coding memory entries`,
+    entries: memoryStore
+  };
+}
+function searchNotes(args) {
+  loadMemoryFromFile();
+  const query = (args.query || "").trim();
+  if (!query) {
+    return {
+      success: false,
+      message: "query is required for action=search",
+      entries: memoryStore,
+      matched: []
+    };
+  }
+  const lower = query.toLowerCase();
+  const matches = memoryStore.filter((e) => {
+    if (e.note.toLowerCase().includes(lower)) return true;
+    return e.tags.some((t) => t.toLowerCase().includes(lower));
+  });
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  for (const entry of matches) {
+    entry.lastUsedAt = nowIso;
+    entry.usageCount = (entry.usageCount || 0) + 1;
+  }
+  saveMemoryToFile();
+  return {
+    success: true,
+    message: matches.length === 0 ? "No matching coding memory entries" : `Found ${matches.length} matching entries`,
+    entries: memoryStore,
+    matched: matches
+  };
+}
+function clearNotes() {
+  loadMemoryFromFile();
+  memoryStore = [];
+  nextId2 = 1;
+  saveMemoryToFile();
+  return {
+    success: true,
+    message: "All coding memory entries cleared",
+    entries: memoryStore
+  };
+}
+async function coding_memory(args) {
+  const action = args.action;
+  switch (action) {
+    case "add":
+      return addNote(args);
+    case "list":
+      return listNotes();
+    case "search":
+      return searchNotes(args);
+    case "clear":
+      return clearNotes();
+    default:
+      return {
+        success: false,
+        message: `Unknown action: ${String(action)}`,
+        entries: memoryStore
+      };
+  }
+}
+
 // src/app/agent/tool_invoker.ts
 var ToolInvoker = class {
   // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
@@ -3441,9 +3653,9 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname2 = path10.dirname(__filename);
-      const configPath = path10.resolve(__dirname2, "config", "native_tools.json");
-      const fileContent = await fs8.readFile(configPath, "utf-8");
+      const __dirname2 = path11.dirname(__filename);
+      const configPath = path11.resolve(__dirname2, "config", "native_tools.json");
+      const fileContent = await fs9.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = config2.nativeTools;
     } catch (error) {
@@ -3474,6 +3686,7 @@ var ToolInvoker = class {
     this.toolImplementations.set("read_artifact", readArtifact);
     this.toolImplementations.set("search_web", searchWeb);
     this.toolImplementations.set("load_skill", loadSkill);
+    this.toolImplementations.set("coding_memory", coding_memory);
   }
   /**
    * Retorna a lista de definições de todas as ferramentas nativas carregadas.
@@ -3503,9 +3716,9 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs9 } from "fs";
-import path11 from "path";
-import os4 from "os";
+import { promises as fs10 } from "fs";
+import path12 from "path";
+import os5 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -3532,9 +3745,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    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 __dirname2 = path12.dirname(__filename);
+    const defaultConfigPath = path12.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path12.join(os5.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -3568,7 +3781,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs9.readFile(configPath, "utf-8");
+      const fileContent = await fs10.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -3587,7 +3800,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os4.platform() === "win32";
+    const isWindows = os5.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -3703,13 +3916,13 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path15 from "path";
+import path16 from "path";
 import { v4 as uuidv43 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path12 from "path";
-import os5 from "os";
-import { promises as fs10 } from "fs";
+import path13 from "path";
+import os6 from "os";
+import { promises as fs11 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -3744,13 +3957,13 @@ function debouncedSave(sessionFile, history) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path12.join(os5.homedir(), p.slice(1));
+    return path13.join(os6.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path12.join(os5.homedir(), ".bluma");
-  return path12.resolve(expandHome(fixed));
+  const fixed = path13.join(os6.homedir(), ".bluma");
+  return path13.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -3758,10 +3971,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path12.dirname(dest);
-      await fs10.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path13.dirname(dest);
+      await fs11.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs10.rename(src, dest);
+      await fs11.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -3774,13 +3987,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs10.access(src);
-    const data = await fs10.readFile(src);
-    const dir = path12.dirname(dest);
-    await fs10.mkdir(dir, { recursive: true }).catch(() => {
+    await fs11.access(src);
+    const data = await fs11.readFile(src);
+    const dir = path13.dirname(dest);
+    await fs11.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs10.writeFile(dest, data);
-    await fs10.unlink(src).catch(() => {
+    await fs11.writeFile(dest, data);
+    await fs11.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -3793,16 +4006,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path12.join(appDir, "sessions");
-  await fs10.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path13.join(appDir, "sessions");
+  await fs11.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path12.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path13.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs10.access(sessionFile);
-    const fileContent = await fs10.readFile(sessionFile, "utf-8");
+    await fs11.access(sessionFile);
+    const fileContent = await fs11.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     return [sessionFile, sessionData.conversation_history || [], []];
   } catch (error) {
@@ -3811,7 +4024,7 @@ async function loadOrcreateSession(sessionId) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs10.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs11.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     return [sessionFile, [], []];
   }
 }
@@ -3819,12 +4032,12 @@ async function doSaveSessionHistory(sessionFile, history) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path12.dirname(sessionFile);
-      await fs10.mkdir(dir, { recursive: true });
+      const dir = path13.dirname(sessionFile);
+      await fs11.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs10.readFile(sessionFile, "utf-8");
+      const fileContent = await fs11.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -3835,14 +4048,14 @@ async function doSaveSessionHistory(sessionFile, history) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path12.basename(sessionFile, ".json");
+      const sessionId = path13.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs10.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs11.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -3850,7 +4063,7 @@ async function doSaveSessionHistory(sessionFile, history) {
     sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs10.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs11.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -3859,7 +4072,7 @@ async function doSaveSessionHistory(sessionFile, history) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs10.unlink(tempSessionFile);
+        await fs11.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -3876,15 +4089,15 @@ async function saveSessionHistory(sessionFile, history) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os7 from "os";
-import fs12 from "fs";
-import path14 from "path";
+import os8 from "os";
+import fs13 from "fs";
+import path15 from "path";
 import { execSync } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs11 from "fs";
-import path13 from "path";
-import os6 from "os";
+import fs12 from "fs";
+import path14 from "path";
+import os7 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
@@ -3893,8 +4106,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path13.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path13.join(os6.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path14.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path14.join(os7.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -3904,16 +4117,16 @@ var SkillLoader = class _SkillLoader {
   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 path14.join(__dirname, "config", "skills");
       }
-      return path13.join(process.cwd(), "dist", "config", "skills");
+      return path14.join(process.cwd(), "dist", "config", "skills");
     }
     try {
       const currentFile = fileURLToPath3(import.meta.url);
-      const distDir = path13.dirname(currentFile);
-      return path13.join(distDir, "config", "skills");
+      const distDir = path14.dirname(currentFile);
+      return path14.join(distDir, "config", "skills");
     } catch {
-      return path13.join(process.cwd(), "dist", "config", "skills");
+      return path14.join(process.cwd(), "dist", "config", "skills");
     }
   }
   /**
@@ -3942,8 +4155,8 @@ var SkillLoader = class _SkillLoader {
         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")
+          userPath: path14.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path14.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -3951,20 +4164,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs11.existsSync(dir)) return [];
+    if (!fs12.existsSync(dir)) return [];
     try {
-      return fs11.readdirSync(dir).filter((d) => {
-        const fullPath = path13.join(dir, d);
-        return fs11.statSync(fullPath).isDirectory() && fs11.existsSync(path13.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path13.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs12.readdirSync(dir).filter((d) => {
+        const fullPath = path14.join(dir, d);
+        return fs12.statSync(fullPath).isDirectory() && fs12.existsSync(path14.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path14.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs11.existsSync(skillPath)) return null;
+    if (!fs12.existsSync(skillPath)) return null;
     try {
-      const raw = fs11.readFileSync(skillPath, "utf-8");
+      const raw = fs12.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -3986,12 +4199,12 @@ var SkillLoader = class _SkillLoader {
    */
   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");
-    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs11.existsSync(bundledPath);
-    const existsProject = fs11.existsSync(projectPath);
-    const existsGlobal = fs11.existsSync(globalPath);
+    const bundledPath = path14.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path14.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path14.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs12.existsSync(bundledPath);
+    const existsProject = fs12.existsSync(projectPath);
+    const existsGlobal = fs12.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -4030,9 +4243,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs11.readFileSync(skillPath, "utf-8");
+      const raw = fs12.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path13.dirname(skillPath);
+      const skillDir = path14.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -4041,22 +4254,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path13.join(skillDir, "references")),
-        scripts: this.scanAssets(path13.join(skillDir, "scripts"))
+        references: this.scanAssets(path14.join(skillDir, "references")),
+        scripts: this.scanAssets(path14.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs11.existsSync(dir)) return [];
+    if (!fs12.existsSync(dir)) return [];
     try {
-      return fs11.readdirSync(dir).filter((f) => {
-        const fp = path13.join(dir, f);
-        return fs11.statSync(fp).isFile();
+      return fs12.readdirSync(dir).filter((f) => {
+        const fp = path14.join(dir, f);
+        return fs12.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path13.resolve(dir, f)
+        path: path14.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -4113,10 +4326,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   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(bundledPath) || fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+    const bundledPath = path14.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path14.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path14.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs12.existsSync(bundledPath) || fs12.existsSync(projectPath) || fs12.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -4175,10 +4388,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs12.existsSync(path14.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs12.existsSync(path14.join(dir, "yarn.lock"))) return "yarn";
-    if (fs12.existsSync(path14.join(dir, "bun.lockb"))) return "bun";
-    if (fs12.existsSync(path14.join(dir, "package-lock.json"))) return "npm";
+    if (fs13.existsSync(path15.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs13.existsSync(path15.join(dir, "yarn.lock"))) return "yarn";
+    if (fs13.existsSync(path15.join(dir, "bun.lockb"))) return "bun";
+    if (fs13.existsSync(path15.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -4186,9 +4399,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs12.readdirSync(dir);
+    const files = fs13.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs12.readFileSync(path14.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs13.readFileSync(path15.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";
@@ -4207,9 +4420,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path14.join(dir, "package.json");
-    if (fs12.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path15.join(dir, "package.json");
+    if (fs13.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -4218,7 +4431,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs12.existsSync(path14.join(dir, "pytest.ini")) || fs12.existsSync(path14.join(dir, "conftest.py"))) return "pytest";
+    if (fs13.existsSync(path15.join(dir, "pytest.ini")) || fs13.existsSync(path15.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -4226,9 +4439,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path14.join(dir, "package.json");
-    if (fs12.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path15.join(dir, "package.json");
+    if (fs13.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -4337,6 +4550,26 @@ You MUST adapt all commands to this environment. Use the correct package manager
 
 ---
 
+<coding_memory>
+## Persistent coding memory (tool: \`coding_memory\`)
+
+You have **durable notes** on disk (typically \`~/.bluma/coding_memory.json\`), separate from chat history. They **survive new sessions**.
+
+### Baseline vs live refresh
+- The **<coding_memory_snapshot>** block (appended after this prompt) is loaded **once at session start** from disk. It can become stale if memory changes later or if the topic was never saved.
+- Act like a teammate who **checks their notes**: before relying on "what we agreed" or project-specific lore, use \`coding_memory\` with \`action: "search"\` and a short \`query\` \u2014 especially when the user asks if you remember something, or when switching back to a topic after a long stretch of work.
+
+### When to write
+- After you learn **stable** facts (architecture, conventions, important URLs, decisions, repeated user preferences), call \`coding_memory\` with \`action: "add"\`, a concise \`note\`, and \`tags\` for later search.
+- When something **changes**, add an updated note (and do not treat outdated snapshot text as truth without searching).
+
+### Habits (continuity)
+- Prefer **search** or **list** over guessing when answering "remember / last time / what we did".
+- Long specs belong in the repo or artifacts; use \`coding_memory\` for **short** reminders and pointers.
+</coding_memory>
+
+---
+
 <workflow>
 ## How You Work
 
@@ -4664,12 +4897,12 @@ In sandbox mode you are a Python-focused, non-interactive, deterministic agent t
 function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const env = {
-    os_type: os7.type(),
-    os_version: os7.release(),
-    architecture: os7.arch(),
+    os_type: os8.type(),
+    os_version: os8.release(),
+    architecture: os8.arch(),
     workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os7.userInfo().username,
+    username: os8.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd) ? "yes" : "no",
@@ -4839,12 +5072,23 @@ User: "Publish the package"
 </available_skills>
 `;
   }
+  const memorySnapshot = readCodingMemoryForPrompt();
+  prompt += `
+
+---
+
+<coding_memory_snapshot>
+## Persistent notes (loaded at session start from disk)
+
+${memorySnapshot.trim().length > 0 ? memorySnapshot : "(No entries yet. Use coding_memory with action add or search to build continuity across sessions.)"}
+</coding_memory_snapshot>
+`;
   return prompt;
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path14.join(dir, ".git");
-    return fs12.existsSync(gitPath) && fs12.lstatSync(gitPath).isDirectory();
+    const gitPath = path15.join(dir, ".git");
+    return fs13.existsSync(gitPath) && fs13.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -4915,7 +5159,7 @@ function createApiContextWindow(fullHistory, maxTurns) {
 }
 
 // src/app/agent/core/llm/llm.ts
-import os8 from "os";
+import os9 from "os";
 import OpenAI from "openai";
 function defaultBlumaUserContextInput(sessionId, userMessage) {
   const msg = String(userMessage || "").slice(0, 300);
@@ -4932,7 +5176,7 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
 }
 function getPreferredMacAddress() {
   try {
-    const ifaces = os8.networkInterfaces();
+    const ifaces = os9.networkInterfaces();
     for (const name of Object.keys(ifaces)) {
       const addrs = ifaces[name];
       if (!addrs) continue;
@@ -4947,7 +5191,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os8.hostname()}`;
+    return `host:${os9.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -4957,7 +5201,7 @@ function defaultInteractiveCliUserContextInput(sessionId, userMessage) {
   const machineId = getPreferredMacAddress();
   let userName = null;
   try {
-    userName = os8.userInfo().username || null;
+    userName = os9.userInfo().username || null;
   } catch {
     userName = null;
   }
@@ -5532,7 +5776,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path15.basename(toolArgs.file_path);
+      const filename = path16.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}`;
@@ -5770,7 +6014,7 @@ import { v4 as uuidv45 } from "uuid";
 import { v4 as uuidv44 } from "uuid";
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os9 from "os";
+import os10 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -5933,12 +6177,12 @@ Rule Summary:
 function getInitPrompt() {
   const now = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os9.type(),
-    os_version: os9.release(),
-    architecture: os9.arch(),
+    os_type: os10.type(),
+    os_version: os10.release(),
+    architecture: os10.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os9.userInfo().username || "Unknown",
+    username: os10.userInfo().username || "Unknown",
     current_date: now.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -6219,14 +6463,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path18, handler) {
-    this.routeHandlers.set(path18, handler);
+  registerRoute(path19, handler) {
+    this.routeHandlers.set(path19, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path18, handler] of this.routeHandlers) {
-      if (inputText === path18 || inputText.startsWith(`${path18} `)) {
+    for (const [path19, handler] of this.routeHandlers) {
+      if (inputText === path19 || inputText.startsWith(`${path19} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -6235,7 +6479,7 @@ var RouteManager = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path16.join(os10.homedir(), ".bluma", ".env");
+var globalEnvPath = path17.join(os11.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -6462,12 +6706,12 @@ var renderShellCommand2 = ({ args }) => {
 };
 var renderLsTool2 = ({ args }) => {
   const parsed = parseArgs(args);
-  const path18 = parsed.directory_path || ".";
+  const path19 = parsed.directory_path || ".";
   return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
     /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: "ls" }),
     /* @__PURE__ */ jsxs8(Text8, { children: [
       " ",
-      path18
+      path19
     ] })
   ] });
 };
@@ -6598,7 +6842,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path18 = parsed.path || ".";
+  const path19 = parsed.path || ".";
   return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
     /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: "grep" }),
     /* @__PURE__ */ jsxs8(Text8, { color: "white", children: [
@@ -6608,7 +6852,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs8(Text8, { children: [
       " ",
-      path18
+      path19
     ] })
   ] });
 };
@@ -7226,16 +7470,16 @@ var SlashCommands_default = SlashCommands;
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import path17 from "path";
-import fs13 from "fs";
+import path18 from "path";
+import fs14 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 = path17.join(dir, "package.json");
-    if (fs13.existsSync(candidate)) {
+    const candidate = path18.join(dir, "package.json");
+    if (fs14.existsSync(candidate)) {
       try {
-        const raw = fs13.readFileSync(candidate, "utf8");
+        const raw = fs14.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: parsed.version };
@@ -7243,7 +7487,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path17.dirname(dir);
+    const parent = path18.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -7256,12 +7500,12 @@ async function checkForUpdates() {
     }
     const binPath = process.argv?.[1];
     let pkg = null;
-    if (binPath && fs13.existsSync(binPath)) {
-      pkg = findBlumaPackageJson(path17.dirname(binPath));
+    if (binPath && fs14.existsSync(binPath)) {
+      pkg = findBlumaPackageJson(path18.dirname(binPath));
     }
     if (!pkg) {
       const __filename = fileURLToPath4(import.meta.url);
-      const __dirname2 = path17.dirname(__filename);
+      const __dirname2 = path18.dirname(__filename);
       pkg = findBlumaPackageJson(__dirname2);
     }
     if (!pkg) {
@@ -7733,7 +7977,7 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "tool_call") {
-          const nextId2 = history.length;
+          const nextId3 = history.length;
           newComponent = /* @__PURE__ */ jsx17(
             ToolCallDisplay,
             {
@@ -7926,9 +8170,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs14.readFileSync(filePath, "utf-8");
+      rawPayload = fs15.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs14.readFileSync(0, "utf-8");
+      rawPayload = fs15.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeJsonl({

package/package.json

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