@oflow-ai/core 0.1.0

package/dist/sandbox/index.d.ts

@@ -0,0 +1,31 @@
+export type SandboxBackend = 'none' | 'docker' | 'podman';
+export interface SandboxConfig {
+    backend: SandboxBackend;
+    image?: string;
+    timeout?: number;
+    memoryLimit?: string;
+    cpuLimit?: string;
+    networkEnabled?: boolean;
+    mountPoints?: {
+        host: string;
+        container: string;
+    }[];
+}
+export interface SandboxResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+}
+export declare class SandboxExecutor {
+    private config;
+    private containerId;
+    constructor(config?: Partial<SandboxConfig>);
+    execute(command: string, cwd?: string): Promise<SandboxResult>;
+    private executeDirectly;
+    private executeInDocker;
+    private executeInPodman;
+    private runContainerCommand;
+    static detectBackend(): Promise<SandboxBackend>;
+}
+export declare function createSandboxExecutor(config?: Partial<SandboxConfig>): Promise<SandboxExecutor>;

package/dist/sandbox/index.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxExecutor = void 0;
+exports.createSandboxExecutor = createSandboxExecutor;
+const child_process_1 = require("child_process");
+const DEFAULT_IMAGE = 'node:20-slim';
+const DEFAULT_TIMEOUT = 120000; // 2 minutes
+class SandboxExecutor {
+    config;
+    containerId = null;
+    constructor(config) {
+        this.config = {
+            backend: config?.backend || 'none',
+            image: config?.image || DEFAULT_IMAGE,
+            timeout: config?.timeout || DEFAULT_TIMEOUT,
+            memoryLimit: config?.memoryLimit,
+            cpuLimit: config?.cpuLimit,
+            networkEnabled: config?.networkEnabled ?? false,
+            mountPoints: config?.mountPoints || []
+        };
+    }
+    async execute(command, cwd) {
+        switch (this.config.backend) {
+            case 'docker':
+                return this.executeInDocker(command, cwd);
+            case 'podman':
+                return this.executeInPodman(command, cwd);
+            case 'none':
+            default:
+                return this.executeDirectly(command, cwd);
+        }
+    }
+    async executeDirectly(command, cwd) {
+        return new Promise((resolve) => {
+            const isWindows = process.platform === 'win32';
+            const shell = isWindows ? 'powershell.exe' : '/bin/bash';
+            const shellArgs = isWindows
+                ? ['-NoProfile', '-Command', command]
+                : ['-c', command];
+            const proc = (0, child_process_1.spawn)(shell, shellArgs, {
+                cwd: cwd || process.cwd(),
+                env: process.env
+            });
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            const timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill();
+            }, this.config.timeout);
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: code || 0,
+                    timedOut
+                });
+            });
+            proc.on('error', (error) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    stdout,
+                    stderr: error.message,
+                    exitCode: 1,
+                    timedOut: false
+                });
+            });
+        });
+    }
+    async executeInDocker(command, cwd) {
+        const workingDir = cwd || process.cwd();
+        // 构建Docker运行命令
+        const dockerArgs = [
+            'run',
+            '--rm',
+            '-v', `${workingDir}:/workspace`,
+            '-w', '/workspace'
+        ];
+        // 网络设置
+        if (!this.config.networkEnabled) {
+            dockerArgs.push('--network', 'none');
+        }
+        // 内存限制
+        if (this.config.memoryLimit) {
+            dockerArgs.push('--memory', this.config.memoryLimit);
+        }
+        // CPU限制
+        if (this.config.cpuLimit) {
+            dockerArgs.push('--cpus', this.config.cpuLimit);
+        }
+        // 超时设置
+        dockerArgs.push('--timeout', String(Math.floor(this.config.timeout / 1000)));
+        // 添加镜像和命令
+        dockerArgs.push(this.config.image);
+        dockerArgs.push('sh', '-c', command);
+        return this.runContainerCommand('docker', dockerArgs);
+    }
+    async executeInPodman(command, cwd) {
+        const workingDir = cwd || process.cwd();
+        // Podman参数与Docker类似
+        const podmanArgs = [
+            'run',
+            '--rm',
+            '-v', `${workingDir}:/workspace`,
+            '-w', '/workspace'
+        ];
+        if (!this.config.networkEnabled) {
+            podmanArgs.push('--network', 'none');
+        }
+        if (this.config.memoryLimit) {
+            podmanArgs.push('--memory', this.config.memoryLimit);
+        }
+        if (this.config.cpuLimit) {
+            podmanArgs.push('--cpus', this.config.cpuLimit);
+        }
+        podmanArgs.push(this.config.image);
+        podmanArgs.push('sh', '-c', command);
+        return this.runContainerCommand('podman', podmanArgs);
+    }
+    runContainerCommand(runtime, args) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(runtime, args, {
+                env: process.env
+            });
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            const timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill();
+            }, this.config.timeout);
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: code || 0,
+                    timedOut
+                });
+            });
+            proc.on('error', (error) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    stdout,
+                    stderr: `Failed to run ${runtime}: ${error.message}`,
+                    exitCode: 1,
+                    timedOut: false
+                });
+            });
+        });
+    }
+    static async detectBackend() {
+        // 检查Docker是否可用
+        try {
+            const dockerCheck = await new Promise((resolve) => {
+                const proc = (0, child_process_1.spawn)('docker', ['--version']);
+                proc.on('close', (code) => resolve(code === 0));
+                proc.on('error', () => resolve(false));
+            });
+            if (dockerCheck)
+                return 'docker';
+        }
+        catch { }
+        // 检查Podman是否可用
+        try {
+            const podmanCheck = await new Promise((resolve) => {
+                const proc = (0, child_process_1.spawn)('podman', ['--version']);
+                proc.on('close', (code) => resolve(code === 0));
+                proc.on('error', () => resolve(false));
+            });
+            if (podmanCheck)
+                return 'podman';
+        }
+        catch { }
+        return 'none';
+    }
+}
+exports.SandboxExecutor = SandboxExecutor;
+// 工具函数：创建沙箱执行器
+async function createSandboxExecutor(config) {
+    const backend = config?.backend || await SandboxExecutor.detectBackend();
+    return new SandboxExecutor({ ...config, backend });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sandbox/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn, ChildProcess } from 'child_process';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\n\nexport type SandboxBackend = 'none' | 'docker' | 'podman';\n\nexport interface SandboxConfig {\n  backend: SandboxBackend;\n  image?: string;\n  timeout?: number;\n  memoryLimit?: string;\n  cpuLimit?: string;\n  networkEnabled?: boolean;\n  mountPoints?: { host: string; container: string }[];\n}\n\nexport interface SandboxResult {\n  stdout: string;\n  stderr: string;\n  exitCode: number;\n  timedOut: boolean;\n}\n\nconst DEFAULT_IMAGE = 'node:20-slim';\nconst DEFAULT_TIMEOUT = 120000; // 2 minutes\n\nexport class SandboxExecutor {\n  private config: SandboxConfig;\n  private containerId: string | null = null;\n\n  constructor(config?: Partial<SandboxConfig>) {\n    this.config = {\n      backend: config?.backend || 'none',\n      image: config?.image || DEFAULT_IMAGE,\n      timeout: config?.timeout || DEFAULT_TIMEOUT,\n      memoryLimit: config?.memoryLimit,\n      cpuLimit: config?.cpuLimit,\n      networkEnabled: config?.networkEnabled ?? false,\n      mountPoints: config?.mountPoints || []\n    };\n  }\n\n  async execute(command: string, cwd?: string): Promise<SandboxResult> {\n    switch (this.config.backend) {\n      case 'docker':\n        return this.executeInDocker(command, cwd);\n      case 'podman':\n        return this.executeInPodman(command, cwd);\n      case 'none':\n      default:\n        return this.executeDirectly(command, cwd);\n    }\n  }\n\n  private async executeDirectly(command: string, cwd?: string): Promise<SandboxResult> {\n    return new Promise((resolve) => {\n      const isWindows = process.platform === 'win32';\n      const shell = isWindows ? 'powershell.exe' : '/bin/bash';\n      const shellArgs = isWindows \n        ? ['-NoProfile', '-Command', command]\n        : ['-c', command];\n\n      const proc = spawn(shell, shellArgs, {\n        cwd: cwd || process.cwd(),\n        env: process.env\n      });\n\n      let stdout = '';\n      let stderr = '';\n      let timedOut = false;\n\n      const timeoutId = setTimeout(() => {\n        timedOut = true;\n        proc.kill();\n      }, this.config.timeout);\n\n      proc.stdout.on('data', (data) => {\n        stdout += data.toString();\n      });\n\n      proc.stderr.on('data', (data) => {\n        stderr += data.toString();\n      });\n\n      proc.on('close', (code) => {\n        clearTimeout(timeoutId);\n        resolve({\n          stdout,\n          stderr,\n          exitCode: code || 0,\n          timedOut\n        });\n      });\n\n      proc.on('error', (error) => {\n        clearTimeout(timeoutId);\n        resolve({\n          stdout,\n          stderr: error.message,\n          exitCode: 1,\n          timedOut: false\n        });\n      });\n    });\n  }\n\n  private async executeInDocker(command: string, cwd?: string): Promise<SandboxResult> {\n    const workingDir = cwd || process.cwd();\n    \n    // 构建Docker运行命令\n    const dockerArgs = [\n      'run',\n      '--rm',\n      '-v', `${workingDir}:/workspace`,\n      '-w', '/workspace'\n    ];\n\n    // 网络设置\n    if (!this.config.networkEnabled) {\n      dockerArgs.push('--network', 'none');\n    }\n\n    // 内存限制\n    if (this.config.memoryLimit) {\n      dockerArgs.push('--memory', this.config.memoryLimit);\n    }\n\n    // CPU限制\n    if (this.config.cpuLimit) {\n      dockerArgs.push('--cpus', this.config.cpuLimit);\n    }\n\n    // 超时设置\n    dockerArgs.push('--timeout', String(Math.floor(this.config.timeout! / 1000)));\n\n    // 添加镜像和命令\n    dockerArgs.push(this.config.image!);\n    dockerArgs.push('sh', '-c', command);\n\n    return this.runContainerCommand('docker', dockerArgs);\n  }\n\n  private async executeInPodman(command: string, cwd?: string): Promise<SandboxResult> {\n    const workingDir = cwd || process.cwd();\n    \n    // Podman参数与Docker类似\n    const podmanArgs = [\n      'run',\n      '--rm',\n      '-v', `${workingDir}:/workspace`,\n      '-w', '/workspace'\n    ];\n\n    if (!this.config.networkEnabled) {\n      podmanArgs.push('--network', 'none');\n    }\n\n    if (this.config.memoryLimit) {\n      podmanArgs.push('--memory', this.config.memoryLimit);\n    }\n\n    if (this.config.cpuLimit) {\n      podmanArgs.push('--cpus', this.config.cpuLimit);\n    }\n\n    podmanArgs.push(this.config.image!);\n    podmanArgs.push('sh', '-c', command);\n\n    return this.runContainerCommand('podman', podmanArgs);\n  }\n\n  private runContainerCommand(runtime: string, args: string[]): Promise<SandboxResult> {\n    return new Promise((resolve) => {\n      const proc = spawn(runtime, args, {\n        env: process.env\n      });\n\n      let stdout = '';\n      let stderr = '';\n      let timedOut = false;\n\n      const timeoutId = setTimeout(() => {\n        timedOut = true;\n        proc.kill();\n      }, this.config.timeout);\n\n      proc.stdout.on('data', (data) => {\n        stdout += data.toString();\n      });\n\n      proc.stderr.on('data', (data) => {\n        stderr += data.toString();\n      });\n\n      proc.on('close', (code) => {\n        clearTimeout(timeoutId);\n        resolve({\n          stdout,\n          stderr,\n          exitCode: code || 0,\n          timedOut\n        });\n      });\n\n      proc.on('error', (error) => {\n        clearTimeout(timeoutId);\n        resolve({\n          stdout,\n          stderr: `Failed to run ${runtime}: ${error.message}`,\n          exitCode: 1,\n          timedOut: false\n        });\n      });\n    });\n  }\n\n  static async detectBackend(): Promise<SandboxBackend> {\n    // 检查Docker是否可用\n    try {\n      const dockerCheck = await new Promise<boolean>((resolve) => {\n        const proc = spawn('docker', ['--version']);\n        proc.on('close', (code) => resolve(code === 0));\n        proc.on('error', () => resolve(false));\n      });\n      if (dockerCheck) return 'docker';\n    } catch {}\n\n    // 检查Podman是否可用\n    try {\n      const podmanCheck = await new Promise<boolean>((resolve) => {\n        const proc = spawn('podman', ['--version']);\n        proc.on('close', (code) => resolve(code === 0));\n        proc.on('error', () => resolve(false));\n      });\n      if (podmanCheck) return 'podman';\n    } catch {}\n\n    return 'none';\n  }\n}\n\n// 工具函数：创建沙箱执行器\nexport async function createSandboxExecutor(config?: Partial<SandboxConfig>): Promise<SandboxExecutor> {\n  const backend = config?.backend || await SandboxExecutor.detectBackend();\n  return new SandboxExecutor({ ...config, backend });\n}\n"]}

