@next-open-ai/openbot 0.2.8 → 0.3.2

package/dist/server/saved-items/saved-items.module.js

@@ -0,0 +1,23 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { DatabaseModule } from '../database/database.module.js';
+import { TagsService } from './tags.service.js';
+import { TagsController } from './tags.controller.js';
+import { SavedItemsService } from './saved-items.service.js';
+import { SavedItemsController } from './saved-items.controller.js';
+let SavedItemsModule = class SavedItemsModule {
+};
+SavedItemsModule = __decorate([
+    Module({
+        imports: [DatabaseModule],
+        controllers: [TagsController, SavedItemsController],
+        providers: [TagsService, SavedItemsService],
+        exports: [TagsService, SavedItemsService],
+    })
+], SavedItemsModule);
+export { SavedItemsModule };

package/dist/server/saved-items/saved-items.service.d.ts

@@ -0,0 +1,31 @@
+import { DatabaseService } from '../database/database.service.js';
+import { TagsService } from './tags.service.js';
+export interface SavedItem {
+    id: string;
+    url: string;
+    title: string | null;
+    workspace: string;
+    createdAt: number;
+    tagIds: string[];
+    tagNames?: string[];
+}
+export declare class SavedItemsService {
+    private readonly db;
+    private readonly tagsService;
+    constructor(db: DatabaseService, tagsService: TagsService);
+    private getTagIdsForItem;
+    private rowToSavedItem;
+    create(dto: {
+        url: string;
+        title?: string;
+        workspace?: string;
+        tagNames?: string[];
+        tagIds?: string[];
+    }): Promise<SavedItem>;
+    findAll(options?: {
+        tagId?: string;
+        workspace?: string;
+    }): Promise<SavedItem[]>;
+    findById(id: string): Promise<SavedItem | null>;
+    delete(id: string): Promise<void>;
+}

package/dist/server/saved-items/saved-items.service.js

@@ -0,0 +1,105 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service.js';
+import { TagsService } from './tags.service.js';
+import { randomUUID } from 'crypto';
+let SavedItemsService = class SavedItemsService {
+    db;
+    tagsService;
+    constructor(db, tagsService) {
+        this.db = db;
+        this.tagsService = tagsService;
+    }
+    async getTagIdsForItem(savedItemId) {
+        const rows = this.db.all('SELECT tag_id FROM saved_item_tags WHERE saved_item_id = ?', [savedItemId]);
+        return rows.map((r) => r.tag_id);
+    }
+    async rowToSavedItem(row) {
+        const tagIds = await this.getTagIdsForItem(row.id);
+        const tagNames = [];
+        for (const tagId of tagIds) {
+            const tag = await this.tagsService.findById(tagId);
+            if (tag)
+                tagNames.push(tag.name);
+        }
+        return {
+            id: row.id,
+            url: row.url,
+            title: row.title,
+            workspace: row.workspace,
+            createdAt: row.created_at,
+            tagIds,
+            tagNames,
+        };
+    }
+    async create(dto) {
+        const url = (dto.url ?? '').trim();
+        if (!url)
+            throw new Error('url is required');
+        const workspace = (dto.workspace ?? 'default').trim() || 'default';
+        const title = dto.title?.trim() ?? null;
+        const id = randomUUID();
+        const createdAt = Date.now();
+        this.db.run('INSERT INTO saved_items (id, url, title, workspace, created_at) VALUES (?, ?, ?, ?, ?)', [id, url, title, workspace, createdAt]);
+        let tagIds = [];
+        if (dto.tagIds?.length) {
+            tagIds = dto.tagIds;
+        }
+        else if (dto.tagNames?.length) {
+            for (const name of dto.tagNames) {
+                const tag = await this.tagsService.findByName(name.trim());
+                if (tag)
+                    tagIds.push(tag.id);
+            }
+        }
+        for (const tagId of tagIds) {
+            this.db.run('INSERT INTO saved_item_tags (saved_item_id, tag_id) VALUES (?, ?)', [id, tagId]);
+        }
+        const row = { id, url, title, workspace, created_at: createdAt };
+        return this.rowToSavedItem(row);
+    }
+    async findAll(options) {
+        let sql = 'SELECT id, url, title, workspace, created_at FROM saved_items WHERE 1=1';
+        const params = [];
+        if (options?.workspace) {
+            sql += ' AND workspace = ?';
+            params.push(options.workspace);
+        }
+        if (options?.tagId) {
+            sql += ' AND id IN (SELECT saved_item_id FROM saved_item_tags WHERE tag_id = ?)';
+            params.push(options.tagId);
+        }
+        sql += ' ORDER BY created_at DESC';
+        const rows = this.db.all(sql, params);
+        const result = [];
+        for (const row of rows) {
+            result.push(await this.rowToSavedItem(row));
+        }
+        return result;
+    }
+    async findById(id) {
+        const row = this.db.get('SELECT id, url, title, workspace, created_at FROM saved_items WHERE id = ?', [id]);
+        return row ? this.rowToSavedItem(row) : null;
+    }
+    async delete(id) {
+        const item = await this.findById(id);
+        if (!item)
+            throw new NotFoundException('收藏不存在');
+        this.db.run('DELETE FROM saved_item_tags WHERE saved_item_id = ?', [id]);
+        this.db.run('DELETE FROM saved_items WHERE id = ?', [id]);
+    }
+};
+SavedItemsService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService,
+        TagsService])
+], SavedItemsService);
+export { SavedItemsService };

