@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for the coding agent.
+ */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];

package/dist/update/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Self-update: `bubble update` / `bubble upgrade`, plus a cached startup
+ * "update available" check.
+ *
+ * Bubble ships as the npm package `@bubblebrain-ai/bubble`. Updating just means
+ * re-installing it globally with whatever package manager put it there, so we
+ * detect the install method and run the matching command.
+ */
+export declare const PACKAGE_NAME = "@bubblebrain-ai/bubble";
+export declare function getCurrentVersion(): string;
+export declare function fetchLatestVersion(timeoutMs?: number): Promise<string | null>;
+/**
+ * Compare two semver-ish strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ * Handles `x.y.z` and a single pre-release tag (`x.y.z-beta.1`); a release
+ * always outranks a pre-release of the same numeric version.
+ */
+export declare function compareVersions(a: string, b: string): number;
+export type PackageManager = "npm" | "bun" | "pnpm" | "yarn" | "homebrew" | "unknown";
+export interface InstallInfo {
+    manager: PackageManager;
+    isGlobal: boolean;
+    isLocalCheckout: boolean;
+    installPath: string;
+}
+export declare function detectInstallFromPath(installPath: string): InstallInfo;
+/**
+ * Figure out how this copy of Bubble was installed by inspecting the real path
+ * of the package directory (two levels up from this module: dist/update -> pkg).
+ */
+export declare function detectInstall(): InstallInfo;
+export declare function upgradeCommandFor(manager: PackageManager): {
+    cmd: string;
+    args: string[];
+} | null;
+/**
+ * `bubble update` entry point. Returns a process exit code.
+ */
+export declare function runUpdateCommand(opts?: {
+    checkOnly?: boolean;
+}): Promise<number>;
+export interface StartupUpdateCheck {
+    /** Notice derived from the local cache — available immediately, no network. */
+    notice: string | null;
+    /**
+     * Resolves once the background registry check completes: a notice string
+     * when it finds a version newer than both the running one and the cached
+     * `notice`, otherwise null. Never rejects.
+     */
+    refreshed: Promise<string | null>;
+}
+/**
+ * Startup "update available" check. The immediate `notice` comes from the
+ * local cache file (fast, no network on the hot path). A registry refresh
+ * always runs in the background (throttled to once per 30 minutes) so a
+ * release published since the last launch surfaces in the *current* session
+ * via `refreshed`, instead of only after the cache TTL plus another restart.
+ * Never throws.
+ */
+export declare function startStartupUpdateCheck(): Promise<StartupUpdateCheck>;
+/** Cache-only variant of {@link startStartupUpdateCheck} (still refreshes in the background). */
+export declare function getStartupUpdateNotice(): Promise<string | null>;

package/dist/update/index.js

