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

package/dist/core/scheduler.js

@@ -1,184 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentSchedulerHandle = exports.Scheduler = void 0;
+exports.Scheduler = void 0;
 class Scheduler {
-    constructor() {
-        this.tasks = new Map();
-        this.stepCounters = new Map();
-        this.timers = [];
-    }
-    every(interval, callback) {
-        const ms = this.parseInterval(interval);
-        const id = `time-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        const task = {
-            id,
-            type: 'time',
-            spec: interval,
-            callback,
-            enabled: true,
-        };
-        this.tasks.set(id, task);
-        const timer = setInterval(() => {
-            if (task.enabled) {
-                task.callback({ count: 0, type: 'time', id });
-                task.lastRun = Date.now();
-            }
-        }, ms);
-        this.timers.push(timer);
-        return this;
-    }
-    everySteps(steps, callback, targetId) {
-        const id = targetId || `step-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        const task = {
-            id,
-            type: 'step',
-            spec: steps,
-            callback,
-            enabled: true,
-        };
-        this.tasks.set(id, task);
-        this.stepCounters.set(id, 0);
-        return this;
-    }
-    daily(time, callback) {
-        const id = `daily-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        const task = {
-            id,
-            type: 'daily',
-            spec: time,
-            callback,
-            enabled: true,
-        };
-        this.tasks.set(id, task);
-        this.scheduleDailyTask(task);
-        return this;
-    }
-    weekly(dayTime, callback) {
-        const id = `weekly-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        const task = {
+    constructor(opts) {
+        this.stepTasks = new Map();
+        this.listeners = new Set();
+        this.queued = Promise.resolve();
+        this.onTrigger = opts?.onTrigger;
+    }
+    everySteps(every, callback) {
+        if (!Number.isFinite(every) || every <= 0) {
+            throw new Error('everySteps: interval must be positive');
+        }
+        const id = this.generateId('steps');
+        this.stepTasks.set(id, {
             id,
-            type: 'weekly',
-            spec: dayTime,
+            every,
             callback,
-            enabled: true,
-        };
-        this.tasks.set(id, task);
-        this.scheduleWeeklyTask(task);
-        return this;
+            lastTriggered: 0,
+        });
+        return id;
     }
-    notifyStep(targetId) {
-        for (const [id, task] of this.tasks) {
-            if (task.type === 'step' && (!targetId || id === targetId)) {
-                const count = (this.stepCounters.get(id) || 0) + 1;
-                this.stepCounters.set(id, count);
-                if (count >= task.spec) {
-                    task.callback({ count, type: 'step', id });
-                    this.stepCounters.set(id, 0);
-                    task.lastRun = Date.now();
-                }
-            }
-        }
+    onStep(callback) {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
     }
-    stop() {
-        for (const timer of this.timers) {
-            clearInterval(timer);
-        }
-        this.timers = [];
-        this.tasks.clear();
-        this.stepCounters.clear();
-    }
-    parseInterval(interval) {
-        const match = interval.match(/^(\d+)(s|m|h|d)$/);
-        if (!match)
-            throw new Error(`Invalid interval: ${interval}`);
-        const value = parseInt(match[1], 10);
-        const unit = match[2];
-        switch (unit) {
-            case 's':
-                return value * 1000;
-            case 'm':
-                return value * 60 * 1000;
-            case 'h':
-                return value * 60 * 60 * 1000;
-            case 'd':
-                return value * 24 * 60 * 60 * 1000;
-            default:
-                throw new Error(`Unknown unit: ${unit}`);
-        }
+    enqueue(callback) {
+        this.queued = this.queued.then(() => Promise.resolve(callback())).catch(() => undefined);
     }
-    scheduleDailyTask(task) {
-        const [hours, minutes] = task.spec.split(':').map(Number);
-        const now = new Date();
-        const target = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes, 0);
-        if (target.getTime() <= now.getTime()) {
-            target.setDate(target.getDate() + 1);
+    notifyStep(stepCount) {
+        for (const listener of this.listeners) {
+            void Promise.resolve(listener({ stepCount }));
         }
-        const delay = target.getTime() - now.getTime();
-        const timeout = setTimeout(() => {
-            if (task.enabled) {
-                task.callback({ time: task.spec, type: 'daily', id: task.id });
-                task.lastRun = Date.now();
-            }
-            this.scheduleDailyTask(task);
-        }, delay);
-        this.timers.push(timeout);
-    }
-    scheduleWeeklyTask(task) {
-        const [day, time] = task.spec.split(' ');
-        const [hours, minutes] = time.split(':').map(Number);
-        const dayMap = {
-            Sun: 0,
-            Mon: 1,
-            Tue: 2,
-            Wed: 3,
-            Thu: 4,
-            Fri: 5,
-            Sat: 6,
-        };
-        const targetDay = dayMap[day];
-        if (targetDay === undefined)
-            throw new Error(`Invalid day: ${day}`);
-        const now = new Date();
-        const target = new Date(now);
-        target.setHours(hours, minutes, 0, 0);
-        const currentDay = now.getDay();
-        let daysUntilTarget = targetDay - currentDay;
-        if (daysUntilTarget < 0 || (daysUntilTarget === 0 && target.getTime() <= now.getTime())) {
-            daysUntilTarget += 7;
+        for (const task of this.stepTasks.values()) {
+            const shouldTrigger = stepCount - task.lastTriggered >= task.every;
+            if (!shouldTrigger)
+                continue;
+            task.lastTriggered = stepCount;
+            void Promise.resolve(task.callback({ stepCount }));
+            this.onTrigger?.({ taskId: task.id, spec: `steps:${task.every}`, kind: 'steps' });
         }
-        target.setDate(target.getDate() + daysUntilTarget);
-        const delay = target.getTime() - now.getTime();
-        const timeout = setTimeout(() => {
-            if (task.enabled) {
-                task.callback({ time: task.spec, type: 'weekly', id: task.id });
-                task.lastRun = Date.now();
-            }
-            this.scheduleWeeklyTask(task);
-        }, delay);
-        this.timers.push(timeout);
     }
-}
-exports.Scheduler = Scheduler;
-class AgentSchedulerHandle {
-    constructor(scheduler, agentId) {
-        this.scheduler = scheduler;
-        this.agentId = agentId;
+    cancel(taskId) {
+        this.stepTasks.delete(taskId);
     }
-    every(interval, callback) {
-        this.scheduler.every(interval, callback);
-        return this;
+    clear() {
+        this.stepTasks.clear();
+        this.listeners.clear();
     }
-    everySteps(steps, callback) {
-        this.scheduler.everySteps(steps, callback, this.agentId);
-        return this;
+    notifyExternalTrigger(info) {
+        this.onTrigger?.(info);
     }
-    daily(time, callback) {
-        this.scheduler.daily(time, callback);
-        return this;
-    }
-    weekly(dayTime, callback) {
-        this.scheduler.weekly(dayTime, callback);
-        return this;
+    generateId(prefix) {
+        return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
     }
 }
-exports.AgentSchedulerHandle = AgentSchedulerHandle;
+exports.Scheduler = Scheduler;

package/dist/core/skills/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Skills 模块导出
+ */
+export { SkillsManager } from './manager';
+export type { SkillMetadata, SkillContent, SandboxConfig } from './types';
+export { generateSkillsMetadataXml } from './xml-generator';
+export { SkillsManagementManager } from './management-manager';
+export { OperationQueue, OperationType, OperationStatus } from './operation-queue';
+export { SandboxFileManager } from './sandbox-file-manager';
+export type { SkillInfo, SkillDetail, SkillFileTree, CreateSkillOptions, ArchivedSkillInfo, } from './types';

package/dist/core/skills/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Skills 模块导出
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFileManager = exports.OperationStatus = exports.OperationType = exports.OperationQueue = exports.SkillsManagementManager = exports.generateSkillsMetadataXml = exports.SkillsManager = void 0;
+// 路径2: Agent使用（现有模块）
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "SkillsManager", { enumerable: true, get: function () { return manager_1.SkillsManager; } });
+var xml_generator_1 = require("./xml-generator");
+Object.defineProperty(exports, "generateSkillsMetadataXml", { enumerable: true, get: function () { return xml_generator_1.generateSkillsMetadataXml; } });
+// 路径1: 技能管理（新增模块）
+var management_manager_1 = require("./management-manager");
+Object.defineProperty(exports, "SkillsManagementManager", { enumerable: true, get: function () { return management_manager_1.SkillsManagementManager; } });
+var operation_queue_1 = require("./operation-queue");
+Object.defineProperty(exports, "OperationQueue", { enumerable: true, get: function () { return operation_queue_1.OperationQueue; } });
+Object.defineProperty(exports, "OperationType", { enumerable: true, get: function () { return operation_queue_1.OperationType; } });
+Object.defineProperty(exports, "OperationStatus", { enumerable: true, get: function () { return operation_queue_1.OperationStatus; } });
+var sandbox_file_manager_1 = require("./sandbox-file-manager");
+Object.defineProperty(exports, "SandboxFileManager", { enumerable: true, get: function () { return sandbox_file_manager_1.SandboxFileManager; } });

package/dist/core/skills/management-manager.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 技能管理器模块（路径1 - 技能管理）
+ *
+ * 设计原则 (UNIX哲学):
+ * - 简洁: 只负责技能文件系统的CRUD操作
+ * - 模块化: 协调OperationQueue、SandboxFileManager进行文件系统操作
+ * - 隔离: 与Agent运行时完全隔离，不参与Agent使用
+ *
+ * ⚠️ 重要说明:
+ * - 此模块专门用于路径1（技能管理）
+ * - 与路径2（Agent运行时）完全独立
+ * - 请勿与SkillsManager混淆
+ */
+import { OperationTask } from './operation-queue';
+import type { SkillInfo, SkillDetail, SkillFileTree, CreateSkillOptions, ArchivedSkillInfo } from './types';
+import { SandboxFactory } from '../../infra/sandbox-factory';
+/**
+ * 技能管理器类
+ *
+ * 职责:
+ * - 提供所有技能管理操作的统一接口（CRUD操作）
+ * - 协调OperationQueue、SandboxFileManager进行文件系统操作
+ * - 处理业务逻辑和权限验证
+ * - ❌ 不参与Agent运行时
+ * - ❌ 不提供技能加载、扫描等Agent使用的功能
+ */
+export declare class SkillsManagementManager {
+    private skillsManager;
+    private operationQueue;
+    private sandboxFileManager;
+    private skillsDir;
+    private archivedDir;
+    constructor(skillsDir: string, sandboxFactory?: SandboxFactory, archivedDir?: string);
+    /**
+     * 获取所有在线技能列表（不包含archived技能）
+     */
+    listSkills(): Promise<SkillInfo[]>;
+    /**
+     * 获取单个在线技能详细信息
+     * @param skillName 技能名称
+     */
+    getSkillInfo(skillName: string): Promise<SkillDetail | null>;
+    /**
+     * 获取已归档技能列表（只读，不支持修改）
+     */
+    listArchivedSkills(): Promise<ArchivedSkillInfo[]>;
+    /**
+     * 创建新技能
+     * @param skillName 技能名称
+     * @param options 技能配置（名称、描述等）
+     */
+    createSkill(skillName: string, options: CreateSkillOptions): Promise<SkillDetail>;
+    /**
+     * 重命名技能
+     * @param oldName 旧技能名称
+     * @param newName 新技能名称
+     */
+    renameSkill(oldName: string, newName: string): Promise<void>;
+    /**
+     * 编辑技能文件
+     * @param skillName 技能名称
+     * @param filePath 文件路径（相对于技能根目录，如"SKILL.md"）
+     * @param content 文件内容
+     * @param useSandbox 是否使用sandbox（默认true）
+     */
+    editSkillFile(skillName: string, filePath: string, content: string, useSandbox?: boolean): Promise<void>;
+    /**
+     * 删除技能（移动到archived）
+     * @param skillName 技能名称
+     */
+    deleteSkill(skillName: string): Promise<void>;
+    /**
+     * 恢复已删除的技能
+     * @param archivedSkillName archived中的技能名称（含时间戳）
+     */
+    restoreSkill(archivedSkillName: string): Promise<void>;
+    /**
+     * 获取技能文件树（仅在线技能）
+     * @param skillName 技能名称
+     */
+    getSkillFileTree(skillName: string): Promise<SkillFileTree>;
+    /**
+     * 获取队列状态
+     */
+    getQueueStatus(): {
+        length: number;
+        processing: boolean;
+        tasks: OperationTask[];
+    };
+    /**
+     * 执行创建技能
+     */
+    private doCreateSkill;
+    /**
+     * 执行重命名技能
+     */
+    private doRenameSkill;
+    /**
+     * 执行编辑技能文件
+     */
+    private doEditSkillFile;
+    /**
+     * 执行删除技能
+     */
+    private doDeleteSkill;
+    /**
+     * 执行恢复技能
+     */
+    private doRestoreSkill;
+    /**
+     * 验证技能名称
+     */
+    private isValidSkillName;
+    /**
+     * 生成SKILL.md内容
+     */
+    private generateSkillMd;
+    /**
+     * 检查文件是否存在
+     */
+    private fileExists;
+    /**
+     * 安全获取文件统计信息
+     */
+    private safeGetFileStat;
+    /**
+     * 等待任务完成
+     */
+    private waitForTask;
+}