moluoxixi-ai-rules 0.1.0

package/dist/scripts/lib/vendor-sync.js

@@ -0,0 +1,129 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+function runGit(args, cwd, options = {}) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: options.stdio ?? 'pipe',
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? '').trim();
+        throw new Error(`git ${args.join(' ')} failed with exit code ${result.status}${stderr ? `: ${stderr}` : ''}`);
+    }
+    return (result.stdout ?? '').trim();
+}
+function listOriginHeadBranches(cloneDir) {
+    return runGit(['-C', cloneDir, 'ls-remote', '--heads', 'origin'], process.cwd())
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const ref = line.split('\t')[1];
+        if (!ref?.startsWith('refs/heads/')) {
+            throw new Error(`Unexpected origin branch format for ${cloneDir}: ${line}`);
+        }
+        return ref.slice('refs/heads/'.length);
+    });
+}
+export function getRemoteDefaultBranch(cloneDir) {
+    let symbolicRefError;
+    const originHeadBranches = listOriginHeadBranches(cloneDir);
+    try {
+        const ref = runGit(['-C', cloneDir, 'symbolic-ref', 'refs/remotes/origin/HEAD'], process.cwd());
+        const branch = ref.replace('refs/remotes/origin/', '');
+        if (originHeadBranches.includes(branch)) {
+            return branch;
+        }
+    }
+    catch (error) {
+        symbolicRefError = error;
+    }
+    const lines = runGit(['-C', cloneDir, 'ls-remote', '--symref', 'origin', 'HEAD'], process.cwd())
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean);
+    const headLine = lines.find(line => line.startsWith('ref: ') && line.endsWith('HEAD'));
+    if (headLine) {
+        const prefix = 'ref: refs/heads/';
+        const suffix = ' HEAD';
+        if (!headLine.startsWith(prefix) || !headLine.endsWith(suffix)) {
+            throw new Error(`Unexpected origin HEAD format for ${cloneDir}: ${headLine}`);
+        }
+        const branch = headLine.slice(prefix.length, -suffix.length);
+        if (originHeadBranches.includes(branch)) {
+            return branch;
+        }
+    }
+    const remoteBranches = runGit(['-C', cloneDir, 'branch', '-r', '--format=%(refname:lstrip=3)'], process.cwd())
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line && line !== 'origin/HEAD');
+    if (remoteBranches.length === 1) {
+        return remoteBranches[0].replace(/^origin\//, '');
+    }
+    // Sparse file:// clones can lack local origin/* refs when remote HEAD is unset.
+    if (originHeadBranches.length === 1) {
+        return originHeadBranches[0];
+    }
+    throw new Error(`Unable to determine origin default branch for ${cloneDir}; symbolic-ref failed with: ${String(symbolicRefError)}`);
+}
+function getSparsePatterns(vendor) {
+    if (!vendor.links?.length)
+        return [];
+    const topDirs = new Set();
+    for (const link of vendor.links) {
+        const first = link.source.split('/')[0];
+        if (first)
+            topDirs.add(first);
+    }
+    return [...topDirs];
+}
+function isLocalRepo(repoUrl) {
+    return !repoUrl.includes('://');
+}
+export function ensureVendorRepo(homeDir, vendor) {
+    const cloneDir = path.resolve(homeDir, vendor.cloneDir);
+    mkdirSync(path.dirname(cloneDir), { recursive: true });
+    const sparsePatterns = getSparsePatterns(vendor);
+    if (!existsSync(path.join(cloneDir, '.git'))) {
+        if (isLocalRepo(vendor.repo)) {
+            runGit(['clone', vendor.repo, cloneDir], process.cwd(), { stdio: 'inherit' });
+        }
+        else {
+            runGit(['clone', '--depth', '1', '--filter=blob:none', '--sparse', vendor.repo, cloneDir], process.cwd(), { stdio: 'inherit' });
+        }
+        if (sparsePatterns.length > 0) {
+            if (isLocalRepo(vendor.repo)) {
+                runGit(['-C', cloneDir, 'sparse-checkout', 'init', '--cone'], process.cwd(), { stdio: 'inherit' });
+            }
+            runGit(['-C', cloneDir, 'sparse-checkout', 'set', ...sparsePatterns], process.cwd(), { stdio: 'inherit' });
+        }
+    }
+    const defaultBranch = getRemoteDefaultBranch(cloneDir);
+    const remoteRef = `origin/${defaultBranch}`;
+    const fetchRefSpec = `refs/heads/${defaultBranch}:refs/remotes/${remoteRef}`;
+    if (!isLocalRepo(vendor.repo)) {
+        runGit(['-C', cloneDir, 'fetch', '--depth', '1', '--prune', 'origin', fetchRefSpec], process.cwd(), { stdio: 'inherit' });
+    }
+    else {
+        runGit(['-C', cloneDir, 'fetch', '--prune', 'origin', fetchRefSpec], process.cwd(), { stdio: 'inherit' });
+    }
+    if (sparsePatterns.length > 0) {
+        if (isLocalRepo(vendor.repo)) {
+            runGit(['-C', cloneDir, 'sparse-checkout', 'set', ...sparsePatterns], process.cwd(), { stdio: 'inherit' });
+        }
+        else {
+            runGit(['-C', cloneDir, 'sparse-checkout', 'reapply'], process.cwd(), { stdio: 'inherit' });
+        }
+    }
+    runGit(['-C', cloneDir, 'reset', '--hard'], process.cwd(), { stdio: 'inherit' });
+    runGit(['-C', cloneDir, 'clean', '-fd'], process.cwd(), { stdio: 'inherit' });
+    runGit(['-C', cloneDir, 'checkout', '-B', defaultBranch, remoteRef], process.cwd(), { stdio: 'inherit' });
+    runGit(['-C', cloneDir, 'reset', '--hard', remoteRef], process.cwd(), { stdio: 'inherit' });
+    runGit(['-C', cloneDir, 'clean', '-fd'], process.cwd(), { stdio: 'inherit' });
+    return cloneDir;
+}

