skill-os 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-os",
-  "version": "0.1.1",
+  "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"

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
@@ -227,76 +226,10 @@ async function cmdInfo(skillPath, options) {
     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) {
@@ -425,9 +358,11 @@ function cmdDownload(skillPath, options) {
 }
 
 // ----------------------------------------------------------------------
-// YAML / Sync Helpers
+// Publishing / Uploading
 // ----------------------------------------------------------------------
 
+const FormData = require('form-data');
+
 function parseSkillMdFrontmatter(skillMdPath) {
     if (!fs.existsSync(skillMdPath)) return {};
     const content = fs.readFileSync(skillMdPath, 'utf8');
@@ -441,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
-    }]);
 
-    if (!confirm) {
-        console.log(chalk.yellow('Cancelled'));
-        process.exit(0);
-    }
+    console.log(chalk.green('✓ Local validation passed.'));
 
-    console.log(`\n${chalk.dim('Saving SKILL_INDEX.yaml...')}`);
-    appendSkillToYaml(skillPath, skillEntry, yamlPath);
+    // 2. Prepare tarball
+    const tarFilename = `${fm.name}-${fm.version}.tar.gz`;
+    const tmpDir = require('os').tmpdir();
+    const tarPath = path.join(tmpDir, tarFilename);
 
-    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]}`);
     }
 }
 
@@ -772,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}`)}`);
@@ -856,13 +626,6 @@ program.command('info')
     .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 locally from repository')
-    .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 locally')
     .argument('<path>', 'Skill path to create (e.g., system/migration)')
@@ -877,15 +640,14 @@ program.command('download')
     .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')

package/test-extract/rpm_find/SKILL.md

@@ -1,97 +0,0 @@
----
-name: rpm-find
-version: 1.0.0
-description: 专业的 Alinux 系统 RPM 软件包搜索工具。支持解析复杂的包名查询，根据用户网络环境（内网/公网）智能提供有效下载链接。当用户请求查找、下载或查询 RPM 软件包时使用此技能。
-
-
-layer: runtime
-category: package
-lifecycle: usage
-
-# Tags: first tag MUST be the category name
-tags:
-  - package
-  - rpm
-  - alinux
-  - search
-
-status: stable
-dependencies:
-  - httpx>=0.24.0
-  - requests>=2.28.0
----
-
-# RPM 软件包搜索技能
-
-当用户请求查找、下载或查询 Alinux 系统的 RPM 软件包时使用此技能。
-
-## 能力概览
-
-此技能能够解析模糊的包名（如 "nginx", "kernel 5.10"），并调用工具搜索实际的下载地址。它能根据用户的身份和网络环境，动态调整搜索策略和回复语气。
-
-## 核心流程
-
-### 步骤 1: 知识库加载 (必选)
-
-在开始任何搜索之前，必须使用 `read_file` 工具读取以下文档以了解 Alinux 的内核与版本命名规则：
-
-- [Alinux 内核与版本识别](./references/kernel_kb.md)
-
-### 步骤 2: 意图识别与扩展 (可选分支)
-
-在进行常规搜索前，请检查用户的具体意图。如果用户明确咨询 **"debuginfo"**, **"崩溃调试"**, **"内核调试"**, 或 **"debug 仓库"** 相关问题：
-
-- **加载**: [Alinux Debuginfo 包查找指南](./references/debuginfo_guide.md)
-- **执行**: 根据该指南中的 "标准用法" 或 "URL拼接" 规则回答用户的问题。
-
-### 步骤 3: 环境判断与 SOP 加载 (分支)
-
-请根据用户的 `source` 字段或当前对话上下文判断用户环境，并加载对应的 SOP 文档：
-
-- **情形 A: 内部开发环境** (例如 `source` 为 `cardbot_in` 或提到 "内部源")
-  - 加载: [内网 RPM 搜索 SOP](./references/inner_rules.md)
-  - 执行重点: 优先使用内网源，不过滤闭源包，回复简洁。
-
-- **情形 B: 外部公网环境** (默认情况，或 `source` 为 `other`)
-  - 加载: [公网 RPM 搜索 SOP](./references/outer_rules.md)
-  - 执行重点: **严禁泄露内网 IP**，必须转换为 `mirrors.aliyun.com`，语气亲切。
-
-### 步骤 4: 工具调用 (CLI 模式)
-
-使用 `execute_shell` 运行 Python 脚本执行操作。
-
-**脚本路径**: `./scripts/rpm_tool.py`
-
-#### 4.1 解析查询
-
-```bash
-uv run ./scripts/rpm_tool.py parse "kernel 5.10"
-```
-
-#### 4.2 搜索 RPM (API)
-
-将解析结果 (JSON) 中的字段传入:
-
-```bash
-uv run ./scripts/rpm_tool.py search "kernel" --version "5.10.134" --release "13.al8" --arch "x86_64"
-```
-
-#### 4.3 验证 URL
-
-将找到的 URL 列表传入验证:
-
-```bash
-uv run ./scripts/rpm_tool.py verify http://url1 http://url2 ...
-```
-
-#### 4.4 备用: URL 拼接 (仅当 API 无结果时)
-
-```bash
-uv run ./scripts/rpm_tool.py construct "kernel-debuginfo" "5.10.134" "13.al8" "x86_64" --is_kernel --alinux_version "3"
-```
-
-## 错误处理
-
-- 如果 API 返回空结果，尝试使用 `construct` 命令拼接 URL
-- 如果所有 URL 验证失败，建议用户检查包名或版本号是否正确
-- 对于闭源包（含 `ali3000`, `ali4000` 等标识），提示用户联系 OS 团队

package/test-extract/rpm_find/pyproject.toml

@@ -1,12 +0,0 @@
-[project]
-name = "package/rpm_search-skill"
-version = "1.0.0"
-description = "RPM package search skill for Alinux systems"
-requires-python = ">=3.9"
-dependencies = [
-    "httpx>=0.24",
-    "requests>=2.28",
-]
-
-[project.scripts]
-rpm-tool = "scripts.rpm_tool:main"

package/test-extract/rpm_find/references/debuginfo_guide.md

@@ -1,29 +0,0 @@
-# Alinux Debuginfo 包查找指南
-
-## 标准用法 (YUM/DNF)
-Alinux 系统找包的标准用法是通过 YUM/DNF 工具。对于 debuginfo 包，需要使用 `yum-utils` 提供的 `debuginfo-install` 命令，因为 debug 仓库默认未开启。
-
-### 常用命令
-- **安装常规包**: `debuginfo-install <pkg>` (例如 `debuginfo-install tree`)
-- **安装内核包**: `debuginfo-install kernel-debuginfo` (必须带后缀，否则安装不上)
-- **仅下载不安装**: `debuginfo-install --downloadonly kernel-debuginfo-$(uname -r)`
-    - 下载位置: `/var/cache/dnf/`
-
-## URL 拼接用法 (不推荐但可用)
-仅在不得不手动下载时使用。**注意**: 仅适用于公网镜像 `mirrors.aliyun.com`。闭源组件 (`ali3000`等) 不适用此法。
-
-### 拼接规则
-1.  **架构推断**:
-    - `.al7` -> Alinux 2
-    - `.al8` -> Alinux 3
-    - `.alnx4` -> Alinux 4
-2.  **内核包 URL**:
-    - **Alinux 2/3**: `<dist>/plus/<arch>/debug/kernels/`
-    - **Alinux 4**: `<dist>/os/<arch>/debug/` 或 `<dist>/updates/<arch>/debug/`
-    - 文件名: `kernel-debuginfo-<version>-<release>.rpm` 和 `kernel-debuginfo-common-<arch>-<version>-<release>.rpm`
-3.  **非内核包 URL**:
-    - 路径: `<dist>/<repo>/<arch>/debug/<pkg>-debuginfo-<version>-<release>.rpm`
-
-### 注意事项
-- 如果需要查找 debuginfo，若是内核包，需同时提供 `kernel-debuginfo` 和 `kernel-debuginfo-common`。
-- 若闭源包无 debuginfo，需联系 OS 团队。

package/test-extract/rpm_find/references/inner_rules.md

@@ -1,17 +0,0 @@
-# 内网 RPM 搜索 SOP (Inner)
-
-**适用场景**: 用户身份为内部员工 (`source: cardbot_in`) 或检测到内网环境。
-
-## 核心准则
-你是一名顶级的 Alinux 系统 RPM 包管理专家智能体。
-1.  **提供有效链接**: 必须提供 `yum.tbsite.net` 等内网源链接。
-2.  **验证**: 所有链接必须先通过 `check_url_availability_batch` 验证。
-3.  **语气**: 专业、直接、技术导向。
-
-## 执行步骤
-1.  **解析**: 调用 `parse_user_query_to_rpm_info` 解析包名。
-2.  **查询**: 调用 `get_rpm_list` 获取内网链接。
-3.  **闭源包处理**: 
-    - 如果发现 `apsara` 或 `aliXXXX` 等闭源包，**可以**显示，并标记为“内部闭源”。
-4.  **验证**: 并行验证所有 URL。
-5.  **输出**: 直接列出 Markdown 格式的下载链接。

package/test-extract/rpm_find/references/kernel_kb.md

@@ -1,16 +0,0 @@
-# Alinux 内核与版本识别知识库
-
-本参考文档包含识别 Alinux 内核及对应系统版本的核心规则。
-
-## 内核识别规则
-- **内核判断**: 版本号以 5.10, 6.6, 4.19, 4.9 等主线版本开头，或包含 `ali3000`, `ali4000`, `ali5000`, `ali6000`, `kernel`, `kmod` 字样，判定为内核。
-    - 注意：`ali5000`, `ali6000` 是内核标识符,而不是软件包名称。
-- **内核包名**: 内核对应 `kernel`, 包名一般为 `kernel`, `kernel-devel`, `kernel-core`, `kernel-modules` 等。
-- **闭源内核**: 包含 `ali3000`, `ali4000`, `ali5000`, `ali6000` 等字样, 或API返回的仓库路径包含 `apsara-xxxx` 等特殊标识, 代表内部闭源包。
-
-## 系统版本对应表
-| 标识符 | Alinux 版本 | 备注 |
-| :--- | :--- | :--- |
-| `.al7` | Alinux 2 | |
-| `.al8` | Alinux 3 | 内核主版本号 5.10 也对应 Alinux 3 |
-| `.alnx4`| Alinux 4 | 内核主版本号 6.6 也对应 Alinux 4 |

package/test-extract/rpm_find/references/outer_rules.md

@@ -1,20 +0,0 @@
-# 公网 RPM 搜索 SOP (Outer)
-
-**适用场景**: 用户身份为外部客户 (`source: other`) 或公网环境。
-
-## 核心准则
-你是一名服务于外部客户的 Alinux 系统专家。
-1.  **只提供公网链接**: *绝对禁止* 泄露 `yum.tbsite.net` 等内网链接。必须转换为 `mirrors.aliyun.com`。
-2.  **验证**: 所有链接必须通过 `check_url_availability_batch` 验证。
-3.  **语气**: 亲切、耐心、解释性强。
-
-## 执行步骤
-1.  **解析**: 调用 `parse_user_query_to_rpm_info`。
-2.  **查询**: 调用 `get_rpm_list`。
-3.  **安全过滤 (关键)**: 
-    - 检查是否为闭源包 (`apsara`, `aliXXXX`)。若是，**绝对不能**提供链接，告知用户“需联系售后获取”。
-    - 将所有内网 URL (`http://yum.tbsite.net/...`) 替换为公网镜像 (`https://mirrors.aliyun.com/...`)。
-4.  **兜底**: 如果转换失败，调用 `construct_url` 尝试拼接。
-5.  **输出**: 
-    - 使用表格形式展示结果。
-    - 对每个步骤做简单解释，帮助客户理解。