package/dist/skills/index.d.ts

@@ -0,0 +1,16 @@
+import { Skill } from '../types';
+export declare class SkillManager {
+    private skillsDir;
+    private projectSkillsDir;
+    private skills;
+    constructor(skillsDir?: string, projectSkillsDir?: string);
+    loadSkills(): Promise<Skill[]>;
+    private loadSkillsFromDir;
+    private parseSkillFile;
+    getSkill(id: string): Skill | undefined;
+    getAllSkills(): Skill[];
+    getSkillContent(id: string): Promise<string | null>;
+    installSkill(source: string, scope?: 'global' | 'project'): Promise<Skill>;
+    private copyDir;
+    uninstallSkill(id: string): Promise<boolean>;
+}

package/dist/skills/index.js

@@ -0,0 +1,169 @@
+"use strict";
+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.SkillManager = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const SKILL_FILE = 'SKILL.md';
+class SkillManager {
+    skillsDir;
+    projectSkillsDir;
+    skills = new Map();
+    constructor(skillsDir, projectSkillsDir) {
+        this.skillsDir = skillsDir || path.join(process.cwd(), '.oflow', 'skills');
+        this.projectSkillsDir = projectSkillsDir || path.join(process.cwd(), '.oflow', 'skills');
+    }
+    async loadSkills() {
+        this.skills.clear();
+        // Load global skills
+        await this.loadSkillsFromDir(this.skillsDir, 'global');
+        // Load project skills (override global with same name)
+        await this.loadSkillsFromDir(this.projectSkillsDir, 'project');
+        return this.getAllSkills();
+    }
+    async loadSkillsFromDir(dir, scope) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillPath = path.join(dir, entry.name);
+                const skillFile = path.join(skillPath, SKILL_FILE);
+                try {
+                    const content = await fs.readFile(skillFile, 'utf-8');
+                    const skill = this.parseSkillFile(skillPath, content);
+                    if (skill) {
+                        this.skills.set(skill.id, { ...skill, path: skillPath });
+                    }
+                }
+                catch {
+                    // Skip invalid skills
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    parseSkillFile(skillPath, content) {
+        try {
+            // Parse YAML frontmatter
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+            if (!frontmatterMatch) {
+                return null;
+            }
+            const frontmatter = frontmatterMatch[1];
+            const mainContent = frontmatterMatch[2];
+            // Parse frontmatter (simple key: value parsing)
+            const meta = {};
+            frontmatter.split('\n').forEach(line => {
+                const match = line.match(/^(\w+):\s*(.*)$/);
+                if (match) {
+                    meta[match[1]] = match[2];
+                }
+            });
+            return {
+                id: meta.id || path.basename(skillPath),
+                name: meta.name || path.basename(skillPath),
+                description: meta.description || '',
+                version: meta.version || '1.0.0',
+                path: skillPath,
+                mainFile: SKILL_FILE
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    getSkill(id) {
+        return this.skills.get(id);
+    }
+    getAllSkills() {
+        return Array.from(this.skills.values());
+    }
+    async getSkillContent(id) {
+        const skill = this.skills.get(id);
+        if (!skill)
+            return null;
+        try {
+            const skillFile = path.join(skill.path, SKILL_FILE);
+            return await fs.readFile(skillFile, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async installSkill(source, scope = 'project') {
+        const targetDir = scope === 'global' ? this.skillsDir : this.projectSkillsDir;
+        const skillId = path.basename(source).replace(/\.git$/, '');
+        const targetPath = path.join(targetDir, skillId);
+        // For now, we'll just copy from a local path
+        // In a real implementation, this would support git repos, archives, etc.
+        await fs.mkdir(targetDir, { recursive: true });
+        // Copy directory
+        await this.copyDir(source, targetPath);
+        // Reload skills
+        await this.loadSkills();
+        const skill = this.skills.get(skillId);
+        if (!skill) {
+            throw new Error('Failed to load installed skill');
+        }
+        return skill;
+    }
+    async copyDir(src, dest) {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDir(srcPath, destPath);
+            }
+            else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+    async uninstallSkill(id) {
+        const skill = this.skills.get(id);
+        if (!skill)
+            return false;
+        await fs.rm(skill.path, { recursive: true, force: true });
+        this.skills.delete(id);
+        return true;
+    }
+}
+exports.SkillManager = SkillManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { Skill } from '../types';\n\nconst SKILL_FILE = 'SKILL.md';\n\nexport class SkillManager {\n  private skillsDir: string;\n  private projectSkillsDir: string;\n  private skills: Map<string, Skill> = new Map();\n\n  constructor(skillsDir?: string, projectSkillsDir?: string) {\n    this.skillsDir = skillsDir || path.join(process.cwd(), '.oflow', 'skills');\n    this.projectSkillsDir = projectSkillsDir || path.join(process.cwd(), '.oflow', 'skills');\n  }\n\n  async loadSkills(): Promise<Skill[]> {\n    this.skills.clear();\n    \n    // Load global skills\n    await this.loadSkillsFromDir(this.skillsDir, 'global');\n    \n    // Load project skills (override global with same name)\n    await this.loadSkillsFromDir(this.projectSkillsDir, 'project');\n\n    return this.getAllSkills();\n  }\n\n  private async loadSkillsFromDir(dir: string, scope: 'global' | 'project'): Promise<void> {\n    try {\n      const entries = await fs.readdir(dir, { withFileTypes: true });\n      \n      for (const entry of entries) {\n        if (!entry.isDirectory()) continue;\n        \n        const skillPath = path.join(dir, entry.name);\n        const skillFile = path.join(skillPath, SKILL_FILE);\n        \n        try {\n          const content = await fs.readFile(skillFile, 'utf-8');\n          const skill = this.parseSkillFile(skillPath, content);\n          \n          if (skill) {\n            this.skills.set(skill.id, { ...skill, path: skillPath });\n          }\n        } catch {\n          // Skip invalid skills\n        }\n      }\n    } catch {\n      // Directory doesn't exist\n    }\n  }\n\n  private parseSkillFile(skillPath: string, content: string): Skill | null {\n    try {\n      // Parse YAML frontmatter\n      const frontmatterMatch = content.match(/^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/);\n      \n      if (!frontmatterMatch) {\n        return null;\n      }\n\n      const frontmatter = frontmatterMatch[1];\n      const mainContent = frontmatterMatch[2];\n\n      // Parse frontmatter (simple key: value parsing)\n      const meta: Record<string, string> = {};\n      frontmatter.split('\\n').forEach(line => {\n        const match = line.match(/^(\\w+):\\s*(.*)$/);\n        if (match) {\n          meta[match[1]] = match[2];\n        }\n      });\n\n      return {\n        id: meta.id || path.basename(skillPath),\n        name: meta.name || path.basename(skillPath),\n        description: meta.description || '',\n        version: meta.version || '1.0.0',\n        path: skillPath,\n        mainFile: SKILL_FILE\n      };\n    } catch {\n      return null;\n    }\n  }\n\n  getSkill(id: string): Skill | undefined {\n    return this.skills.get(id);\n  }\n\n  getAllSkills(): Skill[] {\n    return Array.from(this.skills.values());\n  }\n\n  async getSkillContent(id: string): Promise<string | null> {\n    const skill = this.skills.get(id);\n    if (!skill) return null;\n\n    try {\n      const skillFile = path.join(skill.path, SKILL_FILE);\n      return await fs.readFile(skillFile, 'utf-8');\n    } catch {\n      return null;\n    }\n  }\n\n  async installSkill(source: string, scope: 'global' | 'project' = 'project'): Promise<Skill> {\n    const targetDir = scope === 'global' ? this.skillsDir : this.projectSkillsDir;\n    const skillId = path.basename(source).replace(/\\.git$/, '');\n    const targetPath = path.join(targetDir, skillId);\n\n    // For now, we'll just copy from a local path\n    // In a real implementation, this would support git repos, archives, etc.\n    await fs.mkdir(targetDir, { recursive: true });\n    \n    // Copy directory\n    await this.copyDir(source, targetPath);\n    \n    // Reload skills\n    await this.loadSkills();\n    \n    const skill = this.skills.get(skillId);\n    if (!skill) {\n      throw new Error('Failed to load installed skill');\n    }\n    \n    return skill;\n  }\n\n  private async copyDir(src: string, dest: string): Promise<void> {\n    await fs.mkdir(dest, { recursive: true });\n    const entries = await fs.readdir(src, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const srcPath = path.join(src, entry.name);\n      const destPath = path.join(dest, entry.name);\n\n      if (entry.isDirectory()) {\n        await this.copyDir(srcPath, destPath);\n      } else {\n        await fs.copyFile(srcPath, destPath);\n      }\n    }\n  }\n\n  async uninstallSkill(id: string): Promise<boolean> {\n    const skill = this.skills.get(id);\n    if (!skill) return false;\n\n    await fs.rm(skill.path, { recursive: true, force: true });\n    this.skills.delete(id);\n    \n    return true;\n  }\n}\n"]}

package/dist/tools/ask-user-question.d.ts

@@ -0,0 +1,62 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface AskUserQuestionParams {
+    questions: Array<{
+        question: string;
+        header: string;
+        options: Array<{
+            label: string;
+            description: string;
+        }>;
+        multiSelect?: boolean;
+    }>;
+}
+export declare class AskUserQuestionTool extends BaseTool<AskUserQuestionParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            questions: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        question: {
+                            type: string;
+                            description: string;
+                        };
+                        header: {
+                            type: string;
+                            description: string;
+                        };
+                        options: {
+                            type: string;
+                            description: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    label: {
+                                        type: string;
+                                        description: string;
+                                    };
+                                    description: {
+                                        type: string;
+                                        description: string;
+                                    };
+                                };
+                            };
+                        };
+                        multiSelect: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+    execute(params: AskUserQuestionParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/ask-user-question.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AskUserQuestionTool = void 0;
+const base_1 = require("./base");
+class AskUserQuestionTool extends base_1.BaseTool {
+    name = 'ask_user_question';
+    description = 'Use this tool when you need to ask the user questions during execution to gather preferences, clarify instructions, or make decisions.';
+    parameters = {
+        type: 'object',
+        properties: {
+            questions: {
+                type: 'array',
+                description: 'Questions to ask the user (1-4 questions)',
+                items: {
+                    type: 'object',
+                    properties: {
+                        question: {
+                            type: 'string',
+                            description: 'The complete question to ask'
+                        },
+                        header: {
+                            type: 'string',
+                            description: 'Very short label (max 12 chars)'
+                        },
+                        options: {
+                            type: 'array',
+                            description: 'Available choices (2-4 options)',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    label: {
+                                        type: 'string',
+                                        description: 'Display text for this option'
+                                    },
+                                    description: {
+                                        type: 'string',
+                                        description: 'Explanation of this option'
+                                    }
+                                }
+                            }
+                        },
+                        multiSelect: {
+                            type: 'boolean',
+                            description: 'Allow multiple selections'
+                        }
+                    }
+                }
+            }
+        },
+        required: ['questions']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['questions']);
+        if (params.questions.length === 0 || params.questions.length > 4) {
+            return 'Error: Must provide 1-4 questions';
+        }
+        // 返回需要用户回答的问题
+        // 在交互模式下，CLI会捕获这个并显示给用户
+        return JSON.stringify({
+            type: 'user_question',
+            questions: params.questions.map(q => ({
+                question: q.question,
+                header: q.header,
+                options: q.options,
+                multiSelect: q.multiSelect || false
+            }))
+        });
+    }
+}
+exports.AskUserQuestionTool = AskUserQuestionTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/base.d.ts

@@ -0,0 +1,16 @@
+import { ToolDefinition, ToolResult } from '../types';
+export interface ToolExecuteOptions {
+    workingDirectory?: string;
+    timeout?: number;
+    sandbox?: boolean;
+}
+export declare abstract class BaseTool<TParams = Record<string, unknown>> {
+    abstract readonly name: string;
+    abstract readonly description: string;
+    abstract readonly parameters: Record<string, unknown>;
+    getDefinition(): ToolDefinition;
+    abstract execute(params: TParams, options?: ToolExecuteOptions): Promise<string>;
+    protected validateRequired(params: TParams, required: string[]): void;
+}
+export declare function createToolResult(toolCallId: string, content: string, isError?: boolean): ToolResult;
+export declare function formatToolError(error: unknown): string;