@bubblebrain-ai/bubble 0.0.11 → 0.0.12

package/dist/session.js

@@ -1,11 +1,14 @@
 /**
  * Session Manager - Append-only JSONL persistence over a structured session log.
  */
+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 {
@@ -107,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);
@@ -192,21 +213,23 @@ function summarizeSessionFile(file, cwdDir) {
     const log = new SessionLog();
     log.load(lines);
     const metadata = log.getMetadata();
+    const entries = log.list();
     const messages = log.toMessages();
-    const firstUser = messages.find((m) => m.role === "user");
-    let firstUserText = "";
-    if (firstUser) {
-        firstUserText = typeof firstUser.content === "string"
-            ? firstUser.content
-            : firstUser.content.map((part) => part.type === "text" ? part.text : "").join("");
-    }
-    const snippet = firstUserText.trim().replace(/\s+/g, " ").slice(0, 80);
+    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),
-        firstUserMessage: snippet || "(no user message)",
+        title,
+        preview,
+        firstUserMessage: preview,
         messageCount: messages.length,
         mtime: stat.mtimeMs,
     };
@@ -219,3 +242,46 @@ function decodeCwdDir(safe) {
         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,7 +6,6 @@ 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";
@@ -55,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);
     }
 }
@@ -68,7 +67,6 @@ function syncSystemPrompt(ctx, model) {
         configuredModelId: model,
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
-        skills: ctx.skillRegistry.summaries(),
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }
@@ -257,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",
@@ -339,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([]);
             }

package/dist/slash-commands/registry.js

