@rubixkube/rubix 0.0.6 → 0.0.7

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com),
 and this project adheres to [Semantic Versioning](https://semver.org).
 
+## [0.0.7] - 2025-03-18
+
+### Added
+
+- Bugfixes and performance improvements
+- Introducing Sarvam 105B support
+
 ## [0.0.6] - 2025-03-08
 
 ### Added

package/dist/core/device-auth.js

@@ -130,24 +130,51 @@ async function getUserProfile(idToken) {
     }
     return (await response.json());
 }
-function openUrlInBrowser(url) {
+/** Detect headless environment (SSH, CI, no display server) */
+export function isHeadlessEnvironment() {
+    if (process.env.CI === "true" || process.env.CI === "1")
+        return true;
+    if (process.platform === "linux") {
+        if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)
+            return true;
+    }
+    return false;
+}
+/**
+ * Open URL in browser. No-op in headless environments.
+ * Handles spawn errors (e.g. ENOENT for missing xdg-open) without crashing.
+ */
+export function openUrlSafely(url) {
     const urlStr = String(url).trim();
     if (!urlStr.startsWith("http://") && !urlStr.startsWith("https://"))
         return;
+    if (isHeadlessEnvironment())
+        return;
+    let proc;
     if (process.platform === "darwin") {
-        spawn("open", [urlStr], { stdio: "ignore" });
+        proc = spawn("open", [urlStr], { stdio: "ignore" });
     }
     else if (process.platform === "win32") {
-        spawn("cmd", ["/c", "start", "", urlStr], { stdio: "ignore" });
+        proc = spawn("cmd", ["/c", "start", "", urlStr], { stdio: "ignore" });
     }
     else {
-        spawn("xdg-open", [urlStr], { stdio: "ignore" });
+        proc = spawn("xdg-open", [urlStr], { stdio: "ignore" });
     }
+    proc.on("error", () => {
+        /* Swallow ENOENT and other spawn errors to avoid process crash */
+    });
 }
 export async function authenticateWithDeviceFlow(log) {
     const start = await startDeviceAuth();
-    openUrlInBrowser(start.verificationUrl);
-    log?.(`Opening ${start.verificationUrl} in browser`);
+    const headless = isHeadlessEnvironment();
+    openUrlSafely(start.verificationUrl);
+    if (headless) {
+        log?.("No display detected (SSH/headless). Open this URL in a browser on another device:");
+        log?.(start.verificationUrl);
+    }
+    else {
+        log?.(`Opening ${start.verificationUrl} in browser`);
+    }
     log?.(`Enter code: ${start.userCode}`);
     const tokens = await pollForTokens(start, log);
     const validation = await validateAuth0Token(tokens.id_token);

package/dist/core/rubix-api.js

@@ -134,21 +134,26 @@ function mergeChunks(existing, add) {
         return add; // cumulative resend
     if (existing.startsWith(add))
         return existing; // duplicate smaller resend
-    if (add.includes(existing))
-        return add; // cumulative with prefix text
-    if (existing.includes(add))
-        return existing; // already included
-    // Find maximal overlap where existing ends with the prefix of add
-    // Matches console/opel handling: no guard that could drop partial chunks
-    const maxK = Math.min(existing.length, add.length);
+    // Never use includes() — e.g. "I'" matches inside "I'm", "|" matches in markdown; would silently eat content.
+    // Find maximal overlap where existing ends with the prefix of add.
+    // Use trimEnd when checking so "Investigate " + "igate..." merges correctly
+    // (trailing space would otherwise block suffix overlap).
+    const existingTrimmed = existing.replace(/\s+$/, "");
+    const maxK = Math.min(existingTrimmed.length, add.length);
     for (let k = maxK; k > 0; k -= 1) {
-        if (existing.endsWith(add.slice(0, k))) {
+        if (existingTrimmed.endsWith(add.slice(0, k))) {
             const newPart = add.slice(k);
-            return newPart ? existing + newPart : existing;
+            if (!newPart)
+                return existing;
+            return existingTrimmed + newPart;
         }
     }
     return existing + add;
 }
+/** Exported for thought accumulation in UI (overlap-aware merge). */
+export function mergeTextChunks(existing, add) {
+    return mergeChunks(existing, add);
+}
 function asText(value) {
     if (typeof value === "string")
         return value;
@@ -510,21 +515,27 @@ export async function fetchChatHistory(auth, sessionId, pageSize = 20, appName =
         }
         const turn = turns.get(invId);
         const parts = parseParts(event.content);
+        let thoughtBuffer = ""; // Accumulate consecutive thought parts (raw concat) for token-based storage
         for (const part of parts) {
-            // Thought
-            if (part.thought === true) {
-                if (typeof part.text === "string" && part.text.trim()) {
-                    const wev = {
-                        id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
-                        type: "thought",
-                        content: part.text.trim(),
-                        ts,
-                    };
-                    turn.workflow.push(wev);
-                    pushWorkflowSegment(turn.segments, wev);
-                }
+            const partText = typeof part.text === "string" ? part.text : "";
+            const isThoughtPart = part.thought === true || part.type === "thought";
+            // Thought: accumulate consecutive parts into one entry (LiteLLM stores 100 tokens = 100 parts)
+            if (isThoughtPart) {
+                thoughtBuffer += partText;
                 continue;
             }
+            // Flush accumulated thoughts before processing non-thought part
+            if (thoughtBuffer.length > 0) {
+                const wev = {
+                    id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
+                    type: "thought",
+                    content: thoughtBuffer,
+                    ts,
+                };
+                turn.workflow.push(wev);
+                pushWorkflowSegment(turn.segments, wev);
+                thoughtBuffer = "";
+            }
             // Tool call
             const fc = part.functionCall ?? part.function_call;
             if (fc) {
@@ -555,8 +566,9 @@ export async function fetchChatHistory(auth, sessionId, pageSize = 20, appName =
                 pushWorkflowSegment(turn.segments, wev);
                 continue;
             }
-            // Plain text — user bubble if author === "user", otherwise assistant bubble
-            if (typeof part.text === "string" && part.text.trim()) {
+            // Plain text — user bubble if author === "user", otherwise assistant bubble.
+            // Skip whitespace-only parts (separators in stored data).
+            if (typeof part.text === "string" && part.text.trim().length > 0) {
                 if (event.author === "user") {
                     turn.userText = turn.userText ? `${turn.userText}\n${part.text}` : part.text;
                 }
@@ -567,6 +579,17 @@ export async function fetchChatHistory(auth, sessionId, pageSize = 20, appName =
                 }
             }
         }
+        // Flush any remaining thought buffer after last part
+        if (thoughtBuffer.length > 0) {
+            const wev = {
+                id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
+                type: "thought",
+                content: thoughtBuffer,
+                ts,
+            };
+            turn.workflow.push(wev);
+            pushWorkflowSegment(turn.segments, wev);
+        }
     }
     const messages = [];
     for (const invId of turnOrder) {
@@ -672,13 +695,17 @@ export async function streamChat(input, callbacks = {}) {
         }
         const parts = event.content?.parts ?? [];
         const isThoughtType = normalizedEventType === "thought" || normalizedEventType === "thoughts";
-        // Accumulate all visible text from this event (console pattern: batch per event)
+        // Accumulate all visible text from this event (console pattern: batch per event).
+        // Use mergeChunks per part to avoid duplicates when backend sends overlapping parts.
         let visibleChunk = "";
         for (const part of parts) {
             const partText = typeof part.text === "string" ? part.text : "";
-            if ((part.thought === true || isThoughtType) && partText.trim()) {
+            // Thought: check both part.thought and part.type for safety (LiteLLM vs Gemini).
+            // Pass raw tokens — do not trim; BPE tokens carry their own whitespace.
+            const isThoughtPart = part.thought === true || part.type === "thought" || isThoughtType;
+            if (isThoughtPart && partText.length > 0) {
                 hasWorkflowEvents = true;
-                callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", partText.trim(), {
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", partText, {
                     partial: event.partial === true,
                 }));
                 continue;
@@ -708,9 +735,11 @@ export async function streamChat(input, callbacks = {}) {
                 }));
                 continue;
             }
-            // Visible text (non-thought): accumulate for batch merge
-            if (partText && part.thought !== true) {
-                visibleChunk += partText;
+            // Visible text (non-thought): accumulate with overlap detection.
+            // Skip whitespace-only parts (e.g. {text: "\n"}) used as separators in stored data.
+            const isVisibleText = part.thought !== true && part.type !== "thought";
+            if (isVisibleText && partText.trim().length > 0) {
+                visibleChunk = mergeChunks(visibleChunk, partText);
             }
         }
         // Merge accumulated visible text once per event (handles partial/cumulative chunks)

package/dist/ui/App.js

@@ -2,19 +2,19 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { exec, execSync, spawn } from "child_process";
+import { exec, execSync } from "child_process";
 import { Box, Text, useApp, useInput } from "ink";
 import { Select, Spinner, StatusMessage } from "@inkjs/ui";
 import { addWorkflowEvent, mergeOlderSegments, replaceLastThought, updateStreamingText } from "../core/segments.js";
 import { clearAuthConfig, loadAuthConfig, saveAuthConfig } from "../core/auth-store.js";
-import { authenticateWithDeviceFlow, isTokenNearExpiry } from "../core/device-auth.js";
+import { authenticateWithDeviceFlow, isTokenNearExpiry, openUrlSafely } from "../core/device-auth.js";
 import { isFolderTrusted, trustFolder, untrustFolder } from "../core/trust-store.js";
 import { clearLocalSessions, saveLocalSessions } from "../core/session-store.js";
 import { loadSettings, saveSettings } from "../core/settings.js";
 import { loadWhatsNew } from "../core/whats-new.js";
 import { checkForUpdate } from "../core/update-check.js";
 import { VERSION } from "../version.js";
-import { createSession, fetchChatHistory, fetchSystemStats, firstHealthyEnvironment, getOrCreateSession, listEnvironments, listModels, listSessions, listApps, refreshAndUpdateAuth, streamChat, StreamError, updateSessionState, } from "../core/rubix-api.js";
+import { createSession, fetchChatHistory, fetchSystemStats, firstHealthyEnvironment, getOrCreateSession, listEnvironments, listModels, listSessions, listApps, refreshAndUpdateAuth, streamChat, StreamError, mergeTextChunks, updateSessionState, } from "../core/rubix-api.js";
 import { readFileContext, fetchUrlContext, formatContextBlock, } from "../core/file-context.js";
 import { AnimatedGlyph } from "./components/AnimatedGlyph.js";
 import { ChatTranscript } from "./components/ChatTranscript.js";
@@ -1019,29 +1019,13 @@ export function App({ initialSessionId, seedPrompt }) {
         switch (command) {
             case "/console": {
                 const url = "https://console.rubixkube.ai";
-                if (process.platform === "darwin") {
-                    spawn("open", [url], { stdio: "ignore" });
-                }
-                else if (process.platform === "win32") {
-                    spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
-                }
-                else {
-                    spawn("xdg-open", [url], { stdio: "ignore" });
-                }
+                openUrlSafely(url);
                 addSystemMessage("Opening https://console.rubixkube.ai in your browser.");
                 return;
             }
             case "/docs": {
                 const url = "https://docs.rubixkube.ai";
-                if (process.platform === "darwin") {
-                    spawn("open", [url], { stdio: "ignore" });
-                }
-                else if (process.platform === "win32") {
-                    spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
-                }
-                else {
-                    spawn("xdg-open", [url], { stdio: "ignore" });
-                }
+                openUrlSafely(url);
                 addSystemMessage("Opening https://docs.rubixkube.ai in your browser.");
                 return;
             }
@@ -1412,20 +1396,31 @@ export function App({ initialSessionId, seedPrompt }) {
                     pendingWorkflowEvents.events.push((message) => {
                         const existing = [...(message.workflow ?? [])];
                         const last = existing[existing.length - 1];
-                        const incomingTrim = event.content.trim();
-                        // Exact duplicate — skip
-                        if (last && last.type === event.type && (last.content ?? "").trim() === incomingTrim) {
+                        const incoming = event.content ?? "";
+                        const previous = last?.content ?? "";
+                        // Exact duplicate — skip (use raw match; works for both Gemini & token streams)
+                        if (last && last.type === event.type && previous === incoming) {
                             return message;
                         }
-                        // Streaming thought update: extend rather than duplicate
+                        // Streaming thought update: extend rather than duplicate.
+                        // Merge token fragments (isPartial) but NOT when incoming clearly starts a new thought.
+                        // New-thought heuristic: trimmed incoming starts with capital and previous is substantial.
                         if (event.type === "thought" && last?.type === "thought") {
-                            const incoming = event.content.trim();
-                            const previous = last.content.trim();
+                            const inTrim = incoming.trim();
+                            const prevTrim = previous.trim();
                             const isPartial = event.details?.partial === true;
-                            if (incoming.length > 0 && (isPartial || incoming.startsWith(previous) || previous.startsWith(incoming))) {
+                            const looksLikeNewThought = inTrim.length > 0 &&
+                                /^[A-Z]/.test(inTrim) &&
+                                prevTrim.length > 20;
+                            const isContinuation = inTrim.length > 0 &&
+                                (inTrim.startsWith(prevTrim) ||
+                                    prevTrim.startsWith(inTrim) ||
+                                    (isPartial && !looksLikeNewThought));
+                            if (isContinuation) {
+                                const mergedContent = mergeTextChunks(previous, incoming);
                                 const merged = {
                                     ...last,
-                                    content: incoming.length >= previous.length ? incoming : previous,
+                                    content: mergedContent,
                                     ts: event.ts,
                                     details: { ...(last.details ?? {}), ...(event.details ?? {}) },
                                 };
@@ -1437,7 +1432,7 @@ export function App({ initialSessionId, seedPrompt }) {
                                     isAccumulating: true,
                                 };
                             }
-                            if (incoming === previous)
+                            if (previous === incoming)
                                 return message;
                         }
                         existing.push(event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubixkube/rubix",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Chat with your infrastructure from the terminal. RubixKube CLI for Site Reliability Intelligence—predict, prevent, and fix failures with AI.",
   "type": "module",
   "bin": {