package/dist/scripts/lib/vendors.d.ts

@@ -0,0 +1,29 @@
+import type { SetupCommand } from '../../constants/skills.js';
+export declare function normalizePath(value: string): string;
+export interface VendorLink {
+    kind: string;
+    source: string;
+    target: string;
+    /** 该 skill 的安装前置命令（来自 SkillConfig.setup） */
+    setup?: SetupCommand[];
+}
+export interface Vendor {
+    official?: boolean;
+    repo: string;
+    cloneDir: string;
+    links: VendorLink[];
+}
+export interface VendorManifest {
+    version: number;
+    vendors: Record<string, Vendor>;
+}
+/**
+ * 递归遍历供应商定义树，支持混合数组和对象结构
+ * @param node 当前处理的节点 (VendorRepo | Record | Array)
+ * @param namespaceParts 当前递归深度对应的分类路径
+ * @param vendors 全局积累的供应商对象映射
+ */
+export declare function walkVendorTree(node: any, namespaceParts: string[], vendors: Record<string, Vendor>): void;
+export declare function loadVendorManifest(manifestPath: string): Promise<VendorManifest>;
+export declare function getRepoRoot(fromFileUrl: string): string;
+export declare function resolveHomePath(homeDir: string, relativePath: string): string;

package/dist/scripts/lib/vendors.js

