@nomad-e/bluma-cli 0.26.0 → 0.26.3

package/dist/main.js

@@ -2616,17 +2616,22 @@ var init_CtxInspectTool = __esm({
 import path32 from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 import { promises as fs27 } from "fs";
-import { createRequire } from "module";
-function loadSqlite() {
-  const nodeRequire = createRequire(import.meta.url);
-  return nodeRequire("better-sqlite3");
-}
-function getSessionDbPath(appDir = getPreferredAppDir()) {
-  return path32.join(appDir, BLUMA_SESSION_DB_FILE);
+function getSessionIndexPath(appDir = getPreferredAppDir()) {
+  return path32.join(appDir, SESSION_INDEX_FILE);
 }
 function normalizeRelativePath(relativePath) {
   return relativePath.split(path32.sep).join("/");
 }
+function emptyStore() {
+  return { version: 1, sessions: {} };
+}
+async function persistStore(store2, appDir) {
+  mkdirSync3(appDir, { recursive: true });
+  const filePath = getSessionIndexPath(appDir);
+  const tmp = `${filePath}.${Date.now()}.tmp`;
+  await fs27.writeFile(tmp, JSON.stringify(store2, null, 2), "utf-8");
+  await fs27.rename(tmp, filePath);
+}
 async function walkSessionJsonFiles(dir, onFile) {
   let entries;
   try {
@@ -2707,22 +2712,30 @@ async function readSessionMetaFromJson(absPath) {
     }
   }
 }
-async function runMigrationV1(db, appDir) {
+function upsertIntoStore(store2, row) {
+  const rel = normalizeRelativePath(row.relativePath);
+  const existing = store2.sessions[row.sessionId];
+  if (!existing) {
+    store2.sessions[row.sessionId] = {
+      relativePath: rel,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      preview: row.preview
+    };
+    return;
+  }
+  const existingMs = Date.parse(existing.updatedAt);
+  const incomingMs = Date.parse(row.updatedAt);
+  const incomingIsNewer = Number.isFinite(incomingMs) && incomingMs >= (Number.isFinite(existingMs) ? existingMs : 0);
+  store2.sessions[row.sessionId] = {
+    relativePath: incomingIsNewer ? rel : existing.relativePath,
+    createdAt: existing.createdAt || row.createdAt,
+    updatedAt: incomingIsNewer ? row.updatedAt : existing.updatedAt,
+    preview: incomingIsNewer ? row.preview : existing.preview
+  };
+}
+async function migrateLegacyIndex(store2, appDir) {
   const jsonl = await loadJsonlEntries(appDir);
-  const upsert = db.prepare(`
-    INSERT INTO agent_sessions (session_id, relative_path, created_at, updated_at, preview)
-    VALUES (@sessionId, @relativePath, @createdAt, @updatedAt, @preview)
-    ON CONFLICT(session_id) DO UPDATE SET
-      relative_path = excluded.relative_path,
-      updated_at = CASE
-        WHEN excluded.updated_at > agent_sessions.updated_at THEN excluded.updated_at
-        ELSE agent_sessions.updated_at
-      END,
-      preview = CASE
-        WHEN excluded.updated_at > agent_sessions.updated_at THEN excluded.preview
-        ELSE agent_sessions.preview
-      END
-  `);
   const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
     let rel;
     try {
@@ -2732,7 +2745,7 @@ async function runMigrationV1(db, appDir) {
     }
     const meta = await readSessionMetaFromJson(absPath);
     const updatedAt = jsonlUpdatedAt && Date.parse(jsonlUpdatedAt) > Date.parse(meta.updatedAt) ? jsonlUpdatedAt : meta.updatedAt;
-    upsert.run({
+    upsertIntoStore(store2, {
       sessionId,
       relativePath: rel,
       createdAt: meta.createdAt,
@@ -2746,7 +2759,7 @@ async function runMigrationV1(db, appDir) {
       await fs27.access(full);
       await insertFromPath(sessionId, full, entry.updatedAt);
     } catch {
-      upsert.run({
+      upsertIntoStore(store2, {
         sessionId,
         relativePath: entry.relativePath,
         createdAt: entry.updatedAt,
@@ -2756,109 +2769,74 @@ async function runMigrationV1(db, appDir) {
     }
   }
   const sessionsRoot = path32.join(appDir, "sessions");
-  const existing = db.prepare("SELECT session_id FROM agent_sessions").all();
-  const seen = new Set(existing.map((r) => r.session_id));
   await walkSessionJsonFiles(sessionsRoot, async (absPath) => {
     const sessionId = path32.basename(absPath, ".json");
-    if (!sessionId || seen.has(sessionId)) return;
-    seen.add(sessionId);
+    if (!sessionId || store2.sessions[sessionId]) return;
     await insertFromPath(sessionId, absPath);
   });
-  db.pragma(`user_version = ${SCHEMA_VERSION}`);
-}
-function applySchema(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS agent_sessions (
-      session_id TEXT PRIMARY KEY NOT NULL,
-      relative_path TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      preview TEXT NOT NULL DEFAULT '(no messages)'
-    );
-    CREATE INDEX IF NOT EXISTS idx_agent_sessions_updated
-      ON agent_sessions(updated_at DESC);
-  `);
+}
+async function loadStoreFromDisk(appDir) {
+  try {
+    const raw = await fs27.readFile(getSessionIndexPath(appDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 1 && parsed.sessions && typeof parsed.sessions === "object") {
+      return { version: 1, sessions: { ...parsed.sessions } };
+    }
+  } catch {
+  }
+  return emptyStore();
 }
 async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
-  if (dbInstance && dbAppDir === appDir) {
-    return dbInstance;
+  if (storeCache && storeAppDir === appDir) {
+    return;
   }
-  if (!migratePromise || dbAppDir !== appDir) {
-    migratePromise = (async () => {
-      if (dbInstance) {
-        try {
-          dbInstance.close();
-        } catch {
+  if (!loadPromise || storeAppDir !== appDir) {
+    loadPromise = (async () => {
+      const store2 = await loadStoreFromDisk(appDir);
+      if (Object.keys(store2.sessions).length === 0) {
+        await migrateLegacyIndex(store2, appDir);
+        if (Object.keys(store2.sessions).length > 0) {
+          await persistStore(store2, appDir);
         }
-        dbInstance = null;
-      }
-      const BetterSqlite3 = loadSqlite();
-      const dbPath = getSessionDbPath(appDir);
-      mkdirSync3(path32.dirname(dbPath), { recursive: true });
-      const db = new BetterSqlite3(dbPath);
-      db.pragma("journal_mode = WAL");
-      applySchema(db);
-      const version = db.pragma("user_version", { simple: true });
-      if (version < SCHEMA_VERSION) {
-        await runMigrationV1(db, appDir);
       }
-      dbInstance = db;
-      dbAppDir = appDir;
+      storeCache = store2;
+      storeAppDir = appDir;
     })();
   }
-  await migratePromise;
-  return dbInstance;
+  await loadPromise;
 }
 async function upsertSessionIndexRow(row, appDir = getPreferredAppDir()) {
-  const db = await ensureSessionIndexDb(appDir);
-  const stmt = db.prepare(`
-    INSERT INTO agent_sessions (session_id, relative_path, created_at, updated_at, preview)
-    VALUES (@sessionId, @relativePath, @createdAt, @updatedAt, @preview)
-    ON CONFLICT(session_id) DO UPDATE SET
-      relative_path = excluded.relative_path,
-      updated_at = excluded.updated_at,
-      preview = excluded.preview
-  `);
-  stmt.run({
-    sessionId: row.sessionId,
-    relativePath: normalizeRelativePath(row.relativePath),
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    preview: row.preview
-  });
+  await ensureSessionIndexDb(appDir);
+  const store2 = storeCache;
+  upsertIntoStore(store2, row);
+  await persistStore(store2, appDir);
 }
 async function getSessionPathFromIndex(sessionId, appDir = getPreferredAppDir()) {
-  const db = await ensureSessionIndexDb(appDir);
-  const row = db.prepare("SELECT relative_path FROM agent_sessions WHERE session_id = ?").get(sessionId);
-  return row?.relative_path?.replace(/\//g, path32.sep) ?? null;
+  await ensureSessionIndexDb(appDir);
+  const entry = storeCache?.sessions[sessionId];
+  return entry?.relativePath?.replace(/\//g, path32.sep) ?? null;
 }
 async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
-  const db = await ensureSessionIndexDb(appDir);
-  const rows = db.prepare(
-    `SELECT session_id, relative_path, created_at, updated_at, preview
-       FROM agent_sessions
-       ORDER BY updated_at DESC
-       LIMIT ?`
-  ).all(limit);
-  return rows.map((r) => ({
-    sessionId: r.session_id,
-    relativePath: r.relative_path.replace(/\//g, path32.sep),
-    createdAt: r.created_at,
-    updatedAt: r.updated_at,
-    preview: r.preview
-  }));
+  await ensureSessionIndexDb(appDir);
+  const sessions = storeCache?.sessions ?? {};
+  return Object.entries(sessions).map(([sessionId, row]) => ({
+    sessionId,
+    relativePath: row.relativePath.replace(/\//g, path32.sep),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    preview: row.preview
+  })).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt)).slice(0, limit);
 }
-var AGENT_SESSION_PATHS_JSONL, BLUMA_SESSION_DB_FILE, SCHEMA_VERSION, dbInstance, dbAppDir, migratePromise;
+var AGENT_SESSION_PATHS_JSONL, SESSION_INDEX_FILE, storeCache, storeAppDir, loadPromise;
 var init_session_index_db = __esm({
   "src/app/agent/session_manager/session_index_db.ts"() {
     "use strict";
     init_bluma_app_dir();
     AGENT_SESSION_PATHS_JSONL = "agent_session_paths.jsonl";
-    BLUMA_SESSION_DB_FILE = "bluma.sqlite";
-    SCHEMA_VERSION = 1;
-    dbInstance = null;
-    dbAppDir = null;
-    migratePromise = null;
+    SESSION_INDEX_FILE = "session_index.json";
+    storeCache = null;
+    storeAppDir = null;
+    loadPromise = null;
   }
 });
 
@@ -25733,6 +25711,9 @@ function resolveReasoningEffortForRequest(params, runtimeConfig = getRuntimeConf
   }
   return effort;
 }
+function isReasoningEnabledForRequest(params, runtimeConfig = getRuntimeConfig()) {
+  return resolveReasoningEffortForRequest(params, runtimeConfig) !== void 0;
+}
 function buildChatCompletionRequestBody(params, runtimeConfig = getRuntimeConfig(), stream = false, options) {
   const tools = params.tools;
   const hasTools = Array.isArray(tools) && tools.length > 0;
@@ -26090,15 +26071,19 @@ var LLMService = class {
     }
     const toolCallsAccumulator = /* @__PURE__ */ new Map();
     let reasoningSnapshot = "";
+    const reasoningEnabled = isReasoningEnabledForRequest(params, runtimeConfig);
     for await (const chunk of stream) {
       const choice = chunk.choices[0];
       if (!choice) continue;
       const delta = choice.delta;
       applyDeltaToolCallsToAccumulator(toolCallsAccumulator, delta?.tool_calls);
-      const rawReasoning = delta?.reasoning_content || delta?.reasoning || "";
-      const reasoning = extractStreamingDelta(reasoningSnapshot, rawReasoning);
-      if (reasoning) {
-        reasoningSnapshot += reasoning;
+      let reasoning = "";
+      if (reasoningEnabled) {
+        const rawReasoning = delta?.reasoning_content || delta?.reasoning || "";
+        reasoning = extractStreamingDelta(reasoningSnapshot, rawReasoning);
+        if (reasoning) {
+          reasoningSnapshot += reasoning;
+        }
       }
       const fullToolCalls = choice.finish_reason === "tool_calls" ? Array.from(toolCallsAccumulator.values()) : void 0;
       yield {
@@ -27824,20 +27809,23 @@ var BluMaTurnCoordinator = class {
     let toolCalls;
     let hasEmittedStart = false;
     let currentStreamPhase = "idle";
-    const stream = llmService.chatCompletionStream({
+    const llmUserContext = this.deps.getLlmUserContext();
+    const streamParams = {
       messages: contextWindow,
       temperature: 0,
       tools: this.deps.mcpClient.getAvailableTools(),
       parallel_tool_calls: true,
-      userContext: this.deps.getLlmUserContext()
-    });
+      userContext: llmUserContext
+    };
+    const reasoningEnabled = isReasoningEnabledForRequest(streamParams);
+    const stream = llmService.chatCompletionStream(streamParams);
     for await (const chunk of stream) {
       if (this.deps.isInterrupted()) {
         this.deps.eventBus.emit("stream_end", {});
         this.deps.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
         return;
       }
-      if (chunk.reasoning) {
+      if (chunk.reasoning && reasoningEnabled) {
         if (!hasEmittedStart) {
           this.deps.eventBus.emit("stream_start", {});
           hasEmittedStart = true;
@@ -27958,7 +27946,11 @@ var BluMaTurnCoordinator = class {
     }
     let message2 = response.choices[0].message;
     message2 = ToolCallNormalizer.normalizeAssistantMessage(message2);
-    if (message2.reasoning_content || message2.reasoning) {
+    const reasoningEnabled = isReasoningEnabledForRequest({
+      messages: contextWindow,
+      userContext: this.deps.getLlmUserContext()
+    });
+    if (reasoningEnabled && (message2.reasoning_content || message2.reasoning)) {
       const reasoningText = message2.reasoning_content || message2.reasoning;
       this.deps.eventBus.emit("backend_message", {
         type: "reasoning",
@@ -39031,7 +39023,7 @@ import { promisify as promisify2 } from "util";
 
 // src/app/utils/clipboardNative.ts
 import { existsSync as existsSync7 } from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire } from "module";
 import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname;
@@ -39079,7 +39071,7 @@ function getNativeModule() {
     throw loadError;
   }
   try {
-    const require2 = createRequire2(import.meta.url);
+    const require2 = createRequire(import.meta.url);
     const mod = require2(nativePath);
     nativeModule = mod;
     return nativeModule;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.26.0",
+	"version": "0.26.3",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",
@@ -11,7 +11,6 @@
 		"@babel/preset-env": "^7.28.0",
 		"@babel/preset-react": "^7.27.1",
 		"@babel/preset-typescript": "^7.27.1",
-		"@types/better-sqlite3": "^7.6.13",
 		"@types/diff": "^7.0.2",
 		"@types/glob": "^8.1.0",
 		"@types/jest": "^30.0.0",
@@ -75,7 +74,6 @@
 		"@types/react-dom": "^19.2.3",
 		"auto-bind": "^5.0.1",
 		"axios": "^1.16.0",
-		"better-sqlite3": "^11.10.0",
 		"bidi-js": "^1.0.3",
 		"chalk": "^5.5.0",
 		"class-variance-authority": "^0.7.1",