@bubblebrain-ai/bubble 0.0.10 → 0.0.12

package/dist/session.js

@@ -1,11 +1,14 @@
 /**
  * Session Manager - Append-only JSONL persistence over a structured session log.
  */
-import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { getBubbleHome } from "./bubble-home.js";
 import { compactSessionEntries } from "./context/compact.js";
 import { SessionLog } from "./session-log.js";
+import { normalizeSingleLine, truncateVisual } from "./text-display.js";
+import { deterministicTitleFromUserContent } from "./session-title.js";
 const AUTO_COMPACT_ENTRY_THRESHOLD = 180;
 const AUTO_COMPACT_KEEP_RECENT_TURNS = 3;
 export class SessionManager {
@@ -42,6 +45,44 @@ export class SessionManager {
             return [];
         return readdirSync(sessionsDir).filter((file) => file.endsWith(".jsonl"));
     }
+    static summarizeSessionsForCwd(cwd) {
+        const dir = getSessionsDir(cwd);
+        if (!existsSync(dir))
+            return [];
+        const summaries = [];
+        for (const file of readdirSync(dir)) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            const summary = summarizeSessionFile(join(dir, file), basename(dir));
+            if (summary)
+                summaries.push(summary);
+        }
+        return summaries.sort((a, b) => b.mtime - a.mtime);
+    }
+    static listAllSessions() {
+        const root = join(getBubbleHome(), "sessions");
+        if (!existsSync(root))
+            return [];
+        const summaries = [];
+        for (const cwdDir of readdirSync(root)) {
+            const dir = join(root, cwdDir);
+            try {
+                if (!statSync(dir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            for (const file of readdirSync(dir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const summary = summarizeSessionFile(join(dir, file), cwdDir);
+                if (summary)
+                    summaries.push(summary);
+            }
+        }
+        return summaries.sort((a, b) => b.mtime - a.mtime);
+    }
     load() {
         const content = readFileSync(this.sessionFile, "utf-8");
         const lines = content.split("\n").filter((line) => line.trim() !== "");
@@ -69,10 +110,28 @@ export class SessionManager {
     getMetadata() {
         return this.log.getMetadata();
     }
+    getOrCreatePromptCacheKey() {
+        const existing = this.log.getMetadata().promptCacheKey;
+        if (existing)
+            return existing;
+        const promptCacheKey = randomUUID();
+        this.updateMetadata({ promptCacheKey });
+        return promptCacheKey;
+    }
     setMetadata(metadata) {
         const nextEntries = this.log.setMetadata(metadata);
         this.rewrite(nextEntries);
     }
+    updateMetadata(patch) {
+        this.setMetadata({
+            ...this.log.getMetadata(),
+            ...dropUndefined(patch),
+        });
+    }
+    clearTitleMetadata() {
+        const { title: _title, titleSource: _titleSource, titleUpdatedAt: _titleUpdatedAt, titleUserMessageId: _titleUserMessageId, ...metadata } = this.log.getMetadata();
+        this.setMetadata(metadata);
+    }
     appendMessage(message) {
         const entries = this.log.appendMessage(message);
         this.persist(entries);
@@ -133,3 +192,96 @@ export function getSessionsDir(cwd) {
 function resolveSessionFile(cwd, sessionName) {
     return join(getSessionsDir(cwd), sessionName);
 }
+function summarizeSessionFile(file, cwdDir) {
+    let stat;
+    try {
+        stat = statSync(file);
+    }
+    catch {
+        return undefined;
+    }
+    let content;
+    try {
+        content = readFileSync(file, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+    const lines = content.split("\n").filter((line) => line.trim() !== "");
+    if (lines.length === 0)
+        return undefined;
+    const log = new SessionLog();
+    log.load(lines);
+    const metadata = log.getMetadata();
+    const entries = log.list();
+    const messages = log.toMessages();
+    const firstUserEntry = firstUserEntryAfterLatestClear(entries);
+    const firstUserText = firstUserEntry ? messageText(firstUserEntry.message) : "";
+    const preview = firstUserText
+        ? sessionPreviewFromText(firstUserText)
+        : (messages.length > 0 ? "No user message" : "No messages");
+    const title = usableStoredTitle(metadata, entries)
+        ?? (firstUserEntry ? deterministicTitleFromUserContent(firstUserEntry.message.content) : (messages.length > 0 ? "Assistant-only session" : "Empty session"));
+    return {
+        file,
+        name: basename(file).replace(/\.jsonl$/, ""),
+        cwd: metadata.cwd,
+        cwdLabel: metadata.cwd ?? decodeCwdDir(cwdDir),
+        title,
+        preview,
+        firstUserMessage: preview,
+        messageCount: messages.length,
+        mtime: stat.mtimeMs,
+    };
+}
+function decodeCwdDir(safe) {
+    // safeCwd is cwd.replace(/[/\\:]/g, "_") — not perfectly reversible because we
+    // can't tell underscores apart from path separators. For typical absolute
+    // Unix paths this still produces a readable approximation.
+    if (safe.startsWith("_"))
+        return "/" + safe.slice(1).replace(/_/g, "/");
+    return safe.replace(/_/g, "/");
+}
+function dropUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function firstUserEntryAfterLatestClear(entries) {
+    const startIndex = latestClearIndex(entries) + 1;
+    for (let i = startIndex; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.type === "user_message")
+            return entry;
+    }
+    return undefined;
+}
+function latestClearIndex(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "marker" && entry.kind === "conversation_clear")
+            return i;
+    }
+    return -1;
+}
+function usableStoredTitle(metadata, entries) {
+    const title = normalizeSingleLine(metadata.title ?? "");
+    if (!title)
+        return undefined;
+    if (!metadata.titleUserMessageId)
+        return title;
+    const anchorIndex = entries.findIndex((entry) => entry.id === metadata.titleUserMessageId);
+    if (anchorIndex < 0)
+        return undefined;
+    if (anchorIndex <= latestClearIndex(entries))
+        return undefined;
+    return title;
+}
+function messageText(message) {
+    if (message.role !== "user")
+        return "";
+    if (typeof message.content === "string")
+        return message.content;
+    return message.content.map((part) => part.type === "text" ? part.text : "").join("\n");
+}
+function sessionPreviewFromText(text) {
+    return truncateVisual(normalizeSingleLine(text), 100) || "No user message";
+}

package/dist/skills/invocation.js

@@ -5,24 +5,6 @@ export function parseSkillInvocation(input, registry) {
     const withoutSlash = trimmed.slice(1).trim();
     if (!withoutSlash)
         return undefined;
-    if (withoutSlash.startsWith("skill ")) {
-        const rest = withoutSlash.slice("skill ".length).trim();
-        const firstSpace = rest.indexOf(" ");
-        if (firstSpace === -1)
-            return undefined;
-        const skillName = rest.slice(0, firstSpace).trim();
-        const task = rest.slice(firstSpace + 1).trim();
-        if (!skillName || !task)
-            return undefined;
-        const skill = registry.get(skillName);
-        if (!skill)
-            return undefined;
-        return {
-            skill,
-            task,
-            actualPrompt: buildSkillExecutionPrompt(skill, task),
-        };
-    }
     const firstSpace = withoutSlash.indexOf(" ");
     if (firstSpace === -1)
         return undefined;

package/dist/skills/registry.d.ts

@@ -3,6 +3,7 @@ export interface SkillRegistryOptions {
     cwd?: string;
     bubbleHome?: string;
     agentsHome?: string;
+    claudeHome?: string;
     skillPaths?: string[];
 }
 export declare class SkillRegistry {

package/dist/skills/registry.js

@@ -9,9 +9,11 @@ export class SkillRegistry {
         const cwd = options.cwd ?? process.cwd();
         const bubbleHome = options.bubbleHome ?? getBubbleHome();
         const agentsHome = options.agentsHome ?? join(homedir(), ".agents");
+        const claudeHome = options.claudeHome ?? join(homedir(), ".claude");
         const roots = [
             { path: join(bubbleHome, "skills"), source: "user" },
             { path: join(agentsHome, "skills"), source: "user" },
+            { path: join(claudeHome, "skills"), source: "user" },
             { path: join(cwd, ".bubble", "skills"), source: "project" },
             ...(options.skillPaths ?? []).map((path) => ({ path, source: "configured" })),
         ];

package/dist/slash-commands/commands.js

@@ -6,9 +6,9 @@ import { parseRule } from "../permissions/rule.js";
 import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibleProvider } from "../provider-registry.js";
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "../provider-transform.js";
 import { buildSystemPrompt } from "../system-prompt.js";
-import { formatLoadedSkill } from "../tools/skill.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
 import { buildMemoryPrompt, getMemoryStatus, isMemoryDisabled, resetMemory, searchMemory, } from "../memory/index.js";
+import { feishuCommand } from "./feishu.js";
 const VALID_SCOPES = ["user", "project", "local"];
 const VALID_LISTS = ["allow", "deny"];
 function isScope(value) {
@@ -54,7 +54,7 @@ function persistSelectedModel(model, ctx) {
     userConfig.setDefaultThinkingLevel(ctx.agent.thinking);
     userConfig.pushRecentModel(model);
     if (ctx.sessionManager) {
-        ctx.sessionManager.setMetadata({ model, thinkingLevel: ctx.agent.thinking, reasoningEffort: ctx.agent.thinking });
+        ctx.sessionManager.updateMetadata({ model, thinkingLevel: ctx.agent.thinking, reasoningEffort: ctx.agent.thinking });
         ctx.sessionManager.appendMarker("model_switch", model);
     }
 }
@@ -67,7 +67,6 @@ function syncSystemPrompt(ctx, model) {
         configuredModelId: model,
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
-        skills: ctx.skillRegistry.summaries(),
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }
@@ -256,25 +255,6 @@ const builtinSlashCommandEntries = [
             ctx.openPicker("skill");
         },
     },
-    {
-        name: "skill",
-        description: "Load a skill explicitly. Usage: /skill <name>",
-        async handler(args, ctx) {
-            const name = args.trim();
-            if (!name) {
-                return "Usage: /skill <name>";
-            }
-            const skill = ctx.skillRegistry.get(name);
-            if (!skill) {
-                const available = ctx.skillRegistry.summaries().map((item) => item.name).join(", ");
-                return available
-                    ? `Unknown skill "${name}". Available skills: ${available}`
-                    : `Unknown skill "${name}". No skills are currently available.`;
-            }
-            ctx.sessionManager?.appendMarker("skill_activated", skill.meta.name);
-            return formatLoadedSkill(skill);
-        },
-    },
     {
         name: "help",
         description: "Show available slash commands",
@@ -338,6 +318,7 @@ const builtinSlashCommandEntries = [
         async handler(args, ctx) {
             ctx.agent.messages = ctx.agent.messages.filter((m) => m.role === "system" || m.role === "meta");
             ctx.sessionManager?.appendMarker("conversation_clear", "");
+            ctx.sessionManager?.clearTitleMetadata?.();
             if (ctx.agent.getTodos().length > 0) {
                 ctx.agent.setTodos([]);
             }
@@ -782,10 +763,22 @@ const builtinSlashCommandEntries = [
                 ...(systemMessage ? [systemMessage] : []),
                 ...ctx.sessionManager.getMessages(),
             ];
+            ctx.agent.resetContextUsageAnchor();
             const dropped = result.droppedEntries ?? 0;
             return `✓ Compaction complete · ${dropped} log entr${dropped === 1 ? "y" : "ies"} summarized`;
         },
     },
+    {
+        name: "feedback",
+        description: "Send feedback or report a bug to Bubble developers",
+        async handler(args, ctx) {
+            if (!ctx.openFeedback) {
+                return "Feedback is only available in interactive TUI mode.";
+            }
+            ctx.openFeedback(args ?? "");
+        },
+    },
+    feishuCommand,
 ];
 /**
  * Public export — built-in commands tagged with `source: "builtin"` so the

package/dist/slash-commands/feishu.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `/feishu` slash command — control the Feishu remote-access serve process
+ * from inside the Bubble TUI without leaving it.
+ *
+ * Subcommands:
+ *   /feishu              equivalent to `/feishu status`
+ *   /feishu status       show running state and configured scopes
+ *   /feishu start        spawn `bubble serve --feishu` detached
+ *   /feishu stop         SIGTERM the running serve instance
+ *   /feishu logs [N]     tail last N lines of today's log (default 30)
+ *
+ * The serve subprocess runs independently of the TUI — closing the TUI
+ * does not stop it. Use `/feishu stop` (or kill the PID directly) to
+ * terminate.
+ */
+import type { SlashCommand } from "./types.js";
+export declare const feishuCommand: SlashCommand;