@bubblebrain-ai/bubble 0.0.10 → 0.0.12

package/dist/slash-commands/feishu.js

@@ -0,0 +1,400 @@
+/**
+ * `/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 { spawn } from "node:child_process";
+import { existsSync, openSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { configExists, loadConfig } from "../feishu/config.js";
+import { getConfigPath, getLogsDir } from "../feishu/paths.js";
+import { ProcessRegistry } from "../feishu/process-registry.js";
+import { ScopeRegistry } from "../feishu/scope/scope-registry.js";
+const SUBCOMMANDS = ["status", "setup", "start", "stop", "logs", "discover", "bind"];
+export const feishuCommand = {
+    name: "feishu",
+    description: "Control the Feishu remote-access service (setup/status/start/stop/logs/discover/bind)",
+    async handler(args, ctx) {
+        const [sub, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+        const cmd = (sub ?? "status").toLowerCase();
+        if (!SUBCOMMANDS.includes(cmd)) {
+            return `Unknown subcommand \`${cmd}\`. Usage: /feishu [setup|status|start|stop|logs|discover|bind]`;
+        }
+        switch (cmd) {
+            case "setup":
+                return runSetup(ctx);
+            case "status":
+                return runStatus();
+            case "start":
+                return runStart();
+            case "stop":
+                return runStop();
+            case "logs":
+                return runLogs(parseInt(rest[0] ?? "30", 10));
+            case "discover":
+                return runDiscover();
+            case "bind":
+                return runBind(rest);
+            default:
+                return "";
+        }
+    },
+};
+function runSetup(ctx) {
+    if (!ctx.openPicker) {
+        return "Setup wizard is only available in interactive TUI mode. Run `bubble serve --feishu --setup` from a shell instead.";
+    }
+    if (configExists()) {
+        return [
+            "已检测到现有 config (`~/.bubble/feishu/config.json`)。重新 setup 会覆盖现有的应用注册。",
+            "",
+            "如果只是想加新的 chat scope，编辑 `~/.bubble/feishu/scopes.json` 即可；要重置则先 `rm ~/.bubble/feishu/config.json ~/.bubble/feishu/secrets.enc` 再运行 `/feishu setup`。",
+        ].join("\n");
+    }
+    ctx.openPicker("feishu-setup");
+}
+function runStatus() {
+    if (!configExists()) {
+        return [
+            "Feishu serve is **not configured**.",
+            "",
+            "Run from a shell: `bubble serve --feishu --setup` to scan the QR code and create config.",
+            `Config path: \`${getConfigPath()}\``,
+        ].join("\n");
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    const procRegistry = new ProcessRegistry();
+    const conflicts = procRegistry.findConflicts(config.app.appId);
+    const running = conflicts.length > 0;
+    let scopesCount = 0;
+    try {
+        scopesCount = ScopeRegistry.load().list().length;
+    }
+    catch {
+        // ignore
+    }
+    const lines = [];
+    lines.push(`**Feishu serve status**`);
+    lines.push(`- app: \`${config.app.appId}\``);
+    lines.push(`- owner: \`${config.app.ownerOpenId}\``);
+    lines.push(`- scopes configured: ${scopesCount}`);
+    if (running) {
+        const pids = conflicts.map((c) => c.entry.pid).join(", ");
+        lines.push(`- 🟢 running (pid ${pids})`);
+        lines.push(`  use \`/feishu stop\` to terminate, \`/feishu logs\` to tail logs`);
+    }
+    else {
+        lines.push(`- ⚪ not running`);
+        lines.push(`  use \`/feishu start\` to launch`);
+    }
+    return lines.join("\n");
+}
+function runStart() {
+    if (!configExists()) {
+        return [
+            "Cannot start: no Feishu config found.",
+            "",
+            "Run from a shell first: `bubble serve --feishu --setup`",
+            "(the wizard needs an interactive terminal to scan the QR code).",
+        ].join("\n");
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    // Bail if already running for this appId.
+    const procRegistry = new ProcessRegistry();
+    procRegistry.gc();
+    if (procRegistry.findConflicts(config.app.appId).length > 0) {
+        return "Feishu serve is already running. Use `/feishu status` for details.";
+    }
+    // Spawn detached subprocess. Redirect stdout/stderr to a log file so we
+    // don't fight the TUI for the terminal. Use process.execPath + argv[1] so
+    // the subprocess inherits whatever way the user launched the TUI (npm bin,
+    // node dist/main.js, bun dist/main.js, etc.).
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return "Cannot determine bubble script path; please launch from shell instead.";
+    }
+    const stdoutLog = join(getLogsDir(), "serve-stdout.log");
+    const stderrLog = join(getLogsDir(), "serve-stderr.log");
+    let outFd;
+    let errFd;
+    try {
+        outFd = openSync(stdoutLog, "a");
+        errFd = openSync(stderrLog, "a");
+    }
+    catch (err) {
+        return `Failed to open log files: ${err.message}`;
+    }
+    let child;
+    try {
+        child = spawn(process.execPath, [scriptPath, "serve", "--feishu"], {
+            detached: true,
+            stdio: ["ignore", outFd, errFd],
+            env: { ...process.env },
+        });
+    }
+    catch (err) {
+        return `Failed to spawn: ${err.message}`;
+    }
+    // unref so the parent (TUI) can exit without waiting for the child.
+    child.unref();
+    // If spawn failed asynchronously, we won't catch it here — the user will
+    // see emptiness in /feishu status, which then prompts them to check logs.
+    return [
+        `🚀 Started Feishu serve (pid ${child.pid ?? "?"}).`,
+        `  stdout: \`${stdoutLog}\``,
+        `  stderr: \`${stderrLog}\``,
+        "",
+        "Use `/feishu status` to verify, `/feishu logs` to tail.",
+    ].join("\n");
+}
+function runStop() {
+    if (!configExists())
+        return "No config — nothing to stop.";
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    const procRegistry = new ProcessRegistry();
+    const conflicts = procRegistry.findConflicts(config.app.appId);
+    if (conflicts.length === 0) {
+        return "Feishu serve is not running.";
+    }
+    const killed = procRegistry.killConflicts(config.app.appId);
+    if (killed === 0) {
+        return "Found stale registry entries but no live processes — cleaned up.";
+    }
+    return `⏹ Sent SIGTERM to ${killed} process(es). Use \`/feishu status\` to confirm shutdown.`;
+}
+function runDiscover() {
+    if (!configExists()) {
+        return "未配置。先跑 `/feishu setup`。";
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    // Scan today's + yesterday's log for `scope_not_found` (or user_not_allowed)
+    // events. Most recent first.
+    const events = collectGateEvents();
+    if (events.length === 0) {
+        return [
+            "没找到未授权的 chat 记录。",
+            "",
+            "确保：",
+            "1. `/feishu start` 已经把服务跑起来了（`/feishu status` 看一下）",
+            "2. 你已经在手机飞书里给 bot 发过至少一条消息",
+            "3. 如果之前测试过，可能已经被 `requireMentionInGroup` 过滤；用私聊试试",
+        ].join("\n");
+    }
+    const known = new Set(loadKnownChats());
+    const unknown = events.filter((e) => !known.has(e.chatId));
+    if (unknown.length === 0) {
+        return [
+            "找到的 chat 都已经配置过了：",
+            ...events.slice(0, 5).map((e) => `- ${e.chatId} (user ${e.userId}, ${e.reason})`),
+        ].join("\n");
+    }
+    const lines = [
+        `发现 ${unknown.length} 个未授权的 chat：`,
+        "",
+    ];
+    // Group by chatId, keep latest senderId per chat.
+    const byChat = new Map();
+    for (const e of unknown) {
+        if (!byChat.has(e.chatId))
+            byChat.set(e.chatId, e);
+    }
+    let idx = 1;
+    for (const [chatId, info] of byChat.entries()) {
+        lines.push(`${idx}. \`${chatId}\``);
+        lines.push(`   sender: \`${info.userId}\`  ·  ${info.reason}  ·  ${info.ts}`);
+        lines.push(`   → \`/feishu bind ${chatId} <你的项目路径>\``);
+        lines.push("");
+        idx++;
+    }
+    lines.push(`(owner open_id = \`${config.app.ownerOpenId}\`，会自动加入新 scope 的 allowedUsers)`);
+    return lines.join("\n");
+}
+function collectGateEvents() {
+    const today = new Date();
+    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+    const dates = [iso(today), iso(yesterday)];
+    const all = [];
+    for (const d of dates) {
+        const path = join(getLogsDir(), `${d}.log`);
+        if (!existsSync(path))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.msg !== "gate_rejected")
+                    continue;
+                all.push({
+                    chatId: String(obj.chatId ?? ""),
+                    userId: String(obj.userId ?? ""),
+                    reason: String(obj.reason ?? ""),
+                    ts: String(obj.ts ?? "").slice(11, 19),
+                });
+            }
+            catch { /* skip */ }
+        }
+    }
+    return all.reverse(); // newest first
+}
+function iso(d) {
+    return d.toISOString().slice(0, 10);
+}
+function loadKnownChats() {
+    try {
+        return ScopeRegistry.load().list().map((s) => s.chatId);
+    }
+    catch {
+        return [];
+    }
+}
+function runBind(args) {
+    if (!configExists()) {
+        return "未配置。先跑 `/feishu setup`。";
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    if (args.length < 2) {
+        return [
+            "用法：`/feishu bind <chat_id> <cwd> [display_name]`",
+            "",
+            "示例：`/feishu bind oc_abc123 ~/projects/my-app my-app`",
+            "",
+            "用 `/feishu discover` 找到未授权的 chat_id。",
+        ].join("\n");
+    }
+    const chatId = args[0].trim();
+    const cwdRaw = args[1].trim();
+    const displayName = args.slice(2).join(" ").trim();
+    // Expand ~
+    const cwd = (cwdRaw === "~" || cwdRaw.startsWith("~/"))
+        ? (process.env.HOME ?? "") + cwdRaw.slice(1)
+        : cwdRaw;
+    // Validate
+    let stat;
+    try {
+        stat = existsSync(cwd) ? statSync(cwd) : undefined;
+    }
+    catch {
+        stat = undefined;
+    }
+    if (!stat || !stat.isDirectory()) {
+        return `❌ cwd 无效（不存在或不是目录）：\`${cwd}\``;
+    }
+    if (!chatId.startsWith("oc_")) {
+        // Not strictly required, but worth flagging.
+        return `⚠️ chat_id 看起来不像飞书的（一般以 \`oc_\` 开头）。确认无误后强制添加请直接编辑 \`~/.bubble/feishu/scopes.json\`。收到：\`${chatId}\``;
+    }
+    const registry = ScopeRegistry.load();
+    if (registry.has(chatId)) {
+        return `⚠️ scope \`${chatId}\` 已存在。如果想改 cwd，先 \`rm ~/.bubble/feishu/scopes.json\` 里手动调，或者用 \`/cd\` 在飞书会话里切换。`;
+    }
+    const finalName = displayName || basenameOf(cwd);
+    registry.upsert(chatId, {
+        cwd,
+        displayName: finalName,
+        allowedUsers: [config.app.ownerOpenId],
+        admins: [config.app.ownerOpenId],
+        defaultPermissionMode: "default",
+        model: null,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+    });
+    return [
+        `✅ 已绑定 scope：`,
+        `   chat: \`${chatId}\``,
+        `   cwd:  \`${cwd}\``,
+        `   name: \`${finalName}\``,
+        `   allowedUsers: [\`${config.app.ownerOpenId}\`]`,
+        "",
+        "现在去飞书重新发条消息，应该能看到卡片回复了。",
+    ].join("\n");
+}
+function basenameOf(p) {
+    const parts = p.split(/[\\/]/);
+    return parts[parts.length - 1] || p;
+}
+function runLogs(n) {
+    const tailN = Number.isFinite(n) && n > 0 ? Math.min(n, 500) : 30;
+    const dateKey = new Date().toISOString().slice(0, 10);
+    const path = join(getLogsDir(), `${dateKey}.log`);
+    if (!existsSync(path)) {
+        // Fall back to the most recent log file in the dir.
+        return `No log file for today yet (\`${path}\`). Start the service first or check \`${getLogsDir()}\`.`;
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        return `Failed to read log: ${err.message}`;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim() !== "");
+    const slice = lines.slice(-tailN);
+    if (slice.length === 0)
+        return `(log is empty: \`${path}\`)`;
+    // Format JSON lines compactly for readability in chat.
+    const formatted = slice.map((line) => {
+        try {
+            const obj = JSON.parse(line);
+            const ts = String(obj.ts ?? "").slice(11, 19);
+            const lvl = String(obj.level ?? "?").padEnd(5);
+            const msg = String(obj.msg ?? "");
+            const extra = Object.entries(obj)
+                .filter(([k]) => !["ts", "level", "msg"].includes(k))
+                .map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`)
+                .join(" ");
+            return `${ts} ${lvl} ${msg}${extra ? "  " + extra : ""}`;
+        }
+        catch {
+            return line;
+        }
+    });
+    return ["```", ...formatted, "```", `(${slice.length} lines from \`${path}\`)`].join("\n");
+}

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/slash-commands/types.d.ts

@@ -17,7 +17,7 @@ export interface SlashCommandContext {
     exit: () => void;
     sessionManager?: SessionManager;
     createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
-    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill", providerId?: string) => void;
+    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "feishu-setup", providerId?: string) => void;
     registry: ProviderRegistry;
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;
@@ -34,6 +34,8 @@ export interface SlashCommandContext {
     getResolvedTheme?: () => "light" | "dark";
     /** Persist a new theme mode AND apply it to the running TUI. */
     setThemeMode?: (mode: ThemeMode) => void;
+    /** Open the feedback dialog. `initialDescription` prefills the description field. */
+    openFeedback?: (initialDescription: string) => void;
 }
 /**
  * Return types for a slash command handler:

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,
                 };
             }