package/dist/server/saved-items/tags.controller.d.ts

@@ -0,0 +1,30 @@
+import { TagsService } from './tags.service.js';
+export declare class TagsController {
+    private readonly tagsService;
+    constructor(tagsService: TagsService);
+    list(): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag[];
+    }>;
+    get(id: string): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    create(body: {
+        name: string;
+        sortOrder?: number;
+    }): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    update(id: string, body: {
+        name?: string;
+        sortOrder?: number;
+    }): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/server/saved-items/tags.controller.js

@@ -0,0 +1,85 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Post, Put, Delete, Body, Param, HttpException, HttpStatus } from '@nestjs/common';
+import { TagsService } from './tags.service.js';
+let TagsController = class TagsController {
+    tagsService;
+    constructor(tagsService) {
+        this.tagsService = tagsService;
+    }
+    async list() {
+        const data = await this.tagsService.findAll();
+        return { success: true, data };
+    }
+    async get(id) {
+        const data = await this.tagsService.findById(id);
+        if (!data)
+            throw new HttpException('Tag not found', HttpStatus.NOT_FOUND);
+        return { success: true, data };
+    }
+    async create(body) {
+        const data = await this.tagsService.create({
+            name: body.name,
+            sortOrder: body.sortOrder,
+        });
+        return { success: true, data };
+    }
+    async update(id, body) {
+        const data = await this.tagsService.update(id, body);
+        return { success: true, data };
+    }
+    async delete(id) {
+        await this.tagsService.delete(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "list", null);
+__decorate([
+    Get(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "get", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "create", null);
+__decorate([
+    Put(':id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "update", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "delete", null);
+TagsController = __decorate([
+    Controller('tags'),
+    __metadata("design:paramtypes", [TagsService])
+], TagsController);
+export { TagsController };

package/dist/server/saved-items/tags.service.d.ts

@@ -0,0 +1,24 @@
+import { DatabaseService } from '../database/database.service.js';
+export interface Tag {
+    id: string;
+    name: string;
+    sortOrder: number;
+    createdAt: number;
+}
+export declare class TagsService {
+    private readonly db;
+    constructor(db: DatabaseService);
+    private rowToTag;
+    findAll(): Promise<Tag[]>;
+    findById(id: string): Promise<Tag | null>;
+    findByName(name: string): Promise<Tag | null>;
+    create(dto: {
+        name: string;
+        sortOrder?: number;
+    }): Promise<Tag>;
+    update(id: string, dto: {
+        name?: string;
+        sortOrder?: number;
+    }): Promise<Tag>;
+    delete(id: string): Promise<void>;
+}

package/dist/server/saved-items/tags.service.js

@@ -0,0 +1,84 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service.js';
+import { randomUUID } from 'crypto';
+let TagsService = class TagsService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    rowToTag(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            sortOrder: row.sort_order,
+            createdAt: row.created_at,
+        };
+    }
+    async findAll() {
+        const rows = this.db.all('SELECT id, name, sort_order, created_at FROM tags ORDER BY sort_order ASC, name ASC', []);
+        return rows.map((r) => this.rowToTag(r));
+    }
+    async findById(id) {
+        const row = this.db.get('SELECT id, name, sort_order, created_at FROM tags WHERE id = ?', [id]);
+        return row ? this.rowToTag(row) : null;
+    }
+    async findByName(name) {
+        const row = this.db.get('SELECT id, name, sort_order, created_at FROM tags WHERE name = ?', [
+            name.trim(),
+        ]);
+        return row ? this.rowToTag(row) : null;
+    }
+    async create(dto) {
+        const name = (dto.name ?? '').trim();
+        if (!name)
+            throw new ConflictException('标签名不能为空');
+        const existing = await this.findByName(name);
+        if (existing)
+            throw new ConflictException('该标签名已存在');
+        const id = randomUUID();
+        const sortOrder = dto.sortOrder ?? 0;
+        const createdAt = Date.now();
+        this.db.run('INSERT INTO tags (id, name, sort_order, created_at) VALUES (?, ?, ?, ?)', [id, name, sortOrder, createdAt]);
+        return { id, name, sortOrder, createdAt };
+    }
+    async update(id, dto) {
+        const tag = await this.findById(id);
+        if (!tag)
+            throw new NotFoundException('标签不存在');
+        if (dto.name !== undefined) {
+            const name = dto.name.trim();
+            if (!name)
+                throw new ConflictException('标签名不能为空');
+            const existing = await this.findByName(name);
+            if (existing && existing.id !== id)
+                throw new ConflictException('该标签名已存在');
+            this.db.run('UPDATE tags SET name = ? WHERE id = ?', [name, id]);
+            tag.name = name;
+        }
+        if (dto.sortOrder !== undefined) {
+            this.db.run('UPDATE tags SET sort_order = ? WHERE id = ?', [dto.sortOrder, id]);
+            tag.sortOrder = dto.sortOrder;
+        }
+        return tag;
+    }
+    async delete(id) {
+        const tag = await this.findById(id);
+        if (!tag)
+            throw new NotFoundException('标签不存在');
+        this.db.run('DELETE FROM tags WHERE id = ?', [id]);
+    }
+};
+TagsService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService])
+], TagsService);
+export { TagsService };

package/dist/server/skills/skills.service.d.ts

@@ -51,6 +51,8 @@ export declare class SkillsService {
     getSkillContent(name: string): Promise<string | null>;
     /** 仅返回指定工作区下的技能（文件目录管理，不涉及 SQLite） */
     getSkillsForWorkspace(workspaceName: string): Promise<Skill[]>;
+    /** 从 skill.json 或 package.json 解析出 Skill（兼容无 SKILL.md 的 npm 风格技能目录） */
+    private parseSkillJson;
     getSkillContentForWorkspace(workspaceName: string, name: string): Promise<string | null>;
     /** 在工作区下新增技能（创建目录 + SKILL.md） */
     addSkill(workspaceName: string, name: string, options?: {

package/dist/server/skills/skills.service.js

@@ -20,6 +20,24 @@ import { getOpenbotAgentDir, getOpenbotWorkspaceDir } from '../../core/agent/age
 const execAsync = promisify(exec);
 /** 工作区技能名仅允许英文、数字、下划线、连字符 */
 const SKILL_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+/**
+ * 系统技能目录：仅两条规则，不做复杂搜索。
+ * - 运行时/打包：由桌面 main 或部署方设置 OPENBOT_SYSTEM_SKILLS_DIR，用该目录。
+ * - 开发/测试：未设置时仅尝试「当前工作目录下的 skills」（从项目根启动时即项目目录下的 skills）。
+ */
+function resolveSystemSkillsDir() {
+    const envDir = process.env.OPENBOT_SYSTEM_SKILLS_DIR?.trim();
+    if (envDir) {
+        const abs = resolve(envDir);
+        if (existsSync(abs))
+            return abs;
+        return null;
+    }
+    const cwdSkills = resolve(process.cwd(), 'skills');
+    if (existsSync(cwdSkills))
+        return cwdSkills;
+    return null;
+}
 /** 技能目录与来源：全局=OPENBOT_AGENT_DIR/skills，系统=项目根/skills，工作区=OPENBOT_WORKSPACE_DIR/xxx/skills */
 let SkillsService = class SkillsService {
     /** 待扫描的目录列表 */
@@ -29,14 +47,14 @@ let SkillsService = class SkillsService {
         const workspaceName = process.env.OPENBOT_WORKSPACE || 'default';
         // 全局技能：OPENBOT_AGENT_DIR/skills（默认 ~/.openbot/agent/skills）
         const globalSkillsDir = join(getOpenbotAgentDir(), 'skills');
-        // 系统技能：当前项目代码根目录下的 skills
-        const systemSkillsDir = resolve(cwd, 'skills');
+        // 系统技能：OPENBOT_SYSTEM_SKILLS_DIR 或 cwd/skills（仅此两种）
+        const systemSkillsDir = resolveSystemSkillsDir();
         // 工作区技能：OPENBOT_WORKSPACE_DIR/<name>/skills（默认 ~/.openbot/workspace/xxx/skills）
         const workspaceSkillsDir = join(getOpenbotWorkspaceDir(), workspaceName, 'skills');
         if (existsSync(globalSkillsDir)) {
             this.skillPaths.push({ path: globalSkillsDir, source: 'global' });
         }
-        if (existsSync(systemSkillsDir)) {
+        if (systemSkillsDir) {
             this.skillPaths.push({ path: systemSkillsDir, source: 'system' });
         }
         if (existsSync(workspaceSkillsDir)) {
@@ -220,8 +238,20 @@ let SkillsService = class SkillsService {
     /** 仅返回指定工作区下的技能（文件目录管理，不涉及 SQLite） */
     async getSkillsForWorkspace(workspaceName) {
         const skillPath = this.getWorkspaceSkillsDir(workspaceName);
-        if (!existsSync(skillPath))
-            return [];
+        if (!existsSync(skillPath)) {
+            if (workspaceName === DEFAULT_AGENT_ID || workspaceName === 'default') {
+                try {
+                    await mkdir(skillPath, { recursive: true });
+                }
+                catch (e) {
+                    console.warn(`[skills] 创建 default 工作区技能目录失败: ${skillPath}`, e);
+                }
+            }
+            if (!existsSync(skillPath)) {
+                console.warn(`[skills] 工作区技能目录不存在，返回空列表: workspace=${workspaceName}, path=${skillPath}`);
+                return [];
+            }
+        }
         const skills = [];
         try {
             const entries = await readdir(skillPath);
@@ -232,13 +262,24 @@ let SkillsService = class SkillsService {
                     if (!stats.isDirectory())
                         continue;
                     const skillMdPath = join(fullPath, 'SKILL.md');
-                    if (!existsSync(skillMdPath))
-                        continue;
-                    const content = await readFile(skillMdPath, 'utf-8');
-                    skills.push(this.parseSkillFile(entry, content, fullPath, 'workspace'));
+                    const skillJsonPath = join(fullPath, 'skill.json');
+                    const packageJsonPath = join(fullPath, 'package.json');
+                    if (existsSync(skillMdPath)) {
+                        const content = await readFile(skillMdPath, 'utf-8');
+                        skills.push(this.parseSkillFile(entry, content, fullPath, 'workspace'));
+                    }
+                    else if (existsSync(skillJsonPath)) {
+                        const skill = await this.parseSkillJson(entry, skillJsonPath, fullPath);
+                        if (skill)
+                            skills.push(skill);
+                    }
+                    else if (existsSync(packageJsonPath)) {
+                        const skill = await this.parseSkillJson(entry, packageJsonPath, fullPath);
+                        if (skill)
+                            skills.push(skill);
+                    }
                 }
                 catch (entryError) {
-                    // 跳过无效条目：ENOENT（目录已删/损坏的符号链接）、无权限等
                     if (entryError?.code !== 'ENOENT') {
                         console.warn(`Skipping workspace skill entry ${entry}:`, entryError?.message ?? entryError);
                     }
@@ -250,18 +291,41 @@ let SkillsService = class SkillsService {
         }
         return skills;
     }
+    /** 从 skill.json 或 package.json 解析出 Skill（兼容无 SKILL.md 的 npm 风格技能目录） */
+    async parseSkillJson(entryName, jsonPath, fullPath) {
+        try {
+            const content = await readFile(jsonPath, 'utf-8');
+            const data = JSON.parse(content);
+            const name = (data.name || entryName).trim() || entryName;
+            const description = (data.description || '').trim() || 'No description available';
+            return { name: entryName, description, path: fullPath, source: 'workspace' };
+        }
+        catch {
+            return null;
+        }
+    }
     async getSkillContentForWorkspace(workspaceName, name) {
         const skillPath = this.getWorkspaceSkillsDir(workspaceName);
         const fullPath = join(skillPath, name);
         const skillMdPath = join(fullPath, 'SKILL.md');
-        if (!existsSync(skillMdPath))
-            return null;
-        try {
-            return await readFile(skillMdPath, 'utf-8');
+        const readmePath = join(fullPath, 'README.md');
+        if (existsSync(skillMdPath)) {
+            try {
+                return await readFile(skillMdPath, 'utf-8');
+            }
+            catch {
+                return null;
+            }
         }
-        catch {
-            return null;
+        if (existsSync(readmePath)) {
+            try {
+                return await readFile(readmePath, 'utf-8');
+            }
+            catch {
+                return null;
+            }
         }
+        return null;
     }
     /** 在工作区下新增技能（创建目录 + SKILL.md） */
     async addSkill(workspaceName, name, options) {

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.2.8",
+    "version": "0.3.2",
     "description": "CLI and library to run prompts with skill paths (Agent Skills style). Use as npm package or openbot CLI.",
     "type": "module",
     "main": "dist/index.js",
@@ -33,9 +33,11 @@
         "@nestjs/platform-socket.io": "^10.3.0",
         "@nestjs/websockets": "^10.3.0",
         "@sinclair/typebox": "^0.34.41",
+        "adm-zip": "^0.5.16",
         "agent-browser": "^0.8.5",
         "commander": "^14.0.2",
         "croner": "^9.1.0",
+        "multer": "^1.4.5-lts.1",
         "reflect-metadata": "^0.2.1",
         "rxjs": "^7.8.1",
         "sql.js": "^1.13.0",
@@ -44,8 +46,10 @@
     },
     "devDependencies": {
         "@nestjs/testing": "^10.3.0",
+        "@types/adm-zip": "^0.5.7",
         "@types/express": "^4.17.21",
         "@types/jest": "^29.5.14",
+        "@types/multer": "^2.0.0",
         "@types/node": "^22.0.0",
         "@types/sql.js": "^1.4.9",
         "@types/ws": "^8.18.1",

package/skills/url-bookmark/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: url-bookmark
+description: 根据用户指令将 URL 保存为收藏，并匹配系统中已维护的标签。当用户说「收藏这个链接」「把这条存到技术标签」「保存网址」等时使用。先调用 get_bookmark_tags 获取可用标签列表，再根据用户意图选择匹配的标签，最后用 save_bookmark 保存。
+allowed-tools: get_bookmark_tags, save_bookmark
+---
+
+# URL 收藏技能
+
+## 何时使用
+
+当用户希望**保存一个链接/URL 到收藏**时使用本技能，例如：
+
+- 「收藏这个链接」「把这条链接存一下」
+- 「把这个网址加到技术标签」「存到待读里」
+- 「保存当前页面」「记一下这个地址」
+
+## 工作流程
+
+1. **获取可用标签**：先调用工具 `get_bookmark_tags`，获取系统中已维护的标签列表（用户在「设置 → 标签管理」中维护）。
+2. **理解用户意图**：从用户话里提取：
+   - 要收藏的 **URL**（用户可能直接给出，或说「当前页面」「刚发的那条」等，需结合上下文确定）；
+   - 用户指定的**标签**（如「技术」「待读」），须与 `get_bookmark_tags` 返回的标签名**完全一致**；若用户未指定，可根据内容推断一个已有标签或留空。
+3. **保存收藏**：调用工具 `save_bookmark`，传入：
+   - `url`：必填，要收藏的链接；
+   - `title`：可选，可取自页面标题或用户描述；
+   - `tagNames`：可选，从可用标签中选出的名称数组（须与系统标签一致）。
+
+## 工具说明
+
+- **get_bookmark_tags**：无参数。返回当前可用的标签名称列表，供后续匹配。
+- **save_bookmark**：参数 `url`（必填）、`title`（可选）、`tagNames`（可选，字符串数组）。标签名必须来自 get_bookmark_tags，否则不会关联成功。
+
+## 注意
+
+- 标签由用户在「设置 → 标签管理」中维护；若尚无标签，可只保存 URL，不传 `tagNames`。
+- 用户说「存到某某分类」时，将「某某」与 get_bookmark_tags 返回的标签名做匹配（同义或相近即可选对应标签）。