blun-king-cli 1.0.0

package/bin/blun.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+// BLUN King CLI — Interactive Console
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+const { execSync, spawn } = require("child_process");
+const https = require("https");
+const http = require("http");
+
+// ── Config ──
+var _rawHome = process.env.BLUN_HOME || process.env.REAL_HOME || require("os").homedir();
+// Strip .claude-telegram-profile suffix if present (Claude Code Telegram session override)
+const HOME = _rawHome.replace(/[\/\\]\.claude-telegram-profile$/, "");
+const CONFIG_DIR = path.join(HOME, ".blun");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+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");
+
+if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
+if (!fs.existsSync(SKILLS_DIR)) fs.mkdirSync(SKILLS_DIR, { recursive: true });
+
+// ── Default Config ──
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")); } catch(e) {}
+  }
+  return {
+    auth: { type: "api_key", api_key: "", oauth_token: "", oauth_expires: null },
+    api: { base_url: "http://176.9.158.30:3200", timeout: 60000 },
+    telegram: { enabled: false, bot_token: "", chat_id: "" },
+    model: "blun-king-v100",
+    workdir: process.cwd(),
+    theme: "dark",
+    verbose: false,
+    watchdog: { enabled: false, interval: 600 }
+  };
+}
+
+function saveConfig(cfg) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+
+var config = loadConfig();
+
+// ── Colors ──
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m",
+  blue: "\x1b[34m", magenta: "\x1b[35m", cyan: "\x1b[36m", white: "\x1b[37m",
+  bg_blue: "\x1b[44m", bg_green: "\x1b[42m"
+};
+
+function log(msg) { if (config.verbose) fs.appendFileSync(LOG_FILE, new Date().toISOString() + " " + msg + "\n"); }
+
+// ── API Call ──
+function apiCall(method, endpoint, body) {
+  return new Promise(function(resolve, reject) {
+    var url = new URL(config.api.base_url + endpoint);
+    var isHttps = url.protocol === "https:";
+    var options = {
+      hostname: url.hostname, port: url.port, path: url.pathname,
+      method: method,
+      headers: { "Content-Type": "application/json" },
+      timeout: config.api.timeout
+    };
+
+    if (config.auth.type === "api_key" && config.auth.api_key) {
+      options.headers["Authorization"] = "Bearer " + config.auth.api_key;
+    } else if (config.auth.type === "oauth" && config.auth.oauth_token) {
+      options.headers["Authorization"] = "Bearer " + config.auth.oauth_token;
+    }
+
+    var data = body ? JSON.stringify(body) : null;
+    if (data) options.headers["Content-Length"] = Buffer.byteLength(data);
+
+    var mod = isHttps ? https : http;
+    var req = mod.request(options, function(res) {
+      var chunks = [];
+      res.on("data", function(c) { chunks.push(c); });
+      res.on("end", function() {
+        var raw = Buffer.concat(chunks).toString();
+        try { resolve({ status: res.statusCode, data: JSON.parse(raw) }); }
+        catch(e) { resolve({ status: res.statusCode, data: raw }); }
+      });
+    });
+    req.on("error", function(e) { reject(e); });
+    req.on("timeout", function() { req.destroy(); reject(new Error("Timeout")); });
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+// ── Chat History ──
+var chatHistory = [];
+
+// ── Print Helpers ──
+function printHeader() {
+  console.log("");
+  console.log(C.bold + C.blue + "  ╔══════════════════════════════════════╗" + C.reset);
+  console.log(C.bold + C.blue + "  ║        BLUN KING CLI v1.0           ║" + C.reset);
+  console.log(C.bold + C.blue + "  ║     Premium KI — Local First        ║" + C.reset);
+  console.log(C.bold + C.blue + "  ╚══════════════════════════════════════╝" + C.reset);
+  console.log("");
+  console.log(C.dim + "  API: " + config.api.base_url + C.reset);
+  console.log(C.dim + "  Auth: " + config.auth.type + (config.auth.api_key ? " (key set)" : " (no key)") + C.reset);
+  console.log(C.dim + "  Model: " + config.model + C.reset);
+  console.log(C.dim + "  Workdir: " + config.workdir + C.reset);
+  console.log("");
+  console.log(C.dim + "  Type /help for commands, or just chat." + C.reset);
+  console.log("");
+}
+
+function printAnswer(answer) {
+  console.log("");
+  console.log(C.green + C.bold + "BLUN King:" + C.reset);
+  // Simple markdown rendering
+  var lines = answer.split("\n");
+  var inCode = false;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    if (line.startsWith("```")) {
+      inCode = !inCode;
+      console.log(C.dim + line + C.reset);
+    } else if (inCode) {
+      console.log(C.cyan + line + C.reset);
+    } else if (line.startsWith("# ")) {
+      console.log(C.bold + C.yellow + line + C.reset);
+    } else if (line.startsWith("## ")) {
+      console.log(C.bold + C.magenta + line + C.reset);
+    } else if (line.startsWith("### ")) {
+      console.log(C.bold + line + C.reset);
+    } else if (line.startsWith("- ") || line.startsWith("* ")) {
+      console.log(C.white + "  " + line + C.reset);
+    } else if (line.match(/^\d+\./)) {
+      console.log(C.white + "  " + line + C.reset);
+    } else {
+      console.log(line);
+    }
+  }
+  console.log("");
+}
+
+function printError(msg) { console.log(C.red + "ERROR: " + msg + C.reset); }
+function printInfo(msg) { console.log(C.cyan + msg + C.reset); }
+function printSuccess(msg) { console.log(C.green + "✓ " + msg + C.reset); }
+
+// ── Commands ──
+async function handleCommand(input) {
+  var parts = input.trim().split(/\s+/);
+  var cmd = parts[0].toLowerCase();
+  var args = parts.slice(1).join(" ");
+
+  switch(cmd) {
+    case "/help":
+      console.log("");
+      console.log(C.bold + "BLUN King CLI — Commands:" + C.reset);
+      console.log("");
+      console.log(C.yellow + "  CHAT" + C.reset);
+      console.log("  (just type)       Chat with BLUN King");
+      console.log("  /clear            Clear chat history");
+      console.log("");
+      console.log(C.yellow + "  SKILLS" + C.reset);
+      console.log("  /skills           List all skills");
+      console.log("  /skill install    Install a skill from server");
+      console.log("  /skill info <n>   Show skill details");
+      console.log("");
+      console.log(C.yellow + "  TOOLS" + C.reset);
+      console.log("  /search <query>   Web search");
+      console.log("  /learn <text>     Teach BLUN King");
+      console.log("  /learn-url <url>  Learn from URL");
+      console.log("  /generate <desc>  Generate a file");
+      console.log("  /analyze <url>    Analyze a website");
+      console.log("  /score <text>     Score a response");
+      console.log("  /eval             Run eval suite");
+      console.log("");
+      console.log(C.yellow + "  SETTINGS" + C.reset);
+      console.log("  /settings         Show all settings");
+      console.log("  /set auth api     Switch to API key auth");
+      console.log("  /set auth oauth   Switch to OAuth");
+      console.log("  /set key <key>    Set API key");
+      console.log("  /set url <url>    Set API base URL");
+      console.log("  /set telegram     Configure Telegram bridge");
+      console.log("  /set verbose      Toggle verbose logging");
+      console.log("");
+      console.log(C.yellow + "  SYSTEM" + C.reset);
+      console.log("  /status           Runtime status");
+      console.log("  /versions         Prompt versions");
+      console.log("  /health           Quick health check");
+      console.log("  /watchdog         Watchdog status");
+      console.log("  /watchdog on/off  Enable/disable watchdog");
+      console.log("  /memory           Show local memory");
+      console.log("  /memory save <k>  Save to memory");
+      console.log("  /memory del <k>   Delete from memory");
+      console.log("  /files            List workdir files");
+      console.log("  /exit             Exit CLI");
+      console.log("");
+      break;
+
+    case "/clear":
+      chatHistory = [];
+      printSuccess("Chat history cleared.");
+      break;
+
+    case "/skills":
+      await cmdSkills();
+      break;
+
+    case "/skill":
+      await cmdSkillAction(args);
+      break;
+
+    case "/search":
+      await cmdSearch(args);
+      break;
+
+    case "/learn":
+      await cmdLearn(args, false);
+      break;
+
+    case "/learn-url":
+      await cmdLearn(args, true);
+      break;
+
+    case "/generate":
+      await cmdGenerate(args);
+      break;
+
+    case "/analyze":
+      await cmdAnalyze(args);
+      break;
+
+    case "/score":
+      await cmdScore(args);
+      break;
+
+    case "/eval":
+      await cmdEval();
+      break;
+
+    case "/settings":
+      cmdSettings();
+      break;
+
+    case "/set":
+      cmdSet(args);
+      break;
+
+    case "/status":
+      await cmdStatus();
+      break;
+
+    case "/versions":
+      await cmdVersions();
+      break;
+
+    case "/health":
+      await cmdHealth();
+      break;
+
+    case "/watchdog":
+      cmdWatchdog(args);
+      break;
+
+    case "/memory":
+      cmdMemory(args);
+      break;
+
+    case "/files":
+      cmdFiles();
+      break;
+
+    case "/exit":
+    case "/quit":
+    case "/q":
+      console.log(C.dim + "Bye." + C.reset);
+      process.exit(0);
+
+    default:
+      printError("Unknown command: " + cmd + ". Type /help for commands.");
+  }
+}
+
+// ── Chat ──
+async function sendChat(message) {
+  try {
+    process.stdout.write(C.dim + "⏳ thinking..." + C.reset);
+    var resp = await apiCall("POST", "/chat", {
+      message: message,
+      history: chatHistory.slice(-10)
+    });
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+
+    if (resp.status !== 200) {
+      printError(resp.data.error || "API Error " + resp.status);
+      return;
+    }
+
+    chatHistory.push({ role: "user", content: message });
+    chatHistory.push({ role: "assistant", content: resp.data.answer });
+
+    printAnswer(resp.data.answer);
+
+    // Status line
+    var q = resp.data.quality || {};
+    console.log(C.dim + "  [" + resp.data.task_type + "/" + resp.data.role + " | score: " + (q.score || "?") +
+      (q.retried ? " | retried" : "") +
+      (q.flags && q.flags.length > 0 ? " | flags: " + q.flags.join(", ") : "") + "]" + C.reset);
+    console.log("");
+
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    printError("Connection failed: " + e.message);
+  }
+}
+
+// ── Command Implementations ──
+async function cmdSkills() {
+  try {
+    var resp = await apiCall("POST", "/classify", { message: "test" });
+    // List skills from known role files
+    var skills = [
+      "api", "artifact", "artifact_reviewer", "automation", "business", "creative",
+      "critic", "data", "debug", "decomposer", "design", "dev", "devops", "docs",
+      "eval_designer", "learn_curator", "librarian", "marketing", "math", "mobile",
+      "operator", "prompt_architect", "research", "sales", "security", "seo",
+      "support", "text", "tool_brain", "translator", "web_ui", "website_builder"
+    ];
+    console.log("");
+    console.log(C.bold + "BLUN King Skills (" + skills.length + "):" + C.reset);
+    console.log("");
+    for (var i = 0; i < skills.length; i++) {
+      var installed = fs.existsSync(path.join(SKILLS_DIR, skills[i] + ".txt"));
+      console.log("  " + (installed ? C.green + "●" : C.dim + "○") + C.reset +
+        " " + skills[i] + (installed ? C.dim + " (local)" + C.reset : ""));
+    }
+    console.log("");
+    console.log(C.dim + "  /skill install <name> — Install skill locally" + C.reset);
+    console.log(C.dim + "  /skill info <name> — Show skill details" + C.reset);
+    console.log("");
+  } catch(e) {
+    printError(e.message);
+  }
+}
+
+async function cmdSkillAction(args) {
+  var parts = args.split(/\s+/);
+  var action = parts[0];
+  var name = parts[1];
+
+  if (action === "install" && name) {
+    // Fetch from server
+    try {
+      var resp = await apiCall("POST", "/chat", {
+        message: "Zeige mir den kompletten Inhalt der Rolle " + name + " — nur den Prompt-Text, keine Erklaerung."
+      });
+      if (resp.status === 200 && resp.data.answer) {
+        fs.writeFileSync(path.join(SKILLS_DIR, name + ".txt"), resp.data.answer);
+        printSuccess("Skill '" + name + "' installed to " + SKILLS_DIR);
+      }
+    } catch(e) { printError(e.message); }
+  } else if (action === "info" && name) {
+    var file = path.join(SKILLS_DIR, name + ".txt");
+    if (fs.existsSync(file)) {
+      console.log("");
+      console.log(C.bold + "Skill: " + name + C.reset);
+      console.log(C.dim + "─".repeat(40) + C.reset);
+      console.log(fs.readFileSync(file, "utf8"));
+    } else {
+      printInfo("Skill not installed locally. Use /skill install " + name);
+    }
+  } else {
+    printError("Usage: /skill install <name> or /skill info <name>");
+  }
+}
+
+async function cmdSearch(query) {
+  if (!query) { printError("Usage: /search <query>"); return; }
+  try {
+    process.stdout.write(C.dim + "🔍 searching..." + C.reset);
+    var resp = await apiCall("POST", "/web-search", { query: query, summarize: true });
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    if (resp.status === 200) {
+      console.log("");
+      console.log(C.bold + "Search: " + query + C.reset);
+      console.log("");
+      var results = resp.data.results || [];
+      for (var i = 0; i < results.length; i++) {
+        console.log(C.yellow + "  " + (i+1) + ". " + results[i].title + C.reset);
+        if (results[i].snippet) console.log(C.dim + "     " + results[i].snippet.slice(0, 100) + C.reset);
+        if (results[i].url) console.log(C.blue + "     " + results[i].url + C.reset);
+      }
+      if (resp.data.summary) {
+        console.log("");
+        console.log(C.green + C.bold + "Summary:" + C.reset);
+        console.log(resp.data.summary);
+      }
+      console.log("");
+    } else { printError(resp.data.error || "Search failed"); }
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    printError(e.message);
+  }
+}
+
+async function cmdLearn(input, isUrl) {
+  if (!input) { printError("Usage: /learn <text> or /learn-url <url>"); return; }
+  try {
+    process.stdout.write(C.dim + "📚 learning..." + C.reset);
+    var body = isUrl ? { url: input } : { content: input };
+    var resp = await apiCall("POST", "/learn", body);
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    if (resp.status === 200) {
+      printSuccess("Learned! Category: " + resp.data.category + " | File: " + resp.data.file);
+    } else { printError(resp.data.error || "Learn failed"); }
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    printError(e.message);
+  }
+}
+
+async function cmdGenerate(desc) {
+  if (!desc) { printError("Usage: /generate <description>"); return; }
+  // Parse format from description
+  var format = "txt";
+  var fmatch = desc.match(/\.(html|css|js|json|md|py|txt|yaml|xml|sql|csv)\b/i);
+  if (fmatch) format = fmatch[1].toLowerCase();
+  else if (/html|webseite|landing/i.test(desc)) format = "html";
+  else if (/json|config/i.test(desc)) format = "json";
+  else if (/javascript|node|function/i.test(desc)) format = "js";
+  else if (/python/i.test(desc)) format = "py";
+  else if (/css|style/i.test(desc)) format = "css";
+  else if (/markdown/i.test(desc)) format = "md";
+
+  try {
+    process.stdout.write(C.dim + "⚙️ generating " + format + "..." + C.reset);
+    var resp = await apiCall("POST", "/generate-file", { prompt: desc, format: format });
+    process.stdout.write("\r" + " ".repeat(40) + "\r");
+    if (resp.status === 200) {
+      // Save locally too
+      var localPath = path.join(config.workdir, resp.data.filename);
+      fs.writeFileSync(localPath, resp.data.content);
+      printSuccess("Generated: " + resp.data.filename + " (" + resp.data.size + " bytes)");
+      printInfo("Local: " + localPath);
+      printInfo("Remote: " + config.api.base_url + resp.data.download);
+    } else { printError(resp.data.error || "Generate failed"); }
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(40) + "\r");
+    printError(e.message);
+  }
+}
+
+async function cmdAnalyze(url) {
+  if (!url) { printError("Usage: /analyze <url>"); return; }
+  try {
+    process.stdout.write(C.dim + "🔎 analyzing..." + C.reset);
+    var resp = await apiCall("POST", "/analyze", { url: url, type: "website" });
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    if (resp.status === 200) {
+      var meta = resp.data.meta || {};
+      console.log("");
+      console.log(C.bold + "Analysis: " + url + C.reset);
+      console.log(C.dim + "─".repeat(50) + C.reset);
+      if (meta.title) console.log("  Title: " + meta.title);
+      if (meta.h1s) console.log("  H1s: " + meta.h1s.join(", "));
+      console.log("  Links: " + meta.links + " | Images: " + meta.images);
+      console.log("  Responsive: " + (meta.responsive ? "yes" : "no"));
+      if (meta.frameworks && meta.frameworks.length) console.log("  Frameworks: " + meta.frameworks.join(", "));
+      console.log("");
+      printAnswer(resp.data.analysis);
+    } else { printError(resp.data.error || "Analyze failed"); }
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+    printError(e.message);
+  }
+}
+
+async function cmdScore(text) {
+  if (!text) { printError("Usage: /score <text>"); return; }
+  try {
+    var resp = await apiCall("POST", "/score", { answer: text, task_type: "chat" });
+    if (resp.status === 200) {
+      var s = resp.data.score;
+      var color = s >= 80 ? C.green : s >= 50 ? C.yellow : C.red;
+      console.log("");
+      console.log(C.bold + "Score: " + color + s + "/100" + C.reset);
+      if (resp.data.reasons && resp.data.reasons.length > 0) {
+        console.log(C.dim + "Flags: " + resp.data.reasons.join(", ") + C.reset);
+      }
+      console.log("");
+    } else { printError(resp.data.error || "Score failed"); }
+  } catch(e) { printError(e.message); }
+}
+
+async function cmdEval() {
+  printInfo("Running eval suite... this takes a few minutes.");
+  try {
+    var resp = await apiCall("GET", "/eval");
+    if (resp.status === 200) {
+      var d = resp.data;
+      console.log("");
+      console.log(C.bold + "EVAL RESULTS" + C.reset);
+      console.log(C.dim + "─".repeat(50) + C.reset);
+      if (d.results) {
+        for (var i = 0; i < d.results.length; i++) {
+          var r = d.results[i];
+          var icon = r.passed ? C.green + "PASS" : C.red + "FAIL";
+          console.log("  " + icon + C.reset + " " + r.name +
+            (r.failures && r.failures.length > 0 ? C.dim + " — " + r.failures.join(", ") + C.reset : ""));
+        }
+      }
+      console.log(C.dim + "─".repeat(50) + C.reset);
+      var scoreColor = d.score >= 83 ? C.green : C.red;
+      console.log("  " + C.bold + "Score: " + scoreColor + d.score + "% (" + d.passed + "/" + d.total + ")" + C.reset);
+      console.log("");
+    } else { printError(resp.data.error || "Eval failed"); }
+  } catch(e) { printError(e.message); }
+}
+
+function cmdSettings() {
+  console.log("");
+  console.log(C.bold + "BLUN King Settings:" + C.reset);
+  console.log(C.dim + "─".repeat(40) + C.reset);
+  console.log("  Auth Type:    " + config.auth.type);
+  console.log("  API Key:      " + (config.auth.api_key ? config.auth.api_key.slice(0, 10) + "..." : "(not set)"));
+  console.log("  OAuth Token:  " + (config.auth.oauth_token ? "set (expires: " + config.auth.oauth_expires + ")" : "(not set)"));
+  console.log("  API URL:      " + config.api.base_url);
+  console.log("  Model:        " + config.model);
+  console.log("  Workdir:      " + config.workdir);
+  console.log("  Verbose:      " + config.verbose);
+  console.log("  Telegram:     " + (config.telegram.enabled ? "on (chat: " + config.telegram.chat_id + ")" : "off"));
+  console.log("  Watchdog:     " + (config.watchdog.enabled ? "on (" + config.watchdog.interval + "s)" : "off"));
+  console.log("");
+  console.log(C.dim + "  Config file: " + CONFIG_FILE + C.reset);
+  console.log("");
+}
+
+function cmdSet(args) {
+  var parts = args.split(/\s+/);
+  var key = parts[0];
+  var val = parts.slice(1).join(" ");
+
+  switch(key) {
+    case "auth":
+      if (val === "api" || val === "api_key") {
+        config.auth.type = "api_key";
+        saveConfig(config);
+        printSuccess("Auth switched to API key.");
+      } else if (val === "oauth") {
+        config.auth.type = "oauth";
+        printInfo("Enter OAuth token:");
+        // Will be set interactively
+        var rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl2.question("  OAuth Token: ", function(token) {
+          config.auth.oauth_token = token.trim();
+          rl2.question("  Expires (ISO date or 'never'): ", function(exp) {
+            config.auth.oauth_expires = exp.trim() === "never" ? null : exp.trim();
+            saveConfig(config);
+            printSuccess("OAuth configured.");
+            rl2.close();
+          });
+        });
+        return;
+      } else {
+        printError("Usage: /set auth api or /set auth oauth");
+      }
+      break;
+
+    case "key":
+      config.auth.api_key = val;
+      config.auth.type = "api_key";
+      saveConfig(config);
+      printSuccess("API key set: " + val.slice(0, 10) + "...");
+      break;
+
+    case "url":
+      config.api.base_url = val;
+      saveConfig(config);
+      printSuccess("API URL set: " + val);
+      break;
+
+    case "telegram":
+      printInfo("Telegram Bridge Setup:");
+      var rl3 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl3.question("  Bot Token: ", function(token) {
+        config.telegram.bot_token = token.trim();
+        rl3.question("  Chat ID: ", function(chatId) {
+          config.telegram.chat_id = chatId.trim();
+          config.telegram.enabled = true;
+          saveConfig(config);
+          printSuccess("Telegram bridge configured.");
+          rl3.close();
+        });
+      });
+      return;
+
+    case "verbose":
+      config.verbose = !config.verbose;
+      saveConfig(config);
+      printSuccess("Verbose logging: " + (config.verbose ? "ON" : "OFF"));
+      break;
+
+    case "workdir":
+      if (fs.existsSync(val)) {
+        config.workdir = path.resolve(val);
+        saveConfig(config);
+        printSuccess("Workdir: " + config.workdir);
+      } else { printError("Directory not found: " + val); }
+      break;
+
+    default:
+      printError("Unknown setting. Use /settings to see all options.");
+  }
+}
+
+async function cmdStatus() {
+  try {
+    process.stdout.write(C.dim + "checking..." + C.reset);
+    var resp = await apiCall("GET", "/runtime/status");
+    process.stdout.write("\r" + " ".repeat(20) + "\r");
+    if (resp.status === 200) {
+      var d = resp.data;
+      console.log("");
+      console.log(C.bold + "BLUN King Runtime Status:" + C.reset);
+      console.log(C.dim + "─".repeat(40) + C.reset);
+      console.log("  Status:    " + C.green + d.status + C.reset);
+      console.log("  Model:     " + d.model);
+      console.log("  Ollama:    " + (d.ollama === "connected" ? C.green : C.red) + d.ollama + C.reset);
+      console.log("  Uptime:    " + d.uptime_seconds + "s");
+      console.log("  Artifacts: " + d.artifacts_count);
+      console.log("  Models:    " + (d.available_models || []).join(", "));
+      if (d.prompt_registry && d.prompt_registry.layers) {
+        console.log("");
+        console.log(C.bold + "  Prompt Registry:" + C.reset);
+        d.prompt_registry.layers.forEach(function(l) { console.log("    " + l); });
+      }
+      console.log("");
+    } else { printError(resp.data.error || "Status failed"); }
+  } catch(e) {
+    process.stdout.write("\r" + " ".repeat(20) + "\r");
+    printError(e.message);
+  }
+}
+
+async function cmdVersions() {
+  try {
+    var resp = await apiCall("GET", "/versions");
+    if (resp.status === 200) {
+      console.log("");
+      console.log(C.bold + "Prompt Versions:" + C.reset);
+      if (resp.data.versions) {
+        resp.data.versions.forEach(function(v) {
+          console.log("  " + (v.active ? C.green + "● " : C.dim + "○ ") + v.version + C.reset + " " + v.file);
+        });
+      }
+      console.log("");
+    } else { printError(resp.data.error || "Versions failed"); }
+  } catch(e) { printError(e.message); }
+}
+
+async function cmdHealth() {
+  try {
+    var resp = await apiCall("GET", "/health");
+    if (resp.status === 200) {
+      printSuccess("API healthy — " + resp.data.model + " | uptime: " + Math.round(resp.data.uptime) + "s");
+    } else { printError("API unhealthy: " + resp.status); }
+  } catch(e) { printError("API unreachable: " + e.message); }
+}
+
+function cmdWatchdog(args) {
+  if (args === "on") {
+    config.watchdog.enabled = true;
+    saveConfig(config);
+    printSuccess("Watchdog enabled (interval: " + config.watchdog.interval + "s)");
+  } else if (args === "off") {
+    config.watchdog.enabled = false;
+    saveConfig(config);
+    printSuccess("Watchdog disabled.");
+  } else {
+    console.log("");
+    console.log(C.bold + "Watchdog:" + C.reset);
+    console.log("  Status:   " + (config.watchdog.enabled ? C.green + "ON" : C.red + "OFF") + C.reset);
+    console.log("  Interval: " + config.watchdog.interval + "s");
+    console.log("");
+    console.log(C.dim + "  /watchdog on — Enable" + C.reset);
+    console.log(C.dim + "  /watchdog off — Disable" + C.reset);
+    console.log("");
+  }
+}
+
+function cmdMemory(args) {
+  if (!args) {
+    // List memory
+    var files = fs.existsSync(MEMORY_DIR) ? fs.readdirSync(MEMORY_DIR) : [];
+    console.log("");
+    console.log(C.bold + "Local Memory (" + files.length + " entries):" + C.reset);
+    files.forEach(function(f) {
+      var content = fs.readFileSync(path.join(MEMORY_DIR, f), "utf8").trim();
+      console.log("  " + C.yellow + f.replace(".txt", "") + C.reset + " — " + content.slice(0, 60));
+    });
+    if (files.length === 0) console.log(C.dim + "  (empty)" + C.reset);
+    console.log("");
+  } else {
+    var parts = args.split(/\s+/);
+    if (parts[0] === "save" && parts.length >= 3) {
+      var key = parts[1];
+      var value = parts.slice(2).join(" ");
+      fs.writeFileSync(path.join(MEMORY_DIR, key + ".txt"), value);
+      printSuccess("Saved: " + key);
+    } else if (parts[0] === "del" && parts[1]) {
+      var file = path.join(MEMORY_DIR, parts[1] + ".txt");
+      if (fs.existsSync(file)) { fs.unlinkSync(file); printSuccess("Deleted: " + parts[1]); }
+      else { printError("Not found: " + parts[1]); }
+    } else {
+      printError("Usage: /memory save <key> <value> or /memory del <key>");
+    }
+  }
+}
+
+function cmdFiles() {
+  try {
+    var files = fs.readdirSync(config.workdir).slice(0, 30);
+    console.log("");
+    console.log(C.bold + "Workdir: " + config.workdir + C.reset);
+    files.forEach(function(f) {
+      var stat = fs.statSync(path.join(config.workdir, f));
+      console.log("  " + (stat.isDirectory() ? C.blue + "📁 " : "📄 ") + f + C.reset +
+        (stat.isFile() ? C.dim + " (" + stat.size + " bytes)" + C.reset : ""));
+    });
+    console.log("");
+  } catch(e) { printError(e.message); }
+}
+
+// ── Main Loop ──
+async function main() {
+  // Handle CLI args
+  var cliArgs = process.argv.slice(2);
+  if (cliArgs.length > 0) {
+    // Non-interactive mode
+    if (cliArgs[0] === "setup") {
+      printInfo("BLUN King CLI Setup");
+      var rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question("API Base URL [" + config.api.base_url + "]: ", function(url) {
+        if (url.trim()) config.api.base_url = url.trim();
+        rl.question("API Key: ", function(key) {
+          if (key.trim()) { config.auth.api_key = key.trim(); config.auth.type = "api_key"; }
+          saveConfig(config);
+          printSuccess("Config saved to " + CONFIG_FILE);
+          rl.close();
+        });
+      });
+      return;
+    } else if (cliArgs[0] === "chat") {
+      // One-shot chat
+      var msg = cliArgs.slice(1).join(" ");
+      if (msg) {
+        var resp = await apiCall("POST", "/chat", { message: msg });
+        if (resp.status === 200) console.log(resp.data.answer);
+        else console.error("Error: " + (resp.data.error || resp.status));
+      }
+      return;
+    } else if (cliArgs[0] === "health") {
+      await cmdHealth();
+      return;
+    } else if (cliArgs[0] === "search") {
+      await cmdSearch(cliArgs.slice(1).join(" "));
+      return;
+    }
+  }
+
+  // Interactive mode
+  printHeader();
+
+  // Health check
+  try {
+    var h = await apiCall("GET", "/health");
+    if (h.status === 200) printSuccess("Connected to BLUN King API");
+    else printError("API returned " + h.status);
+  } catch(e) {
+    printError("Cannot reach API at " + config.api.base_url);
+    printInfo("Run: blun setup — to configure");
+  }
+
+  var rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: C.blue + C.bold + "blun > " + C.reset
+  });
+
+  rl.prompt();
+
+  rl.on("line", async function(line) {
+    var input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    if (input.startsWith("/")) {
+      await handleCommand(input);
+    } else {
+      await sendChat(input);
+    }
+    rl.prompt();
+  });
+
+  rl.on("close", function() {
+    console.log(C.dim + "\nBye." + C.reset);
+    process.exit(0);
+  });
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "blun-king-cli",
+  "version": "1.0.0",
+  "description": "BLUN King CLI — Premium KI Console",
+  "bin": {
+    "blun": "./bin/blun.js"
+  },
+  "keywords": ["ai", "cli", "blun", "king"],
+  "license": "MIT"
+}

package/setup.js

@@ -0,0 +1,30 @@
+// Quick setup script for BLUN King CLI
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+
+var home = os.homedir().replace(/[\/\\]\.claude-telegram-profile$/, "");
+var dir = path.join(home, ".blun");
+var configFile = path.join(dir, "config.json");
+
+console.log("Home:", home);
+console.log("Config:", configFile);
+
+// Create dirs
+[dir, path.join(dir, "memory"), path.join(dir, "skills")].forEach(function(d) {
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+});
+
+var config = {
+  auth: { type: "api_key", api_key: "blun_cdab41afb0913b367bdf05e4271864aed964b67862a7802d", oauth_token: "", oauth_expires: null },
+  api: { base_url: "http://176.9.158.30:3200", timeout: 60000 },
+  telegram: { enabled: false, bot_token: "", chat_id: "" },
+  model: "blun-king-v100",
+  workdir: home,
+  theme: "dark",
+  verbose: false,
+  watchdog: { enabled: false, interval: 600 }
+};
+
+fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+console.log("Config saved!");