package/test-extract/rpm_find/scripts/rpm_tool.py

@@ -1,417 +0,0 @@
-#!/usr/bin/env python3
-"""
-RPM Search Tool Script
-此脚本封装了 RPM 搜索相关的核心功能，供 AI Agent 通过命令行调用。
-"""
-
-import argparse
-import asyncio
-import json
-import logging
-import re
-
-from typing import Any
-
-import httpx
-import requests
-
-
-# 设置日志
-logging.basicConfig(level=logging.ERROR, format="%(message)s")
-logger = logging.getLogger(__name__)
-
-# --- Core Functions from example_agent.py ---
-
-
-def fetch_webpage_content(
-    url: str, params: dict | None = None, timeout: int = 10
-) -> str:
-    """获取url返回的数据"""
-    try:
-        response = requests.get(url=url, params=params, timeout=timeout)
-        response.raise_for_status()
-        return response.text
-    except requests.exceptions.RequestException as e:
-        logger.error(f"网络请求失败: {e}")
-        return ""
-
-
-def parse_user_query_to_rpm_info(query: str) -> list[dict[str, Any]]:
-    query = query.replace("内核", " kernel ")
-    cleaned_query = re.sub(r"[\u4e00-\u9fa5]", " ", query)
-    work_str = " ".join(cleaned_query.split())
-    package_queries = re.findall(
-        r"[\w\.~-]*?(?:\d{1,2}\.\d{1,2}|al[78]|alnx4|x86_64|aarch64)[\w\.~-]*",
-        work_str,
-    )
-    if not package_queries:
-        package_queries = [work_str]
-    results = []
-    for part in package_queries:
-        if not part or len(part) < 5:
-            continue
-        info = {
-            "name": "",
-            "version": "",
-            "release": "",
-            "arch": "",
-            "type": "standard",
-            "is_kernel": False,
-            "alinux_version": "unknown",
-            "original_text": part,
-        }
-        arch_match = re.search(r"\b(x86_64|aarch64)\b", part)
-        if arch_match:
-            info["arch"] = arch_match.group(1)
-            part = part.replace(arch_match.group(0), "").strip()
-        dist_match = re.search(r"[\.-](al[78]|alnx4)", part)
-        if dist_match:
-            info["alinux_version"] = {"al7": "2", "al8": "3", "alnx4": "4"}.get(
-                dist_match.group(1)
-            )
-            part = part[: dist_match.start()]
-        ver_match = re.search(r"(\d{1,2}\.\d{1,2}(?:\.\d{1,3})?)", part)
-        if ver_match:
-            name_candidate = part[: ver_match.start()].strip("-_ ")
-            version_release_candidate = part[ver_match.start() :]
-            vr_parts = version_release_candidate.split("-", 1)
-            info["version"] = vr_parts[0]
-            if len(vr_parts) > 1:
-                info["release"] = vr_parts[1]
-            else:
-                final_vr_parts = info["version"].rsplit("-", 1)
-                if len(final_vr_parts) == 2:
-                    info["version"] = final_vr_parts[0]
-                    info["release"] = final_vr_parts[1]
-            info["name"] = name_candidate
-        else:
-            name_ver_parts = part.rsplit("-", 1)
-            if len(name_ver_parts) == 2 and re.match(r"\d", name_ver_parts[1]):
-                info["name"] = name_ver_parts[0]
-                ver_rel_parts = name_ver_parts[1].rsplit("-", 1)
-                info["version"] = ver_rel_parts[0]
-                if len(ver_rel_parts) > 1:
-                    info["release"] = ver_rel_parts[1]
-            else:
-                info["name"] = part
-        final_name = info["name"].replace(".rpm", "").strip("-_ ")
-        if not final_name and ("kernel" in work_str or "vmlinux" in work_str):
-            final_name = "kernel"
-        kernel_markers = [
-            "ali3000",
-            "ali4000",
-            "ali5000",
-            "ali6000",
-            "kernel",
-            "kmod",
-        ]
-        if any(marker in final_name for marker in kernel_markers) or (
-            ver_match and ver_match.group(1).startswith(("5.10", "4.19", "6.6"))
-        ):
-            info["is_kernel"] = True
-        if info["alinux_version"] == "unknown":
-            if info.get("release") and "al8" in info["release"]:
-                info["alinux_version"] = "3"
-            elif info.get("release") and "al7" in info["release"]:
-                info["alinux_version"] = "2"
-            elif info.get("release") and "alnx4" in info["release"]:
-                info["alinux_version"] = "4"
-            elif info["is_kernel"] and info.get("version", "").startswith(
-                "5.10"
-            ):
-                info["alinux_version"] = "3"
-            elif info["is_kernel"] and info.get("version", "").startswith(
-                "6.6"
-            ):
-                info["alinux_version"] = "4"
-        if (
-            "debug" in work_str
-            or "vmlinux" in work_str
-            or "debuginfo" in final_name
-        ):
-            info["type"] = "debuginfo"
-        if info["type"] == "debuginfo" and "debuginfo" not in final_name:
-            final_name += "-debuginfo"
-        info["name"] = final_name.strip("-")
-        if info["name"]:
-            results.append(info)
-    return results
-
-
-# 全局共享的AsyncClient实例,配置连接池以支持高并发
-_shared_http_client: httpx.AsyncClient | None = None
-
-
-def _get_shared_http_client() -> httpx.AsyncClient:
-    """获取共享的httpx AsyncClient实例,配置连接池支持高并发"""
-    global _shared_http_client
-    if _shared_http_client is None:
-        # 配置连接池限制,支持高并发请求
-        limits = httpx.Limits(
-            max_connections=200,  # 最大连接数
-            max_keepalive_connections=50,  # 保持活动的连接数
-        )
-        _shared_http_client = httpx.AsyncClient(
-            limits=limits,
-            timeout=1.5,
-            follow_redirects=True,
-        )
-    return _shared_http_client
-
-
-async def _check_single_url(client: httpx.AsyncClient, url: str) -> dict:
-    """
-    异步检查单个URL的可用性
-    """
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-    }
-    result = {"url": url}
-    try:
-        response = await client.head(url, headers=headers)
-        if response.status_code == 200:
-            result["status"] = "valid"
-            result["status_code"] = "200"
-        else:
-            result["status"] = "invalid"
-            result["status_code"] = str(response.status_code)
-    except httpx.TimeoutException:
-        result["status"] = "error"
-        result["reason"] = "Request timed out"
-    except httpx.ConnectError as e:
-        result["status"] = "error"
-        result["reason"] = f"Connection error: {e}"
-    except httpx.HTTPError as e:
-        result["status"] = "error"
-        result["reason"] = f"An unexpected error occurred: {e}"
-    return result
-
-
-async def check_urls_availability_batch(
-    urls: list[str],
-) -> list[dict[str, Any]]:
-    """
-    并发检查一批URLs是否有效且可访问。
-    """
-    if not urls:
-        return []
-
-    client = _get_shared_http_client()
-    # 使用asyncio.gather并发执行所有URL检查
-    tasks = [_check_single_url(client, url) for url in urls]
-    results = await asyncio.gather(*tasks)
-    return list(results)
-
-
-def get_rpm_list(
-    name: str, version: str = "", release: str = "", arch: str = ""
-) -> list[dict[str, str]]:
-    """
-    通过内部API查询RPM包的详细信息。返回结果是内网URL,需要后续处理。
-    """
-    base_url = "http://opsx.vip.tbsite.net/gapi/v1/cms/rpm/list?"
-    # 确保version包含2位小数点,避免精确查询失败
-    if version and version.count(".") != 2:
-        version = ""
-    params = {
-        "name": name,
-        "version": version,
-        "release": release,
-        "arch": arch,
-    }
-
-    rep_text = fetch_webpage_content(base_url, params=params)
-    if not rep_text:
-        return []
-
-    try:
-        rep_json = json.loads(rep_text)
-        rpms = rep_json.get("data", {}).get("rpms", [])
-        return [
-            {
-                "name": item.get("name", ""),
-                "version": item.get("version", ""),
-                "release": item.get("release", ""),
-                "arch": item.get("arch", ""),
-                "internal_url": item.get("download_url", ""),
-            }
-            for item in rpms
-            if "alinux" in item.get("download_url", "")
-        ]
-    except (json.JSONDecodeError, TypeError) as e:
-        logger.error(f"API响应解析失败: {e}")
-        return []
-
-
-async def construct_url(
-    name: str,
-    version: str,
-    release: str,
-    arch: str,
-    is_kernel: bool = False,
-    alinux_version: str = "3",
-) -> list[str]:
-    """
-    根据包信息拼接公网URL作为备用方案,name大小写敏感。
-    """
-    # 步骤1: 输入验证
-    if (
-        not all([name, version, release, arch, alinux_version])
-        or alinux_version == "unknown"
-    ):
-        return []
-
-    urls = []
-    full_rpm_filename = f"{name}-{version}-{release}.{arch}.rpm"
-
-    # 步骤2: 根据包类型选择不同的拼接逻辑
-    # 逻辑分支 A: 内核Debuginfo包
-    if is_kernel and "debuginfo" in name:
-        full_ver_rel = f"{version}-{release}"
-        if alinux_version in ["2", "3"]:
-            # Alinux 2/3 的 debuginfo 在 plus 仓库的特定子目录
-            base_url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/plus/{arch}/debug/kernels"
-            urls.append(
-                f"{base_url}/kernel-debuginfo-{full_ver_rel}.{arch}.rpm"
-            )
-            # 内核debuginfo需要common包
-            urls.append(
-                f"{base_url}/kernel-debuginfo-common-{arch}-{version}-{release}.rpm"
-            )
-        elif alinux_version == "4":
-            # Alinux 4 可能在 os 或 updates 仓库
-            for repo in ["os", "updates"]:
-                base_url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/debug"
-                urls.append(
-                    f"{base_url}/kernel-debuginfo-{full_ver_rel}.{arch}.rpm"
-                )
-                urls.append(
-                    f"{base_url}/kernel-debuginfo-common-{arch}-{version}-{release}.rpm"
-                )
-
-    # 逻辑分支 B: 普通RPM包
-    else:
-        # common_repos = ['os', 'plus', 'updates', 'powertools', 'extras']
-        common_repos = ["os"]
-        for repo in common_repos:
-            url = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/Packages/{full_rpm_filename}"
-            urls.append(url)
-            # 对于debuginfo包,有可能在debug目录下
-            if "debuginfo" in name:
-                url_debug_repo = f"https://mirrors.aliyun.com/alinux/{alinux_version}/{repo}/{arch}/debug/Packages/{full_rpm_filename}"
-                urls.append(url_debug_repo)
-    # 使用并发批量检查所有URL
-    client = _get_shared_http_client()
-    tasks = [_check_single_url(client, url) for url in urls]
-    check_results = await asyncio.gather(*tasks)
-
-    return [
-        result["url"]
-        for result in check_results
-        if result.get("status") == "valid"
-    ]
-
-
-# --- CLI Wrappers ---
-
-
-def cmd_parse(args):
-    results = parse_user_query_to_rpm_info(args.query)
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-
-def cmd_search(args):
-    results = get_rpm_list(
-        name=args.name,
-        version=args.version,
-        release=args.release,
-        arch=args.arch,
-    )
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-
-async def async_cmd_verify(args):
-    urls = args.urls
-    results = await check_urls_availability_batch(urls)
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-
-def cmd_verify(args):
-    asyncio.run(async_cmd_verify(args))
-
-
-async def async_cmd_construct(args):
-    results = await construct_url(
-        name=args.name,
-        version=args.version,
-        release=args.release,
-        arch=args.arch,
-        is_kernel=args.is_kernel,
-        alinux_version=args.alinux_version,
-    )
-    print(json.dumps(results, ensure_ascii=False, indent=2))
-
-
-def cmd_construct(args):
-    asyncio.run(async_cmd_construct(args))
-
-
-def main():
-    parser = argparse.ArgumentParser(description="RPM Search Tool CLI")
-    subparsers = parser.add_subparsers(
-        dest="command", help="Available commands"
-    )
-
-    # Command: parse
-    parser_parse = subparsers.add_parser(
-        "parse", help="Parse user query to RPM info"
-    )
-    parser_parse.add_argument("query", type=str, help="User query string")
-    parser_parse.set_defaults(func=cmd_parse)
-
-    # Command: search
-    parser_search = subparsers.add_parser("search", help="Search RPM via API")
-    parser_search.add_argument("name", type=str, help="Package name")
-    parser_search.add_argument(
-        "--version", type=str, default="", help="Package version"
-    )
-    parser_search.add_argument(
-        "--release", type=str, default="", help="Package release"
-    )
-    parser_search.add_argument(
-        "--arch", type=str, default="", help="Architecture"
-    )
-    parser_search.set_defaults(func=cmd_search)
-
-    # Command: verify
-    parser_verify = subparsers.add_parser(
-        "verify", help="Verify URLs availability"
-    )
-    parser_verify.add_argument("urls", nargs="+", help="List of URLs to verify")
-    parser_verify.set_defaults(func=cmd_verify)
-
-    # Command: construct
-    parser_construct = subparsers.add_parser(
-        "construct", help="Construct URL fallback"
-    )
-    parser_construct.add_argument("name", type=str, help="Package name")
-    parser_construct.add_argument("version", type=str, help="Package version")
-    parser_construct.add_argument("release", type=str, help="Package release")
-    parser_construct.add_argument("arch", type=str, help="Architecture")
-    parser_construct.add_argument(
-        "--is_kernel", action="store_true", help="Is kernel package"
-    )
-    parser_construct.add_argument(
-        "--alinux_version", type=str, default="3", help="Alinux version"
-    )
-    parser_construct.set_defaults(func=cmd_construct)
-
-    args = parser.parse_args()
-    if hasattr(args, "func"):
-        args.func(args)
-    else:
-        parser.print_help()
-
-
-if __name__ == "__main__":
-    main()