@@ -48,7 +48,7 @@ export class SlashCommandRegistry {
             if (skill) {
                 return {
                     handled: true,
-                    result: `Skill "${skill.meta.name}": ${skill.meta.description}\nUse /${skill.meta.name} <your request> to run with this skill, or /skill ${skill.meta.name} to inspect it.`,
+                    result: `Skill "${skill.meta.name}": ${skill.meta.description}\nUse /${skill.meta.name} <your request> to run with this skill, or /skills to choose from the picker.`,
                 };
             }
             return {

package/dist/text-display.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeSingleLine(text: string): string;
+export declare function truncateVisual(text: string, maxWidth: number): string;
+export declare function padVisual(text: string, width: number): string;

package/dist/text-display.js

@@ -0,0 +1,25 @@
+import stringWidth from "string-width";
+export function normalizeSingleLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function truncateVisual(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    if (maxWidth === 1)
+        return "…";
+    let out = "";
+    let width = 0;
+    for (const ch of text) {
+        const chWidth = stringWidth(ch);
+        if (width + chWidth > maxWidth - 1)
+            break;
+        out += ch;
+        width += chWidth;
+    }
+    return `${out}…`;
+}
+export function padVisual(text, width) {
+    return `${text}${" ".repeat(Math.max(0, width - stringWidth(text)))}`;
+}

package/dist/tools/index.d.ts

@@ -11,6 +11,7 @@ export { createLspTool } from "./lsp.js";
 export { createWebFetchTool } from "./web-fetch.js";
 export { createWebSearchTool } from "./web-search.js";
 export { createSkillTool } from "./skill.js";
+export { createSkillSearchTool } from "./skill-search.js";
 export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
 export { createTodoTool, type TodoStore } from "./todo.js";
 export { createExitPlanModeTool, type PlanController } from "./exit-plan-mode.js";

package/dist/tools/index.js

@@ -11,6 +11,7 @@ export { createLspTool } from "./lsp.js";
 export { createWebFetchTool } from "./web-fetch.js";
 export { createWebSearchTool } from "./web-search.js";
 export { createSkillTool } from "./skill.js";
+export { createSkillSearchTool } from "./skill-search.js";
 export { createAgentLifecycleTools, createCloseAgentTool, createSendInputTool, createSpawnAgentTool, createWaitAgentTool } from "./agent-lifecycle.js";
 export { createTodoTool } from "./todo.js";
 export { createExitPlanModeTool } from "./exit-plan-mode.js";
@@ -26,6 +27,7 @@ import { getLspService } from "../lsp/index.js";
 import { createLspTool } from "./lsp.js";
 import { createReadTool } from "./read.js";
 import { createSkillTool } from "./skill.js";
+import { createSkillSearchTool } from "./skill-search.js";
 import { createAgentLifecycleTools } from "./agent-lifecycle.js";
 import { createTodoTool } from "./todo.js";
 import { createToolSearchTool } from "./tool-search.js";
@@ -53,7 +55,7 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         createMemoryReadSummaryTool(cwd),
         ...createAgentLifecycleTools(),
         ...(options.questionController ? [createQuestionTool(options.questionController)] : []),
-        ...(skillRegistry ? [createSkillTool(skillRegistry)] : []),
+        ...(skillRegistry ? [createSkillSearchTool(skillRegistry), createSkillTool(skillRegistry)] : []),
         ...(options.todoStore ? [createTodoTool(options.todoStore)] : []),
         ...(options.planController ? [createExitPlanModeTool(options.planController)] : []),
         ...(options.toolSearchController ? [createToolSearchTool(options.toolSearchController)] : []),

package/dist/tools/skill-search.d.ts

@@ -0,0 +1,10 @@
+import type { SkillRegistry } from "../skills/registry.js";
+import type { SkillSummary } from "../skills/types.js";
+import type { ToolRegistryEntry } from "../types.js";
+interface SkillSearchMatch {
+    skill: SkillSummary;
+    score: number;
+}
+export declare function createSkillSearchTool(registry: SkillRegistry): ToolRegistryEntry;
+export declare function searchSkillSummaries(skills: SkillSummary[], query: string): SkillSearchMatch[];
+export {};

package/dist/tools/skill-search.js

@@ -0,0 +1,134 @@
+const DEFAULT_MAX_RESULTS = 8;
+const MAX_RESULTS = 25;
+const SOURCE_PRIORITY = {
+    project: 0,
+    configured: 1,
+    user: 2,
+};
+export function createSkillSearchTool(registry) {
+    return {
+        name: "skill_search",
+        readOnly: true,
+        effect: "read",
+        description: "Search available skills by name, description, tags, and source. Use this before loading a skill when a task may match a specialized workflow.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search terms describing the desired skill or workflow.",
+                },
+                max_results: {
+                    type: "number",
+                    description: `Maximum number of matches to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS}).`,
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const query = typeof args.query === "string" ? args.query.trim() : "";
+            const maxResults = typeof args.max_results === "number" && args.max_results > 0
+                ? Math.min(Math.floor(args.max_results), MAX_RESULTS)
+                : DEFAULT_MAX_RESULTS;
+            const skills = registry.summaries();
+            if (skills.length === 0) {
+                return { content: "No skills are currently available." };
+            }
+            const matches = searchSkillSummaries(skills, query).slice(0, maxResults);
+            if (matches.length === 0) {
+                return {
+                    content: `No skills matched "${query}". Try broader terms or use /skills to browse all skills manually.`,
+                };
+            }
+            return {
+                content: formatSkillSearchResults(matches, skills.length, query),
+            };
+        },
+    };
+}
+export function searchSkillSummaries(skills, query) {
+    const terms = normalizeTerms(query);
+    const scored = [];
+    for (const skill of skills) {
+        const score = scoreSkill(skill, terms, query);
+        if (score > 0 || terms.length === 0) {
+            scored.push({ skill, score });
+        }
+    }
+    scored.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        const ap = SOURCE_PRIORITY[a.skill.source ?? "user"] ?? 3;
+        const bp = SOURCE_PRIORITY[b.skill.source ?? "user"] ?? 3;
+        if (ap !== bp)
+            return ap - bp;
+        return a.skill.name.localeCompare(b.skill.name);
+    });
+    return scored;
+}
+function scoreSkill(skill, terms, rawQuery) {
+    const name = skill.name.toLowerCase();
+    const desc = (skill.description ?? "").toLowerCase();
+    const tags = (skill.tags ?? []).map((tag) => tag.toLowerCase());
+    const source = skill.source ?? "user";
+    const sourceBonus = source === "project" ? 4 : source === "configured" ? 2 : 0;
+    const query = rawQuery.trim().toLowerCase();
+    if (terms.length === 0)
+        return 1 + sourceBonus;
+    let score = 0;
+    if (name === query)
+        score += 80;
+    if (name.includes(query) && query.length > 0)
+        score += 30;
+    for (const term of terms) {
+        if (name === term)
+            score += 30;
+        else if (name.includes(term))
+            score += 12;
+        if (tags.some((tag) => tag === term))
+            score += 10;
+        else if (tags.some((tag) => tag.includes(term)))
+            score += 6;
+        if (desc.includes(term))
+            score += 3;
+        if (source.includes(term))
+            score += 2;
+    }
+    return score > 0 ? score + sourceBonus : 0;
+}
+function normalizeTerms(query) {
+    const rawTerms = query
+        .toLowerCase()
+        .split(/[^a-z0-9_\-\u3000-\u9fff]+/i)
+        .map((term) => term.trim())
+        .filter(Boolean);
+    const terms = new Set();
+    for (const term of rawTerms) {
+        terms.add(term);
+        const chars = Array.from(term);
+        if (chars.some(isCjkChar) && chars.length > 2) {
+            for (let i = 0; i < chars.length - 1; i++) {
+                terms.add(`${chars[i]}${chars[i + 1]}`);
+            }
+        }
+    }
+    return [...terms];
+}
+function isCjkChar(ch) {
+    const code = ch.codePointAt(0) ?? 0;
+    return code >= 0x3000 && code <= 0x9fff;
+}
+function formatSkillSearchResults(matches, total, query) {
+    const lines = [
+        query ? `Skill search results for "${query}" (${matches.length} of ${total}):` : `Available skills (${matches.length} of ${total}):`,
+    ];
+    for (const { skill } of matches) {
+        const tags = skill.tags && skill.tags.length > 0 ? ` [tags: ${skill.tags.join(", ")}]` : "";
+        const source = skill.source ? ` (${skill.source})` : "";
+        lines.push(`- ${skill.name}${source}: ${skill.description}${tags}`);
+    }
+    lines.push("");
+    lines.push("Call skill with the exact name to load a selected skill.");
+    return lines.join("\n");
+}

package/dist/tools/skill.js

@@ -38,11 +38,8 @@ export function createSkillTool(registry) {
             }
             const skill = registry.get(name);
             if (!skill) {
-                const available = registry.summaries().map((item) => item.name).join(", ");
                 return {
-                    content: available
-                        ? `Error: Unknown skill "${name}". Available skills: ${available}`
-                        : `Error: Unknown skill "${name}". No skills are currently available.`,
+                    content: `Error: Unknown skill "${name}". Use skill_search to find available skills, then retry with the exact skill name.`,
                     isError: true,
                 };
             }