blun-king-cli 3.0.7 → 4.0.0

package/bin/blun.js

@@ -581,11 +581,46 @@ var _globalEraseUI = null;
 var _globalUILines = 5; // how many lines the input box takes up
 
 // ── Chat ──
+// ── SSE Stream Request ──
+function apiStreamCall(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: "POST",
+      headers: { "Content-Type": "application/json" }
+    };
+    var authToken = config.api.key || config.auth.api_key;
+    if (authToken) options.headers["Authorization"] = "Bearer " + authToken;
+
+    var data = JSON.stringify(body);
+    options.headers["Content-Length"] = Buffer.byteLength(data);
+
+    var mod = isHttps ? https : http;
+    var req = mod.request(options, function(res) {
+      if (res.statusCode !== 200) {
+        var chunks = [];
+        res.on("data", function(c) { chunks.push(c); });
+        res.on("end", function() {
+          try { reject(new Error(JSON.parse(Buffer.concat(chunks).toString()).error || "API Error " + res.statusCode)); }
+          catch(e) { reject(new Error("API Error " + res.statusCode)); }
+        });
+        return;
+      }
+      resolve(res);
+    });
+    req.on("error", function(e) { reject(e); });
+    req.write(data);
+    req.end();
+  });
+}
+
 async function sendChat(message) {
   try {
     printUserMessage(message);
 
-    // Show thinking status on a single line (no input box during thinking — simpler, more reliable)
+    // Show thinking animation
     var dots = 0;
     var thinkFrames = ["thinking", "thinking.", "thinking..", "thinking..."];
     console.log("");
@@ -594,36 +629,170 @@ async function sendChat(message) {
       dots++;
     }, 300);
 
-    var resp = await apiCall("POST", "/chat", {
-      message: message,
-      history: chatHistory.slice(-10)
-    });
+    // Try streaming first, fall back to non-streaming
+    var useStreaming = true;
+    var fullAnswer = "";
+    var receivedFiles = [];
+    var meta = "";
+    var headerPrinted = false;
 
-    clearInterval(thinkTimer);
-    process.stdout.write("\r\x1b[2K");
+    try {
+      var stream = await apiStreamCall("/chat/stream", {
+        message: message,
+        workdir: config.workdir,
+        history: chatHistory.slice(-10)
+      });
 
-    if (resp.status !== 200) {
-      printError(resp.data.error || "API Error " + resp.status);
-      return;
+      clearInterval(thinkTimer);
+      process.stdout.write("\r\x1b[2K");
+
+      var buffer = "";
+      var tokenBuffer = "";
+      var flushTimer = null;
+
+      await new Promise(function(resolve, reject) {
+        stream.on("data", function(chunk) {
+          buffer += chunk.toString();
+          var lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+
+          for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (line.startsWith("event: ")) {
+              var eventType = line.slice(7);
+              // Next line should be data:
+              i++;
+              if (i < lines.length && lines[i].trim().startsWith("data: ")) {
+                var dataStr = lines[i].trim().slice(6);
+                try {
+                  var eventData = JSON.parse(dataStr);
+                  handleSSEEvent(eventType, eventData);
+                } catch(e) {}
+              }
+            }
+          }
+        });
+
+        stream.on("end", function() {
+          // Flush remaining token buffer
+          if (tokenBuffer.length > 0) {
+            process.stdout.write(tokenBuffer);
+            tokenBuffer = "";
+          }
+          resolve();
+        });
+
+        stream.on("error", function(e) { reject(e); });
+
+        function handleSSEEvent(type, data) {
+          switch(type) {
+            case "meta":
+              // Print header
+              if (!headerPrinted) {
+                console.log("");
+                console.log(C.green + C.bold + "  " + BOX.bot + " BLUN King" + C.reset +
+                  C.gray + "  " + BOX.dot + " " + (data.task_type || "") + "/" + (data.role || "") + C.reset);
+                console.log(C.green + "  " + BOX.h.repeat(40) + C.reset);
+                process.stdout.write("  ");
+                headerPrinted = true;
+              }
+              break;
+
+            case "token":
+              fullAnswer += data.text;
+              // Write token directly to stdout for live streaming
+              process.stdout.write(data.text);
+              break;
+
+            case "retry":
+              process.stdout.write("\n" + C.yellow + "  ↻ retry: " + (data.reason || []).join(", ") + C.reset + "\n  ");
+              fullAnswer = "";
+              break;
+
+            case "tool":
+              process.stdout.write("\n" + C.cyan + "  ⚙ " + data.name + C.reset + "\n  ");
+              break;
+
+            case "tool_result":
+              process.stdout.write(C.dim + "  → " + (data.result || "").slice(0, 100) + C.reset + "\n  ");
+              break;
+
+            case "files":
+              receivedFiles = data.files || [];
+              break;
+
+            case "done":
+              meta = "score: " + ((data.quality || {}).score || "?") +
+                (data.status ? " " + BOX.dot + " " + data.status : "");
+              break;
+
+            case "error":
+              process.stdout.write("\n" + C.red + "  ERROR: " + data.error + C.reset + "\n");
+              break;
+          }
+        }
+      });
+
+      process.stdout.write("\n\n");
+
+    } catch(streamErr) {
+      // Fallback to non-streaming
+      useStreaming = false;
+      clearInterval(thinkTimer);
+      process.stdout.write("\r\x1b[2K");
+
+      var resp = await apiCall("POST", "/chat", {
+        message: message,
+        workdir: config.workdir,
+        history: chatHistory.slice(-10)
+      });
+
+      if (resp.status !== 200) {
+        printError(resp.data.error || "API Error " + resp.status);
+        return;
+      }
+
+      fullAnswer = resp.data.answer || "";
+      receivedFiles = resp.data.files || [];
+      var q = resp.data.quality || {};
+      meta = (resp.data.task_type || "") + "/" + (resp.data.role || "") + " " + BOX.dot + " score: " + (q.score || "?") +
+        (q.retried ? " " + BOX.dot + " retried" : "") +
+        (resp.data.status ? " " + BOX.dot + " " + resp.data.status : "");
+
+      await streamAnswer(fullAnswer, meta);
     }
 
     chatHistory.push({ role: "user", content: message });
-    chatHistory.push({ role: "assistant", content: resp.data.answer });
+    chatHistory.push({ role: "assistant", content: fullAnswer });
 
     // Token tracking
     var inTok = Math.ceil(message.length / 3.5);
-    var outTok = Math.ceil((resp.data.answer || "").length / 3.5);
+    var outTok = Math.ceil(fullAnswer.length / 3.5);
     sessionCost.requests++;
     sessionCost.inputTokensEst += inTok;
     sessionCost.outputTokensEst += outTok;
 
-    var q = resp.data.quality || {};
-    var tokInfo = C.dim + (inTok + outTok) + " tok" + C.reset;
-    var meta = resp.data.task_type + "/" + resp.data.role + " " + BOX.dot + " score: " + (q.score || "?") +
-      (q.retried ? " " + BOX.dot + " retried" : "") + " " + BOX.dot + " " + tokInfo;
+    // ── Save received files to local workdir ──
+    if (receivedFiles.length > 0) {
+      console.log(C.green + "  📁 Dateien gespeichert:" + C.reset);
+      for (var fi = 0; fi < receivedFiles.length; fi++) {
+        var f = receivedFiles[fi];
+        if (f.content && f.name) {
+          var localPath = path.join(config.workdir, f.name);
+          var localDir = path.dirname(localPath);
+          if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
+          fs.writeFileSync(localPath, f.content, "utf8");
+          console.log("    " + C.brightCyan + localPath + C.reset + C.dim + " (" + f.size + " bytes)" + C.reset);
+        }
+      }
+      console.log("");
+    }
 
-    // Streaming typewriter effect
-    await streamAnswer(resp.data.answer, meta);
+    // Show meta for streaming mode
+    if (useStreaming && meta) {
+      console.log(C.dim + "  " + meta + C.reset);
+      console.log("");
+    }
 
     // Auto Memory Dream Mode
     dreamCounter++;
@@ -1547,27 +1716,16 @@ async function cmdAgent(args) {
       var d = resp.data;
       lastAnswer = d.answer || "";
 
-      // Save files locally to workspace
+      // Save files locally to workspace — API now returns file contents
       if (d.files && d.files.length > 0) {
         for (var fi = 0; fi < d.files.length; fi++) {
           var f = d.files[fi];
-          var localPath = path.join(workdir, f.name);
-          var localDir = path.dirname(localPath);
-          if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
-          // If file has content directly, write it
-          if (f.content) {
+          if (f.content && f.name) {
+            var localPath = path.join(workdir, f.name);
+            var localDir = path.dirname(localPath);
+            if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
             fs.writeFileSync(localPath, f.content, "utf8");
             f.localPath = localPath;
-          } else if (f.download) {
-            // Download from server
-            try {
-              var dlResp = await apiCall("GET", f.download);
-              if (dlResp.status === 200) {
-                var content = typeof dlResp.data === "string" ? dlResp.data : JSON.stringify(dlResp.data, null, 2);
-                fs.writeFileSync(localPath, content, "utf8");
-                f.localPath = localPath;
-              }
-            } catch(dlErr) {}
           }
           totalFiles.push(f);
         }

package/package.json

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