@@ -0,0 +1,155 @@
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { flattenedSkillName, flattenedVendorSkillTarget } from './skill-projection.js';
+export function normalizePath(value) {
+    return value.replace(/\\/g, '/');
+}
+/**
+ * 判断是否为有效的 VendorRepo 定义
+ */
+function isVendorEntry(value) {
+    return Boolean(value
+        && typeof value === 'object'
+        && typeof value.name === 'string'
+        && typeof value.source === 'string');
+}
+/**
+ * 构造 vendor 侧技能目标路径。
+ * 源配置允许多级分类或嵌套源路径，但 vendor/skills 始终以叶子 skill 名称展平。
+ * @param outputName 最终的技能目录名
+ */
+function buildTargetPath(outputName) {
+    return flattenedVendorSkillTarget(outputName);
+}
+/**
+ * 构建 skills projection 中单个 skill 的链接计划
+ * @param sourceBaseDir 仓库内技能基准目录
+ * @param skillDef 字符串简写或带输出名/setup 的 skill 配置
+ */
+function buildSkillLink(sourceBaseDir, skillDef) {
+    if (typeof skillDef === 'string') {
+        return {
+            kind: 'skill',
+            source: path.posix.join(sourceBaseDir, skillDef),
+            target: buildTargetPath(skillDef),
+        };
+    }
+    const sourceName = skillDef.name;
+    const outputName = (skillDef.output ?? flattenedSkillName(sourceName));
+    return {
+        kind: 'skill',
+        source: path.posix.join(sourceBaseDir, sourceName),
+        target: buildTargetPath(outputName),
+        setup: skillDef.setup,
+    };
+}
+/**
+ * 构建单个供应商实体的链接计划
+ * @param entry 供应商定义实体
+ */
+function buildLinksForEntry(entry) {
+    if (entry.sourceDir || entry.sourceBaseDir || entry.skills || entry.setup) {
+        throw new Error(`供应商 "${entry.name}" 必须使用 projections 配置`);
+    }
+    if (!Array.isArray(entry.projections)) {
+        throw new TypeError(`供应商 "${entry.name}" 必须使用 projections 配置`);
+    }
+    return entry.projections.flatMap((projection) => {
+        if (projection.kind === 'namespace') {
+            return [{
+                    kind: 'namespace-dir',
+                    source: projection.sourceDir,
+                    target: buildTargetPath(projection.output),
+                    setup: projection.setup,
+                }];
+        }
+        if (projection.kind === 'skills') {
+            return projection.skills.map((skillDef) => buildSkillLink(projection.sourceBaseDir, skillDef));
+        }
+        throw new Error(`供应商 "${entry.name}" 存在未知 projection 类型: ${projection.kind}`);
+    });
+}
+/**
+ * 合并供应商定义到全局清单
+ */
+function mergeVendor(vendors, vendorName, entry) {
+    if (entry.local === true) {
+        throw new Error('暂不支持本地供应商实体 (Local vendor entries)');
+    }
+    const cloneDir = path.posix.join('vendor', 'repos', vendorName);
+    const links = buildLinksForEntry(entry);
+    if (!vendors[vendorName]) {
+        vendors[vendorName] = {
+            official: entry.official,
+            repo: entry.source,
+            cloneDir,
+            links,
+        };
+        return;
+    }
+    const existing = vendors[vendorName];
+    if (existing.repo !== entry.source
+        || existing.cloneDir !== cloneDir) {
+        throw new Error(`供应商 "${vendorName}" 在不同模块中的定义不一致`);
+    }
+    existing.official = existing.official || entry.official;
+    existing.links.push(...links);
+}
+/**
+ * 递归遍历供应商定义树，支持混合数组和对象结构
+ * @param node 当前处理的节点 (VendorRepo | Record | Array)
+ * @param namespaceParts 当前递归深度对应的分类路径
+ * @param vendors 全局积累的供应商对象映射
+ */
+export function walkVendorTree(node, namespaceParts, vendors) {
+    if (!node)
+        return;
+    if (Array.isArray(node)) {
+        for (const entry of node) {
+            if (isVendorEntry(entry)) {
+                mergeVendor(vendors, entry.name, entry);
+            }
+            else if (entry && typeof entry === 'object') {
+                // 如果数组元素是普通对象，则视为分类节点（例如 { "frontend": [...] }）
+                for (const [key, value] of Object.entries(entry)) {
+                    walkVendorTree(value, [...namespaceParts, key], vendors);
+                }
+            }
+            else {
+                throw new Error(`在分类 "${namespaceParts.join('/') || '根目录'}" 下发现无效的供应商节点定义`);
+            }
+        }
+    }
+    else if (typeof node === 'object') {
+        // 处理直接传入的对象结构（用于递归或旧版兼容）
+        for (const [key, value] of Object.entries(node)) {
+            walkVendorTree(value, [...namespaceParts, key], vendors);
+        }
+    }
+}
+export async function loadVendorManifest(manifestPath) {
+    const manifestUrl = pathToFileURL(path.resolve(manifestPath)).href;
+    const module = await import(manifestUrl);
+    const vendorTree = module.vendors ?? module.default?.vendors ?? module.default;
+    if (!vendorTree || typeof vendorTree !== 'object') {
+        throw new Error(`Vendor manifest "${manifestPath}" must export a "vendors" object`);
+    }
+    const vendors = {};
+    walkVendorTree(vendorTree, [], vendors);
+    return {
+        version: 1,
+        vendors,
+    };
+}
+export function getRepoRoot(fromFileUrl) {
+    return path.resolve(fileURLToPath(new URL('../..', fromFileUrl)));
+}
+export function resolveHomePath(homeDir, relativePath) {
+    // Preserve caller-provided absolute path style so tests and generated plans stay OS-neutral.
+    const pathApi = path.win32.isAbsolute(homeDir)
+        ? path.win32
+        : path.posix.isAbsolute(homeDir)
+            ? path.posix
+            : path;
+    return normalizePath(pathApi.resolve(homeDir, relativePath));
+}

