@crewx/cli 0.8.0-rc.66 → 0.8.0-rc.82

package/dist/services/skill.service.js

@@ -1,779 +0,0 @@
-"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 __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 __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;
-    };
-})();
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var SkillService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SkillService = void 0;
-const common_1 = require("@nestjs/common");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("js-yaml"));
-const sdk_1 = require("@crewx/sdk");
-const child_process_1 = require("child_process");
-const tracing_service_1 = require("./tracing.service");
-let SkillService = SkillService_1 = class SkillService {
-    constructor() {
-        this.logger = new common_1.Logger(SkillService_1.name);
-        this.tracingService = null;
-        this.crewxDir = path.join(process.cwd(), '.crewx');
-        this.installedSkillsDir = path.join(this.crewxDir, 'skills');
-        this.skillsDirs = [
-            path.join(process.cwd(), 'skills'),
-            this.installedSkillsDir
-        ];
-        this.initTracing();
-    }
-    initTracing() {
-        try {
-            this.tracingService = new tracing_service_1.TracingService();
-            this.tracingService.onModuleInit();
-        }
-        catch (error) {
-            this.logger.warn(`Failed to initialize TracingService for skill tracking: ${error}`);
-            this.tracingService = null;
-        }
-    }
-    loadCrewxConfig() {
-        try {
-            const configPath = path.join(process.cwd(), 'crewx.yaml');
-            if (!fs.existsSync(configPath))
-                return null;
-            const content = fs.readFileSync(configPath, 'utf-8');
-            return yaml.load(content);
-        }
-        catch (e) {
-            this.logger.warn(`Failed to parse crewx.yaml: ${e}`);
-            return null;
-        }
-    }
-    getRegistries() {
-        try {
-            const config = this.loadCrewxConfig();
-            const registries = config?.skills?.registries;
-            if (!Array.isArray(registries))
-                return [];
-            return registries.filter((r) => r && typeof r === 'object' && typeof r.id === 'string');
-        }
-        catch {
-            return [];
-        }
-    }
-    ensureCrewxDir() {
-        if (!fs.existsSync(this.crewxDir)) {
-            fs.mkdirSync(this.crewxDir, { recursive: true });
-        }
-    }
-    ensureInstalledSkillsDir() {
-        this.ensureCrewxDir();
-        if (!fs.existsSync(this.installedSkillsDir)) {
-            fs.mkdirSync(this.installedSkillsDir, { recursive: true });
-        }
-    }
-    parseSource(source) {
-        if (source.startsWith('npm:')) {
-            return { type: 'npm', package: source.slice(4) };
-        }
-        if (source.startsWith('template:')) {
-            return { type: 'template', name: source.slice(9) };
-        }
-        if (source.startsWith('github:')) {
-            const rest = source.slice(7);
-            const atIndex = rest.lastIndexOf('@');
-            if (atIndex > 0 && !rest.slice(0, atIndex).includes('/')) {
-                return null;
-            }
-            if (atIndex > 0) {
-                return { type: 'github', repo: rest.slice(0, atIndex), version: rest.slice(atIndex + 1) };
-            }
-            return { type: 'github', repo: rest };
-        }
-        return null;
-    }
-    async discover() {
-        const skills = [];
-        const seen = new Set();
-        for (const dirPath of this.skillsDirs) {
-            if (!fs.existsSync(dirPath))
-                continue;
-            try {
-                const dirs = fs.readdirSync(dirPath, { withFileTypes: true })
-                    .filter(d => d.isDirectory());
-                for (const dir of dirs) {
-                    const skillPath = path.join(dirPath, dir.name);
-                    const skillMdPath = path.join(skillPath, 'SKILL.md');
-                    if (fs.existsSync(skillMdPath)) {
-                        try {
-                            const manifest = (0, sdk_1.parseSkillManifestFromFile)(skillMdPath, {
-                                loadContent: false,
-                                validationMode: 'lenient'
-                            });
-                            const entryPoint = this.detectEntryPoint(skillPath, dir.name);
-                            const source = dirPath === this.installedSkillsDir ? 'installed' : 'custom';
-                            const skillName = manifest.metadata.name || dir.name;
-                            seen.add(skillName);
-                            skills.push({
-                                name: skillName,
-                                description: manifest.metadata.description || '',
-                                version: manifest.metadata.version || '0.0.0',
-                                entryPoint: entryPoint || null,
-                                path: skillPath,
-                                source,
-                            });
-                        }
-                        catch (e) {
-                            this.logger.debug(`Failed to parse SKILL.md in ${skillPath}: ${e}`);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                this.logger.warn(`Failed to read skills directory ${dirPath}: ${e}`);
-            }
-        }
-        this.discoverBuiltInSkills(skills, seen);
-        return skills;
-    }
-    findSkillMd(skillPath) {
-        const candidates = [
-            path.join(skillPath, 'SKILL.md'),
-            path.join(skillPath, 'skill', 'SKILL.md'),
-        ];
-        for (const candidate of candidates) {
-            if (fs.existsSync(candidate))
-                return candidate;
-        }
-        return null;
-    }
-    discoverBuiltInSkills(skills, seen) {
-        const crewxModulesDir = path.join(process.cwd(), 'node_modules', '@crewx');
-        if (!fs.existsSync(crewxModulesDir))
-            return;
-        try {
-            const entries = fs.readdirSync(crewxModulesDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory() && !entry.isSymbolicLink())
-                    continue;
-                const pkgDir = path.join(crewxModulesDir, entry.name);
-                const candidates = [
-                    path.join(pkgDir, 'SKILL.md'),
-                    path.join(pkgDir, 'skill', 'SKILL.md'),
-                ];
-                for (const skillMdPath of candidates) {
-                    if (!fs.existsSync(skillMdPath))
-                        continue;
-                    try {
-                        const manifest = (0, sdk_1.parseSkillManifestFromFile)(skillMdPath, {
-                            loadContent: false,
-                            validationMode: 'lenient',
-                        });
-                        const skillName = manifest.metadata.name || `crewx/${entry.name}`;
-                        if (seen.has(skillName))
-                            break;
-                        const shorthand = skillName.startsWith('crewx/') ? skillName.slice('crewx/'.length) : null;
-                        if (shorthand && seen.has(shorthand))
-                            break;
-                        seen.add(skillName);
-                        const entryPoint = this.detectEntryPoint(pkgDir, entry.name);
-                        skills.push({
-                            name: skillName,
-                            description: manifest.metadata.description || '',
-                            version: manifest.metadata.version || '0.0.0',
-                            entryPoint: entryPoint || null,
-                            path: pkgDir,
-                            source: 'built-in',
-                        });
-                    }
-                    catch (e) {
-                        this.logger.debug(`Failed to parse SKILL.md in ${pkgDir}: ${e}`);
-                    }
-                    break;
-                }
-            }
-        }
-        catch (e) {
-            this.logger.warn(`Failed to scan node_modules/@crewx: ${e}`);
-        }
-    }
-    async getSkill(name) {
-        const skills = await this.discover();
-        const exact = skills.find(s => s.name === name);
-        if (exact)
-            return exact;
-        if (!name.includes('/')) {
-            const scoped = skills.find(s => s.name === `crewx/${name}`);
-            if (scoped)
-                return scoped;
-        }
-        return null;
-    }
-    detectEntryPoint(skillPath, skillName) {
-        const pkgJsonPath = path.join(skillPath, 'package.json');
-        if (fs.existsSync(pkgJsonPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-                if (pkg.bin) {
-                    const binValue = typeof pkg.bin === 'string'
-                        ? pkg.bin
-                        : Object.values(pkg.bin)[0];
-                    if (binValue) {
-                        const resolved = path.resolve(skillPath, binValue);
-                        if (fs.existsSync(resolved))
-                            return resolved;
-                    }
-                }
-                if (pkg.main) {
-                    const resolved = path.resolve(skillPath, pkg.main);
-                    if (fs.existsSync(resolved))
-                        return resolved;
-                }
-            }
-            catch {
-            }
-        }
-        const candidates = [
-            `${skillName}.js`,
-            `${skillName}.sh`,
-            `${skillName}.py`,
-            'index.js',
-            'main.js',
-        ];
-        for (const candidate of candidates) {
-            const fullPath = path.join(skillPath, candidate);
-            if (fs.existsSync(fullPath)) {
-                return candidate;
-            }
-        }
-        return null;
-    }
-    async execute(name, args) {
-        const skill = await this.getSkill(name);
-        if (!skill) {
-            throw new Error(`Skill '${name}' not found`);
-        }
-        if (!skill.entryPoint) {
-            const skillMdPath = this.findSkillMd(skill.path);
-            if (!skillMdPath)
-                throw new Error(`SKILL.md not found for '${name}'`);
-            const content = fs.readFileSync(skillMdPath, 'utf-8');
-            console.log(content);
-            return { code: 0, output: content };
-        }
-        const entryPoint = skill.entryPoint;
-        const entryPath = path.isAbsolute(entryPoint) ? entryPoint : path.join(skill.path, entryPoint);
-        const taskId = process.env.CREWX_TASK_ID;
-        const spanAlreadyCreated = process.env.CREWX_SKILL_SPAN_CREATED === 'true';
-        let spanId = null;
-        const startTime = Date.now();
-        if (taskId && this.tracingService?.isEnabled() && !spanAlreadyCreated) {
-            spanId = this.tracingService.createSpan({
-                task_id: taskId,
-                name: `skill:${name}`,
-                kind: tracing_service_1.SpanKind.INTERNAL,
-                input: JSON.stringify({ skill: name, args }),
-            });
-        }
-        return new Promise((resolve, reject) => {
-            let command;
-            let cmdArgs;
-            if (entryPoint.endsWith('.js')) {
-                command = 'node';
-                cmdArgs = [entryPath, ...args];
-            }
-            else if (entryPoint.endsWith('.sh')) {
-                command = 'sh';
-                cmdArgs = [entryPath, ...args];
-            }
-            else if (entryPoint.endsWith('.py')) {
-                command = 'python3';
-                cmdArgs = [entryPath, ...args];
-            }
-            else {
-                if (spanId && this.tracingService) {
-                    this.tracingService.failSpan(spanId, `Unsupported entry point: ${entryPoint}`);
-                }
-                reject(new Error(`Unsupported entry point: ${entryPoint}`));
-                return;
-            }
-            const child = (0, child_process_1.spawn)(command, cmdArgs, {
-                cwd: skill.path,
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    CREWX_WORKSPACE: process.env.CREWX_WORKSPACE || process.cwd(),
-                },
-            });
-            child.on('close', (code) => {
-                const durationMs = Date.now() - startTime;
-                if (spanId && this.tracingService) {
-                    if (code === 0) {
-                        this.tracingService.completeSpan(spanId, JSON.stringify({
-                            code,
-                            duration_ms: durationMs
-                        }));
-                    }
-                    else {
-                        this.tracingService.failSpan(spanId, `Skill exited with code ${code}`);
-                    }
-                }
-                resolve({ code: code || 0, output: '' });
-            });
-            child.on('error', (err) => {
-                if (spanId && this.tracingService) {
-                    this.tracingService.failSpan(spanId, err.message);
-                }
-                reject(err);
-            });
-        });
-    }
-    async executeShell(name, commandString) {
-        const skill = await this.getSkill(name);
-        if (!skill) {
-            throw new Error(`Skill '${name}' not found`);
-        }
-        const taskId = process.env.CREWX_TASK_ID;
-        const env = {
-            ...process.env,
-            SKILL_DIR: skill.path,
-            CREWX_TASK_ID: taskId || '',
-            CREWX_WORKSPACE: process.env.CREWX_WORKSPACE || process.cwd(),
-        };
-        const spanAlreadyCreated = process.env.CREWX_SKILL_SPAN_CREATED === 'true';
-        let spanId = null;
-        const startTime = Date.now();
-        if (taskId && this.tracingService?.isEnabled() && !spanAlreadyCreated) {
-            spanId = this.tracingService.createSpan({
-                task_id: taskId,
-                name: `skill:exec:${name}`,
-                kind: tracing_service_1.SpanKind.INTERNAL,
-                input: JSON.stringify({ skill: name, command: commandString }),
-            });
-        }
-        return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)(commandString, {
-                cwd: process.cwd(),
-                shell: true,
-                env: env,
-                stdio: 'inherit',
-            });
-            child.on('close', (code) => {
-                const durationMs = Date.now() - startTime;
-                if (spanId && this.tracingService) {
-                    if (code === 0) {
-                        this.tracingService.completeSpan(spanId, JSON.stringify({ code, duration_ms: durationMs }));
-                    }
-                    else {
-                        this.tracingService.failSpan(spanId, `Skill shell exited with code ${code}`);
-                    }
-                }
-                resolve({ code: code || 0 });
-            });
-            child.on('error', (err) => {
-                if (spanId && this.tracingService) {
-                    this.tracingService.failSpan(spanId, err.message);
-                }
-                reject(err);
-            });
-        });
-    }
-    async add(sourceStr) {
-        const source = this.parseSource(sourceStr);
-        if (!source) {
-            return {
-                success: false,
-                name: '',
-                message: `Invalid source format: ${sourceStr}. Use npm:<package>, template:<name>, or github:<owner/repo>`
-            };
-        }
-        switch (source.type) {
-            case 'npm':
-                return this.addFromNpm(source.package);
-            case 'template':
-                return this.addFromTemplate(source.name);
-            case 'github':
-                return {
-                    success: false,
-                    name: '',
-                    message: 'GitHub source is planned for Phase 1.5 (v0.8.1+). Use npm: or template: for now.'
-                };
-            default:
-                return { success: false, name: '', message: `Unknown source type` };
-        }
-    }
-    validatePackageName(packageName) {
-        if (packageName.startsWith('-')) {
-            return false;
-        }
-        const validNpmPackagePattern = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(@[a-z0-9-._~]+)?$/i;
-        return validNpmPackagePattern.test(packageName);
-    }
-    async addFromNpm(packageName) {
-        this.ensureInstalledSkillsDir();
-        if (!this.validatePackageName(packageName)) {
-            return {
-                success: false,
-                name: '',
-                message: `Invalid package name: ${packageName}. Package name contains invalid characters.`
-            };
-        }
-        try {
-            const tempDir = path.join(this.crewxDir, '.tmp-install');
-            if (fs.existsSync(tempDir)) {
-                fs.rmSync(tempDir, { recursive: true });
-            }
-            fs.mkdirSync(tempDir, { recursive: true });
-            fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'temp', private: true }));
-            this.logger.log(`Installing ${packageName} from npm...`);
-            (0, child_process_1.execSync)(`npm install ${packageName} --prefix "${tempDir}"`, {
-                stdio: 'inherit'
-            });
-            const nodeModulesPath = path.join(tempDir, 'node_modules');
-            const installedPkgPath = this.findInstalledPackage(nodeModulesPath, packageName);
-            if (!installedPkgPath) {
-                fs.rmSync(tempDir, { recursive: true });
-                return { success: false, name: '', message: `Failed to locate installed package: ${packageName}` };
-            }
-            const skillMdPath = path.join(installedPkgPath, 'SKILL.md');
-            if (!fs.existsSync(skillMdPath)) {
-                fs.rmSync(tempDir, { recursive: true });
-                return { success: false, name: '', message: `Package ${packageName} does not contain a SKILL.md file` };
-            }
-            const manifest = (0, sdk_1.parseSkillManifestFromFile)(skillMdPath, {
-                loadContent: false,
-                validationMode: 'lenient'
-            });
-            const skillName = manifest.metadata.name || path.basename(installedPkgPath);
-            const skillVersion = manifest.metadata.version || '0.0.0';
-            const customSkillPath = path.join(process.cwd(), 'skills', skillName);
-            if (fs.existsSync(customSkillPath)) {
-                fs.rmSync(tempDir, { recursive: true });
-                return {
-                    success: false,
-                    name: skillName,
-                    message: `Skill '${skillName}' already exists in skills/ directory (custom skills take priority)`
-                };
-            }
-            const targetPath = path.join(this.installedSkillsDir, skillName);
-            if (fs.existsSync(targetPath)) {
-                fs.rmSync(targetPath, { recursive: true });
-            }
-            this.copyDir(installedPkgPath, targetPath);
-            fs.rmSync(tempDir, { recursive: true });
-            return {
-                success: true,
-                name: skillName,
-                message: `Successfully installed ${skillName}@${skillVersion} from npm:${packageName}`
-            };
-        }
-        catch (e) {
-            return { success: false, name: '', message: `Failed to install from npm: ${e}` };
-        }
-    }
-    findInstalledPackage(nodeModulesPath, packageName) {
-        if (packageName.startsWith('@')) {
-            const parts = packageName.split('/');
-            const scope = parts[0];
-            const name = parts[1];
-            if (scope && name) {
-                const scopedPath = path.join(nodeModulesPath, scope, name);
-                if (fs.existsSync(scopedPath)) {
-                    return scopedPath;
-                }
-            }
-        }
-        else {
-            const directPath = path.join(nodeModulesPath, packageName);
-            if (fs.existsSync(directPath)) {
-                return directPath;
-            }
-        }
-        return null;
-    }
-    copyDir(src, dest) {
-        fs.mkdirSync(dest, { recursive: true });
-        const entries = fs.readdirSync(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()) {
-                if (entry.name === 'node_modules')
-                    continue;
-                this.copyDir(srcPath, destPath);
-            }
-            else {
-                fs.copyFileSync(srcPath, destPath);
-            }
-        }
-    }
-    async addFromTemplate(templateName) {
-        this.ensureInstalledSkillsDir();
-        const builtInTemplates = {
-            hello: {
-                description: 'Simple greeting demo skill',
-                files: {
-                    'SKILL.md': `---
-name: {{name}}
-description: A simple greeting skill
-version: 0.0.1
----
-
-# {{name}} Skill
-
-A simple greeting skill created from template.
-
-## Usage
-\`\`\`bash
-node skills/{{name}}/{{name}}.js [name]
-\`\`\`
-`,
-                    '{{name}}.js': `#!/usr/bin/env node
-
-const args = process.argv.slice(2);
-
-if (args.includes('--help') || args.includes('-h')) {
-  console.log('Usage: node {{name}}.js [name]');
-  process.exit(0);
-}
-
-const name = args[0] || 'World';
-console.log(\`Hello, \${name}! (from {{name}} skill)\`);
-`
-                }
-            },
-            memory: {
-                description: 'Key-value memory storage skill',
-                files: {
-                    'SKILL.md': `---
-name: {{name}}
-description: Simple key-value memory storage
-version: 0.0.1
----
-
-# {{name}} Skill
-
-A simple key-value memory storage skill.
-
-## Commands
-- \`save <key> <value>\` - Save a value
-- \`load <key>\` - Load a value
-- \`list\` - List all keys
-- \`delete <key>\` - Delete a key
-`,
-                    '{{name}}.js': `#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-
-const dataFile = path.join(__dirname, 'data.json');
-
-function loadData() {
-  try {
-    return JSON.parse(fs.readFileSync(dataFile, 'utf-8'));
-  } catch {
-    return {};
-  }
-}
-
-function saveData(data) {
-  fs.writeFileSync(dataFile, JSON.stringify(data, null, 2));
-}
-
-const [command, ...args] = process.argv.slice(2);
-
-switch (command) {
-  case 'save':
-    const data = loadData();
-    data[args[0]] = args.slice(1).join(' ');
-    saveData(data);
-    console.log(\`Saved: \${args[0]}\`);
-    break;
-  case 'load':
-    const stored = loadData();
-    console.log(stored[args[0]] || '(not found)');
-    break;
-  case 'list':
-    console.log(Object.keys(loadData()).join('\\n') || '(empty)');
-    break;
-  case 'delete':
-    const d = loadData();
-    delete d[args[0]];
-    saveData(d);
-    console.log(\`Deleted: \${args[0]}\`);
-    break;
-  default:
-    console.log('Usage: {{name}}.js <save|load|list|delete> [args]');
-}
-`
-                }
-            },
-            api: {
-                description: 'HTTP API client skill',
-                files: {
-                    'SKILL.md': `---
-name: {{name}}
-description: HTTP API client skill
-version: 0.0.1
----
-
-# {{name}} Skill
-
-An HTTP API client skill for making REST requests.
-
-## Commands
-- \`get <url>\` - GET request
-- \`post <url> <data>\` - POST request with JSON data
-`,
-                    '{{name}}.js': `#!/usr/bin/env node
-
-const https = require('https');
-const http = require('http');
-
-const [method, url, ...rest] = process.argv.slice(2);
-
-if (!method || !url) {
-  console.log('Usage: {{name}}.js <get|post> <url> [data]');
-  process.exit(1);
-}
-
-const client = url.startsWith('https') ? https : http;
-
-const req = client.request(url, { method: method.toUpperCase() }, (res) => {
-  let data = '';
-  res.on('data', chunk => data += chunk);
-  res.on('end', () => console.log(data));
-});
-
-if (method.toLowerCase() === 'post' && rest.length) {
-  req.setHeader('Content-Type', 'application/json');
-  req.write(rest.join(' '));
-}
-
-req.end();
-`
-                }
-            }
-        };
-        const template = builtInTemplates[templateName];
-        if (!template) {
-            const available = Object.keys(builtInTemplates).join(', ');
-            return {
-                success: false,
-                name: '',
-                message: `Template '${templateName}' not found. Available: ${available}`
-            };
-        }
-        let skillName = templateName;
-        let counter = 1;
-        while (fs.existsSync(path.join(this.installedSkillsDir, skillName)) ||
-            fs.existsSync(path.join(process.cwd(), 'skills', skillName))) {
-            skillName = `${templateName}-${counter}`;
-            counter++;
-        }
-        const targetPath = path.join(this.installedSkillsDir, skillName);
-        fs.mkdirSync(targetPath, { recursive: true });
-        for (const [fileNameTemplate, contentTemplate] of Object.entries(template.files)) {
-            const fileName = fileNameTemplate.replace(/\{\{name\}\}/g, skillName);
-            const content = contentTemplate.replace(/\{\{name\}\}/g, skillName);
-            const filePath = path.join(targetPath, fileName);
-            fs.writeFileSync(filePath, content);
-            if (fileName.endsWith('.js')) {
-                fs.chmodSync(filePath, '755');
-            }
-        }
-        return {
-            success: true,
-            name: skillName,
-            message: `Successfully created skill '${skillName}' from template '${templateName}' at .crewx/skills/${skillName}/`
-        };
-    }
-    validateSkillName(name) {
-        if (name === '.' || name === '..')
-            return false;
-        if (name.includes('\\') || name.includes('..'))
-            return false;
-        const SCOPED = /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]+$/;
-        const FLAT = /^[a-z0-9][a-z0-9-._~]*$/i;
-        return SCOPED.test(name) || FLAT.test(name);
-    }
-    async remove(name) {
-        if (!this.validateSkillName(name)) {
-            return {
-                success: false,
-                message: `Invalid skill name: '${name}'. Skill name cannot contain path separators (/, \\, ..).`
-            };
-        }
-        const skill = await this.getSkill(name);
-        if (skill?.source === 'built-in') {
-            return {
-                success: false,
-                message: `Built-in skill '${name}' cannot be removed via crewx. Use npm uninstall instead.`,
-            };
-        }
-        const installedPath = path.join(this.installedSkillsDir, name);
-        if (!fs.existsSync(installedPath)) {
-            const customPath = path.join(process.cwd(), 'skills', name);
-            if (fs.existsSync(customPath)) {
-                return {
-                    success: false,
-                    message: `'${name}' is a custom skill in skills/ directory. Remove it manually if intended.`
-                };
-            }
-            return { success: false, message: `Skill '${name}' not found in installed skills.` };
-        }
-        try {
-            fs.rmSync(installedPath, { recursive: true });
-            return { success: true, message: `Successfully removed skill '${name}'` };
-        }
-        catch (e) {
-            return { success: false, message: `Failed to remove skill '${name}': ${e}` };
-        }
-    }
-    getAvailableTemplates() {
-        return ['hello', 'memory', 'api'];
-    }
-};
-exports.SkillService = SkillService;
-exports.SkillService = SkillService = SkillService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
-], SkillService);
-//# sourceMappingURL=skill.service.js.map