@@ -0,0 +1,267 @@
+/**
+ * Self-update: `bubble update` / `bubble upgrade`, plus a cached startup
+ * "update available" check.
+ *
+ * Bubble ships as the npm package `@bubblebrain-ai/bubble`. Updating just means
+ * re-installing it globally with whatever package manager put it there, so we
+ * detect the install method and run the matching command.
+ */
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const require = createRequire(import.meta.url);
+export const PACKAGE_NAME = "@bubblebrain-ai/bubble";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+// Throttle for the startup registry check. Short on purpose: with frequent
+// releases, a long TTL means users only learn about a new version a day late.
+const REFRESH_THROTTLE_MS = 30 * 60 * 1000;
+export function getCurrentVersion() {
+    try {
+        const pkg = require("../../package.json");
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export async function fetchLatestVersion(timeoutMs = 5000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(REGISTRY_URL, {
+                signal: controller.signal,
+                headers: { accept: "application/json" },
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            return data.version ?? null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare two semver-ish strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ * Handles `x.y.z` and a single pre-release tag (`x.y.z-beta.1`); a release
+ * always outranks a pre-release of the same numeric version.
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const cleaned = v.trim().replace(/^v/, "");
+        const [core, pre] = cleaned.split("-", 2);
+        const nums = core.split(".").map((n) => parseInt(n, 10) || 0);
+        while (nums.length < 3)
+            nums.push(0);
+        return { nums, pre: pre ?? "" };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    for (let i = 0; i < 3; i++) {
+        if (pa.nums[i] > pb.nums[i])
+            return 1;
+        if (pa.nums[i] < pb.nums[i])
+            return -1;
+    }
+    // Equal numeric core: no pre-release beats a pre-release.
+    if (pa.pre === pb.pre)
+        return 0;
+    if (!pa.pre)
+        return 1;
+    if (!pb.pre)
+        return -1;
+    return pa.pre > pb.pre ? 1 : -1;
+}
+export function detectInstallFromPath(installPath) {
+    const lower = installPath.replace(/\\/g, "/").toLowerCase();
+    const isUnderNodeModules = lower.includes("/node_modules/");
+    // A dev/source checkout has src/ alongside dist/ and isn't under node_modules.
+    const isLocalCheckout = !isUnderNodeModules;
+    let manager = "unknown";
+    // Package-manager-specific node_modules layouts take precedence over a
+    // parent directory name (for example /opt/homebrew/lib/node_modules is npm).
+    if (lower.includes("/.bun/") || lower.includes("/bun/install/")) {
+        manager = "bun";
+    }
+    else if (lower.includes("/pnpm/") || lower.includes("/.pnpm/")) {
+        manager = "pnpm";
+    }
+    else if (lower.includes("/.yarn/") || lower.includes("/yarn/global")) {
+        manager = "yarn";
+    }
+    else if (isUnderNodeModules) {
+        manager = "npm";
+    }
+    else if (lower.includes("/cellar/") || lower.includes("/homebrew/")) {
+        manager = "homebrew";
+    }
+    return { manager, isGlobal: isUnderNodeModules, isLocalCheckout, installPath };
+}
+/**
+ * Figure out how this copy of Bubble was installed by inspecting the real path
+ * of the package directory (two levels up from this module: dist/update -> pkg).
+ */
+export function detectInstall() {
+    const rawRoot = fileURLToPath(new URL("../../", import.meta.url));
+    let installPath = rawRoot;
+    try {
+        installPath = realpathSync(rawRoot);
+    }
+    catch {
+        // keep rawRoot
+    }
+    return detectInstallFromPath(installPath);
+}
+export function upgradeCommandFor(manager) {
+    const spec = `${PACKAGE_NAME}@latest`;
+    switch (manager) {
+        case "npm":
+        case "unknown": // default to npm
+            return { cmd: "npm", args: ["install", "-g", spec] };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", spec] };
+        case "pnpm":
+            return { cmd: "pnpm", args: ["add", "-g", spec] };
+        case "yarn":
+            return { cmd: "yarn", args: ["global", "add", spec] };
+        case "homebrew":
+            return null; // handled separately (brew upgrade)
+    }
+}
+function spawnInherit(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit", env: process.env });
+        child.on("error", () => resolve(127));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * `bubble update` entry point. Returns a process exit code.
+ */
+export async function runUpdateCommand(opts = {}) {
+    const current = getCurrentVersion();
+    process.stdout.write(`Bubble v${current}\n`);
+    process.stdout.write("Checking npm for the latest version…\n");
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        process.stderr.write("Could not reach the npm registry. Check your connection and try again.\n");
+        return 1;
+    }
+    if (compareVersions(latest, current) <= 0) {
+        process.stdout.write(`You're already on the latest version (v${current}).\n`);
+        return 0;
+    }
+    process.stdout.write(`Update available: v${current} → v${latest}\n`);
+    if (opts.checkOnly) {
+        process.stdout.write("Run `bubble update` to install it.\n");
+        return 0;
+    }
+    const info = detectInstall();
+    if (info.isLocalCheckout) {
+        process.stderr.write("This looks like a local/development checkout, not a global install.\n" +
+            "Update it with:\n  git pull && npm run build\n");
+        return 1;
+    }
+    if (info.manager === "homebrew") {
+        process.stderr.write("Bubble was installed via Homebrew. Update it with:\n  brew upgrade bubble\n");
+        return 1;
+    }
+    const command = upgradeCommandFor(info.manager);
+    if (!command) {
+        process.stderr.write(`Couldn't determine how to update automatically. Run:\n  npm install -g ${PACKAGE_NAME}@latest\n`);
+        return 1;
+    }
+    process.stdout.write(`\nUpdating via ${command.cmd}…\n\n`);
+    const code = await spawnInherit(command.cmd, command.args);
+    if (code === 0) {
+        process.stdout.write(`\n✓ Updated to v${latest}. Restart bubble to use the new version.\n`);
+        return 0;
+    }
+    process.stderr.write(`\nUpdate failed (exit ${code}). Try running it manually:\n  ${command.cmd} ${command.args.join(" ")}\n` +
+        "If this is a permissions error, you may need elevated privileges or to fix your global install prefix.\n");
+    return code;
+}
+function cacheFile() {
+    return join(getBubbleHome(), "update-check.json");
+}
+async function readCache() {
+    try {
+        const raw = await readFile(cacheFile(), "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data.lastCheck === "number" && typeof data.latest === "string") {
+            return { lastCheck: data.lastCheck, latest: data.latest };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cache) {
+    try {
+        const file = cacheFile();
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(cache), "utf8");
+    }
+    catch {
+        // best-effort; never fail startup over a cache write
+    }
+}
+function formatUpdateNotice(current, latest) {
+    return `Update available: v${current} → v${latest} · run \`bubble update\``;
+}
+/**
+ * Startup "update available" check. The immediate `notice` comes from the
+ * local cache file (fast, no network on the hot path). A registry refresh
+ * always runs in the background (throttled to once per 30 minutes) so a
+ * release published since the last launch surfaces in the *current* session
+ * via `refreshed`, instead of only after the cache TTL plus another restart.
+ * Never throws.
+ */
+export async function startStartupUpdateCheck() {
+    try {
+        const current = getCurrentVersion();
+        const now = Date.now();
+        const cache = await readCache();
+        const notice = cache && compareVersions(cache.latest, current) > 0
+            ? formatUpdateNotice(current, cache.latest)
+            : null;
+        const refreshed = (async () => {
+            try {
+                if (cache && now - cache.lastCheck < REFRESH_THROTTLE_MS)
+                    return null;
+                const latest = await fetchLatestVersion(4000);
+                if (!latest)
+                    return null;
+                await writeCache({ lastCheck: now, latest });
+                if (compareVersions(latest, current) <= 0)
+                    return null;
+                // The cache already surfaced this version in `notice` — stay quiet.
+                if (notice && cache && compareVersions(latest, cache.latest) <= 0)
+                    return null;
+                return formatUpdateNotice(current, latest);
+            }
+            catch {
+                return null;
+            }
+        })();
+        return { notice, refreshed };
+    }
+    catch {
+        return { notice: null, refreshed: Promise.resolve(null) };
+    }
+}
+/** Cache-only variant of {@link startStartupUpdateCheck} (still refreshes in the background). */
+export async function getStartupUpdateNotice() {
+    const check = await startStartupUpdateCheck();
+    return check.notice;
+}

package/dist/variant/thinking-level.d.ts

@@ -0,0 +1,5 @@
+import { type ThinkingLevel } from "../types.js";
+export { THINKING_LEVELS } from "../types.js";
+export declare function isThinkingLevel(value: string | undefined): value is ThinkingLevel;
+export declare function clampThinkingLevel(requestedLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;
+export declare function getNextThinkingLevel(currentLevel: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;

package/dist/variant/thinking-level.js

@@ -0,0 +1,26 @@
+import { THINKING_LEVELS } from "../types.js";
+export { THINKING_LEVELS } from "../types.js";
+export function isThinkingLevel(value) {
+    return !!value && THINKING_LEVELS.includes(value);
+}
+export function clampThinkingLevel(requestedLevel, supportedLevels) {
+    if (supportedLevels.length === 0) {
+        return "off";
+    }
+    if (supportedLevels.includes(requestedLevel)) {
+        return requestedLevel;
+    }
+    const requestedIndex = THINKING_LEVELS.indexOf(requestedLevel);
+    for (let index = requestedIndex; index >= 0; index--) {
+        const candidate = THINKING_LEVELS[index];
+        if (supportedLevels.includes(candidate)) {
+            return candidate;
+        }
+    }
+    return supportedLevels[0];
+}
+export function getNextThinkingLevel(currentLevel, supportedLevels) {
+    const normalizedCurrent = clampThinkingLevel(currentLevel, supportedLevels);
+    const currentIndex = supportedLevels.indexOf(normalizedCurrent);
+    return supportedLevels[(currentIndex + 1) % supportedLevels.length];
+}

package/dist/variant/variant-resolver.d.ts

@@ -0,0 +1,28 @@
+import type { ThinkingLevel } from "../types.js";
+export declare function getAvailableThinkingLevels(providerId: string, modelId: string): ThinkingLevel[];
+export declare function getDefaultThinkingLevel(providerId: string, modelId: string): ThinkingLevel;
+/**
+ * A lone "medium" means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade. Any other
+ * lone level (e.g. DashScope's max-only Kimi K3) is a real fixed grade that
+ * the provider sends verbatim, so it is shown.
+ */
+export declare function isThinkingOnlyLevels(levels: readonly ThinkingLevel[]): boolean;
+export declare function isThinkingOnlyModel(providerId?: string, modelId?: string): boolean;
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export declare function isThinkingToggleModel(providerId?: string, modelId?: string): boolean;
+export declare function normalizeThinkingLevel(level: ThinkingLevel, supportedLevels: readonly ThinkingLevel[]): ThinkingLevel;
+/**
+ * Normalizes effort inherited from a previous model or restored session.
+ *
+ * Unlike an explicit CLI/config choice, an inherited unsupported value does
+ * not express a direction the user just chose for the target model. Prefer the
+ * target model's declared default in that case, then fall back to the canonical
+ * downward clamp for legacy models without an explicit default.
+ */
+export declare function normalizeInheritedThinkingLevel(providerId: string, modelId: string, inheritedLevel: ThinkingLevel): ThinkingLevel;

package/dist/variant/variant-resolver.js

@@ -0,0 +1,62 @@
+import { getBuiltinModel, getModelDefaultReasoningLevel } from "../model-catalog.js";
+import { clampThinkingLevel } from "./thinking-level.js";
+const KIMI_TOGGLE_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding", "alibaba"]);
+const KIMI_THINKING_TOGGLE_MODELS = new Set(["kimi-k2.5", "kimi-k2.6", "kimi/kimi-k2.6"]);
+export function getAvailableThinkingLevels(providerId, modelId) {
+    return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
+}
+export function getDefaultThinkingLevel(providerId, modelId) {
+    const levels = getAvailableThinkingLevels(providerId, modelId);
+    const explicitDefault = getModelDefaultReasoningLevel(providerId, modelId);
+    if (explicitDefault && levels.includes(explicitDefault))
+        return explicitDefault;
+    return levels.includes("medium") ? "medium" : levels[0] || "off";
+}
+/**
+ * A lone "medium" means the model is always in thinking mode with no
+ * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
+ * placeholder and must not be shown to the user as an effort grade. Any other
+ * lone level (e.g. DashScope's max-only Kimi K3) is a real fixed grade that
+ * the provider sends verbatim, so it is shown.
+ */
+export function isThinkingOnlyLevels(levels) {
+    return levels.length === 1 && levels[0] === "medium";
+}
+export function isThinkingOnlyModel(providerId = "", modelId = "") {
+    return isThinkingOnlyLevels(getAvailableThinkingLevels(providerId, modelId));
+}
+/**
+ * Some providers expose thinking as a true enabled/disabled switch. We may store
+ * the enabled state as "medium" internally for compatibility with ThinkingLevel,
+ * but it is not a real user-facing effort grade.
+ */
+export function isThinkingToggleModel(providerId = "", modelId = "") {
+    const normalizedProvider = providerId.toLowerCase();
+    const normalizedModel = modelId.toLowerCase();
+    if (normalizedProvider === "mimo-token-plan")
+        return true;
+    if (normalizedProvider.includes("minimax") || normalizedModel.includes("minimax"))
+        return true;
+    return KIMI_TOGGLE_PROVIDER_IDS.has(normalizedProvider)
+        && KIMI_THINKING_TOGGLE_MODELS.has(normalizedModel);
+}
+export function normalizeThinkingLevel(level, supportedLevels) {
+    return clampThinkingLevel(level, supportedLevels);
+}
+/**
+ * Normalizes effort inherited from a previous model or restored session.
+ *
+ * Unlike an explicit CLI/config choice, an inherited unsupported value does
+ * not express a direction the user just chose for the target model. Prefer the
+ * target model's declared default in that case, then fall back to the canonical
+ * downward clamp for legacy models without an explicit default.
+ */
+export function normalizeInheritedThinkingLevel(providerId, modelId, inheritedLevel) {
+    const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
+    if (supportedLevels.includes(inheritedLevel))
+        return inheritedLevel;
+    const modelDefault = getModelDefaultReasoningLevel(providerId, modelId);
+    if (modelDefault && supportedLevels.includes(modelDefault))
+        return modelDefault;
+    return clampThinkingLevel(inheritedLevel, supportedLevels);
+}

package/node_modules/@bubblebrain-ai/pi-tui/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.