@shareai-lab/kode-sdk 1.0.0-beta.9 → 2.7.0

package/dist/core/skills/manager.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Skills 管理器
+ *
+ * 设计原则 (UNIX哲学):
+ * - 简洁: 只负责扫描和加载skills，不处理业务逻辑
+ * - 模块化: 单一职责，易于测试和维护
+ * - 热更新: 每次调用都重新扫描文件系统，确保数据最新
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsManager = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("../../utils/logger");
+/**
+ * Skills 管理器
+ */
+class SkillsManager {
+    constructor(skillsDir, allowedSkills) {
+        this.cache = new Map();
+        // 优先使用传入的路径，其次使用环境变量，最后使用默认路径
+        // 默认路径：程序当前工作目录下的 skills/
+        const envSkillsDir = process.env.SKILLS_DIR;
+        const defaultSkillsDir = path.join(process.cwd(), 'skills');
+        this.skillsDir = path.resolve(skillsDir ||
+            envSkillsDir ||
+            defaultSkillsDir);
+        // 设置允许加载的 skills 白名单
+        this.allowedSkills = allowedSkills;
+        logger_1.logger.log(`[SkillsManager] Initialized with skills directory: ${this.skillsDir}`);
+        if (this.allowedSkills) {
+            logger_1.logger.log(`[SkillsManager] Allowed skills whitelist: ${this.allowedSkills.join(', ')}`);
+        }
+    }
+    /**
+     * 扫描skills目录（支持热更新）
+     * 每次调用时重新扫描，确保读取最新数据
+     */
+    async scan() {
+        // 清空缓存
+        this.cache.clear();
+        try {
+            // 检查目录是否存在
+            const exists = await this.fileExists(this.skillsDir);
+            if (!exists) {
+                logger_1.logger.log(`[SkillsManager] Skills directory does not exist: ${this.skillsDir}`);
+                return [];
+            }
+            // 递归扫描skills目录
+            const entries = await this.scanDirectory(this.skillsDir);
+            // 提取每个skill的元数据
+            for (const entry of entries) {
+                const metadata = await this.parseSkillMetadata(entry);
+                if (metadata) {
+                    // 如果设置了白名单，只加载白名单中的 skills
+                    if (this.allowedSkills) {
+                        if (this.allowedSkills.includes(metadata.name)) {
+                            this.cache.set(metadata.name, metadata);
+                        }
+                        else {
+                            logger_1.logger.log(`[SkillsManager] Skipping skill not in whitelist: ${metadata.name}`);
+                        }
+                    }
+                    else {
+                        // 没有设置白名单，加载所有 skills
+                        this.cache.set(metadata.name, metadata);
+                    }
+                }
+            }
+            logger_1.logger.log(`[SkillsManager] Scanned ${this.cache.size} skill(s)`);
+            return Array.from(this.cache.values());
+        }
+        catch (error) {
+            logger_1.logger.error(`[SkillsManager] Error scanning skills directory:`, error.message);
+            return [];
+        }
+    }
+    /**
+     * 获取所有skills的元数据列表（供LLM选择）
+     */
+    async getSkillsMetadata() {
+        // 每次调用时重新扫描，支持热更新
+        return await this.scan();
+    }
+    /**
+     * 加载指定skill的完整内容
+     */
+    async loadSkillContent(skillName) {
+        // 先扫描确保元数据最新
+        await this.scan();
+        const metadata = this.cache.get(skillName);
+        if (!metadata) {
+            return null;
+        }
+        try {
+            // 读取SKILL.md内容
+            const content = await fs.readFile(metadata.path, 'utf-8');
+            // 扫描子目录
+            const references = await this.listSubdirectory(metadata.baseDir, 'references');
+            const scripts = await this.listSubdirectory(metadata.baseDir, 'scripts');
+            const assets = await this.listSubdirectory(metadata.baseDir, 'assets');
+            return {
+                metadata,
+                content,
+                references,
+                scripts,
+                assets,
+            };
+        }
+        catch (error) {
+            logger_1.logger.error(`[SkillsManager] Error loading skill content:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * 递归扫描目录，查找所有SKILL.md
+     */
+    async scanDirectory(dir) {
+        const skillFiles = [];
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // 检查是否有SKILL.md
+                    const skillMdPath = path.join(fullPath, 'SKILL.md');
+                    if (await this.fileExists(skillMdPath)) {
+                        skillFiles.push(skillMdPath);
+                    }
+                    else {
+                        // 递归扫描子目录
+                        const subSkills = await this.scanDirectory(fullPath);
+                        skillFiles.push(...subSkills);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn(`[SkillsManager] Error reading directory ${dir}:`, error.message);
+        }
+        return skillFiles;
+    }
+    /**
+     * 解析SKILL.md，提取元数据
+     */
+    async parseSkillMetadata(skillMdPath) {
+        try {
+            const content = await fs.readFile(skillMdPath, 'utf-8');
+            // 提取YAML frontmatter
+            const match = content.match(/^---\n([\s\S]+?)\n---/);
+            if (!match) {
+                logger_1.logger.warn(`[SkillsManager] Invalid SKILL.md (missing YAML frontmatter): ${skillMdPath}`);
+                return null;
+            }
+            const yaml = match[1];
+            const nameMatch = yaml.match(/^name:\s*(.+)$/m);
+            const descMatch = yaml.match(/^description:\s*(.+)$/m);
+            if (!nameMatch) {
+                logger_1.logger.warn(`[SkillsManager] Invalid SKILL.md (missing name): ${skillMdPath}`);
+                return null;
+            }
+            return {
+                name: nameMatch[1].trim(),
+                description: descMatch ? descMatch[1].trim() : '',
+                path: skillMdPath,
+                baseDir: path.dirname(skillMdPath),
+            };
+        }
+        catch (error) {
+            logger_1.logger.warn(`[SkillsManager] Error parsing ${skillMdPath}:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * 列出子目录下的文件
+     */
+    async listSubdirectory(baseDir, subdir) {
+        const fullPath = path.join(baseDir, subdir);
+        if (!(await this.fileExists(fullPath))) {
+            return [];
+        }
+        const files = [];
+        try {
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    files.push(path.join(fullPath, entry.name));
+                }
+            }
+        }
+        catch (error) {
+            // 目录不存在或无权限访问，返回空数组
+            logger_1.logger.debug(`[SkillsManager] Subdirectory not accessible: ${fullPath}`);
+        }
+        return files;
+    }
+    /**
+     * 检查文件是否存在
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.SkillsManager = SkillsManager;

package/dist/core/skills/operation-queue.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 操作队列模块
+ *
+ * 设计原则 (UNIX哲学):
+ * - 简洁: 只负责队列管理，单一职责
+ * - 模块化: 独立的队列逻辑，易于测试和维护
+ * - 隔离: 与技能管理逻辑分离，专注于并发控制
+ */
+/**
+ * 操作类型枚举
+ */
+export declare enum OperationType {
+    CREATE = "create",
+    RENAME = "rename",
+    EDIT = "edit",
+    DELETE = "delete",
+    RESTORE = "restore"
+}
+/**
+ * 操作状态枚举
+ */
+export declare enum OperationStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+/**
+ * 操作任务接口
+ */
+export interface OperationTask {
+    /** 操作ID */
+    id: string;
+    /** 操作类型 */
+    type: OperationType;
+    /** 目标技能 */
+    targetSkill: string;
+    /** 操作状态 */
+    status: OperationStatus;
+    /** 执行操作 */
+    execute(): Promise<void>;
+    /** 创建时间 */
+    createdAt: Date;
+    /** 开始时间 */
+    startedAt?: Date;
+    /** 完成时间 */
+    completedAt?: Date;
+    /** 错误信息 */
+    error?: Error;
+}
+/**
+ * 操作队列类
+ *
+ * 职责:
+ * - 管理技能管理操作的并发执行
+ * - 按FIFO顺序处理操作
+ * - 防止操作冲突
+ */
+export declare class OperationQueue {
+    private queue;
+    private processing;
+    private readonly maxConcurrent;
+    /**
+     * 入队操作
+     */
+    enqueue(task: OperationTask): Promise<void>;
+    /**
+     * 出队操作
+     */
+    private dequeue;
+    /**
+     * 处理队列
+     */
+    private processQueue;
+    /**
+     * 获取队列状态
+     */
+    getQueueStatus(): {
+        length: number;
+        processing: boolean;
+        tasks: OperationTask[];
+    };
+    /**
+     * 清空队列
+     */
+    clear(): void;
+}

package/dist/core/skills/operation-queue.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * 操作队列模块
+ *
+ * 设计原则 (UNIX哲学):
+ * - 简洁: 只负责队列管理，单一职责
+ * - 模块化: 独立的队列逻辑，易于测试和维护
+ * - 隔离: 与技能管理逻辑分离，专注于并发控制
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationQueue = exports.OperationStatus = exports.OperationType = void 0;
+const logger_1 = require("../../utils/logger");
+/**
+ * 操作类型枚举
+ */
+var OperationType;
+(function (OperationType) {
+    OperationType["CREATE"] = "create";
+    OperationType["RENAME"] = "rename";
+    OperationType["EDIT"] = "edit";
+    OperationType["DELETE"] = "delete";
+    OperationType["RESTORE"] = "restore";
+})(OperationType || (exports.OperationType = OperationType = {}));
+/**
+ * 操作状态枚举
+ */
+var OperationStatus;
+(function (OperationStatus) {
+    OperationStatus["PENDING"] = "pending";
+    OperationStatus["PROCESSING"] = "processing";
+    OperationStatus["COMPLETED"] = "completed";
+    OperationStatus["FAILED"] = "failed";
+})(OperationStatus || (exports.OperationStatus = OperationStatus = {}));
+/**
+ * 操作队列类
+ *
+ * 职责:
+ * - 管理技能管理操作的并发执行
+ * - 按FIFO顺序处理操作
+ * - 防止操作冲突
+ */
+class OperationQueue {
+    constructor() {
+        this.queue = [];
+        this.processing = false;
+        this.maxConcurrent = 1; // 串行执行，避免冲突
+    }
+    /**
+     * 入队操作
+     */
+    async enqueue(task) {
+        this.queue.push(task);
+        logger_1.logger.log(`[OperationQueue] 操作已入队: ${task.type} - ${task.targetSkill}`);
+        // 如果没有正在处理，启动处理（不等待，异步执行）
+        if (!this.processing) {
+            // 不使用await，让队列异步处理
+            this.processQueue().catch(error => {
+                logger_1.logger.error('[OperationQueue] Queue processing error:', error);
+            });
+        }
+    }
+    /**
+     * 出队操作
+     */
+    dequeue() {
+        return this.queue.shift() || null;
+    }
+    /**
+     * 处理队列
+     */
+    async processQueue() {
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const task = this.dequeue();
+            if (!task)
+                break;
+            task.status = OperationStatus.PROCESSING;
+            task.startedAt = new Date();
+            try {
+                logger_1.logger.log(`[OperationQueue] 开始处理: ${task.type} - ${task.targetSkill}`);
+                await task.execute();
+                task.status = OperationStatus.COMPLETED;
+                task.completedAt = new Date();
+                logger_1.logger.log(`[OperationQueue] 操作完成: ${task.type} - ${task.targetSkill}`);
+            }
+            catch (error) {
+                task.status = OperationStatus.FAILED;
+                task.completedAt = new Date();
+                task.error = error;
+                logger_1.logger.error(`[OperationQueue] 操作失败: ${task.type} - ${task.targetSkill}`, error);
+            }
+        }
+        this.processing = false;
+    }
+    /**
+     * 获取队列状态
+     */
+    getQueueStatus() {
+        return {
+            length: this.queue.length,
+            processing: this.processing,
+            tasks: [...this.queue],
+        };
+    }
+    /**
+     * 清空队列
+     */
+    clear() {
+        this.queue = [];
+        logger_1.logger.log('[OperationQueue] 队列已清空');
+    }
+}
+exports.OperationQueue = OperationQueue;

package/dist/core/skills/sandbox-file-manager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Sandbox文件管理器模块
+ *
+ * 设计原则 (UNIX哲学):
+ * - 简洁: 只负责sandbox中的文件操作
+ * - 模块化: 独立的文件操作逻辑
+ * - 安全: 强制边界控制，确保只能访问技能目录内文件
+ */
+import { SandboxFactory } from '../../infra/sandbox-factory';
+/**
+ * 文件树节点接口
+ */
+export interface SkillFileTree {
+    /** 文件/目录名 */
+    name: string;
+    /** 类型 */
+    type: 'file' | 'dir';
+    /** 相对于技能根目录的路径 */
+    path: string;
+    /** 文件大小（字节） */
+    size?: number;
+    /** 修改时间 */
+    modifiedTime?: string;
+    /** 子节点（目录） */
+    children?: SkillFileTree[];
+}
+/**
+ * Sandbox文件管理器类
+ *
+ * 职责:
+ * - 在sandbox隔离环境中执行文件操作
+ * - 确保文件访问边界在技能目录内
+ * - 提供read、write、delete、list等基础文件操作
+ */
+export declare class SandboxFileManager {
+    private sandboxFactory;
+    constructor(sandboxFactory: SandboxFactory);
+    /**
+     * 在sandbox中读取文件
+     * @param skillBaseDir 技能根目录
+     * @param relativePath 相对路径
+     */
+    readFile(skillBaseDir: string, relativePath: string): Promise<string>;
+    /**
+     * 在sandbox中写入文件
+     * @param skillBaseDir 技能根目录
+     * @param relativePath 相对路径
+     * @param content 文件内容
+     */
+    writeFile(skillBaseDir: string, relativePath: string, content: string): Promise<void>;
+    /**
+     * 在sandbox中删除文件
+     * @param skillBaseDir 技能根目录
+     * @param relativePath 相对路径
+     */
+    deleteFile(skillBaseDir: string, relativePath: string): Promise<void>;
+    /**
+     * 在sandbox中列出目录
+     * @param skillBaseDir 技能根目录
+     * @param relativePath 相对路径
+     */
+    listFiles(skillBaseDir: string, relativePath?: string): Promise<SkillFileTree>;
+    /**
+     * 在sandbox中创建目录
+     * @param skillBaseDir 技能根目录
+     * @param relativePath 相对路径
+     */
+    createDir(skillBaseDir: string, relativePath: string): Promise<void>;
+    /**
+     * 创建技能的sandbox实例
+     * 关键：设置enforceBoundary=true，确保只能在技能目录内操作
+     */
+    private createSkillSandbox;
+    /**
+     * 获取删除命令（跨平台）
+     */
+    private getDeleteCommand;
+    /**
+     * 构建文件树
+     */
+    private buildFileTree;
+}