skill-os 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-os",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Skill-OS CLI for managing OS skills",
   "main": "skill-os.js",
   "bin": {
@@ -19,7 +19,7 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^13.1.0",
-    "inquirer": "^8.2.6",
+    "form-data": "^4.0.5",
     "js-yaml": "^4.1.0",
     "jsonschema": "^1.4.1",
     "node-fetch": "^2.7.0"
@@ -27,4 +27,4 @@
   "engines": {
     "node": ">=14.0.0"
   }
-}
+}

package/skill-os.js

@@ -5,7 +5,6 @@ const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const inquirer = require('inquirer');
 const { execSync } = require('child_process');
 
 // Define specific layer icons matching original python CLI
@@ -61,20 +60,78 @@ function loadIndex() {
     return JSON.parse(raw);
 }
 
+// ----------------------------------------------------------------------
+// API Configuration
+// ----------------------------------------------------------------------
+
+const DEFAULT_API_BASE = "https://oscopilot.alibaba-inc.com/skills/api/v1";
+
+function getApiBase(options) {
+    let url = options?.url || process.env.SKILL_OS_REGISTRY || DEFAULT_API_BASE;
+    return url.replace(/\/$/, "");
+}
+
+async function fetchFromApi(endpoint, options = {}) {
+    // Only require node-fetch dynamically when needed
+    let fetchFn = require('node-fetch');
+    if (typeof fetchFn !== 'function' && fetchFn.default) {
+        fetchFn = fetchFn.default;
+    }
+
+    let baseUrl;
+    // Extract url option if passed inside options object
+    if (options && options.url) {
+        baseUrl = getApiBase({ url: options.url });
+        delete options.url;
+    } else {
+        baseUrl = getApiBase({});
+    }
+
+    const url = `${baseUrl}${endpoint}`;
+
+    try {
+        const response = await fetchFn(url, options);
+        if (!response.ok) {
+            throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    } catch (error) {
+        console.error(chalk.red(`\n✗ Error connecting to remote registry at ${url}`));
+        console.error(chalk.dim(error.message));
+        process.exit(1);
+    }
+}
+
 // ----------------------------------------------------------------------
 // Commmands Implementations
 // ----------------------------------------------------------------------
 
-function cmdList() {
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdList(options) {
+    console.log(`\n${chalk.dim('Fetching skills from external registry...')}`);
+    const index = await fetchFromApi('/skills', options);
+
+    // API returns an array of skills, or an object with a data/skills array property
+    let skillsList = [];
+    if (Array.isArray(index)) {
+        skillsList = index;
+    } else if (Array.isArray(index.data)) {
+        skillsList = index.data;
+    } else if (Array.isArray(index.skills)) {
+        skillsList = index.skills;
+    } else if (typeof index === 'object') {
+        // Fallback if it is an object map
+        skillsList = Object.entries(index.skills || index).map(([k, v]) => ({ path: k, ...v }));
+    }
 
     console.log(`\n${chalk.bold('📚 Skill-OS Available Skills')}`);
     console.log(`${chalk.dim('─'.repeat(60))}\n`);
 
     const layers = {};
-    for (const [skillPath, info] of Object.entries(skills)) {
-        const layer = skillPath.split('/')[0];
+    for (const info of skillsList) {
+        // Fallback path resolution. If the API returns 'path', use it. Otherwise, construct it or use name.
+        const skillPath = info.path || (info.layer ? `${info.layer}/${info.category || 'misc'}/${info.name}` : info.name || 'unknown');
+        const layer = info.layer || (skillPath.includes('/') ? skillPath.split('/')[0] : 'misc');
+
         if (!layers[layer]) layers[layer] = [];
         layers[layer].push({ path: skillPath, info });
     }
@@ -99,16 +156,22 @@ function cmdList() {
     }
 }
 
-function cmdSearch(query) {
-    const lowercaseQuery = query.toLowerCase();
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdSearch(query, options) {
+    console.log(`\n${chalk.dim(`Searching remote registry for '${query}'...`)}`);
+
+    // API Endpoint: /api/v1/search?q={{skill.name}}
+    const encodedQuery = encodeURIComponent(query);
+    const response = await fetchFromApi(`/search?q=${encodedQuery}`, options);
 
-    const matches = [];
-    for (const [skillPath, info] of Object.entries(skills)) {
-        const searchable = `${skillPath} ${info.name || ''} ${info.description || ''}`.toLowerCase();
-        if (searchable.includes(lowercaseQuery)) {
-            matches.push({ path: skillPath, info });
+    // The API likely returns an array or an object map. Normalize to an array of objects.
+    let matches = [];
+    const rawResults = response.data || response.results || response.skills || response || [];
+
+    if (Array.isArray(rawResults)) {
+        matches = rawResults;
+    } else if (typeof rawResults === 'object') {
+        for (const [skillPath, info] of Object.entries(rawResults)) {
+            matches.push({ path: skillPath, ...info });
         }
     }
 
@@ -120,124 +183,53 @@ function cmdSearch(query) {
     console.log(`\n${chalk.bold(`🔍 Search Results for '${query}'`)}`);
     console.log(`${chalk.dim(`Found ${matches.length} skill(s)`)}\n`);
 
-    for (const { path: skillPath, info } of matches) {
+    for (const info of matches) {
+        const skillPath = info.path || info.name; // Fallback to name if path isn't provided separately
         const icon = formatLayerIcon(skillPath);
         const status = formatStatus(info.status);
-        const name = info.name || skillPath;
         const version = info.version || '?';
         const desc = info.description || '';
 
         console.log(`${icon} ${chalk.cyan(skillPath)}`);
-        console.log(`   ${chalk.bold(name)} (${version}) [${status}]`);
+        console.log(`   ${chalk.bold(info.name)} (${version}) [${status}]`);
         console.log(`   ${desc}\n`);
     }
 }
 
-function cmdInfo(skillPath) {
-    const index = loadIndex();
-    const skills = index.skills || {};
+async function cmdInfo(skillPath, options) {
+    console.log(`\n${chalk.dim(`Fetching details from remote registry...`)}`);
 
-    if (!skills[skillPath]) {
-        console.error(chalk.red(`Error: Skill '${skillPath}' not found`));
-        console.log(chalk.dim("Use 'skill-os list' to see available skills"));
-        process.exit(1);
-    }
+    // API Endpoint: /api/v1/skills/{{skill.path}}/content
+    const info = await fetchFromApi(`/skills/${skillPath}/content`, options);
 
-    const info = skills[skillPath];
     const icon = formatLayerIcon(skillPath);
-    const status = formatStatus(info.status);
+    const status = formatStatus(info.status || info.metadata?.status);
+    const metadata = info.metadata || info || {}; // Handle if nested or flat
 
-    console.log(`\n${icon} ${chalk.bold(info.name || skillPath)}`);
+    console.log(`\n${icon} ${chalk.bold(metadata.name || skillPath)}`);
     console.log(chalk.dim('─'.repeat(40)));
     console.log(`  Path:         ${chalk.cyan(skillPath)}`);
-    console.log(`  Version:      ${info.version || 'unknown'}`);
+    console.log(`  Version:      ${metadata.version || 'unknown'}`);
     console.log(`  Status:       ${status}`);
-    console.log(`  Description:  ${info.description || 'No description'}`);
+    console.log(`  Description:  ${metadata.description || 'No description'}`);
 
-    if (info.dependencies && info.dependencies.length > 0) {
-        console.log(`  Dependencies: ${info.dependencies.join(', ')}`);
+    if (metadata.dependencies && metadata.dependencies.length > 0) {
+        console.log(`  Dependencies: ${metadata.dependencies.join(', ')}`);
     } else {
         console.log(`  Dependencies: ${chalk.dim('None')}`);
     }
 
-    const repoRoot = getRepoRoot();
-    const skillMdPath = path.join(repoRoot, skillPath, 'SKILL.md');
-    if (fs.existsSync(skillMdPath)) {
-        console.log(`\n  ${chalk.dim(`SKILL.md: ${skillMdPath}`)}`);
+    // If the API returns the actual markdown content, display a snippet or note
+    if (info.content || info.markdown) {
+        console.log(`\n  ${chalk.dim('[Remote Document Content Available]')}`);
     }
     console.log();
 }
 
-function cmdInstall(skillPath, options) {
-    const index = loadIndex();
-    const skills = index.skills || {};
-
-    // Expand ~ relative to HOME
-    const homeDir = require('os').homedir();
-    const rawTarget = options.target.startsWith('~/') ?
-        path.join(homeDir, options.target.slice(2)) :
-        path.resolve(options.target);
-
-    const targetDir = path.resolve(rawTarget);
-
-    if (!skills[skillPath]) {
-        console.error(chalk.red(`Error: Skill '${skillPath}' not found`));
-        console.log(chalk.dim("Use 'skill-os list' to see available skills"));
-        process.exit(1);
-    }
-
-    const info = skills[skillPath];
-    const repoRoot = getRepoRoot();
-    const sourceDir = path.join(repoRoot, skillPath);
-
-    if (!fs.existsSync(sourceDir)) {
-        console.error(chalk.red(`Error: Skill directory not found: ${sourceDir}`));
-        process.exit(1);
-    }
-
-    const skillName = path.basename(skillPath);
-    const installTarget = path.join(targetDir, skillName);
-
-    if (fs.existsSync(installTarget)) {
-        if (options.force) {
-            console.log(chalk.yellow(`Removing existing: ${installTarget}`));
-            fs.rmSync(installTarget, { recursive: true, force: true });
-        } else {
-            console.error(chalk.red(`Error: Target already exists: ${installTarget}`));
-            console.log(chalk.dim("Use --force to overwrite"));
-            process.exit(1);
-        }
-    }
-
-    fs.mkdirSync(targetDir, { recursive: true });
 
-    console.log(`\n${chalk.bold(`📥 Installing ${info.name || skillPath}...`)}`);
-    console.log(`  Source: ${chalk.cyan(sourceDir)}`);
-    console.log(`  Target: ${chalk.cyan(installTarget)}`);
-
-    try {
-        // Simple recursive copy
-        fs.cpSync(sourceDir, installTarget, { recursive: true });
-        console.log(`\n${chalk.green('✓ Successfully installed!')}`);
-
-        console.log(`\n${chalk.bold('📋 Usage:')}`);
-        console.log(`  SKILL.md: ${installTarget}/SKILL.md`);
-
-        const deps = info.dependencies || [];
-        if (deps.length > 0) {
-            console.log(`\n${chalk.yellow('⚠️  Dependencies required:')}`);
-            deps.forEach(dep => console.log(`    - ${dep}`));
-            console.log(`\n  Install with: ${chalk.dim(`pip install ${deps.join(' ')}`)}`);
-        }
-    } catch (e) {
-        console.error(chalk.red(`Error during installation: ${e.message}`));
-        process.exit(1);
-    }
-}
 
 function cmdCreate(skillPath, options) {
-    const repoRoot = getRepoRoot();
-    const targetDir = path.join(repoRoot, 'skills', skillPath);
+    const targetDir = path.resolve(skillPath);
 
     if (fs.existsSync(targetDir)) {
         if (!options.force) {
@@ -329,36 +321,48 @@ TODO: Add skill documentation here.
     console.log(`  3. Sync: ${chalk.dim(`skill-os sync ${skillPath}`)}`);
 }
 
-function cmdDownload(skillName, options) {
-    const targetDir = options.platform
-        ? path.join(process.cwd(), `.${options.platform}`, "skills")
-        : process.cwd();
+function cmdDownload(skillPath, options) {
+    // 1. Determine target directory
+    const homeDir = require('os').homedir();
+    let rawTarget = process.cwd();
 
-    fs.mkdirSync(targetDir, { recursive: true });
+    if (options.target) {
+        rawTarget = options.target.startsWith('~/') ?
+            path.join(homeDir, options.target.slice(2)) :
+            path.resolve(options.target);
+    } else if (options.platform) {
+        rawTarget = path.join(process.cwd(), `.${options.platform}`, "skills");
+    }
 
-    let serverUrl = options.url || process.env.SKILL_OS_REGISTRY || "https://example.com/skills";
-    serverUrl = serverUrl.replace(/\/$/, ""); // Trim trailing slash
+    const targetDir = path.resolve(rawTarget);
+    fs.mkdirSync(targetDir, { recursive: true });
 
-    const downloadUrl = `${serverUrl}/${skillName}.tar.gz`;
+    // 2. Determine API source
+    const serverUrl = getApiBase(options);
+    const downloadUrl = `${serverUrl}/skills/${skillPath}/download`;
 
-    console.log(`\n${chalk.bold(`📥 Downloading ${skillName}...`)}`);
+    console.log(`\n${chalk.bold(`📥 Downloading and extracting ${skillPath}...`)}`);
     console.log(`  Source: ${chalk.cyan(downloadUrl)}`);
     console.log(`  Target: ${chalk.cyan(targetDir)}\n`);
 
     try {
-        // Using curl synchronously for simplicity, similar to the bash version
-        execSync(`curl -L -O ${downloadUrl}`, { cwd: targetDir, stdio: 'inherit' });
-        console.log(`\n${chalk.green(`✓ Successfully downloaded ${skillName} to ${targetDir}`)}`);
+        // Stream the curl output directly into tar to extract the directory structure
+        // -s: silent curl, -L: follow redirects
+        // tar -xzf -: extract gzipped tar from stdin
+        execSync(`curl -s -L "${downloadUrl}" | tar -xzf -`, { cwd: targetDir, stdio: 'inherit' });
+        console.log(`\n${chalk.green(`✓ Successfully downloaded and extracted to: ${targetDir}`)}`);
     } catch (e) {
-        console.error(`\n${chalk.red(`✗ Failed to download ${skillName}: command returned error code ${e.status}`)}`);
+        console.error(`\n${chalk.red(`✗ Failed to download. The API may have returned an error instead of a tarball.`)}`);
         process.exit(1);
     }
 }
 
 // ----------------------------------------------------------------------
-// YAML / Sync Helpers
+// Publishing / Uploading
 // ----------------------------------------------------------------------
 
+const FormData = require('form-data');
+
 function parseSkillMdFrontmatter(skillMdPath) {
     if (!fs.existsSync(skillMdPath)) return {};
     const content = fs.readFileSync(skillMdPath, 'utf8');
@@ -372,284 +376,120 @@ function parseSkillMdFrontmatter(skillMdPath) {
     }
 }
 
-function loadYamlIndex() {
-    const repoRoot = getRepoRoot();
-    const yamlPath = path.join(repoRoot, 'SKILL_INDEX.yaml');
-    if (!fs.existsSync(yamlPath)) {
-        console.error(chalk.red('Error: SKILL_INDEX.yaml not found'));
-        process.exit(1);
-    }
-    const raw = fs.readFileSync(yamlPath, 'utf8');
-    return { data: yaml.load(raw), yamlPath };
-}
-
-function syncToJson(repoRoot) {
-    const yamlPath = path.join(repoRoot, 'SKILL_INDEX.yaml');
-    const jsonPath = path.join(repoRoot, 'SKILL_INDEX.json');
-
-    const data = yaml.load(fs.readFileSync(yamlPath, 'utf8'));
-    data.generated_at = new Date().toISOString();
-
-    fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2), 'utf8');
-}
-
-function appendSkillToYaml(skillPath, skillEntry, yamlPath) {
-    let content = fs.readFileSync(yamlPath, 'utf8');
-    const escapedPath = skillPath.replace(/[.*+?^$\\{}()|[\\]\\\\]/g, '\\\\$&');
-
-    // JS Regex to match existing block (simplified approximation matching python's pattern)
-    // Find "  skill/path:" and everything indented under it until the next line that isn't indented by at least 4 spaces
-    const pattern = new RegExp(`(^|\\n)  ${escapedPath}:\\n(?:    .*\\n)*`);
-
-    let newBlock = `
-  ${skillPath}:
-    name: ${skillEntry.name}
-    version: "${skillEntry.version}"
-    description: ${skillEntry.description}
-    status: ${skillEntry.status}
-    layer: ${skillEntry.layer}
-    lifecycle: ${skillEntry.lifecycle}
-    category: ${skillEntry.category}
-    tags:
-`;
-    const tags = skillEntry.tags || [];
-    if (tags.length) {
-        tags.forEach(t => newBlock += `      - ${t}\n`);
-    } else {
-        newBlock += `    tags: []\n`;
-    }
-
-    const deps = skillEntry.dependencies || [];
-    if (deps.length) {
-        newBlock += `    dependencies:\n`;
-        deps.forEach(d => newBlock += `      - ${d}\n`);
-    } else {
-        newBlock += `    dependencies: []\n`;
-    }
-
-    if (pattern.test(content)) {
-        content = content.replace(pattern, `$1${newBlock.trimStart()}`);
-    } else {
-        content = content.trimEnd() + '\n' + newBlock;
-    }
-
-    fs.writeFileSync(yamlPath, content, 'utf8');
-}
+async function cmdUpload(skillPath, options) {
+    const skillDir = path.resolve(skillPath);
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
 
-async function cmdSync(skillPath) {
-    const repoRoot = getRepoRoot();
-    const skillDir = path.join(repoRoot, 'skills', skillPath);
+    console.log(`\n${chalk.bold(`🚀 Publishing Skill: ${skillPath}`)}`);
+    console.log(`${chalk.dim('─'.repeat(50))}\n`);
 
-    if (!fs.existsSync(skillDir)) {
-        console.error(chalk.red(`Error: Skill directory not found: ${skillDir}`));
-        console.log(chalk.dim(`Create it first with: skill-os create ${skillPath}`));
+    // 1. Validation (Requires hoisted functions)
+    const { isValid: isDirValid, errors: dirErrors } = validateDirectoryStructure(skillDir);
+    if (!isDirValid) {
+        console.error(chalk.red('✗ Validation failed: Directory structure errors:'));
+        dirErrors.forEach(err => console.error(`  - ${err}`));
         process.exit(1);
     }
 
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
     if (!fs.existsSync(skillMdPath)) {
-        console.error(chalk.red(`Error: SKILL.md not found in ${skillDir}`));
+        console.log(`${chalk.red('✗ Fatal: SKILL.md not found')}`);
         process.exit(1);
     }
 
-    console.log(`\n${chalk.bold('📝 Skill-OS Sync')}`);
-    console.log(chalk.dim('─'.repeat(50)));
-    console.log(`Skill path: ${chalk.cyan(skillPath)}\n`);
-
     const fm = parseSkillMdFrontmatter(skillMdPath);
-    const { data: indexData, yamlPath } = loadYamlIndex();
-    const skills = indexData.skills || {};
-    const existing = skills[skillPath] || {};
-    const isUpdate = !!existing.name;
-
-    if (isUpdate) {
-        console.log(`${chalk.yellow('⚠ Skill already registered, updating...')}\n`);
-    } else {
-        console.log(`${chalk.green('✨ Registering new skill...')}\n`);
+    if (!fm || Object.keys(fm).length === 0) {
+        console.log(`${chalk.red('✗ SKILL.md missing or invalid frontmatter')}`);
+        process.exit(1);
     }
 
-    console.log(`${chalk.bold('Please confirm or enter skill metadata:')}\n`);
-
-    const pathParts = skillPath.split('/');
-    const inferredCategory = pathParts.length >= 2 ? pathParts[1] : '';
-
-    const questions = [
-        { name: 'name', message: '  name', default: existing.name || fm.name || pathParts[pathParts.length - 1] },
-        { name: 'description', message: '  description', default: existing.description || fm.description || '' },
-        { name: 'version', message: '  version', default: existing.version || fm.version || '1.0.0' },
-        { name: 'status', message: `  status ${chalk.dim('(stable, beta, placeholder)')}`, default: existing.status || fm.status || 'beta' },
-        { name: 'dependencies', message: `  dependencies ${chalk.dim('(comma-separated)')}`, default: (existing.dependencies || fm.dependencies || []).join(', ') }
-    ];
-
-    const answers = await inquirer.prompt(questions);
-
-    const depsArr = answers.dependencies.split(',').map(d => d.trim()).filter(Boolean);
-    const category = existing.category || fm.category || inferredCategory;
-    let tags = existing.tags || fm.tags || [];
-
-    if (category && (!tags.length || tags[0] !== category)) {
-        tags = [category, ...tags.filter(t => t !== category)];
+    const v = new Validator();
+    const result = v.validate(fm, skillSchema);
+    if (fm.category && fm.tags && fm.tags.length > 0 && fm.tags[0] !== fm.category) {
+        result.errors.push({ stack: `tags[0] must equal category name '${fm.category}'` });
     }
 
-    const skillEntry = {
-        name: answers.name,
-        version: answers.version,
-        description: answers.description,
-        status: answers.status,
-        layer: existing.layer || fm.layer || pathParts[0],
-        lifecycle: existing.lifecycle || fm.lifecycle || 'usage',
-        category: category,
-        tags: tags,
-        dependencies: depsArr
-    };
-
-    console.log(`\n${chalk.bold('📋 Summary:')}`);
-    console.log(`  ${chalk.cyan(skillPath)}:`);
-    for (const [k, v] of Object.entries(skillEntry)) {
-        console.log(`    ${k}: ${Array.isArray(v) ? (v.length ? JSON.stringify(v) : '[]') : v}`);
+    if (!result.valid || result.errors.length > 0) {
+        console.error(chalk.red('✗ Validation failed: SKILL.md has errors:'));
+        result.errors.forEach(err => console.error(`  - ${err.stack.replace('instance.', '')}`));
+        process.exit(1);
     }
-    console.log();
 
-    const { confirm } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirm',
-        message: 'Confirm and save?',
-        default: true
-    }]);
+    console.log(chalk.green('✓ Local validation passed.'));
 
-    if (!confirm) {
-        console.log(chalk.yellow('Cancelled'));
-        process.exit(0);
-    }
+    // 2. Prepare tarball
+    const tarFilename = `${fm.name}-${fm.version}.tar.gz`;
+    const tmpDir = require('os').tmpdir();
+    const tarPath = path.join(tmpDir, tarFilename);
 
-    console.log(`\n${chalk.dim('Saving SKILL_INDEX.yaml...')}`);
-    appendSkillToYaml(skillPath, skillEntry, yamlPath);
-
-    console.log(chalk.dim('Syncing to SKILL_INDEX.json...'));
-    syncToJson(repoRoot);
+    console.log(chalk.dim(`📦 Creating package archive...`));
+    try {
+        // -C changes to directory, . archives contents
+        // COPYFILE_DISABLE=1 prevents macOS tar from including ._* extended attribute files
+        execSync(`tar -czf "${tarPath}" -C "${skillDir}" .`, {
+            env: { ...process.env, COPYFILE_DISABLE: '1' }
+        });
+    } catch (e) {
+        console.error(chalk.red('✗ Failed to create tar archive.'));
+        process.exit(1);
+    }
 
-    console.log(`\n${chalk.green(`✅ Skill ${isUpdate ? 'updated' : 'registered'} successfully!`)}`);
-    console.log(`\n${chalk.bold('📋 Next steps:')}`);
-    console.log("  git add SKILL_INDEX.yaml SKILL_INDEX.json");
-    console.log(`  git commit -m 'feat: ${isUpdate ? 'update' : 'add'} ${skillPath} skill'`);
-}
+    // 3. Prepare Form Data
+    const form = new FormData();
+    form.append('package', fs.createReadStream(tarPath), {
+        filename: tarFilename,
+        contentType: 'application/gzip'
+    });
+    form.append('metadata', JSON.stringify(fm));
 
-function findSkillMds(dir, fileList = []) {
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const stat = fs.statSync(path.join(dir, file));
-        if (stat.isDirectory()) {
-            findSkillMds(path.join(dir, file), fileList);
-        } else if (file === 'SKILL.md') {
-            fileList.push(path.join(dir, file));
-        }
+    if (options.update) {
+        form.append('is_update', 'true');
+        console.log(chalk.yellow(`⚠ Uploading as an UPDATE (Version: ${fm.version}). Ensure the version number has been bumped!`));
+    } else {
+        console.log(chalk.cyan(`✨ Uploading as a NEW skill (Version: ${fm.version}).`));
     }
-    return fileList;
-}
 
-function cmdSyncAll(options) {
-    const repoRoot = getRepoRoot();
-    const skillsDir = path.join(repoRoot, 'skills');
+    const serverUrl = getApiBase(options);
+    const uploadUrl = `${serverUrl}/skills/upload`;
 
-    console.log(`\n${chalk.bold('🔄 Skill-OS Sync All')}`);
-    console.log(chalk.dim('─'.repeat(50)));
-    console.log(`Scanning: ${chalk.cyan(skillsDir)}\n`);
+    const fetchOptions = {
+        method: 'POST',
+        body: form,
+        headers: form.getHeaders()
+    };
 
-    const skillMds = findSkillMds(skillsDir);
-    if (skillMds.length === 0) {
-        console.log(chalk.yellow('No SKILL.md files found'));
-        return;
+    if (options.token) {
+        fetchOptions.headers['Authorization'] = `Bearer ${options.token}`;
     }
 
-    console.log(`Found ${chalk.green(skillMds.length)} skills\n`);
-
-    const newSkills = {};
-    const errors = [];
+    console.log(chalk.dim(`\n📡 Uploading to ${uploadUrl}...`));
 
-    skillMds.sort().forEach(skillMd => {
-        const relPath = path.relative(skillsDir, path.dirname(skillMd));
-        const fm = parseSkillMdFrontmatter(skillMd);
+    let fetchFn = require('node-fetch');
+    if (typeof fetchFn !== 'function' && fetchFn.default) {
+        fetchFn = fetchFn.default;
+    }
 
-        if (!fm || Object.keys(fm).length === 0) {
-            errors.push(`  ⚠ ${relPath}: Failed to parse frontmatter`);
-            return;
+    try {
+        const response = await fetchFn(uploadUrl, fetchOptions);
+        if (!response.ok) {
+            let errorMsg = response.statusText;
+            try {
+                const errBody = await response.json();
+                if (errBody.error || errBody.message) errorMsg = errBody.error || errBody.message;
+            } catch (e) { }
+            throw new Error(`HTTP ${response.status}: ${errorMsg}`);
         }
-
-        let status = fm.status || 'beta';
-        let icon = '✓';
-        if (status === 'placeholder') {
-            if (!options.includePlaceholder) {
-                status = 'beta'; // Default placeholder -> beta
-            }
-            icon = '🔸';
+        console.log(`\n${chalk.green('✅ Publish successful!')}`);
+    } catch (error) {
+        console.error(chalk.red(`\n✗ Publish failed.`));
+        console.error(chalk.red(`  ${error.message}`));
+        if (!options.update && error.message.includes('already exists')) {
+            console.log(chalk.yellow(`\n💡 If you intended to update an existing skill, use the --update flag.`));
         }
-
-        const name = fm.name || path.basename(path.dirname(skillMd));
-        const layer = fm.layer || relPath.split('/')[0];
-        const category = fm.category || (relPath.includes('/') ? relPath.split('/')[1] : '');
-        let tags = fm.tags || [];
-
-        if (tags && category && tags[0] !== category) {
-            tags = [category, ...tags.filter(t => t !== category)];
+        process.exit(1);
+    } finally {
+        if (fs.existsSync(tarPath)) {
+            fs.unlinkSync(tarPath);
         }
-
-        let description = fm.description || '';
-        if (description.length > 200) description = description.substring(0, 200);
-
-        newSkills[relPath] = {
-            name,
-            version: fm.version || '0.1.0',
-            description,
-            status,
-            layer,
-            lifecycle: fm.lifecycle || 'usage',
-            category,
-            tags: tags.slice(0, 5),
-            dependencies: fm.dependencies || []
-        };
-
-        console.log(`  ${icon} ${chalk.cyan(relPath)} (${layer}/${newSkills[relPath].lifecycle})`);
-    });
-
-    if (errors.length) {
-        console.log(`\n${chalk.yellow('Warnings:')}`);
-        errors.forEach(e => console.log(e));
-    }
-
-    const { data: indexData, yamlPath } = loadYamlIndex();
-    indexData.skills = newSkills;
-    indexData.version = "3.0";
-
-    const yamlDump = yaml.dump(indexData, {
-        sortKeys: false,
-        noCompatMode: true
-    });
-
-    const header = `# Skill-OS 技能索引
-# ====================
-# Generated: ${new Date().toISOString()}
-# Layers: core | system | runtime | application | meta
-# Lifecycle: production | maintenance | operations | usage | meta
-
-`;
-
-    fs.writeFileSync(yamlPath, header + yamlDump, 'utf8');
-    console.log(`\n${chalk.green(`✓ Updated ${path.basename(yamlPath)}`)}`);
-
-    syncToJson(repoRoot);
-    console.log(`${chalk.green(`✓ Updated SKILL_INDEX.json`)}`);
-
-    console.log(`\n${chalk.bold('📊 Summary:')}`);
-    console.log(`  Total skills: ${Object.keys(newSkills).length}`);
-
-    const layerCounts = {};
-    for (const info of Object.values(newSkills)) {
-        const layer = info.layer || 'unknown';
-        layerCounts[layer] = (layerCounts[layer] || 0) + 1;
-    }
-
-    for (const layer of Object.keys(layerCounts).sort()) {
-        console.log(`  ${formatLayerIcon(layer + '/')} ${layer}: ${layerCounts[layer]}`);
     }
 }
 
@@ -703,8 +543,7 @@ function validateDirectoryStructure(skillDir) {
 }
 
 function cmdValidate(skillPath) {
-    const repoRoot = getRepoRoot();
-    const skillDir = path.join(repoRoot, 'skills', skillPath);
+    const skillDir = path.resolve(skillPath);
     const skillMdPath = path.join(skillDir, 'SKILL.md');
 
     console.log(`\n${chalk.bold(`🔍 Validating Skill: ${skillPath}`)}`);
@@ -771,48 +610,44 @@ program
     .description('Skill-OS CLI');
 
 program.command('list')
-    .description('List all available skills')
+    .description('List all available skills from the remote registry')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdList);
 
 program.command('search')
-    .description('Search for skills')
+    .description('Search for skills in the remote registry')
     .argument('<query>', 'Search query')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdSearch);
 
 program.command('info')
-    .description('Show skill details')
-    .argument('<path>', 'Skill path (e.g., package/package/rpm_search)')
+    .description('Show skill details from the remote registry')
+    .argument('<path>', 'Skill path (e.g., package/rpm_search)')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdInfo);
 
-program.command('install')
-    .description('Install a skill to target directory')
-    .argument('<path>', 'Skill path to install')
-    .option('-t, --target <dir>', 'Target directory', '~/.skills')
-    .option('-f, --force', 'Force overwrite if exists', false)
-    .action(cmdInstall);
-
 program.command('create')
-    .description('Create a new skill scaffold')
+    .description('Create a new skill scaffold locally')
     .argument('<path>', 'Skill path to create (e.g., system/migration)')
     .option('-f, --force', 'Force overwrite if exists', false)
     .action(cmdCreate);
 
 program.command('download')
-    .description('Download a skill package')
-    .argument('<skill_name>', 'Name of the skill to download')
+    .description('Download and extract a skill package from the remote registry')
+    .argument('<skill_path>', 'Path of the skill to download (e.g., core/kernel/kernel-info)')
+    .option('-t, --target <dir>', 'Target directory to extract into (defaults to current dir)')
     .option('--platform <platform>', 'Specify the platform (e.g., qoder will download to .qoder/skills/)')
-    .option('--url <url>', 'Specify the base URL for the registry (defaults to SKILL_OS_REGISTRY env var)')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
     .action(cmdDownload);
 
-program.command('sync')
-    .description('Register or update a skill in the index with interactive prompts')
-    .argument('<path>', 'Skill path to sync (e.g., cloud/alicloud-api)')
-    .action(cmdSync);
-
-program.command('sync-all')
-    .description('Regenerate index from all SKILL.md files (one-click sync)')
-    .option('--include-placeholder', 'Include placeholder skills in output', false)
-    .action(cmdSyncAll);
+program.command('upload')
+    .alias('publish')
+    .description('Upload a local skill to the remote registry')
+    .argument('<path>', 'Skill path to upload (e.g., system/migration)')
+    .option('-u, --update', 'Publish as an update to an existing skill', false)
+    .option('--token <token>', 'Authentication token for the remote registry')
+    .option('--url <url>', 'Override the base URL for the registry', DEFAULT_API_BASE)
+    .action(cmdUpload);
 
 program.command('validate')
     .description('Validate a skill against spec')