blun-king-cli 1.6.0 → 2.0.0

package/bin/blun.js

@@ -17,6 +17,7 @@ const MEMORY_DIR = path.join(CONFIG_DIR, "memory");
 const SKILLS_DIR = path.join(CONFIG_DIR, "skills");
 const HISTORY_FILE = path.join(CONFIG_DIR, "history.json");
 const LOG_FILE = path.join(CONFIG_DIR, "cli.log");
+const PKG_VERSION = (() => { try { return require(path.join(__dirname, "..", "package.json")).version; } catch(e) { return "1.7.0"; } })();
 
 if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
 if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
@@ -108,7 +109,7 @@ function printHeader() {
   var line = BOX.h.repeat(w - 4);
   console.log("");
   console.log(C.brightBlue + "  " + BOX.tl + line + BOX.tr + C.reset);
-  console.log(C.brightBlue + "  " + BOX.v + C.reset + C.bold + C.brightWhite + "  " + BOX.bot + " BLUN KING CLI" + C.reset + C.dim + " v1.4" + C.reset + " ".repeat(Math.max(0, w - 24)) + C.brightBlue + BOX.v + C.reset);
+  console.log(C.brightBlue + "  " + BOX.v + C.reset + C.bold + C.brightWhite + "  " + BOX.bot + " BLUN KING CLI" + C.reset + C.dim + " v" + PKG_VERSION + C.reset + " ".repeat(Math.max(0, w - 24)) + C.brightBlue + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + C.reset + C.gray + "  Premium KI — Local First — Autonom" + C.reset + " ".repeat(Math.max(0, w - 41)) + C.brightBlue + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + line + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + C.reset + C.gray + "  API    " + C.brightCyan + config.api.base_url + C.reset + " ".repeat(Math.max(0, w - 14 - config.api.base_url.length)) + C.brightBlue + BOX.v + C.reset);
@@ -2066,14 +2067,54 @@ async function main() {
   }
 
   // Interactive mode
-  // Workdir selection (like Claude Code)
-  if (!process.argv.includes("--no-workdir-prompt")) {
+  // Workdir selection (like Claude Code — trust prompt)
+  config.workdir = process.cwd();
+
+  if (!process.argv.includes("--no-workdir-prompt") && !process.argv.includes("--trust")) {
     var cwdHasBlun = fs.existsSync(path.join(process.cwd(), ".blun"));
     var cwdHasGit = fs.existsSync(path.join(process.cwd(), ".git"));
-    if (cwdHasBlun || cwdHasGit) {
-      config.workdir = process.cwd();
+    var trustedDirs = [];
+    var trustFile = path.join(CONFIG_DIR, "trusted.json");
+    if (fs.existsSync(trustFile)) {
+      try { trustedDirs = JSON.parse(fs.readFileSync(trustFile, "utf8")); } catch(e) {}
+    }
+    var isTrusted = trustedDirs.includes(process.cwd());
+
+    if (!isTrusted && (cwdHasBlun || cwdHasGit)) {
+      console.log("");
+      console.log(C.yellow + "  " + BOX.bot + " Working in: " + C.brightWhite + process.cwd() + C.reset);
+      console.log(C.gray + "  Do you trust this folder? BLUN King will read/write files here." + C.reset);
+      console.log(C.gray + "  [y] Yes, trust  [n] Choose another folder  [a] Always trust" + C.reset);
+
+      var trustAnswer = await new Promise(function(resolve) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.once("data", function(key) {
+          process.stdin.setRawMode(false);
+          resolve(key.toLowerCase());
+        });
+      });
+
+      if (trustAnswer === "a") {
+        trustedDirs.push(process.cwd());
+        fs.writeFileSync(trustFile, JSON.stringify(trustedDirs, null, 2));
+        printSuccess("Folder trusted permanently.");
+      } else if (trustAnswer === "n") {
+        var rlDir = readline.createInterface({ input: process.stdin, output: process.stdout });
+        var newDir = await new Promise(function(resolve) {
+          rlDir.question(C.brightBlue + "  Enter path: " + C.reset, resolve);
+        });
+        rlDir.close();
+        if (newDir.trim() && fs.existsSync(newDir.trim())) {
+          config.workdir = newDir.trim();
+        } else {
+          printError("Invalid path, using current directory.");
+        }
+      }
+      // y or anything else = trust for this session
+      console.log("");
     }
-    // Show workdir in header
   }
 
   printHeader();
@@ -2103,76 +2144,239 @@ async function main() {
     "/compact", "/review", "/cost", "/exit"
   ];
 
-  var rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: "\n" + C.brightBlue + C.bold + "  " + BOX.arrow + " " + C.reset,
-    completer: function(line) {
-      if (line.startsWith("/")) {
-        var hits = ALL_COMMANDS.filter(function(c) { return c.startsWith(line); });
-        return [hits.length ? hits : ALL_COMMANDS, line];
+  // ── Bordered Input Box + Live Slash Menu ──
+  var inputBuffer = "";
+  var inputHistory = [];
+  var historyIdx = -1;
+  var menuVisible = false;
+  var menuItems = [];
+  var menuSelected = 0;
+  var cursorPos = 0;
+  var processing = false;
+
+  function getTermWidth() { return process.stdout.columns || 80; }
+
+  function renderInputBox() {
+    var w = Math.min(getTermWidth() - 4, 76);
+    var displayText = inputBuffer;
+    if (displayText.length > w - 4) displayText = displayText.slice(-(w - 4));
+    var pad = Math.max(0, w - 2 - displayText.length);
+    process.stdout.write("\r\x1b[K"); // clear line
+    process.stdout.write(C.brightBlue + "  " + BOX.tl + BOX.h.repeat(w - 2) + BOX.tr + C.reset + "\n");
+    process.stdout.write(C.brightBlue + "  " + BOX.v + " " + C.reset + C.brightWhite + displayText + C.reset + " ".repeat(pad) + C.brightBlue + BOX.v + C.reset + "\n");
+    process.stdout.write(C.brightBlue + "  " + BOX.bl + BOX.h.repeat(w - 2) + BOX.br + C.reset);
+    // Move cursor back to input position
+    process.stdout.write("\x1b[1A"); // up 1
+    process.stdout.write("\r\x1b[" + (4 + displayText.length) + "C"); // position cursor
+  }
+
+  function clearInputBox() {
+    process.stdout.write("\r\x1b[K"); // clear current line
+    process.stdout.write("\x1b[1B\r\x1b[K"); // clear line below
+    process.stdout.write("\x1b[1A\r"); // back up
+  }
+
+  function renderMenu() {
+    if (!menuVisible || menuItems.length === 0) return;
+    // Save cursor, move below input box, render menu
+    var show = menuItems.slice(0, 8);
+    process.stdout.write("\x1b[s"); // save cursor
+    process.stdout.write("\n\n"); // below input box
+    show.forEach(function(item, i) {
+      var prefix = i === menuSelected ? C.brightBlue + C.bold + "  " + BOX.arrow + " " : "    ";
+      var cmdStr = (item.cmd + " ".repeat(20)).slice(0, 18);
+      var descStr = item.desc.slice(0, getTermWidth() - 28);
+      process.stdout.write(prefix + C.brightCyan + cmdStr + C.gray + descStr + C.reset + "\x1b[K\n");
+    });
+    if (menuItems.length > 8) {
+      process.stdout.write(C.dim + "    ... " + (menuItems.length - 8) + " more" + C.reset + "\x1b[K\n");
+    }
+    process.stdout.write("\x1b[u"); // restore cursor
+  }
+
+  function clearMenu() {
+    if (!menuVisible) return;
+    var lines = Math.min(menuItems.length, 8) + (menuItems.length > 8 ? 1 : 0) + 2;
+    process.stdout.write("\x1b[s"); // save
+    for (var i = 0; i < lines; i++) {
+      process.stdout.write("\n\x1b[K");
+    }
+    process.stdout.write("\x1b[u"); // restore
+    menuVisible = false;
+  }
+
+  function updateMenu() {
+    if (inputBuffer.startsWith("/")) {
+      var filter = inputBuffer.toLowerCase();
+      menuItems = COMMAND_DESCRIPTIONS.filter(function(c) {
+        return c.cmd.includes(filter) || c.desc.toLowerCase().includes(filter.slice(1));
+      });
+      if (menuItems.length > 0) {
+        menuVisible = true;
+        menuSelected = Math.min(menuSelected, menuItems.length - 1);
+        renderMenu();
+      } else {
+        clearMenu();
       }
-      return [[], line];
+    } else {
+      if (menuVisible) clearMenu();
     }
-  });
+  }
 
-  rl.prompt();
+  function drawPrompt() {
+    if (processing) return;
+    console.log(""); // spacing
+    renderInputBox();
+    updateMenu();
+  }
 
-  rl.on("line", async function(line) {
-    var input = line.trim();
-    if (!input) { rl.prompt(); return; }
+  async function processInput(input) {
+    processing = true;
+    clearMenu();
+    clearInputBox();
+    // Move below the box area
+    process.stdout.write("\x1b[2B\r\x1b[K\x1b[1A\r\x1b[K\x1b[1A\r\x1b[K");
 
-    // ! prefix = direct bash
     if (input.startsWith("!")) {
       cmdShell(input.slice(1).trim());
-    }
-    // # prefix = memory shortcut
-    else if (input.startsWith("#save ")) {
+    } else if (input.startsWith("#save ")) {
       var memParts = input.slice(6).split(/\s+/);
-      var memKey = memParts[0];
-      var memVal = memParts.slice(1).join(" ");
-      if (memKey && memVal) {
-        fs.writeFileSync(path.join(MEMORY_DIR, memKey + ".txt"), memVal);
-        printSuccess("Memory saved: " + memKey);
+      if (memParts[0] && memParts.length > 1) {
+        fs.writeFileSync(path.join(MEMORY_DIR, memParts[0] + ".txt"), memParts.slice(1).join(" "));
+        printSuccess("Memory saved: " + memParts[0]);
       }
+    } else if (input.startsWith("#")) {
+      var memKey = input.slice(1).trim();
+      var memFile = path.join(MEMORY_DIR, memKey + ".txt");
+      if (fs.existsSync(memFile)) console.log(C.brightCyan + fs.readFileSync(memFile, "utf8") + C.reset);
+      else printError("Memory not found: " + memKey);
+    } else if (input.startsWith("/")) {
+      runHook("pre", input.split(/\s+/)[0].slice(1));
+      await handleCommand(input);
+      runHook("post", input.split(/\s+/)[0].slice(1));
+    } else {
+      await sendChat(input);
     }
-    else if (input.startsWith("#") && !input.startsWith("#save")) {
-      var memKey2 = input.slice(1).trim();
-      var memFile = path.join(MEMORY_DIR, memKey2 + ".txt");
-      if (fs.existsSync(memFile)) {
-        console.log(C.brightCyan + fs.readFileSync(memFile, "utf8") + C.reset);
-      } else {
-        printError("Memory not found: " + memKey2);
+
+    inputBuffer = "";
+    cursorPos = 0;
+    menuSelected = 0;
+    processing = false;
+    drawPrompt();
+  }
+
+  // ── Raw Input Handler ──
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+
+  drawPrompt();
+
+  process.stdin.on("data", function(key) {
+    if (processing) return;
+
+    // Ctrl+C
+    if (key === "\x03") {
+      session.history = chatHistory.slice(-50);
+      saveSessionHistory(session);
+      clearMenu();
+      console.log(C.dim + "\nBye." + C.reset);
+      process.exit(0);
+    }
+
+    // Ctrl+D
+    if (key === "\x04") {
+      session.history = chatHistory.slice(-50);
+      saveSessionHistory(session);
+      clearMenu();
+      console.log(C.dim + "\nBye." + C.reset);
+      process.exit(0);
+    }
+
+    // Enter
+    if (key === "\r" || key === "\n") {
+      var input = inputBuffer.trim();
+      // If menu is visible and a command is selected, use that
+      if (menuVisible && menuItems.length > 0 && inputBuffer.startsWith("/") && !inputBuffer.includes(" ")) {
+        input = menuItems[menuSelected].cmd;
+      }
+      if (!input) return;
+      inputHistory.unshift(input);
+      historyIdx = -1;
+      processInput(input);
+      return;
+    }
+
+    // Tab — autocomplete from menu
+    if (key === "\t") {
+      if (menuVisible && menuItems.length > 0) {
+        inputBuffer = menuItems[menuSelected].cmd + " ";
+        cursorPos = inputBuffer.length;
+        clearMenu();
+        renderInputBox();
+        updateMenu();
       }
+      return;
     }
-    // / alone = show menu
-    else if (input === "/") {
-      showSlashMenu("/");
+
+    // Backspace
+    if (key === "\x7f" || key === "\b") {
+      if (inputBuffer.length > 0) {
+        inputBuffer = inputBuffer.slice(0, -1);
+        cursorPos = inputBuffer.length;
+        clearMenu();
+        renderInputBox();
+        updateMenu();
+      }
+      return;
     }
-    // / prefix = command
-    else if (input.startsWith("/")) {
-      // If it's a partial command without space, show filtered menu
-      if (!input.includes(" ") && !ALL_COMMANDS.includes(input)) {
-        showSlashMenu(input);
-      } else {
-        runHook("pre", input.split(/\s+/)[0].slice(1));
-        await handleCommand(input);
-        runHook("post", input.split(/\s+/)[0].slice(1));
+
+    // Arrow keys (escape sequences)
+    if (key === "\x1b[A") { // Up
+      if (menuVisible && menuItems.length > 0) {
+        menuSelected = Math.max(0, menuSelected - 1);
+        clearMenu();
+        renderMenu();
+      } else if (inputHistory.length > 0) {
+        historyIdx = Math.min(historyIdx + 1, inputHistory.length - 1);
+        inputBuffer = inputHistory[historyIdx];
+        cursorPos = inputBuffer.length;
+        renderInputBox();
       }
+      return;
     }
-    // plain text = chat
-    else {
-      await sendChat(input);
+    if (key === "\x1b[B") { // Down
+      if (menuVisible && menuItems.length > 0) {
+        menuSelected = Math.min(menuItems.length - 1, menuSelected + 1);
+        clearMenu();
+        renderMenu();
+      } else if (historyIdx > 0) {
+        historyIdx--;
+        inputBuffer = inputHistory[historyIdx];
+        cursorPos = inputBuffer.length;
+        renderInputBox();
+      }
+      return;
     }
-    rl.prompt();
-  });
 
-  rl.on("close", function() {
-    // Save session history
-    session.history = chatHistory.slice(-50);
-    saveSessionHistory(session);
-    console.log(C.dim + "\nBye." + C.reset);
-    process.exit(0);
+    // Escape — close menu
+    if (key === "\x1b" || key === "\x1b\x1b") {
+      if (menuVisible) {
+        clearMenu();
+        menuVisible = false;
+      }
+      return;
+    }
+
+    // Ignore other escape sequences
+    if (key.startsWith("\x1b")) return;
+
+    // Regular character
+    inputBuffer += key;
+    cursorPos = inputBuffer.length;
+    clearMenu();
+    renderInputBox();
+    updateMenu();
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "1.6.0",
+  "version": "2.0.0",
   "description": "BLUN King CLI — Premium KI Console",
   "bin": {
     "blun": "./bin/blun.js"