moluoxixi-ai-rules 0.1.0

package/dist/scripts/lib/install.js

@@ -0,0 +1,367 @@
+import { execFileSync } from 'node:child_process';
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync, } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { findHostConfig, resolveHostPaths } from '../../constants/hosts.js';
+import { buildLinkPlan } from './links.js';
+import { collectFlattenedSkillSources, discoverSkillDirectories, flattenedSkillName } from './skill-projection.js';
+import { loadVendorManifest } from './vendors.js';
+// ─── 路径辅助函数：集中管理重复路径模式 ──────────────────────────────────────
+/** 基线文件文件名（宿主与 vendor 目录下均使用此名） */
+const BASELINE_FILE_NAME = 'AGENTS.md';
+/** 仓库内基线源文件位于 rules/ 目录 */
+const BASELINE_SOURCE_PATH = path.join('rules', BASELINE_FILE_NAME);
+/** 获取基线文件在 vendor 目录下的绝对路径（所有宿主软链接的统一源） */
+function vendorBaselinePath(moluoHome) {
+    return path.join(moluoHome, 'vendor', BASELINE_FILE_NAME);
+}
+/** 获取 vendor 技能目录的绝对路径 */
+function vendorSkillsPath(homeDir) {
+    return path.join(homeDir, 'vendor', 'skills');
+}
+/** 获取全局 .agents/skills 目录的绝对路径 */
+function agentsSkillsPath(userHome) {
+    return path.join(userHome, '.agents', 'skills');
+}
+function resetDir(targetDir) {
+    rmSync(targetDir, { recursive: true, force: true });
+    mkdirSync(targetDir, { recursive: true });
+}
+/**
+ * 执行各 skill 的安装前置命令（per-skill 精度）。
+ * 遍历 manifest 中所有 vendor 的 links，对具有 setup 字段的 link 执行其命令。
+ * 任一命令失败都会抛出错误，避免安装流程伪装成功。
+ * @param manifest 已解析的 VendorManifest
+ */
+export function runSkillSetupCommands(manifest) {
+    for (const [vendorName, vendor] of Object.entries(manifest.vendors)) {
+        for (const link of vendor.links) {
+            if (!link.setup || link.setup.length === 0)
+                continue;
+            const skillName = path.basename(link.target);
+            console.log(`\n[setup] 执行 ${vendorName}/${skillName} 的安装前置命令...`);
+            for (const command of link.setup) {
+                const commandText = setupCommandText(command);
+                console.log(`[setup] > ${commandText}`);
+                try {
+                    execFileSync(command.command, command.args ?? [], { stdio: 'inherit' });
+                }
+                catch (error) {
+                    throw new Error(`[setup] ${vendorName}/${skillName} 安装前置命令失败: ${commandText}\n${String(error)}`);
+                }
+            }
+        }
+    }
+}
+function setupCommandText(command) {
+    return [command.command, ...(command.args ?? [])].join(' ');
+}
+function copyDirContents(sourceDir, targetDir, options = {}) {
+    mkdirSync(targetDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        const source = path.join(sourceDir, entry.name);
+        const target = path.join(targetDir, entry.name);
+        const sourceStats = lstatSync(source);
+        if (options.skipSymlinks && sourceStats.isSymbolicLink()) {
+            continue;
+        }
+        const copySource = sourceStats.isSymbolicLink() ? realpathSync(source) : source;
+        rmSync(target, { recursive: true, force: true });
+        cpSync(copySource, target, { recursive: true });
+    }
+}
+function copyRequiredFile(sourceFile, targetFile) {
+    mkdirSync(path.dirname(targetFile), { recursive: true });
+    rmSync(targetFile, { recursive: true, force: true });
+    cpSync(sourceFile, targetFile);
+}
+function syncOptionalDir(sourceDir, targetDir) {
+    if (!existsSync(sourceDir)) {
+        rmSync(targetDir, { recursive: true, force: true });
+        return;
+    }
+    resetDir(targetDir);
+    copyDirContents(sourceDir, targetDir);
+}
+function rememberFlattenedTarget(targets, target, source) {
+    const targetKey = path.resolve(target).toLowerCase();
+    const previousSource = targets.get(targetKey);
+    if (previousSource && !isSamePath(previousSource, source)) {
+        throw new Error(`Flattened skill target collision "${target}": ${previousSource} conflicts with ${source}`);
+    }
+    targets.set(targetKey, source);
+}
+export function isSamePath(p1, p2) {
+    if (!p1 || !p2)
+        return false;
+    const n1 = path.resolve(p1).toLowerCase().replace(/\\/g, '/').replace(/\/$/, '');
+    const n2 = path.resolve(p2).toLowerCase().replace(/\\/g, '/').replace(/\/$/, '');
+    return n1 === n2;
+}
+function linkTypeForCurrentPlatform() {
+    return process.platform === 'win32' ? 'junction' : 'dir';
+}
+function linkFileForCurrentPlatform() {
+    return 'file';
+}
+export function replaceWithSymlink(source, target, type) {
+    if (isSamePath(source, target)) {
+        return;
+    }
+    // 如果目标已经是一个软链接并指向了源码，则无需重复创建
+    if (existsSync(target) && lstatSync(target).isSymbolicLink()) {
+        if (isSamePath(realpathSync(target), source)) {
+            return;
+        }
+    }
+    mkdirSync(path.dirname(target), { recursive: true });
+    rmSync(target, { recursive: true, force: true });
+    try {
+        symlinkSync(source, target, type);
+    }
+    catch (error) {
+        const fileSystemError = error;
+        if (type === 'file' && fileSystemError.code === 'EPERM' && process.platform === 'win32') {
+            cpSync(source, target);
+            return;
+        }
+        throw error;
+    }
+}
+export function getDefaultInstallPaths(userHome = os.homedir()) {
+    const moluoHome = path.join(userHome, '.moluoxixi');
+    return {
+        userHome,
+        moluoHome,
+        repoRoot: moluoHome,
+        moluoBaselineFile: vendorBaselinePath(moluoHome),
+        globalAgentSkillsHome: agentsSkillsPath(userHome),
+    };
+}
+export function ensureInstallRoot(paths) {
+    for (const dir of [
+        paths.moluoHome,
+        path.join(paths.moluoHome, 'vendor'),
+        path.join(paths.moluoHome, 'vendor', 'repos'),
+        vendorSkillsPath(paths.moluoHome),
+        paths.globalAgentSkillsHome,
+    ]) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * 确保全局 Agent 技能目录 (~/.agents/skills) 的链接正确。
+ * ~/.agents 是行业标准共享层，始终存在。
+ * 直接从 vendor/skills 映射，无中间层。
+ * 遵循层级自愈同步逻辑。
+ */
+export function ensureGlobalSkillLink(paths) {
+    const sourceSkillsDir = vendorSkillsPath(paths.moluoHome);
+    const targetLinkDir = paths.globalAgentSkillsHome;
+    syncFlattenedSkills(sourceSkillsDir, targetLinkDir, paths.moluoHome);
+}
+/**
+ * 同步展平的技能软链接，并清理过时链接。
+ * @param sourceDir 源技能目录
+ * @param targetDir 目标链接目录
+ * @param moluoHome moluoxixi 根目录（用于识别自愈时需要删除的内部链接）
+ */
+export function syncFlattenedSkills(sourceDir, targetDir, moluoHome) {
+    if (!existsSync(sourceDir)) {
+        return;
+    }
+    mkdirSync(targetDir, { recursive: true });
+    const skillSources = collectFlattenedSkillSources(sourceDir);
+    const currentSkills = new Set(skillSources.map(skill => skill.name));
+    // 自愈式同步：清理目标目录中不再需要的技能链接
+    if (existsSync(targetDir)) {
+        for (const entry of readdirSync(targetDir, { withFileTypes: true })) {
+            const targetPath = path.join(targetDir, entry.name);
+            if (entry.isSymbolicLink()) {
+                const isBroken = !existsSync(targetPath);
+                if (isBroken) {
+                    rmSync(targetPath, { recursive: true, force: true });
+                    console.log(`[cleanup] 已移除失效的死链接: ${entry.name}`);
+                    continue;
+                }
+                const resolvedPath = realpathSync(targetPath);
+                const normalizedResolved = path.resolve(resolvedPath);
+                const normalizedMoluo = path.resolve(moluoHome);
+                const normalizedRepo = path.resolve(process.cwd()); // 仓库根目录
+                const isInternal = normalizedResolved.startsWith(normalizedMoluo)
+                    || normalizedResolved.startsWith(normalizedRepo);
+                // 如果该链接指向我们的项目，但不在当前技能集合中，则视为过时并移除
+                if (isInternal && !currentSkills.has(entry.name)) {
+                    rmSync(targetPath, { recursive: true, force: true });
+                }
+            }
+        }
+    }
+    // 为所有当前有效的技能创建或更新软链接
+    for (const skill of skillSources) {
+        const source = skill.source;
+        const target = path.join(targetDir, skill.name);
+        replaceWithSymlink(source, target, linkTypeForCurrentPlatform());
+    }
+}
+/**
+ * 同步第一方（当前仓库内）的 agents 和基线文件到本地 moluoxixi 主目录。
+ * skills 统一走 clone → vendor/skills 流程，不在此处理。
+ *
+ * rules/AGENTS.md 始终复制到 vendor/ 目录下，作为所有宿主基线软链接的统一源。
+ * 即使 repoRoot === moluoHome（仓库本身就是安装目录），也需要执行此步骤，
+ * 因为软链接最终指向的是 vendor/AGENTS.md。
+ */
+export function syncFirstPartyToHome(repoRoot, moluoHome) {
+    // rules/AGENTS.md 始终同步到 vendor/ 下（所有宿主基线的软链接源）
+    copyRequiredFile(path.join(repoRoot, BASELINE_SOURCE_PATH), vendorBaselinePath(moluoHome));
+    if (isSamePath(repoRoot, moluoHome)) {
+        return;
+    }
+    syncOptionalDir(path.join(repoRoot, 'agents'), path.join(moluoHome, 'agents'));
+}
+/**
+ * 将第一方 skills 源目录投影到 vendor/skills，作为第三方 vendor 后的本地覆盖层。
+ * 该函数只清理曾经指向同一 source skills 根目录的过时链接，不会删除第三方 vendor 技能。
+ */
+export function syncFirstPartySkillsToVendor(sourceRoot, moluoHome) {
+    const sourceSkillsDir = path.join(sourceRoot, 'skills');
+    if (!existsSync(sourceSkillsDir)) {
+        return;
+    }
+    const vendorSkillsDir = vendorSkillsPath(moluoHome);
+    mkdirSync(vendorSkillsDir, { recursive: true });
+    const seenSkillNames = new Map();
+    const skillSources = discoverSkillDirectories(sourceSkillsDir).map((source) => {
+        const name = flattenedSkillName(path.basename(source));
+        const nameKey = name.toLowerCase();
+        const previousSource = seenSkillNames.get(nameKey);
+        if (previousSource && path.resolve(previousSource) !== path.resolve(source)) {
+            throw new Error(`First-party skill name collision "${name}": ${previousSource} conflicts with ${source}`);
+        }
+        seenSkillNames.set(nameKey, source);
+        return { name, source };
+    });
+    const currentSkillNames = new Set(skillSources.map(skill => skill.name));
+    const normalizedSourceSkillsDir = path.resolve(sourceSkillsDir);
+    for (const entry of readdirSync(vendorSkillsDir, { withFileTypes: true })) {
+        const targetPath = path.join(vendorSkillsDir, entry.name);
+        if (!entry.isSymbolicLink()) {
+            continue;
+        }
+        if (!existsSync(targetPath)) {
+            rmSync(targetPath, { recursive: true, force: true });
+            continue;
+        }
+        const resolvedPath = path.resolve(realpathSync(targetPath));
+        if (resolvedPath.startsWith(normalizedSourceSkillsDir) && !currentSkillNames.has(entry.name)) {
+            rmSync(targetPath, { recursive: true, force: true });
+        }
+    }
+    for (const skill of skillSources) {
+        replaceWithSymlink(skill.source, path.join(vendorSkillsDir, skill.name), linkTypeForCurrentPlatform());
+    }
+}
+export async function rebuildVendorSkillLinks({ homeDir, manifestPath }) {
+    const manifest = await loadVendorManifest(manifestPath);
+    const plan = buildLinkPlan(manifest, homeDir);
+    const vendorSkillsDir = vendorSkillsPath(homeDir);
+    const targetSources = new Map();
+    resetDir(vendorSkillsDir);
+    for (const entry of plan) {
+        if (!existsSync(entry.source)) {
+            continue;
+        }
+        const linkSources = entry.kind === 'namespace-dir'
+            ? collectFlattenedSkillSources(entry.source).map(skill => ({
+                source: skill.source,
+                target: path.join(vendorSkillsDir, skill.name),
+            }))
+            : [{
+                    source: entry.source,
+                    target: path.join(vendorSkillsDir, flattenedSkillName(path.basename(entry.target))),
+                }];
+        for (const linkSource of linkSources) {
+            rememberFlattenedTarget(targetSources, linkSource.target, linkSource.source);
+            if (isSamePath(linkSource.source, linkSource.target)) {
+                console.log(`[link] Skip (source === target): ${linkSource.target}`);
+                continue;
+            }
+            mkdirSync(path.dirname(linkSource.target), { recursive: true });
+            replaceWithSymlink(linkSource.source, linkSource.target, linkTypeForCurrentPlatform());
+        }
+    }
+    // 为 vendor/skills 生成 .gitignore
+    const projectedSkillNames = readdirSync(vendorSkillsDir).filter(n => !n.startsWith('.'));
+    const gitignoreContent = [
+        '# 由 rebuildVendorSkillLinks 自动生成，请勿手动编辑',
+        '# 这些 vendor skill 软链接应被 git 忽略',
+        ...projectedSkillNames,
+        '',
+    ].join('\n');
+    mkdirSync(vendorSkillsDir, { recursive: true });
+    writeFileSync(path.join(vendorSkillsDir, '.gitignore'), gitignoreContent, 'utf8');
+    return plan;
+}
+/**
+ * 将所有技能投影到宿主软件目录（如 .claude 或 .cursor）。
+ * 链路：vendor/skills → ~/.agents/skills → 宿主/skills
+ * ~/.agents 是行业标准共享层，始终存在（不存在则创建）。
+ */
+export function projectSkillsToHost(userHome, moluoHome, hostSkillsHome) {
+    const sourceSkillsDir = vendorSkillsPath(moluoHome);
+    const agentsSkillsDir = agentsSkillsPath(userHome);
+    // 1. vendor/skills → ~/.agents/skills
+    mkdirSync(path.join(userHome, '.agents'), { recursive: true });
+    syncFlattenedSkills(sourceSkillsDir, agentsSkillsDir, moluoHome);
+    // 2. ~/.agents/skills → 宿主 skills 目录
+    syncFlattenedSkills(agentsSkillsDir, hostSkillsHome, moluoHome);
+}
+function projectSharedSkillsHost(userHome, hostHome, moluoHome, customSkillsDirName = 'skills') {
+    mkdirSync(hostHome, { recursive: true });
+    rmSync(path.join(hostHome, 'rules'), { recursive: true, force: true });
+    rmSync(path.join(hostHome, 'agents'), { recursive: true, force: true });
+    projectSkillsToHost(userHome, moluoHome, path.join(hostHome, customSkillsDirName));
+    if (existsSync(path.join(moluoHome, 'agents'))) {
+        const agentsSource = path.join(moluoHome, 'agents');
+        const agentsTarget = path.join(hostHome, 'agents');
+        replaceWithSymlink(agentsSource, agentsTarget, linkTypeForCurrentPlatform());
+    }
+}
+export function projectToHost({ userHome, moluoHome, hostHome, hostBaselineFile, customSkillsDirName = 'skills', }) {
+    projectSharedSkillsHost(userHome, hostHome, moluoHome, customSkillsDirName);
+    replaceWithSymlink(vendorBaselinePath(moluoHome), hostBaselineFile, linkFileForCurrentPlatform());
+}
+export function linkHostBaseline({ moluoHome, host, userHome = os.homedir() }) {
+    const source = vendorBaselinePath(moluoHome);
+    const config = findHostConfig(host);
+    if (!config) {
+        throw new Error(`Unknown host: ${host}`);
+    }
+    const { hostBaselineFile } = resolveHostPaths(config, userHome);
+    replaceWithSymlink(source, hostBaselineFile, linkFileForCurrentPlatform());
+    return hostBaselineFile;
+}
+/**
+ * 将技能和基线投影到指定宿主，并返回是否成功（宿主目录不存在则跳过）。
+ */
+export function projectHostById(host, userHome, moluoHome) {
+    const config = findHostConfig(host);
+    if (!config) {
+        throw new Error(`Unknown host: ${host}`);
+    }
+    const { hostHome, hostBaselineFile, skillsDirName } = resolveHostPaths(config, userHome);
+    const hostHomePath = path.resolve(hostHome);
+    if (!existsSync(hostHomePath)) {
+        console.warn(`[skip] 宿主目录不存在，跳过投影: ${host} (${hostHomePath})`);
+        return { success: false, hostBaselineFile };
+    }
+    projectToHost({
+        userHome,
+        moluoHome,
+        hostHome,
+        hostBaselineFile,
+        customSkillsDirName: skillsDirName,
+    });
+    return { success: true, hostBaselineFile };
+}

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

@@ -0,0 +1,8 @@
+import type { VendorManifest } from './vendors.js';
+export interface LinkEntry {
+    kind: string;
+    vendorId: string;
+    source: string;
+    target: string;
+}
+export declare function buildLinkPlan(manifest: VendorManifest, homeDir: string): LinkEntry[];

package/dist/scripts/lib/links.js

@@ -0,0 +1,18 @@
+import path from 'node:path';
+import { resolveHomePath } from './vendors.js';
+export function buildLinkPlan(manifest, homeDir) {
+    const plan = [];
+    for (const [vendorId, vendor] of Object.entries(manifest.vendors ?? {})) {
+        for (const link of vendor.links ?? []) {
+            const source = resolveHomePath(homeDir, path.posix.join(vendor.cloneDir, link.source));
+            const target = resolveHomePath(homeDir, link.target);
+            plan.push({
+                kind: link.kind,
+                vendorId,
+                source,
+                target,
+            });
+        }
+    }
+    return plan.sort((left, right) => left.target.localeCompare(right.target));
+}

package/dist/scripts/lib/skill-projection.d.ts

@@ -0,0 +1,14 @@
+export interface FlattenedSkillSource {
+    name: string;
+    source: string;
+}
+/**
+ * vendor/skills 是分发边界，只暴露叶子 skill 名称，不继承源仓库分类路径。
+ */
+export declare function flattenedSkillName(value: string): string;
+export declare function flattenedVendorSkillTarget(outputName: string): string;
+/**
+ * 递归收集真实 skill 根目录；包含 SKILL.md 的目录即为叶子 skill，内部子目录不再继续展开。
+ */
+export declare function discoverSkillDirectories(rootDir: string): string[];
+export declare function collectFlattenedSkillSources(sourceDir: string): FlattenedSkillSource[];

package/dist/scripts/lib/skill-projection.js

@@ -0,0 +1,54 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+const SKILL_FILE_NAME = 'SKILL.md';
+/**
+ * vendor/skills 是分发边界，只暴露叶子 skill 名称，不继承源仓库分类路径。
+ */
+export function flattenedSkillName(value) {
+    return path.posix.basename(value.replace(/\\/g, '/'));
+}
+export function flattenedVendorSkillTarget(outputName) {
+    return path.posix.join('vendor', 'skills', flattenedSkillName(outputName));
+}
+/**
+ * 递归收集真实 skill 根目录；包含 SKILL.md 的目录即为叶子 skill，内部子目录不再继续展开。
+ */
+export function discoverSkillDirectories(rootDir) {
+    const skillDirs = [];
+    function visit(currentDir) {
+        if (existsSync(path.join(currentDir, SKILL_FILE_NAME))) {
+            skillDirs.push(currentDir);
+            return;
+        }
+        const entries = readdirSync(currentDir, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const childDir = path.join(currentDir, entry.name);
+            if (entry.isDirectory() || (entry.isSymbolicLink() && statSync(childDir).isDirectory())) {
+                visit(childDir);
+            }
+        }
+    }
+    visit(rootDir);
+    return skillDirs.sort((left, right) => left.localeCompare(right));
+}
+export function collectFlattenedSkillSources(sourceDir) {
+    const discoveredSources = discoverSkillDirectories(sourceDir);
+    const sources = discoveredSources.length > 0
+        ? discoveredSources
+        : readdirSync(sourceDir)
+            .filter(name => name !== '.gitignore')
+            .sort((left, right) => left.localeCompare(right))
+            .map(name => path.join(sourceDir, name));
+    const seenNames = new Map();
+    return sources.map((source) => {
+        const name = flattenedSkillName(path.basename(source));
+        const nameKey = name.toLowerCase();
+        const previousSource = seenNames.get(nameKey);
+        if (previousSource && path.resolve(previousSource) !== path.resolve(source)) {
+            throw new Error(`Flattened skill name collision "${name}": ${previousSource} conflicts with ${source}`);
+        }
+        seenNames.set(nameKey, source);
+        return { name, source };
+    });
+}

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

@@ -0,0 +1,40 @@
+export interface ToolPaths {
+    repoRoot: string;
+    moluoHome: string;
+    userHome: string;
+    manifestPath: string;
+}
+export interface SyncOptions {
+    repoRoot: string;
+    home: string;
+    userHome?: string;
+    host: string;
+    skipVendors: boolean;
+    verify: boolean;
+}
+export interface SyncResult {
+    moluoHome: string;
+    projectedHosts: string[];
+    skippedHosts: string[];
+}
+export interface AddSkillOptions {
+    sourceDir: string;
+    moluoHome: string;
+    name?: string;
+    overwrite: boolean;
+}
+export interface AddSkillResult {
+    skillName: string;
+    targetDir: string;
+}
+export interface VerifyOptions {
+    home: string;
+    userHome?: string;
+    host: string;
+}
+export declare function getDefaultMoluoHome(): string;
+export declare function resolveToolPaths(repoRoot: string, home: string, userHome?: string): ToolPaths;
+export declare function resolveHostTargets(host: string): string[];
+export declare function addLocalSkill(options: AddSkillOptions): AddSkillResult;
+export declare function syncToHosts(options: SyncOptions): Promise<SyncResult>;
+export declare function verifyHosts(options: VerifyOptions): Promise<string[]>;

package/dist/scripts/lib/tool.js

@@ -0,0 +1,125 @@
+import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ALL_HOST_IDS } from '../../constants/hosts.js';
+import { ensureInstallRoot, getDefaultInstallPaths, isSamePath, linkHostBaseline, projectHostById, rebuildVendorSkillLinks, runSkillSetupCommands, syncFirstPartySkillsToVendor, syncFirstPartyToHome, } from './install.js';
+import { flattenedSkillName } from './skill-projection.js';
+import { ensureVendorRepo } from './vendor-sync.js';
+import { loadVendorManifest } from './vendors.js';
+import { verifyHost } from './verify.js';
+export function getDefaultMoluoHome() {
+    return path.join(os.homedir(), '.moluoxixi');
+}
+function resolveManifestPath(repoRoot) {
+    const sourceManifestTs = path.join(repoRoot, 'constants', 'skills.ts');
+    const sourceManifestJs = path.join(repoRoot, 'constants', 'skills.js');
+    if (existsSync(sourceManifestTs) || existsSync(sourceManifestJs)) {
+        return sourceManifestJs;
+    }
+    return path.join(repoRoot, 'dist', 'constants', 'skills.js');
+}
+export function resolveToolPaths(repoRoot, home, userHome = os.homedir()) {
+    const moluoHome = path.resolve(home);
+    const resolvedRepoRoot = path.resolve(repoRoot);
+    return {
+        repoRoot: resolvedRepoRoot,
+        moluoHome,
+        userHome: path.resolve(userHome),
+        manifestPath: resolveManifestPath(resolvedRepoRoot),
+    };
+}
+export function resolveHostTargets(host) {
+    return host === 'all' ? ALL_HOST_IDS : [host];
+}
+async function syncVendorsIfNeeded(paths, skipVendors) {
+    if (skipVendors) {
+        return;
+    }
+    const manifest = await loadVendorManifest(paths.manifestPath);
+    for (const vendor of Object.values(manifest.vendors)) {
+        ensureVendorRepo(paths.moluoHome, vendor);
+    }
+    runSkillSetupCommands(manifest);
+}
+function syncLocalSkillLayers(paths) {
+    syncFirstPartySkillsToVendor(paths.repoRoot, paths.moluoHome);
+    if (!isSamePath(paths.repoRoot, paths.moluoHome)) {
+        syncFirstPartySkillsToVendor(paths.moluoHome, paths.moluoHome);
+    }
+}
+export function addLocalSkill(options) {
+    const sourceDir = path.resolve(options.sourceDir);
+    const skillName = flattenedSkillName(options.name ?? path.basename(sourceDir));
+    const targetDir = path.join(path.resolve(options.moluoHome), 'skills', skillName);
+    if (!existsSync(path.join(sourceDir, 'SKILL.md'))) {
+        throw new Error(`Skill source must contain SKILL.md: ${sourceDir}`);
+    }
+    if (existsSync(targetDir) && !options.overwrite && !isSamePath(sourceDir, targetDir)) {
+        throw new Error(`Skill already exists: ${targetDir}. Re-run with --overwrite to replace it.`);
+    }
+    if (isSamePath(sourceDir, targetDir)) {
+        return { skillName, targetDir };
+    }
+    mkdirSync(path.dirname(targetDir), { recursive: true });
+    rmSync(targetDir, { recursive: true, force: true });
+    cpSync(sourceDir, targetDir, { recursive: true });
+    return { skillName, targetDir };
+}
+export async function syncToHosts(options) {
+    const paths = resolveToolPaths(options.repoRoot, options.home, options.userHome);
+    const installPaths = getDefaultInstallPaths(paths.userHome);
+    installPaths.moluoHome = paths.moluoHome;
+    installPaths.repoRoot = paths.repoRoot;
+    ensureInstallRoot(installPaths);
+    syncFirstPartyToHome(paths.repoRoot, paths.moluoHome);
+    await syncVendorsIfNeeded(paths, options.skipVendors);
+    await rebuildVendorSkillLinks({
+        homeDir: paths.moluoHome,
+        manifestPath: paths.manifestPath,
+    });
+    syncLocalSkillLayers(paths);
+    const projectedHosts = [];
+    const skippedHosts = [];
+    const failedHosts = [];
+    for (const host of resolveHostTargets(options.host)) {
+        const { success } = projectHostById(host, paths.userHome, paths.moluoHome);
+        if (!success) {
+            skippedHosts.push(host);
+            continue;
+        }
+        projectedHosts.push(host);
+        linkHostBaseline({
+            moluoHome: paths.moluoHome,
+            host,
+            userHome: paths.userHome,
+        });
+        if (options.verify) {
+            const verified = await verifyHost(host, paths.moluoHome, paths.userHome);
+            if (!verified) {
+                failedHosts.push(host);
+            }
+        }
+    }
+    if (failedHosts.length > 0) {
+        throw new Error(`Host verification failed: ${failedHosts.join(', ')}`);
+    }
+    return {
+        moluoHome: paths.moluoHome,
+        projectedHosts,
+        skippedHosts,
+    };
+}
+export async function verifyHosts(options) {
+    const paths = resolveToolPaths(process.cwd(), options.home, options.userHome);
+    const failedHosts = [];
+    for (const host of resolveHostTargets(options.host)) {
+        const verified = await verifyHost(host, paths.moluoHome, paths.userHome);
+        if (!verified) {
+            failedHosts.push(host);
+        }
+    }
+    if (failedHosts.length > 0) {
+        throw new Error(`Host verification failed: ${failedHosts.join(', ')}`);
+    }
+    return resolveHostTargets(options.host);
+}

package/dist/scripts/lib/vendor-sync.d.ts

@@ -0,0 +1,3 @@
+import type { Vendor } from './vendors.js';
+export declare function getRemoteDefaultBranch(cloneDir: string): string;
+export declare function ensureVendorRepo(homeDir: string, vendor: Vendor): string;