package/dist/scripts/lib/verify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 验证指定宿主的技能链接完整性
+ * @param host 宿主名称
+ * @param moluoHome AIRules 的本地安装目录
+ * @returns 是否验证通过
+ */
+export declare function verifyHost(host: string, moluoHome: string, userHome?: string): Promise<boolean>;

package/dist/scripts/lib/verify.js

@@ -0,0 +1,84 @@
+import { existsSync, lstatSync, readdirSync, realpathSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import kleur from 'kleur';
+import { findHostConfig, resolveHostPaths } from '../../constants/hosts.js';
+/**
+ * 验证指定宿主的技能链接完整性
+ * @param host 宿主名称
+ * @param moluoHome AIRules 的本地安装目录
+ * @returns 是否验证通过
+ */
+export async function verifyHost(host, moluoHome, userHome = os.homedir()) {
+    console.log(`\n--- 正在验证宿主: ${host} ---`);
+    const config = findHostConfig(host);
+    if (!config)
+        return false;
+    const { hostHome, skillsDirName } = resolveHostPaths(config, userHome);
+    const resolvedHostHome = path.resolve(hostHome);
+    if (!existsSync(resolvedHostHome)) {
+        console.warn(`[SKIP] 宿主目录不存在: ${resolvedHostHome}`);
+        return true; // 跳过但不视为失败
+    }
+    const targetSkillsDir = path.join(resolvedHostHome, skillsDirName);
+    if (!existsSync(targetSkillsDir)) {
+        console.error(`[FAIL] 技能目录缺失: ${targetSkillsDir}`);
+        return false;
+    }
+    // 1. 获取预期技能列表 (从 vendor/skills)
+    const expectedSkills = new Set();
+    const vendorSkillsDir = path.join(moluoHome, 'vendor', 'skills');
+    if (existsSync(vendorSkillsDir)) {
+        readdirSync(vendorSkillsDir).forEach((name) => {
+            if (name !== '.gitignore')
+                expectedSkills.add(name);
+        });
+    }
+    console.log(`[info] 预期技能总数: ${expectedSkills.size}`);
+    // 2. 检查实际存在的链接
+    let missingCount = 0;
+    let brokenCount = 0;
+    let validCount = 0;
+    const targetSkillNames = new Set(readdirSync(targetSkillsDir));
+    for (const skill of expectedSkills) {
+        const skillPath = path.join(targetSkillsDir, skill);
+        if (!targetSkillNames.has(skill)) {
+            console.error(`[FAIL] 缺失技能链接 (Missing): ${skill}`);
+            missingCount++;
+            continue;
+        }
+        const stats = lstatSync(skillPath);
+        if (stats.isSymbolicLink() && !existsSync(skillPath)) {
+            console.error(`[FAIL] 损坏的软链接 (Broken Link): ${skill}`);
+            brokenCount++;
+            continue;
+        }
+        if (!stats.isSymbolicLink()) {
+            console.warn(`[WARN] 技能不是软链接 (可能是物理拷贝): ${skill}`);
+            validCount++;
+        }
+        else {
+            const real = realpathSync(skillPath);
+            const normalizedReal = path.resolve(real);
+            const normalizedMoluo = path.resolve(moluoHome);
+            const normalizedRepo = path.resolve(process.cwd());
+            // 验证指向是否在 moluoxixi 内部或仓库根目录
+            if (normalizedReal.startsWith(normalizedMoluo) || normalizedReal.startsWith(normalizedRepo)) {
+                validCount++;
+            }
+            else {
+                console.warn(`[WARN] 链接指向外部路径: ${skill} -> ${real}`);
+                validCount++;
+            }
+        }
+    }
+    console.log(`[result] 有效=${validCount}, 缺失=${missingCount}, 损坏=${brokenCount}`);
+    const success = missingCount === 0 && brokenCount === 0;
+    if (success) {
+        console.log(kleur.green(`✅ ${host} 验证通过`));
+    }
+    else {
+        console.log(kleur.red(`❌ ${host} 验证失败`));
+    }
+    return success;
+}

package/dist/scripts/sync-vendors.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/sync-vendors.js

@@ -0,0 +1,173 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { vendors as vendorsConfig } from '../constants/skills.js';
+import { collectFlattenedSkillSources, flattenedSkillName } from './lib/skill-projection.js';
+import { walkVendorTree } from './lib/vendors.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = resolve(__dirname, '..');
+const VENDOR_SKILLS_DIR = join(PROJECT_ROOT, 'vendor', 'skills');
+const CACHE_DIR = join(PROJECT_ROOT, '.cache-git');
+const CONSTANTS_DIR = join(PROJECT_ROOT, 'constants');
+const REMOVE_DIR_OPTIONS = { recursive: true, force: true, maxRetries: 5, retryDelay: 200 };
+/** 同步状态文件：记录上次同步时 constants/ 的内容指纹 */
+const SYNC_FINGERPRINT_FILE = join(PROJECT_ROOT, 'vendor', '.sync-fingerprint');
+/**
+ * 计算 constants/ 目录下所有文件的内容指纹（SHA-256）。
+ * 排序保证结果稳定，与文件系统列出顺序无关。
+ */
+function computeConstantsFingerprint() {
+    const hash = createHash('sha256');
+    const files = readdirSync(CONSTANTS_DIR)
+        .filter(f => !f.startsWith('.'))
+        .sort();
+    for (const file of files) {
+        const content = readFileSync(join(CONSTANTS_DIR, file));
+        hash.update(file); // 文件名也纳入哈希，防止重命名被忽略
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}
+/**
+ * 读取上次同步时保存的指纹，不存在则返回空字符串。
+ */
+function readSavedFingerprint() {
+    if (!existsSync(SYNC_FINGERPRINT_FILE))
+        return '';
+    return readFileSync(SYNC_FINGERPRINT_FILE, 'utf8').trim();
+}
+/**
+ * 将当前指纹写入 lockfile。
+ */
+function saveSyncFingerprint(fingerprint) {
+    mkdirSync(dirname(SYNC_FINGERPRINT_FILE), { recursive: true });
+    writeFileSync(SYNC_FINGERPRINT_FILE, fingerprint, 'utf8');
+}
+/**
+ * 删除 Git 临时目录。Windows 上 Git 进程退出后文件句柄可能短暂滞留，
+ * 这里使用 Node 的受限重试机制；重试耗尽后仍会抛出原始文件系统错误。
+ */
+function removeWorkingDir(targetDir) {
+    rmSync(targetDir, REMOVE_DIR_OPTIONS);
+}
+/**
+ * 以参数数组执行 Git，避免把 vendor 配置拼进 shell 命令字符串。
+ */
+function runGit(args, cwd) {
+    const printableCommand = ['git', ...args].join(' ');
+    console.log(`[GIT] ${printableCommand} (in ${cwd})`);
+    const result = spawnSync('git', args, { cwd, stdio: 'inherit' });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`Git command failed with exit code ${result.status}: ${printableCommand}`);
+    }
+}
+function rememberTarget(targets, target, source) {
+    const key = resolve(target).toLowerCase();
+    const existingSource = targets.get(key);
+    if (existingSource && resolve(existingSource) !== resolve(source)) {
+        throw new Error(`Flattened vendor skill target collision "${target}": ${existingSource} conflicts with ${source}`);
+    }
+    targets.set(key, source);
+}
+/**
+ * 供应商技能同步脚本 (核心逻辑)
+ *
+ * 缓存策略：
+ *   - 计算 constants/ 目录的内容指纹
+ *   - 与上次同步时保存的指纹对比
+ *   - 指纹相同 → 跳过同步（constants 未变化）
+ *   - 指纹不同 / 无 lockfile → 执行完整同步并更新指纹
+ *
+ * 使用方式：
+ *   npx tsx scripts/sync-vendors.ts          # 自动判断是否需要同步
+ *   npx tsx scripts/sync-vendors.ts --force  # 忽略缓存，强制重新克隆
+ */
+async function main() {
+    const force = process.argv.includes('--force');
+    const currentFingerprint = computeConstantsFingerprint();
+    const savedFingerprint = readSavedFingerprint();
+    if (!force && currentFingerprint === savedFingerprint) {
+        console.log('[SYNC] constants/ 未发生变化，跳过供应商同步。');
+        console.log('[SYNC] 使用 --force 可忽略缓存强制重新克隆。');
+        return;
+    }
+    if (force) {
+        console.log('[SYNC] --force 模式：忽略缓存，强制重新同步。');
+    }
+    else {
+        console.log('[SYNC] 检测到 constants/ 已变化，开始重新同步...');
+    }
+    // 1. 清理环境
+    if (existsSync(VENDOR_SKILLS_DIR)) {
+        removeWorkingDir(VENDOR_SKILLS_DIR);
+    }
+    if (existsSync(CACHE_DIR)) {
+        removeWorkingDir(CACHE_DIR);
+    }
+    mkdirSync(VENDOR_SKILLS_DIR, { recursive: true });
+    mkdirSync(CACHE_DIR, { recursive: true });
+    // 2. 构造同步清单
+    const vendorsMap = {};
+    walkVendorTree(vendorsConfig, [], vendorsMap);
+    // 3. 处理每个供应商
+    const copiedTargets = new Map();
+    for (const [vendorName, vendor] of Object.entries(vendorsMap)) {
+        if (!vendor.repo)
+            continue;
+        const cacheTarget = join(CACHE_DIR, vendorName);
+        console.log(`\n--- 正在拉取远程供应商: ${vendorName} ---`);
+        try {
+            runGit(['clone', '--filter=blob:none', '--no-checkout', vendor.repo, vendorName], CACHE_DIR);
+            const checkoutPaths = new Set();
+            for (const link of vendor.links) {
+                checkoutPaths.add(link.source);
+            }
+            if (checkoutPaths.size > 0) {
+                runGit(['sparse-checkout', 'set', ...checkoutPaths], cacheTarget);
+            }
+            runGit(['checkout'], cacheTarget);
+            for (const link of vendor.links) {
+                const sourcePath = join(cacheTarget, link.source);
+                if (!existsSync(sourcePath)) {
+                    throw new Error(`供应商 ${vendorName} 缺失配置的源目录: ${link.source}`);
+                }
+                const sources = link.kind === 'namespace-dir'
+                    ? collectFlattenedSkillSources(sourcePath).map(skill => ({
+                        source: skill.source,
+                        target: join(PROJECT_ROOT, 'vendor', 'skills', skill.name),
+                    }))
+                    : [{
+                            source: sourcePath,
+                            target: join(PROJECT_ROOT, 'vendor', 'skills', flattenedSkillName(link.target)),
+                        }];
+                for (const source of sources) {
+                    rememberTarget(copiedTargets, source.target, source.source);
+                    mkdirSync(dirname(source.target), { recursive: true });
+                    cpSync(source.source, source.target, { recursive: true });
+                    console.log(`[COPIED] ${vendorName} -> ${source.target.replace(PROJECT_ROOT, '').replace(/^[/\\]/, '')}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[ERROR] 供应商 ${vendorName} 同步失败:`, err);
+            throw err;
+        }
+    }
+    // 4. 清除 Git 缓存
+    console.log('\n[SYNC] 正在清理远程缓存...');
+    removeWorkingDir(CACHE_DIR);
+    // 5. 保存本次同步的指纹
+    saveSyncFingerprint(currentFingerprint);
+    console.log(`[SYNC] 已更新同步指纹: ${currentFingerprint.slice(0, 12)}...`);
+    console.log('\n[SYNC] 供应商技能同步完成。');
+}
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/scripts/verify-host.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx tsx
+export {};

package/dist/scripts/verify-host.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env npx tsx
+import os from 'node:os';
+import path from 'node:path';
+import { parseArgs as nodeParseArgs } from 'node:util';
+import { ALL_HOST_IDS } from '../constants/hosts.js';
+import { verifyHost } from './lib/verify.js';
+async function main() {
+    const result = nodeParseArgs({
+        options: {
+            'host': { type: 'string' },
+            'home': { type: 'string' },
+            'user-home': { type: 'string' },
+        },
+        strict: false,
+    });
+    const { values } = result;
+    const { host, home } = values;
+    const moluoHome = home ? path.resolve(home) : path.join(os.homedir(), '.moluoxixi');
+    const userHome = values['user-home'] === undefined ? os.homedir() : path.resolve(String(values['user-home']));
+    if (!host || (host !== 'all' && !ALL_HOST_IDS.includes(host))) {
+        console.error(`Usage: npx tsx scripts/verify-host.ts --host <name|all> [--home <dir>] [--user-home <dir>]`);
+        process.exit(1);
+    }
+    const targets = host === 'all' ? ALL_HOST_IDS : [host];
+    let allPerfect = true;
+    for (const targetHost of targets) {
+        const success = await verifyHost(targetHost, moluoHome, userHome);
+        if (!success)
+            allPerfect = false;
+    }
+    if (allPerfect) {
+        console.log('\n✅ [SUCCESS] 所有的验证检查均通过！所有链接均正确且有效。');
+    }
+    else {
+        console.log('\n❌ [FAILURE] 部分验证检查未通过，请检查上述错误信息。');
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});