skill-os 0.1.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "skill-os",
+  "version": "0.1.0",
+  "description": "Skill-OS CLI for managing OS skills",
+  "main": "skill-os.js",
+  "bin": {
+    "skill-os": "skill-os.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "skills",
+    "os-copilot"
+  ],
+  "author": "OS-Copilot Team",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^13.1.0",
+    "inquirer": "^8.2.6",
+    "js-yaml": "^4.1.0",
+    "jsonschema": "^1.4.1",
+    "node-fetch": "^2.7.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/skill-os.js

@@ -0,0 +1,822 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+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
+const layerIcons = {
+    core: "🧠",
+    system: "🔧",
+    runtime: "📦",
+    application: "🚀",
+    cloud: "☁️",
+    package: "📦",
+    network: "🌐",
+    storage: "💾",
+    user: "👤",
+    meta: "🛠️",
+};
+
+function formatLayerIcon(skillPath) {
+    const layer = skillPath.split("/")[0];
+    return layerIcons[layer] || "📄";
+}
+
+function formatStatus(status) {
+    switch (status?.toLowerCase()) {
+        case 'stable': return chalk.green(status);
+        case 'beta': return chalk.yellow(status);
+        case 'placeholder': return chalk.dim(status);
+        default: return status || 'unknown';
+    }
+}
+
+function getRepoRoot() {
+    let current = path.dirname(__dirname); // Usually cli is in the repo root
+    if (fs.existsSync(path.join(current, 'SKILL_INDEX.json'))) {
+        return current;
+    }
+
+    if (fs.existsSync(path.join(process.cwd(), 'SKILL_INDEX.json'))) {
+        return process.cwd();
+    }
+    return current;
+}
+
+function loadIndex() {
+    const repoRoot = getRepoRoot();
+    const indexPath = path.join(repoRoot, 'SKILL_INDEX.json');
+
+    if (!fs.existsSync(indexPath)) {
+        console.error(chalk.red('Error: SKILL_INDEX.json not found'));
+        process.exit(1);
+    }
+
+    const raw = fs.readFileSync(indexPath, 'utf-8');
+    return JSON.parse(raw);
+}
+
+// ----------------------------------------------------------------------
+// Commmands Implementations
+// ----------------------------------------------------------------------
+
+function cmdList() {
+    const index = loadIndex();
+    const skills = index.skills || {};
+
+    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];
+        if (!layers[layer]) layers[layer] = [];
+        layers[layer].push({ path: skillPath, info });
+    }
+
+    for (const layer of Object.keys(layers).sort()) {
+        const icon = layerIcons[layer] || "📄";
+        console.log(`${chalk.bold(icon + ' ' + layer.toUpperCase())}`);
+
+        const sortedSkills = layers[layer].sort((a, b) => a.path.localeCompare(b.path));
+
+        for (const { path: skillPath, info } of sortedSkills) {
+            const status = formatStatus(info.status);
+            const name = info.name || skillPath;
+            const version = info.version || '?';
+            const desc = (info.description || '').substring(0, 50);
+
+            console.log(`  ${chalk.cyan(skillPath)}`);
+            console.log(`    ${name} (${version}) [${status}]`);
+            console.log(`    ${chalk.dim(desc + '...')}`);
+        }
+        console.log();
+    }
+}
+
+function cmdSearch(query) {
+    const lowercaseQuery = query.toLowerCase();
+    const index = loadIndex();
+    const skills = index.skills || {};
+
+    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 });
+        }
+    }
+
+    if (matches.length === 0) {
+        console.log(chalk.yellow(`No skills found matching '${query}'`));
+        return;
+    }
+
+    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) {
+        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(`   ${desc}\n`);
+    }
+}
+
+function cmdInfo(skillPath) {
+    const index = loadIndex();
+    const skills = index.skills || {};
+
+    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 icon = formatLayerIcon(skillPath);
+    const status = formatStatus(info.status);
+
+    console.log(`\n${icon} ${chalk.bold(info.name || skillPath)}`);
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Path:         ${chalk.cyan(skillPath)}`);
+    console.log(`  Version:      ${info.version || 'unknown'}`);
+    console.log(`  Status:       ${status}`);
+    console.log(`  Description:  ${info.description || 'No description'}`);
+
+    if (info.dependencies && info.dependencies.length > 0) {
+        console.log(`  Dependencies: ${info.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}`)}`);
+    }
+    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);
+
+    if (fs.existsSync(targetDir)) {
+        if (!options.force) {
+            console.error(chalk.red(`Error: Directory already exists: ${targetDir}`));
+            console.log(chalk.dim("Use --force to overwrite"));
+            process.exit(1);
+        }
+        fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    const parts = skillPath.split('/');
+    if (parts.length < 3) {
+        console.error(chalk.red("Error: Invalid path format"));
+        console.log(chalk.dim("Expected: <layer>/<category>/<skill>"));
+        console.log(chalk.dim("Example: system/security/cve-repair"));
+        process.exit(1);
+    }
+
+    const layer = parts[0];
+    const category = parts[1];
+    const skillName = parts[parts.length - 1];
+
+    const validLayers = ["core", "system", "runtime", "application"];
+    if (!validLayers.includes(layer)) {
+        console.log(chalk.yellow(`Warning: Layer '${layer}' not in spec`));
+        console.log(chalk.dim(`Valid layers: ${validLayers.join(', ')}`));
+    }
+
+    const titleCaseName = skillName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+    const skillMdContent = `---
+name: ${skillName}
+version: 0.1.0
+description: TODO: Add skill description here
+author: Your Name
+
+layer: ${layer}
+category: ${category}
+lifecycle: usage  # production | maintenance | operations | usage | meta
+
+# Tags: first tag MUST be the category name
+tags:
+  - ${category}
+  - TODO
+
+status: placeholder
+dependencies: []
+
+# Optional: Permissions (for security classification)
+# permissions:
+#   requires_root: false
+#   dangerous_operations: []
+---
+
+# ${titleCaseName}
+
+TODO: Add skill documentation here.
+
+## 能力概览
+
+- TODO: List capabilities
+
+## 使用示例
+
+\`\`\`bash
+# TODO: Add usage examples
+\`\`\`
+
+## TODO
+
+- [ ] Implement core functionality
+- [ ] Add scripts if needed
+- [ ] Run: skill-os validate ${skillPath}
+- [ ] Run: skill-os sync ${skillPath}
+`;
+
+    const skillMdPath = path.join(targetDir, "SKILL.md");
+    fs.writeFileSync(skillMdPath, skillMdContent, 'utf-8');
+
+    console.log(`\n${chalk.green('✓ Created skill scaffold:')}`);
+    console.log(`  ${chalk.cyan(targetDir)}`);
+    console.log("  └── SKILL.md");
+
+    console.log(`\n${chalk.bold('📋 Next Steps:')}`);
+    console.log(`  1. Edit ${chalk.cyan(skillMdPath)}`);
+    console.log(`  2. Validate: ${chalk.dim(`skill-os validate ${skillPath}`)}`);
+    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();
+
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    let serverUrl = options.url || process.env.SKILL_OS_REGISTRY || "https://example.com/skills";
+    serverUrl = serverUrl.replace(/\/$/, ""); // Trim trailing slash
+
+    const downloadUrl = `${serverUrl}/${skillName}.tar.gz`;
+
+    console.log(`\n${chalk.bold(`📥 Downloading ${skillName}...`)}`);
+    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}`)}`);
+    } catch (e) {
+        console.error(`\n${chalk.red(`✗ Failed to download ${skillName}: command returned error code ${e.status}`)}`);
+        process.exit(1);
+    }
+}
+
+// ----------------------------------------------------------------------
+// YAML / Sync Helpers
+// ----------------------------------------------------------------------
+
+function parseSkillMdFrontmatter(skillMdPath) {
+    if (!fs.existsSync(skillMdPath)) return {};
+    const content = fs.readFileSync(skillMdPath, 'utf8');
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match) return {};
+
+    try {
+        return yaml.load(match[1]) || {};
+    } catch (e) {
+        return {};
+    }
+}
+
+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 cmdSync(skillPath) {
+    const repoRoot = getRepoRoot();
+    const skillDir = path.join(repoRoot, 'skills', skillPath);
+
+    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}`));
+        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}`));
+        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`);
+    }
+
+    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 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}`);
+    }
+    console.log();
+
+    const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Confirm and save?',
+        default: true
+    }]);
+
+    if (!confirm) {
+        console.log(chalk.yellow('Cancelled'));
+        process.exit(0);
+    }
+
+    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(`\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'`);
+}
+
+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));
+        }
+    }
+    return fileList;
+}
+
+function cmdSyncAll(options) {
+    const repoRoot = getRepoRoot();
+    const skillsDir = path.join(repoRoot, 'skills');
+
+    console.log(`\n${chalk.bold('🔄 Skill-OS Sync All')}`);
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(`Scanning: ${chalk.cyan(skillsDir)}\n`);
+
+    const skillMds = findSkillMds(skillsDir);
+    if (skillMds.length === 0) {
+        console.log(chalk.yellow('No SKILL.md files found'));
+        return;
+    }
+
+    console.log(`Found ${chalk.green(skillMds.length)} skills\n`);
+
+    const newSkills = {};
+    const errors = [];
+
+    skillMds.sort().forEach(skillMd => {
+        const relPath = path.relative(skillsDir, path.dirname(skillMd));
+        const fm = parseSkillMdFrontmatter(skillMd);
+
+        if (!fm || Object.keys(fm).length === 0) {
+            errors.push(`  ⚠ ${relPath}: Failed to parse frontmatter`);
+            return;
+        }
+
+        let status = fm.status || 'beta';
+        let icon = '✓';
+        if (status === 'placeholder') {
+            if (!options.includePlaceholder) {
+                status = 'beta'; // Default placeholder -> beta
+            }
+            icon = '🔸';
+        }
+
+        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)];
+        }
+
+        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]}`);
+    }
+}
+
+// ----------------------------------------------------------------------
+// Validation Helpers
+// ----------------------------------------------------------------------
+
+const { Validator } = require('jsonschema');
+
+const skillSchema = {
+    id: "/SkillMetadata",
+    type: "object",
+    properties: {
+        name: { type: "string", minLength: 1 },
+        version: { type: ["string", "number"] },
+        description: { type: "string" },
+        layer: { enum: ["core", "system", "runtime", "application"] },
+        lifecycle: { enum: ["production", "maintenance", "operations", "usage", "meta"] },
+        category: { type: ["string", "null"] },
+        tags: { type: "array", items: { type: "string" } },
+        status: { enum: ["stable", "beta", "placeholder"] },
+        dependencies: { type: "array", items: { type: "string" } },
+        permissions: {
+            type: "object",
+            properties: {
+                requires_root: { type: "boolean" },
+                dangerous_operations: { type: "array", items: { type: "string" } }
+            }
+        }
+    },
+    required: ["name", "version", "layer", "lifecycle", "status"]
+};
+
+function validateDirectoryStructure(skillDir) {
+    const errors = [];
+    if (!fs.existsSync(skillDir)) {
+        return { isValid: false, errors: ["Directory does not exist"] };
+    }
+
+    const skillMd = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(skillMd)) {
+        errors.push("Missing SKILL.md file");
+    } else {
+        const content = fs.readFileSync(skillMd, 'utf8');
+        if (!content.includes('---')) {
+            errors.push("SKILL.md missing frontmatter");
+        }
+    }
+
+    return { isValid: errors.length === 0, errors };
+}
+
+function cmdValidate(skillPath) {
+    const repoRoot = getRepoRoot();
+    const skillDir = path.join(repoRoot, 'skills', skillPath);
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+    console.log(`\n${chalk.bold(`🔍 Validating Skill: ${skillPath}`)}`);
+    console.log(`${chalk.dim('─'.repeat(50))}\n`);
+
+    const { isValid: isDirValid, errors: dirErrors } = validateDirectoryStructure(skillDir);
+    if (isDirValid) {
+        console.log(`${chalk.green('✓ Directory structure valid')}`);
+    } else {
+        console.log(`${chalk.red('✗ Directory structure errors:')}`);
+        dirErrors.forEach(err => console.log(`  - ${err}`));
+    }
+
+    if (!fs.existsSync(skillMdPath)) {
+        console.log(`${chalk.red('✗ Fatal: SKILL.md not found')}`);
+        process.exit(1);
+    }
+
+    const fm = parseSkillMdFrontmatter(skillMdPath);
+
+    // Check if empty frontmatter
+    if (!fm || Object.keys(fm).length === 0) {
+        console.log(`${chalk.red('✗ SKILL.md missing or invalid frontmatter')}`);
+        process.exit(1);
+    }
+
+    const v = new Validator();
+    const result = v.validate(fm, skillSchema);
+
+    // Custom tag validation: first tag MUST be category
+    if (fm.category && fm.tags && fm.tags.length > 0) {
+        if (fm.tags[0] !== fm.category) {
+            result.errors.push({ stack: `tags[0] must equal category name '${fm.category}'` });
+        }
+    }
+
+    if (result.valid && result.errors.length === 0) {
+        console.log(`${chalk.green('✓ SKILL.md is spec compliant')}`);
+        console.log(`\n${chalk.bold('📋 Parsed Metadata:')}`);
+        console.log(`  name:      ${fm.name}`);
+        console.log(`  version:   ${fm.version}`);
+        console.log(`  layer:     ${fm.layer}`);
+        console.log(`  lifecycle: ${fm.lifecycle}`);
+        console.log(`  category:  ${fm.category || '(missing)'}`);
+        console.log(`  tags:      ${JSON.stringify(fm.tags || [])}`);
+        if (fm.permissions) {
+            console.log(`  requires_root: ${fm.permissions.requires_root}`);
+        }
+    } else {
+        console.log(`${chalk.red('✗ SKILL.md validation errors:')}`);
+        result.errors.forEach(err => console.log(`  - ${err.stack.replace('instance.', '')}`));
+        process.exit(1);
+    }
+
+    console.log(`\n${chalk.green('✅ Validation passed!')}\n`);
+}
+
+// ----------------------------------------------------------------------
+// CLI Setup
+// ----------------------------------------------------------------------
+
+program
+    .name('skill-os')
+    .description('Skill-OS CLI');
+
+program.command('list')
+    .description('List all available skills')
+    .action(cmdList);
+
+program.command('search')
+    .description('Search for skills')
+    .argument('<query>', 'Search query')
+    .action(cmdSearch);
+
+program.command('info')
+    .description('Show skill details')
+    .argument('<path>', 'Skill path (e.g., package/package/rpm_search)')
+    .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')
+    .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')
+    .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)')
+    .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('validate')
+    .description('Validate a skill against spec')
+    .argument('<path>', 'Skill path to validate (e.g., system/security/cve-repair)')
+    .action(cmdValidate);
+
+program.parse(process.argv);