assetplex 0.1.0

package/dist/index.js

@@ -0,0 +1,4152 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return levelPriority[level] >= levelPriority[currentLevel];
+}
+var levelPriority, currentLevel, log;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    levelPriority = {
+      debug: 10,
+      info: 20,
+      success: 25,
+      warn: 30,
+      error: 40
+    };
+    currentLevel = "info";
+    log = {
+      debug(msg, ...args) {
+        if (shouldLog("debug")) {
+          console.error(chalk.gray(`[debug] ${msg}`), ...args);
+        }
+      },
+      info(msg, ...args) {
+        if (shouldLog("info")) {
+          console.log(chalk.cyan(msg), ...args);
+        }
+      },
+      success(msg, ...args) {
+        if (shouldLog("success")) {
+          console.log(chalk.green(`\u2713 ${msg}`), ...args);
+        }
+      },
+      warn(msg, ...args) {
+        if (shouldLog("warn")) {
+          console.warn(chalk.yellow(`! ${msg}`), ...args);
+        }
+      },
+      error(msg, ...args) {
+        if (shouldLog("error")) {
+          console.error(chalk.red(`\u2717 ${msg}`), ...args);
+        }
+      },
+      raw(msg, ...args) {
+        console.log(msg, ...args);
+      }
+    };
+  }
+});
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { resolve, normalize } from "path";
+function expandHome(filepath) {
+  if (!filepath) return filepath;
+  if (filepath === "~") return homedir();
+  if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
+    return resolve(homedir(), filepath.slice(2));
+  }
+  if (filepath.startsWith("~")) {
+    return filepath;
+  }
+  return normalize(filepath);
+}
+function getHubRoot() {
+  const fromEnv = process.env.ASSETPLEX_DIR;
+  if (fromEnv) return expandHome(fromEnv);
+  return expandHome("~/.assetplex");
+}
+function hubPath(...segments) {
+  return resolve(getHubRoot(), ...segments);
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/config.ts
+import { z } from "zod";
+import * as TOML from "@iarna/toml";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+function loadHubConfig(configPath) {
+  const path2 = configPath ?? resolveHubConfigPath();
+  if (!existsSync(path2)) {
+    return HubConfigSchema.parse({});
+  }
+  const raw = readFileSync(path2, "utf-8");
+  const parsed = TOML.parse(raw);
+  return HubConfigSchema.parse(parsed);
+}
+function resolveHubConfigPath() {
+  const hubRoot = process.env.ASSETPLEX_DIR ?? "~/.assetplex";
+  return resolve2(expandHome(hubRoot), "hub.toml");
+}
+function saveHubConfig(config, configPath) {
+  const path2 = configPath ?? resolveHubConfigPath();
+  mkdirSync(dirname(path2), { recursive: true });
+  const validated = HubConfigSchema.parse(config);
+  const toml = TOML.stringify(validated);
+  writeFileSync(path2, toml, "utf-8");
+}
+function generateDefaultConfigToml() {
+  return `# AssetPlex Configuration
+# See: https://github.com/wynter-cai/assetplex
+
+[hub]
+version = "1.0"
+default_sync_strategy = "hybrid"           # native-import | symlink | copy | hybrid | per-project
+backup_dir = "~/.assetplex/.backups"
+auto_watch = false
+backup_keep_count = 10
+
+[identity]
+profile_auto_learn = true
+learn_sources = ["trae-cn", "claude-code"]
+learn_interval_hours = 24
+learn_max_facts = 100
+
+[tools.trae-cn]
+enabled = true
+config_dir = "~/.trae-cn"
+sync_strategy = "symlink"
+mcp_format = "json"
+targets = [
+  "memory/user_profile.md",
+  "skills/",
+  "rules/",
+  "mcp.json",
+]
+
+[tools.claude-code]
+enabled = true
+config_dir = "~/.claude"
+sync_strategy = "native-import"
+import_max_depth = 4
+claude_md_aggregator = true
+
+[tools.codex]
+enabled = true
+config_dir = "~/.codex"
+sync_strategy = "copy"
+mcp_format = "toml"
+strip_frontmatter_keys = []
+
+[tools.workbuddy]
+enabled = true
+config_dir = "~/.workbuddy"
+sync_strategy = "symlink"
+env_interpolation = true
+mcp_filename = ".mcp.json"
+
+[tools.qoder]
+enabled = false
+sync_strategy = "per-project"
+project_targets = []
+
+[marketplace]
+enabled = true
+sources = [
+  "https://claudeskills.info/api",
+  "https://agentskills.io/api",
+  "https://agskills.dev/api",
+]
+cache_dir = "~/.assetplex/.marketplace-cache"
+cache_ttl_hours = 24
+`;
+}
+var SyncStrategySchema, McpFormatSchema, HubConfigSchema;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    SyncStrategySchema = z.enum([
+      "native-import",
+      "symlink",
+      "copy",
+      "hybrid",
+      "per-project"
+    ]);
+    McpFormatSchema = z.enum(["json", "toml"]);
+    HubConfigSchema = z.object({
+      hub: z.object({
+        version: z.string().default("1.0"),
+        defaultSyncStrategy: SyncStrategySchema.default("hybrid"),
+        backupDir: z.string().default("~/.assetplex/.backups"),
+        autoWatch: z.boolean().default(false),
+        backupKeepCount: z.number().int().positive().default(10)
+      }).default({}),
+      identity: z.object({
+        profileAutoLearn: z.boolean().default(true),
+        learnSources: z.array(z.string()).default(["trae-cn", "claude-code"]),
+        learnIntervalHours: z.number().int().positive().default(24),
+        learnMaxFacts: z.number().int().positive().default(100)
+      }).default({}),
+      tools: z.object({
+        "trae-cn": z.object({
+          enabled: z.boolean().default(true),
+          configDir: z.string().default("~/.trae-cn"),
+          syncStrategy: SyncStrategySchema.default("symlink"),
+          mcpFormat: McpFormatSchema.default("json"),
+          targets: z.array(z.string()).default([])
+        }).default({}),
+        "claude-code": z.object({
+          enabled: z.boolean().default(true),
+          configDir: z.string().default("~/.claude"),
+          syncStrategy: SyncStrategySchema.default("native-import"),
+          importMaxDepth: z.number().int().positive().max(5).default(4),
+          claudeMdAggregator: z.boolean().default(true)
+        }).default({}),
+        codex: z.object({
+          enabled: z.boolean().default(true),
+          configDir: z.string().default("~/.codex"),
+          syncStrategy: SyncStrategySchema.default("copy"),
+          mcpFormat: McpFormatSchema.default("toml"),
+          stripFrontmatterKeys: z.array(z.string()).default([])
+        }).default({}),
+        workbuddy: z.object({
+          enabled: z.boolean().default(true),
+          configDir: z.string().default("~/.workbuddy"),
+          syncStrategy: SyncStrategySchema.default("symlink"),
+          envInterpolation: z.boolean().default(true),
+          mcpFilename: z.string().default(".mcp.json")
+        }).default({}),
+        qoder: z.object({
+          enabled: z.boolean().default(false),
+          syncStrategy: SyncStrategySchema.default("per-project"),
+          projectTargets: z.array(z.string()).default([])
+        }).default({})
+      }).default({}),
+      marketplace: z.object({
+        enabled: z.boolean().default(true),
+        sources: z.array(z.string()).default([
+          "https://claudeskills.info/api",
+          "https://agentskills.io/api",
+          "https://agskills.dev/api"
+        ]),
+        cacheDir: z.string().default("~/.assetplex/.marketplace-cache"),
+        cacheTtlHours: z.number().int().positive().default(24)
+      }).default({})
+    });
+  }
+});
+
+// src/utils/fs.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readlinkSync,
+  unlinkSync,
+  rmdirSync,
+  rmSync,
+  copyFileSync,
+  readdirSync,
+  statSync
+} from "fs";
+import { resolve as resolve4, dirname as dirname2, isAbsolute, relative, join } from "path";
+import { execSync } from "child_process";
+function ensureDir(path2) {
+  if (!existsSync3(path2)) {
+    mkdirSync3(path2, { recursive: true });
+  }
+}
+function isSymlink(path2) {
+  if (!existsSync3(path2)) return false;
+  try {
+    readlinkSync(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readSymlinkTarget(path2) {
+  try {
+    const target = readlinkSync(path2);
+    if (isAbsolute(target)) return target;
+    return resolve4(dirname2(path2), target);
+  } catch {
+    return null;
+  }
+}
+function safeRemove(path2) {
+  if (!existsSync3(path2) && !isSymlink(path2)) return;
+  if (isSymlink(path2)) {
+    try {
+      unlinkSync(path2);
+      return;
+    } catch {
+      try {
+        rmdirSync(path2);
+        return;
+      } catch {
+      }
+    }
+  }
+  try {
+    rmSync(path2, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+  } catch {
+  }
+  if (!existsSync3(path2)) return;
+  if (process.platform === "win32") {
+    try {
+      execSync(`rmdir /S /Q "${path2}"`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  for (let i = 0; i < 5; i++) {
+    if (!existsSync3(path2)) return;
+    const start = Date.now();
+    while (Date.now() - start < 100) {
+    }
+  }
+}
+function copyRecursive(src, dest) {
+  if (!existsSync3(src)) {
+    throw new Error(`\u6E90\u8DEF\u5F84\u4E0D\u5B58\u5728: ${src}`);
+  }
+  const stat = statSync(src);
+  if (stat.isFile()) {
+    ensureDir(dirname2(dest));
+    copyFileSync(src, dest);
+    return;
+  }
+  if (stat.isDirectory()) {
+    if (isSymlink(dest)) {
+      safeRemove(dest);
+    }
+    ensureDir(dest);
+    for (const entry of readdirSync(src)) {
+      const srcPath = resolve4(src, entry);
+      const destPath = resolve4(dest, entry);
+      copyRecursive(srcPath, destPath);
+    }
+    return;
+  }
+  throw new Error(`\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B: ${src}`);
+}
+function listMarkdownFilesRecursive(dir) {
+  if (!existsSync3(dir)) return [];
+  const result = [];
+  const walk = (current, prefix) => {
+    let entries;
+    try {
+      entries = readdirSync(current);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const full = join(current, name);
+      let stat;
+      try {
+        stat = statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(full, `${prefix}${name}/`);
+      } else if (name.toLowerCase().endsWith(".md")) {
+        result.push(`${prefix}${name}`);
+      }
+    }
+  };
+  walk(dir, "");
+  return result.sort((a, b) => a.localeCompare(b));
+}
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/transforms/symlink.ts
+import { symlink, existsSync as existsSync4, lstatSync, readlinkSync as readlinkSync2, readdirSync as readdirSync2, rmdirSync as rmdirSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
+function isEmptyDir(path2) {
+  try {
+    const stat = lstatSync(path2);
+    if (!stat.isDirectory()) return false;
+    if (isSymlink(path2)) return false;
+    return readdirSync2(path2).length === 0;
+  } catch {
+    return false;
+  }
+}
+async function createSymlink(target, linkPath, options = {}) {
+  const { isDirectory = false, force = false } = options;
+  if (!existsSync4(target)) {
+    return {
+      success: false,
+      method: "symlink",
+      message: `\u6E90\u8DEF\u5F84\u4E0D\u5B58\u5728: ${target}`
+    };
+  }
+  ensureDir(dirname3(linkPath));
+  if (existsSync4(linkPath) || isSymlink(linkPath)) {
+    if (!force) {
+      const currentTarget = readLinkTargetSafe(linkPath);
+      if (currentTarget && resolve5(currentTarget) === resolve5(target)) {
+        return {
+          success: true,
+          method: "symlink",
+          message: "\u94FE\u63A5\u5DF2\u5B58\u5728\u4E14\u6307\u5411\u6B63\u786E\u76EE\u6807\uFF0C\u8DF3\u8FC7"
+        };
+      }
+      return {
+        success: false,
+        method: "symlink",
+        message: `\u76EE\u6807\u5DF2\u5B58\u5728: ${linkPath}\uFF08\u4F7F\u7528 force: true \u8986\u76D6\uFF09`
+      };
+    }
+    safeRemove(linkPath);
+    if (existsSync4(linkPath) && isEmptyDir(linkPath)) {
+      try {
+        rmdirSync2(linkPath);
+      } catch {
+      }
+    }
+  }
+  const symlinkType = isDirectory ? "dir" : "file";
+  try {
+    await new Promise((resolvePromise, rejectPromise) => {
+      symlink(target, linkPath, symlinkType, (err) => {
+        if (err) rejectPromise(err);
+        else resolvePromise();
+      });
+    });
+    if (existsSync4(linkPath)) {
+      return { success: true, method: "symlink" };
+    }
+  } catch (err) {
+    if (process.platform !== "win32") {
+      return {
+        success: false,
+        method: "symlink",
+        message: `symlink \u521B\u5EFA\u5931\u8D25: ${err.message}`
+      };
+    }
+  }
+  if (isDirectory && process.platform === "win32") {
+    try {
+      await new Promise((resolvePromise, rejectPromise) => {
+        symlink(target, linkPath, "junction", (err) => {
+          if (err) rejectPromise(err);
+          else resolvePromise();
+        });
+      });
+      if (existsSync4(linkPath)) {
+        return {
+          success: true,
+          method: "junction",
+          message: "\u4F7F\u7528 junction\uFF08\u5EFA\u8BAE\u5F00\u542F Windows \u5F00\u53D1\u8005\u6A21\u5F0F\u4EE5\u83B7\u5F97\u539F\u751F symlink\uFF09"
+        };
+      }
+    } catch {
+    }
+  }
+  try {
+    copyRecursive(target, linkPath);
+    return {
+      success: true,
+      method: "copy",
+      message: "\u964D\u7EA7\u4E3A copy\uFF08\u5EFA\u8BAE\u5F00\u542F Windows \u5F00\u53D1\u8005\u6A21\u5F0F\u4EE5\u83B7\u5F97\u539F\u751F symlink\uFF09"
+    };
+  } catch (err) {
+    return {
+      success: false,
+      method: "copy",
+      message: `copy fallback \u5931\u8D25: ${err.message}`
+    };
+  }
+}
+function readLinkTargetSafe(linkPath) {
+  try {
+    if (!existsSync4(linkPath) && !isSymlink(linkPath)) return null;
+    const stat = lstatSync(linkPath);
+    if (!stat.isSymbolicLink()) return null;
+    const target = readlinkSync2(linkPath);
+    if (isAbsolute2(target)) return target;
+    return resolve5(dirname3(linkPath), target);
+  } catch {
+    return null;
+  }
+}
+var init_symlink = __esm({
+  "src/transforms/symlink.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs();
+  }
+});
+
+// src/core/adapters/base.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2, statSync as statSync2, readdirSync as readdirSync3 } from "fs";
+import { resolve as resolve6, normalize as normalize2, relative as relative2, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var BaseAdapter;
+var init_base = __esm({
+  "src/core/adapters/base.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_fs();
+    init_symlink();
+    init_paths();
+    BaseAdapter = class {
+      homepage;
+      /**
+       * 默认 detect 实现：检查配置目录是否存在，是否有标志性文件
+       */
+      async detect() {
+        const configDir = this.getConfigDir();
+        const configDirExists = configDir ? existsSync5(configDir) : false;
+        let installed = configDirExists;
+        if (configDirExists) {
+          let hasSignature = false;
+          for (const file of this.signatureFiles) {
+            if (existsSync5(resolve6(configDir, file))) {
+              hasSignature = true;
+              break;
+            }
+          }
+          installed = hasSignature;
+        }
+        let version;
+        try {
+          version = await this.detectVersion();
+        } catch {
+        }
+        return {
+          name: this.name,
+          installed,
+          configDirExists,
+          version,
+          configDir,
+          error: installed ? void 0 : configDirExists ? "\u7F3A\u5C11\u6807\u5FD7\u6027\u6587\u4EF6" : "\u672A\u5B89\u88C5"
+        };
+      }
+      /**
+       * 获取工具配置目录（子类可重写以支持环境变量重定向）
+       */
+      getConfigDir() {
+        return this.expandHome(this.defaultConfigDir);
+      }
+      /**
+       * 默认 resolveHubItems 实现：基于 targets() 返回路径，HubItem.relativePath 留空
+       *
+       * 子类应重写此方法以提供准确的 HubItem 关联
+       */
+      resolveHubItems(hubConfig, _hubRoot) {
+        const toolConfig = this.getToolConfig(hubConfig);
+        if (!toolConfig) return [];
+        const targets = this.targets(toolConfig);
+        return targets.map((target) => ({
+          item: {
+            type: "preference",
+            relativePath: "",
+            absolutePath: ""
+          },
+          target
+        }));
+      }
+      /**
+       * 默认 apply 实现：根据 SyncTarget.strategy 派发
+       * - symlink: 用 createSymlink()
+       * - copy: 用 copyRecursive()
+       * - native-import: 调用子类的 applyNativeImport()
+       * - per-project: 调用子类的 applyPerProject()
+       */
+      async apply(item, target) {
+        if (!item.absolutePath) {
+          throw new Error(`HubItem.absolutePath \u4E3A\u7A7A\uFF0C\u65E0\u6CD5 apply \u5230 ${target.targetPath}`);
+        }
+        switch (target.strategy) {
+          case "symlink": {
+            const r = await createSymlink(item.absolutePath, target.targetPath, {
+              isDirectory: target.isDirectory,
+              force: true
+            });
+            if (!r.success) {
+              throw new Error(`${this.name}: \u521B\u5EFA symlink \u5931\u8D25 - ${r.message}`);
+            }
+            if (r.method === "copy") {
+              log.warn(`${this.name}: symlink \u964D\u7EA7\u4E3A copy\uFF08${r.message}\uFF09`);
+            } else if (r.method === "junction") {
+              log.debug(`${this.name}: \u4F7F\u7528 junction\uFF08${r.message ?? ""}\uFF09`);
+            }
+            break;
+          }
+          case "copy": {
+            copyRecursive(item.absolutePath, target.targetPath);
+            break;
+          }
+          case "native-import": {
+            await this.applyNativeImport(item, target);
+            break;
+          }
+          case "per-project": {
+            await this.applyPerProject(item, target);
+            break;
+          }
+          default:
+            throw new Error(`\u672A\u77E5\u7684\u540C\u6B65\u7B56\u7565: ${target.strategy}`);
+        }
+      }
+      /** 子类可选实现：native-import 策略的具体逻辑 */
+      async applyNativeImport(_item, _target) {
+        throw new Error(`${this.name} \u4E0D\u652F\u6301 native-import \u7B56\u7565`);
+      }
+      /** 子类可选实现：per-project 策略的具体逻辑 */
+      async applyPerProject(_item, _target) {
+        throw new Error(`${this.name} \u4E0D\u652F\u6301 per-project \u7B56\u7565`);
+      }
+      /**
+       * 默认 import 实现：读取目标文件内容返回 HubItem
+       */
+      async import(targetPath) {
+        const content = readFileSync2(targetPath);
+        return {
+          type: "preference",
+          relativePath: "",
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /** 默认 transform：直接返回原内容 */
+      transform(content, _format) {
+        return content;
+      }
+      /**
+       * 默认 scan 实现：返回空数组。
+       * 子类必须重写此方法以扫描工具目录中的可导入内容。
+       */
+      async scan() {
+        return [];
+      }
+      /**
+       * 辅助方法：为单个文件创建 DiscoveredItem，自动检测冲突状态
+       *
+       * @param absolutePath 源文件绝对路径
+       * @param baseDir 工具配置目录（用于计算 relativePath）
+       * @param hubTargetPath 导入到 Hub 的目标相对路径
+       * @param category 文件类别
+       * @returns DiscoveredItem
+       */
+      makeDiscoveredItem(absolutePath, baseDir, hubTargetPath, category) {
+        try {
+          const stat = statSync2(absolutePath);
+          if (!stat.isFile()) return null;
+          const relPath = relative2(baseDir, absolutePath);
+          const hubFullPath = hubPath(hubTargetPath);
+          let conflict = "none";
+          let existingSize;
+          if (existsSync5(hubFullPath)) {
+            try {
+              const existingStat = statSync2(hubFullPath);
+              existingSize = existingStat.size;
+              if (existingStat.size === stat.size) {
+                const existingContent = readFileSync2(hubFullPath);
+                const newContent = readFileSync2(absolutePath);
+                conflict = existingContent.equals(newContent) ? "exists" : "differs";
+              } else {
+                conflict = "differs";
+              }
+            } catch {
+              conflict = "differs";
+            }
+          }
+          return {
+            absolutePath,
+            relativePath: relPath,
+            size: stat.size,
+            modified: stat.mtime.toISOString(),
+            category,
+            hubTargetPath,
+            conflict,
+            existingSize,
+            tool: this.name
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * 辅助方法：递归扫描目录下所有文件，为每个文件创建 DiscoveredItem
+       *
+       * @param dirPath 要扫描的目录绝对路径
+       * @param baseDir 工具配置目录（用于计算 relativePath）
+       * @param hubPrefix Hub 目标路径前缀（如 'skills'、'rules'）
+       * @param category 文件类别
+       * @returns DiscoveredItem[]
+       */
+      scanDirectory(dirPath, baseDir, hubPrefix, category) {
+        if (!existsSync5(dirPath)) return [];
+        const results = [];
+        const walk = (currentDir) => {
+          try {
+            const entries = readdirSync3(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+              const fullPath = join2(currentDir, entry.name);
+              if (entry.isDirectory()) {
+                walk(fullPath);
+              } else if (entry.isFile()) {
+                const relFromDir = relative2(dirPath, fullPath);
+                const hubTarget = `${hubPrefix}/${relFromDir.split(/[/\\]/).join("/")}`;
+                const item = this.makeDiscoveredItem(fullPath, baseDir, hubTarget, category);
+                if (item) results.push(item);
+              }
+            }
+          } catch {
+          }
+        };
+        walk(dirPath);
+        return results;
+      }
+      /**
+       * 默认版本检测：返回 undefined，子类可重写
+       */
+      async detectVersion() {
+        return void 0;
+      }
+      /**
+       * 从 hubConfig 中提取当前工具的配置
+       */
+      getToolConfig(hubConfig) {
+        const tools = hubConfig.tools;
+        const raw = tools[this.name];
+        if (!raw) return null;
+        return {
+          enabled: raw.enabled ?? false,
+          configDir: raw.configDir ?? "",
+          syncStrategy: raw.syncStrategy ?? "hybrid",
+          mcpFormat: raw.mcpFormat,
+          ...raw
+        };
+      }
+      /**
+       * 展开 ~ 为 home 目录
+       */
+      expandHome(filepath) {
+        if (!filepath) return filepath;
+        if (filepath === "~") return homedir2();
+        if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
+          return normalize2(resolve6(homedir2(), filepath.slice(2)));
+        }
+        return normalize2(filepath);
+      }
+    };
+  }
+});
+
+// src/core/adapters/trae-cn.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve7 } from "path";
+var TraeCnAdapter;
+var init_trae_cn = __esm({
+  "src/core/adapters/trae-cn.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_base();
+    init_paths();
+    TraeCnAdapter = class extends BaseAdapter {
+      name = "trae-cn";
+      displayName = "TRAE \u4E2D\u56FD\u7248";
+      homepage = "https://docs.trae.ai/";
+      defaultConfigDir = "~/.trae-cn";
+      signatureFiles = ["argv.json", "skill-config.json"];
+      supportedTargets = [
+        "memory/user_profile.md",
+        "skills/",
+        "rules/",
+        "mcp.json"
+      ];
+      /**
+       * 重写 detect：TRAE CN 的特殊检测逻辑
+       * - 检查 ~/.trae-cn/argv.json 是否存在
+       * - 检查 ~/.trae-cn/memory/user_profile.md 是否存在（身份画像源）
+       */
+      async detect() {
+        const configDir = this.getConfigDir();
+        const argvPath = resolve7(configDir, "argv.json");
+        const skillConfigPath = resolve7(configDir, "skill-config.json");
+        const profilePath = resolve7(configDir, "memory/user_profile.md");
+        const configDirExists = existsSync6(configDir);
+        const hasArgv = existsSync6(argvPath);
+        const hasSkillConfig = existsSync6(skillConfigPath);
+        const hasProfile = existsSync6(profilePath);
+        const installed = configDirExists && (hasArgv || hasSkillConfig);
+        let extraInfo;
+        if (installed && !hasProfile) {
+          extraInfo = "\u5DF2\u5B89\u88C5\uFF0C\u4F46 memory/user_profile.md \u7F3A\u5931\uFF08\u53EF\u8FD0\u884C assetplex profile learn \u751F\u6210\uFF09";
+        }
+        let version;
+        const versionPath = resolve7(configDir, "builtin/ide_version.json");
+        if (existsSync6(versionPath)) {
+          try {
+            const { readFileSync: readFileSync9 } = await import("fs");
+            const data = JSON.parse(readFileSync9(versionPath, "utf-8"));
+            version = data.version ?? data.ideVersion;
+          } catch {
+          }
+        }
+        return {
+          name: this.name,
+          installed,
+          configDirExists,
+          version,
+          configDir,
+          error: installed ? extraInfo : configDirExists ? "\u7F3A\u5C11\u6807\u5FD7\u6027\u6587\u4EF6" : "\u672A\u5B89\u88C5"
+        };
+      }
+      /**
+       * 重写 resolveHubItems：明确关联 Hub 内文件与 TRAE CN 目标
+       *
+       * 关联关系：
+       * - Hub: identity/profile.md           → TRAE: memory/user_profile.md (symlink)
+       * - Hub: skills/                        → TRAE: skills                 (symlink, dir)
+       * - Hub: rules/                         → TRAE: rules                  (symlink, dir)
+       * - Hub: mcp/mcp.sources.json          → TRAE: mcp.json               (copy, JSON 格式直接复制)
+       */
+      resolveHubItems(_hubConfig, _hubRoot) {
+        const base = this.getConfigDir();
+        return [
+          {
+            item: {
+              type: "identity",
+              relativePath: "identity/profile.md",
+              absolutePath: hubPath("identity/profile.md")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve7(base, "memory/user_profile.md"),
+              strategy: "symlink",
+              isDirectory: false
+            }
+          },
+          {
+            item: {
+              type: "skill",
+              relativePath: "skills",
+              absolutePath: hubPath("skills")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve7(base, "skills"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "rule",
+              relativePath: "rules",
+              absolutePath: hubPath("rules")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve7(base, "rules"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "mcp",
+              relativePath: "mcp/mcp.sources.json",
+              absolutePath: hubPath("mcp/mcp.sources.json")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve7(base, "mcp.json"),
+              strategy: "copy",
+              isDirectory: false
+            }
+          }
+        ];
+      }
+      /**
+       * 同步目标列表（向后兼容）
+       */
+      targets(config) {
+        const configDir = config.configDir || this.defaultConfigDir;
+        const base = this.expandHome(configDir);
+        return [
+          {
+            tool: this.name,
+            targetPath: resolve7(base, "memory/user_profile.md"),
+            strategy: "symlink",
+            isDirectory: false
+          },
+          {
+            tool: this.name,
+            targetPath: resolve7(base, "skills"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve7(base, "rules"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve7(base, "mcp.json"),
+            strategy: "copy",
+            isDirectory: false
+          }
+        ];
+      }
+      /**
+       * 反向导入：从 TRAE CN 读取现有配置到 Hub
+       *
+       * 注意：memory/user_profile.md 是 TRAE AI 维护的，反向导入会覆盖 Hub 的 profile.md
+       */
+      async import(targetPath) {
+        const { readFileSync: readFileSync9 } = await import("fs");
+        const content = readFileSync9(targetPath);
+        let type = "preference";
+        if (targetPath.includes("user_profile")) type = "identity";
+        else if (targetPath.includes("skills")) type = "skill";
+        else if (targetPath.includes("rules")) type = "rule";
+        else if (targetPath.includes("mcp")) type = "mcp";
+        return {
+          type,
+          relativePath: "",
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /**
+       * 扫描 TRAE CN 目录，发现所有可导入内容
+       */
+      async scan() {
+        const base = this.getConfigDir();
+        const items = [];
+        const profilePath = resolve7(base, "memory/user_profile.md");
+        const profileItem = this.makeDiscoveredItem(profilePath, base, "identity/profile.md", "identity");
+        if (profileItem) items.push(profileItem);
+        const memoryDir = resolve7(base, "memory");
+        if (existsSync6(memoryDir)) {
+          const { readdirSync: readdirSync5 } = await import("fs");
+          try {
+            const memoryEntries = readdirSync5(memoryDir, { withFileTypes: true });
+            for (const entry of memoryEntries) {
+              if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "user_profile.md") {
+                const fullPath = resolve7(memoryDir, entry.name);
+                const item = this.makeDiscoveredItem(fullPath, base, `preferences/${entry.name}`, "preference");
+                if (item) items.push(item);
+              }
+            }
+          } catch {
+          }
+        }
+        items.push(...this.scanDirectory(resolve7(base, "skills"), base, "skills", "skill"));
+        items.push(...this.scanDirectory(resolve7(base, "rules"), base, "rules", "rule"));
+        const mcpPath = resolve7(base, "mcp.json");
+        const mcpItem = this.makeDiscoveredItem(mcpPath, base, "mcp/mcp.sources.json", "mcp");
+        if (mcpItem) items.push(mcpItem);
+        return items;
+      }
+    };
+  }
+});
+
+// src/core/adapters/claude-code.ts
+import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve8, basename } from "path";
+import { homedir as homedir3 } from "os";
+function buildImportList() {
+  const rulesImports = listMarkdownFilesRecursive(hubPath("rules")).map(
+    (rel) => `rules/${rel}`
+  );
+  return [...CLAUDE_MD_FIXED_IMPORTS, ...rulesImports];
+}
+var CLAUDE_MD_FIXED_IMPORTS, CLAUDE_MD_HEADER, ClaudeCodeAdapter;
+var init_claude_code = __esm({
+  "src/core/adapters/claude-code.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_base();
+    init_paths();
+    init_fs();
+    CLAUDE_MD_FIXED_IMPORTS = [
+      "identity/profile.md",
+      "identity/profile.auto.md",
+      "identity/communication-style.md",
+      "identity/tech-stack.md",
+      "identity/env.md",
+      "preferences/coding-style.md",
+      "preferences/git-workflow.md"
+    ];
+    CLAUDE_MD_HEADER = "<!-- AUTO-GENERATED by assetplex. Do not edit directly. Run `assetplex sync` to update. -->\n";
+    ClaudeCodeAdapter = class extends BaseAdapter {
+      name = "claude-code";
+      displayName = "Claude Code";
+      homepage = "https://code.claude.com/docs";
+      defaultConfigDir = "~/.claude";
+      signatureFiles = ["settings.json"];
+      supportedTargets = [
+        "CLAUDE.md",
+        "skills/",
+        "rules/",
+        "commands/",
+        "agents/"
+      ];
+      /**
+       * 重写 detect：
+       * - 检查 ~/.claude/ 是否存在
+       * - 支持 CLAUDE_CONFIG_DIR 环境变量重定向
+       * - 检查 ~/.claude.json 是否存在（全局 MCP）
+       */
+      async detect() {
+        const configDir = this.getConfigDir();
+        const settingsPath = resolve8(configDir, "settings.json");
+        const claudeMdPath = resolve8(configDir, "CLAUDE.md");
+        const configDirExists = existsSync7(configDir);
+        const hasSettings = existsSync7(settingsPath);
+        const hasClaudeMd = existsSync7(claudeMdPath);
+        const installed = configDirExists && (hasSettings || hasClaudeMd);
+        let version;
+        try {
+          const { execSync: execSync2 } = await import("child_process");
+          const output = execSync2("claude --version 2>&1", {
+            encoding: "utf-8",
+            timeout: 3e3,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          const match = output.match(/(\d+\.\d+\.\d+)/);
+          if (match) version = match[1];
+        } catch {
+        }
+        return {
+          name: this.name,
+          installed,
+          configDirExists,
+          version,
+          configDir,
+          error: installed ? void 0 : configDirExists ? "\u7F3A\u5C11\u6807\u5FD7\u6027\u6587\u4EF6 settings.json" : "\u672A\u5B89\u88C5 Claude Code CLI"
+        };
+      }
+      /**
+       * 获取配置目录（支持 CLAUDE_CONFIG_DIR 环境变量）
+       */
+      getConfigDir() {
+        const fromEnv = process.env.CLAUDE_CONFIG_DIR;
+        if (fromEnv) return this.expandHome(fromEnv);
+        return this.expandHome(this.defaultConfigDir);
+      }
+      /**
+       * 重写 resolveHubItems：明确关联 Hub 内文件与 Claude Code 目标
+       *
+       * 关联关系：
+       * - Hub: identity/* + preferences/* + rules/* → Claude: CLAUDE.md (native-import)
+       * - Hub: skills/                                  → Claude: skills         (symlink, dir)
+       * - Hub: rules/                                   → Claude: rules           (symlink, dir)
+       * - Hub: commands/                                → Claude: commands        (symlink, dir)
+       * - Hub: agents/                                  → Claude: agents          (symlink, dir)
+       * - Hub: mcp/mcp.sources.json                     → Claude: ~/.claude.json  (copy)
+       */
+      resolveHubItems(_hubConfig, _hubRoot) {
+        const base = this.getConfigDir();
+        const home = homedir3();
+        const claudeMdItem = {
+          type: "identity",
+          relativePath: "CLAUDE.md",
+          // 虚拟路径，仅用于标识
+          absolutePath: hubPath("identity/profile.md")
+          // 第一个被 import 的文件作为锚点
+        };
+        return [
+          {
+            item: claudeMdItem,
+            target: {
+              tool: this.name,
+              targetPath: resolve8(base, "CLAUDE.md"),
+              strategy: "native-import",
+              isDirectory: false
+            }
+          },
+          {
+            item: {
+              type: "skill",
+              relativePath: "skills",
+              absolutePath: hubPath("skills")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve8(base, "skills"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "rule",
+              relativePath: "rules",
+              absolutePath: hubPath("rules")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve8(base, "rules"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "command",
+              relativePath: "commands",
+              absolutePath: hubPath("commands")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve8(base, "commands"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "agent",
+              relativePath: "agents",
+              absolutePath: hubPath("agents")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve8(base, "agents"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          // 全局 MCP 配置（在 home 根，不在 .claude 内）
+          {
+            item: {
+              type: "mcp",
+              relativePath: "mcp/mcp.sources.json",
+              absolutePath: hubPath("mcp/mcp.sources.json")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve8(home, ".claude.json"),
+              strategy: "copy",
+              isDirectory: false
+            }
+          }
+        ];
+      }
+      /**
+       * 同步目标列表（向后兼容）
+       * 注意：CLAUDE.md 用 native-import 策略，其余用 symlink
+       */
+      targets(config) {
+        const configDir = config.configDir || this.defaultConfigDir;
+        const base = this.expandHome(configDir);
+        return [
+          {
+            tool: this.name,
+            targetPath: resolve8(base, "CLAUDE.md"),
+            strategy: "native-import",
+            isDirectory: false
+          },
+          {
+            tool: this.name,
+            targetPath: resolve8(base, "skills"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve8(base, "rules"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve8(base, "commands"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve8(base, "agents"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve8(homedir3(), ".claude.json"),
+            strategy: "copy",
+            isDirectory: false
+          }
+        ];
+      }
+      /**
+       * 重写 applyNativeImport：生成 CLAUDE.md 聚合 @import
+       *
+       * 生成内容：
+       *   <!-- AUTO-GENERATED by assetplex ... -->
+       *   @~/.assetplex/identity/profile.md
+       *   @~/.assetplex/identity/profile.auto.md
+       *   ...
+       */
+      async applyNativeImport(_item, target) {
+        const lines = [CLAUDE_MD_HEADER, ""];
+        for (const relPath of buildImportList()) {
+          const absPath = hubPath(relPath);
+          if (existsSync7(absPath)) {
+            lines.push(`@${absPath.replace(/\\/g, "/")}`);
+          }
+        }
+        lines.push("");
+        writeFileSync3(target.targetPath, lines.join("\n"), "utf-8");
+      }
+      /**
+       * 重写 apply：处理 .claude.json 的特殊逻辑（直接复制，不转换格式）
+       */
+      async apply(item, target) {
+        if (target.targetPath.endsWith(".claude.json")) {
+          const content = readFileSync3(item.absolutePath);
+          writeFileSync3(target.targetPath, content, "utf-8");
+          return;
+        }
+        return super.apply(item, target);
+      }
+      /**
+       * 反向导入：从 Claude Code 读 CLAUDE.md 到 Hub
+       *
+       * 注意：CLAUDE.md 是自动生成的，反向导入意义不大；
+       * 但 .claude.json 反向导入可恢复 MCP 配置
+       */
+      async import(targetPath) {
+        const content = readFileSync3(targetPath);
+        let type = "preference";
+        if (targetPath.endsWith("CLAUDE.md")) type = "identity";
+        else if (targetPath.endsWith(".claude.json")) type = "mcp";
+        else if (targetPath.includes("skills")) type = "skill";
+        else if (targetPath.includes("rules")) type = "rule";
+        else if (targetPath.includes("commands")) type = "command";
+        else if (targetPath.includes("agents")) type = "agent";
+        return {
+          type,
+          relativePath: basename(targetPath),
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /**
+       * 扫描 Claude Code 目录，发现所有可导入内容
+       */
+      async scan() {
+        const base = this.getConfigDir();
+        const home = homedir3();
+        const items = [];
+        const claudeMdPath = resolve8(base, "CLAUDE.md");
+        if (existsSync7(claudeMdPath)) {
+          try {
+            const content = readFileSync3(claudeMdPath, "utf-8");
+            if (!content.includes("AUTO-GENERATED by assetplex")) {
+              const item = this.makeDiscoveredItem(claudeMdPath, base, "identity/claude-code.md", "identity");
+              if (item) items.push(item);
+            }
+          } catch {
+          }
+        }
+        items.push(...this.scanDirectory(resolve8(base, "skills"), base, "skills", "skill"));
+        items.push(...this.scanDirectory(resolve8(base, "rules"), base, "rules", "rule"));
+        items.push(...this.scanDirectory(resolve8(base, "commands"), base, "commands", "preference"));
+        items.push(...this.scanDirectory(resolve8(base, "agents"), base, "agents", "preference"));
+        const claudeJsonPath = resolve8(home, ".claude.json");
+        const claudeJsonItem = this.makeDiscoveredItem(claudeJsonPath, home, "mcp/mcp.sources.json", "mcp");
+        if (claudeJsonItem) items.push(claudeJsonItem);
+        return items;
+      }
+    };
+  }
+});
+
+// src/transforms/json-toml.ts
+var json_toml_exports = {};
+__export(json_toml_exports, {
+  isValidJson: () => isValidJson,
+  isValidToml: () => isValidToml,
+  jsonObjToToml: () => jsonObjToToml,
+  jsonToToml: () => jsonToToml,
+  mcpJsonToToml: () => mcpJsonToToml,
+  mcpTomlToJson: () => mcpTomlToJson,
+  tomlToJson: () => tomlToJson,
+  tomlToJsonObj: () => tomlToJsonObj
+});
+import * as TOML2 from "@iarna/toml";
+function jsonToToml(jsonStr) {
+  const obj = JSON.parse(jsonStr);
+  return jsonObjToToml(obj);
+}
+function jsonObjToToml(obj) {
+  return TOML2.stringify(obj);
+}
+function tomlToJsonObj(tomlStr) {
+  return TOML2.parse(tomlStr);
+}
+function tomlToJson(tomlStr) {
+  return JSON.stringify(TOML2.parse(tomlStr), null, 2);
+}
+function mcpJsonToToml(jsonStr) {
+  const obj = JSON.parse(jsonStr);
+  const result = {};
+  if (obj && typeof obj === "object" && "mcpServers" in obj) {
+    result.mcp_servers = obj.mcpServers;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (key !== "mcpServers") {
+      result[key] = value;
+    }
+  }
+  return TOML2.stringify(result);
+}
+function mcpTomlToJson(tomlStr) {
+  const obj = TOML2.parse(tomlStr);
+  const result = {};
+  if ("mcp_servers" in obj) {
+    result.mcpServers = obj.mcp_servers;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (key !== "mcp_servers") {
+      result[key] = value;
+    }
+  }
+  return JSON.stringify(result, null, 2);
+}
+function isValidToml(str) {
+  try {
+    TOML2.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidJson(str) {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_json_toml = __esm({
+  "src/transforms/json-toml.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/adapters/codex.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve9 } from "path";
+function buildAgentsSections() {
+  const rulesFiles = listMarkdownFilesRecursive(hubPath("rules")).map(
+    (rel) => `rules/${rel}`
+  );
+  return [...AGENTS_MD_FIXED_SECTIONS, { title: "Rules", files: rulesFiles }];
+}
+var AGENTS_MD_FIXED_SECTIONS, CodexAdapter;
+var init_codex = __esm({
+  "src/core/adapters/codex.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_base();
+    init_paths();
+    init_fs();
+    init_json_toml();
+    AGENTS_MD_FIXED_SECTIONS = [
+      { title: "Identity", files: [
+        "identity/profile.md",
+        "identity/profile.auto.md",
+        "identity/communication-style.md",
+        "identity/tech-stack.md",
+        "identity/env.md"
+      ] },
+      { title: "Preferences", files: [
+        "preferences/coding-style.md",
+        "preferences/git-workflow.md"
+      ] }
+    ];
+    CodexAdapter = class extends BaseAdapter {
+      name = "codex";
+      displayName = "Codex (OpenAI Codex CLI)";
+      homepage = "https://github.com/openai/codex";
+      defaultConfigDir = "~/.codex";
+      signatureFiles = ["config.toml"];
+      supportedTargets = ["AGENTS.md", "skills/", "config.toml"];
+      /**
+       * 重写 detect：
+       * - 检查 ~/.codex/config.toml 是否存在
+       */
+      async detect() {
+        const configDir = this.getConfigDir();
+        const configPath = resolve9(configDir, "config.toml");
+        const agentsMdPath = resolve9(configDir, "AGENTS.md");
+        const configDirExists = existsSync8(configDir);
+        const hasConfig = existsSync8(configPath);
+        const hasAgentsMd = existsSync8(agentsMdPath);
+        const installed = configDirExists && (hasConfig || hasAgentsMd);
+        let version;
+        try {
+          const { execSync: execSync2 } = await import("child_process");
+          const output = execSync2("codex --version 2>&1", {
+            encoding: "utf-8",
+            timeout: 3e3,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          const match = output.match(/(\d+\.\d+\.\d+)/);
+          if (match) version = match[1];
+        } catch {
+        }
+        return {
+          name: this.name,
+          installed,
+          configDirExists,
+          version,
+          configDir,
+          error: installed ? void 0 : configDirExists ? "\u7F3A\u5C11 config.toml" : "\u672A\u5B89\u88C5 Codex CLI"
+        };
+      }
+      /**
+       * 重写 resolveHubItems：明确关联 Hub 内文件与 Codex 目标
+       *
+       * 关联关系：
+       * - Hub: identity/* + preferences/* + rules/* → Codex: AGENTS.md   (copy, 聚合)
+       * - Hub: skills/                                 → Codex: skills      (symlink, dir)
+       * - Hub: mcp/mcp.sources.json                  → Codex: config.toml (copy, JSON→TOML 转换)
+       */
+      resolveHubItems(_hubConfig, _hubRoot) {
+        const base = this.getConfigDir();
+        return [
+          {
+            item: {
+              type: "identity",
+              relativePath: "AGENTS.md",
+              // 虚拟路径，apply 时会聚合多个 Hub 文件
+              absolutePath: hubPath("identity/profile.md")
+              // 锚点文件
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve9(base, "AGENTS.md"),
+              strategy: "copy",
+              isDirectory: false
+            }
+          },
+          {
+            item: {
+              type: "skill",
+              relativePath: "skills",
+              absolutePath: hubPath("skills")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve9(base, "skills"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "mcp",
+              relativePath: "mcp/mcp.sources.json",
+              absolutePath: hubPath("mcp/mcp.sources.json")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve9(base, "config.toml"),
+              strategy: "copy",
+              isDirectory: false
+            }
+          }
+        ];
+      }
+      /**
+       * 同步目标列表（向后兼容）
+       */
+      targets(config) {
+        const configDir = config.configDir || this.defaultConfigDir;
+        const base = this.expandHome(configDir);
+        return [
+          {
+            tool: this.name,
+            targetPath: resolve9(base, "AGENTS.md"),
+            strategy: "copy",
+            isDirectory: false
+          },
+          {
+            tool: this.name,
+            targetPath: resolve9(base, "skills"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve9(base, "config.toml"),
+            strategy: "copy",
+            isDirectory: false
+          }
+        ];
+      }
+      /**
+       * 重写 apply：处理 AGENTS.md 聚合 和 config.toml JSON→TOML 转换
+       */
+      async apply(item, target) {
+        if (target.targetPath.endsWith("AGENTS.md")) {
+          this.applyAgentsMd(target);
+          return;
+        }
+        if (target.targetPath.endsWith("config.toml")) {
+          this.applyConfigToml(item, target);
+          return;
+        }
+        return super.apply(item, target);
+      }
+      /**
+       * 生成 AGENTS.md：聚合 Hub 内 identity + preferences + rules 内容
+       */
+      applyAgentsMd(target) {
+        const lines = [
+          "<!-- AUTO-GENERATED by assetplex. Do not edit directly. Run `assetplex sync` to update. -->",
+          "# AGENTS.md",
+          "",
+          "> \u6B64\u6587\u4EF6\u7531 assetplex \u81EA\u52A8\u805A\u5408 Hub \u4E2D\u7684\u8EAB\u4EFD\u3001\u504F\u597D\u548C\u89C4\u5219\u6587\u4EF6\u751F\u6210\u3002",
+          "> \u4FEE\u6539\u8BF7\u7F16\u8F91 ~/.assetplex/ \u4E0B\u5BF9\u5E94\u6587\u4EF6\u540E\u8FD0\u884C `assetplex sync`\u3002",
+          ""
+        ];
+        for (const section of buildAgentsSections()) {
+          lines.push(`## ${section.title}`, "");
+          for (const relPath of section.files) {
+            const absPath = hubPath(relPath);
+            if (existsSync8(absPath)) {
+              const content = readFileSync4(absPath, "utf-8").trim();
+              if (content) {
+                lines.push(`### ${relPath}`, "", content, "");
+              }
+            }
+          }
+        }
+        writeFileSync4(target.targetPath, lines.join("\n"), "utf-8");
+      }
+      /**
+       * 生成 config.toml：从 mcp.sources.json (JSON) 转换为 TOML
+       */
+      applyConfigToml(item, target) {
+        const jsonContent = readFileSync4(item.absolutePath, "utf-8");
+        const tomlContent = mcpJsonToToml(jsonContent);
+        writeFileSync4(target.targetPath, tomlContent, "utf-8");
+      }
+      /**
+       * 重写 transform：JSON → TOML 转换
+       */
+      transform(content, format) {
+        if (format === "toml") {
+          const jsonStr = content.toString("utf-8");
+          const tomlStr = mcpJsonToToml(jsonStr);
+          return Buffer.from(tomlStr, "utf-8");
+        }
+        return content;
+      }
+      /**
+       * 反向导入：从 Codex 读 config.toml 转 JSON 到 Hub
+       */
+      async import(targetPath) {
+        const content = readFileSync4(targetPath);
+        let type = "preference";
+        if (targetPath.endsWith("config.toml")) type = "mcp";
+        else if (targetPath.endsWith("AGENTS.md")) type = "identity";
+        else if (targetPath.includes("skills")) type = "skill";
+        if (targetPath.endsWith("config.toml")) {
+          const tomlStr = content.toString("utf-8");
+          const jsonStr = mcpTomlToJson(tomlStr);
+          return {
+            type,
+            relativePath: "mcp/mcp.sources.json",
+            absolutePath: targetPath,
+            content: Buffer.from(jsonStr, "utf-8")
+          };
+        }
+        return {
+          type,
+          relativePath: "",
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /**
+       * 扫描 Codex 目录，发现所有可导入内容
+       */
+      async scan() {
+        const base = this.getConfigDir();
+        const items = [];
+        const agentsMdPath = resolve9(base, "AGENTS.md");
+        if (existsSync8(agentsMdPath)) {
+          try {
+            const content = readFileSync4(agentsMdPath, "utf-8");
+            if (!content.includes("AUTO-GENERATED by assetplex")) {
+              const item = this.makeDiscoveredItem(agentsMdPath, base, "identity/codex.md", "identity");
+              if (item) items.push(item);
+            }
+          } catch {
+          }
+        }
+        items.push(...this.scanDirectory(resolve9(base, "skills"), base, "skills", "skill"));
+        const configTomlPath = resolve9(base, "config.toml");
+        const tomlItem = this.makeDiscoveredItem(configTomlPath, base, "mcp/mcp.sources.json", "mcp");
+        if (tomlItem) items.push(tomlItem);
+        return items;
+      }
+    };
+  }
+});
+
+// src/transforms/env-interpolation.ts
+var env_interpolation_exports = {};
+__export(env_interpolation_exports, {
+  buildEnvMap: () => buildEnvMap,
+  desinterpolateEnv: () => desinterpolateEnv,
+  extractEnvVars: () => extractEnvVars,
+  interpolateEnv: () => interpolateEnv
+});
+function interpolateEnv(input, options = {}) {
+  const env = options.env ?? process.env;
+  const strict = options.strict ?? false;
+  const missing = /* @__PURE__ */ new Set();
+  const replaced = /* @__PURE__ */ new Set();
+  const output = input.replace(ENV_VAR_PATTERN, (match, varName) => {
+    const value = env[varName];
+    if (value === void 0 || value === "") {
+      if (strict) {
+        throw new Error(`\u73AF\u5883\u53D8\u91CF\u7F3A\u5931: ${varName}`);
+      }
+      missing.add(varName);
+      return match;
+    }
+    replaced.add(varName);
+    return value;
+  });
+  return {
+    output,
+    missing: Array.from(missing),
+    replaced: Array.from(replaced)
+  };
+}
+function desinterpolateEnv(input, envMap) {
+  let result = input;
+  const sortedValues = Object.keys(envMap).sort((a, b) => b.length - a.length);
+  for (const value of sortedValues) {
+    if (!value) continue;
+    const varName = envMap[value];
+    const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(escaped, "g"), `\${${varName}}`);
+  }
+  return result;
+}
+function extractEnvVars(input) {
+  const matches = /* @__PURE__ */ new Set();
+  let match;
+  const pattern = new RegExp(ENV_VAR_PATTERN.source, "g");
+  while ((match = pattern.exec(input)) !== null) {
+    matches.add(match[1]);
+  }
+  return Array.from(matches);
+}
+function buildEnvMap(varNames, env = process.env) {
+  const map = {};
+  for (const name of varNames) {
+    const value = env[name];
+    if (value) {
+      map[value] = name;
+    }
+  }
+  return map;
+}
+var ENV_VAR_PATTERN;
+var init_env_interpolation = __esm({
+  "src/transforms/env-interpolation.ts"() {
+    "use strict";
+    init_esm_shims();
+    ENV_VAR_PATTERN = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+  }
+});
+
+// src/core/adapters/workbuddy.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve10 } from "path";
+var WorkBuddyAdapter;
+var init_workbuddy = __esm({
+  "src/core/adapters/workbuddy.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_base();
+    init_paths();
+    init_env_interpolation();
+    WorkBuddyAdapter = class extends BaseAdapter {
+      name = "workbuddy";
+      displayName = "WorkBuddy / CodeBuddy";
+      homepage = "https://www.tencentcloud.com/products/codebuddy";
+      defaultConfigDir = "~/.workbuddy";
+      signatureFiles = [".mcp.json", "mcp.json", "models.json"];
+      supportedTargets = ["rules/", "skills/", ".mcp.json"];
+      /**
+       * 重写 detect：同时检查 ~/.workbuddy 和 ~/.codebuddy
+       */
+      async detect() {
+        const workbuddyDir = this.expandHome("~/.workbuddy");
+        const codebuddyDir = this.expandHome("~/.codebuddy");
+        const workbuddyExists = existsSync9(workbuddyDir);
+        const codebuddyExists = existsSync9(codebuddyDir);
+        const configDir = workbuddyExists ? workbuddyDir : codebuddyDir;
+        const configDirExists = workbuddyExists || codebuddyExists;
+        let hasSignature = false;
+        if (workbuddyExists) {
+          hasSignature = existsSync9(resolve10(workbuddyDir, ".mcp.json")) || existsSync9(resolve10(workbuddyDir, "mcp.json")) || existsSync9(resolve10(workbuddyDir, "models.json"));
+        }
+        if (!hasSignature && codebuddyExists) {
+          hasSignature = existsSync9(resolve10(codebuddyDir, ".mcp.json")) || existsSync9(resolve10(codebuddyDir, "mcp.json")) || existsSync9(resolve10(codebuddyDir, "models.json"));
+        }
+        const installed = configDirExists && hasSignature;
+        return {
+          name: this.name,
+          installed,
+          configDirExists,
+          configDir,
+          error: installed ? void 0 : configDirExists ? "\u7F3A\u5C11\u6807\u5FD7\u6027\u6587\u4EF6" : "\u672A\u5B89\u88C5 WorkBuddy/CodeBuddy"
+        };
+      }
+      /**
+       * 获取配置目录（动态：workbuddy 或 codebuddy）
+       */
+      getConfigDir() {
+        const workbuddyDir = this.expandHome("~/.workbuddy");
+        const codebuddyDir = this.expandHome("~/.codebuddy");
+        if (existsSync9(workbuddyDir)) return workbuddyDir;
+        if (existsSync9(codebuddyDir)) return codebuddyDir;
+        return workbuddyDir;
+      }
+      /**
+       * 重写 resolveHubItems：明确关联 Hub 内文件与 WorkBuddy 目标
+       *
+       * 关联关系：
+       * - Hub: rules/                       → WorkBuddy: rules       (symlink, dir)
+       * - Hub: skills/                       → WorkBuddy: skills      (symlink, dir)
+       * - Hub: mcp/mcp.sources.json          → WorkBuddy: .mcp.json   (copy, ${VAR} 插值)
+       */
+      resolveHubItems(_hubConfig, _hubRoot) {
+        const base = this.getConfigDir();
+        return [
+          {
+            item: {
+              type: "rule",
+              relativePath: "rules",
+              absolutePath: hubPath("rules")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve10(base, "rules"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          {
+            item: {
+              type: "skill",
+              relativePath: "skills",
+              absolutePath: hubPath("skills")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve10(base, "skills"),
+              strategy: "symlink",
+              isDirectory: true
+            }
+          },
+          // 注意前导点（与 Claude Code 的 .mcp.json 同名但路径不同）
+          {
+            item: {
+              type: "mcp",
+              relativePath: "mcp/mcp.sources.json",
+              absolutePath: hubPath("mcp/mcp.sources.json")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve10(base, ".mcp.json"),
+              strategy: "copy",
+              // 需要 ${VAR} 插值
+              isDirectory: false
+            }
+          }
+        ];
+      }
+      /**
+       * 同步目标列表（向后兼容）
+       */
+      targets(config) {
+        const configDir = config.configDir || this.defaultConfigDir;
+        const base = this.expandHome(configDir);
+        return [
+          {
+            tool: this.name,
+            targetPath: resolve10(base, "rules"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve10(base, "skills"),
+            strategy: "symlink",
+            isDirectory: true
+          },
+          {
+            tool: this.name,
+            targetPath: resolve10(base, ".mcp.json"),
+            strategy: "copy",
+            isDirectory: false
+          }
+        ];
+      }
+      /**
+       * 重写 apply：处理 .mcp.json 的 ${VAR} 插值
+       */
+      async apply(item, target) {
+        if (target.targetPath.endsWith(".mcp.json")) {
+          this.applyMcpJson(item, target);
+          return;
+        }
+        return super.apply(item, target);
+      }
+      /**
+       * 生成 .mcp.json：读取 Hub 的 mcp.sources.json，做 ${VAR} 插值
+       */
+      applyMcpJson(item, target) {
+        const content = readFileSync5(item.absolutePath, "utf-8");
+        const varNames = extractEnvVars(content);
+        if (varNames.length === 0) {
+          writeFileSync5(target.targetPath, content, "utf-8");
+          return;
+        }
+        const result = interpolateEnv(content);
+        if (result.missing.length > 0) {
+          console.warn(`[workbuddy] \u7F3A\u5931\u73AF\u5883\u53D8\u91CF: ${result.missing.join(", ")}\uFF08\u4FDD\u7559\u4E3A \${VAR} \u539F\u6837\uFF09`);
+        }
+        writeFileSync5(target.targetPath, result.output, "utf-8");
+      }
+      /**
+       * 反向导入：从 WorkBuddy 读 .mcp.json，去插值后写回 Hub
+       */
+      async import(targetPath) {
+        const content = readFileSync5(targetPath);
+        let type = "preference";
+        if (targetPath.endsWith(".mcp.json")) type = "mcp";
+        else if (targetPath.includes("skills")) type = "skill";
+        else if (targetPath.includes("rules")) type = "rule";
+        if (targetPath.endsWith(".mcp.json")) {
+          const str = content.toString("utf-8");
+          const varNames = extractEnvVars(str);
+          const envMap = buildEnvMap(varNames);
+          if (Object.keys(envMap).length > 0) {
+            const restored = desinterpolateEnv(str, envMap);
+            return {
+              type,
+              relativePath: "mcp/mcp.sources.json",
+              absolutePath: targetPath,
+              content: Buffer.from(restored, "utf-8")
+            };
+          }
+        }
+        return {
+          type,
+          relativePath: "",
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /**
+       * 扫描 WorkBuddy/CodeBuddy 目录，发现所有可导入内容
+       */
+      async scan() {
+        const base = this.getConfigDir();
+        const items = [];
+        items.push(...this.scanDirectory(resolve10(base, "skills"), base, "skills", "skill"));
+        items.push(...this.scanDirectory(resolve10(base, "rules"), base, "rules", "rule"));
+        const mcpDotPath = resolve10(base, ".mcp.json");
+        const mcpDotItem = this.makeDiscoveredItem(mcpDotPath, base, "mcp/mcp.sources.json", "mcp");
+        if (mcpDotItem) items.push(mcpDotItem);
+        const mcpPath = resolve10(base, "mcp.json");
+        if (existsSync9(mcpPath)) {
+          if (!mcpDotItem) {
+            const item = this.makeDiscoveredItem(mcpPath, base, "mcp/mcp.sources.json", "mcp");
+            if (item) items.push(item);
+          } else {
+            const item = this.makeDiscoveredItem(mcpPath, base, "preferences/mcp.json", "preference");
+            if (item) items.push(item);
+          }
+        }
+        const modelsPath = resolve10(base, "models.json");
+        const modelsItem = this.makeDiscoveredItem(modelsPath, base, "preferences/models.json", "preference");
+        if (modelsItem) items.push(modelsItem);
+        return items;
+      }
+    };
+  }
+});
+
+// src/core/adapters/qoder.ts
+import { existsSync as existsSync10, writeFileSync as writeFileSync6, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve11, basename as basename2 } from "path";
+function buildQoderSections() {
+  const rulesFiles = listMarkdownFilesRecursive(hubPath("rules")).map(
+    (rel) => `rules/${rel}`
+  );
+  return [...QODER_FIXED_SECTIONS, ...rulesFiles];
+}
+var QODER_FIXED_SECTIONS, QoderAdapter;
+var init_qoder = __esm({
+  "src/core/adapters/qoder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_base();
+    init_paths();
+    init_fs();
+    init_symlink();
+    init_config();
+    QODER_FIXED_SECTIONS = [
+      "identity/profile.md",
+      "identity/profile.auto.md",
+      "identity/communication-style.md",
+      "identity/tech-stack.md",
+      "preferences/coding-style.md",
+      "preferences/git-workflow.md"
+    ];
+    QoderAdapter = class extends BaseAdapter {
+      name = "qoder";
+      displayName = "Qoder";
+      homepage = "https://docs.qoder.com/";
+      defaultConfigDir = "";
+      // Qoder 无统一用户级目录
+      signatureFiles = [];
+      // 由项目级 .qoder/ 判定
+      supportedTargets = ["rules/", "skills/", "quests/", "knowledge/"];
+      /**
+       * 重写 detect：Qoder 无用户级目录，detect 永远返回未安装
+       * sync 时会通过 resolveHubItems 返回的 targets 处理 per-project
+       */
+      async detect() {
+        return {
+          name: this.name,
+          installed: false,
+          configDirExists: false,
+          configDir: "",
+          error: "Qoder \u662F\u9879\u76EE\u7EA7\u5DE5\u5177\uFF0C\u65E0\u7528\u6237\u7EA7\u76EE\u5F55\uFF1B\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u626B\u63CF .qoder/"
+        };
+      }
+      /**
+       * 获取配置目录（Qoder 不适用，返回空）
+       */
+      getConfigDir() {
+        return "";
+      }
+      /**
+       * 重写 resolveHubItems：从 hub.toml 读取 project_targets，
+       * 为每个项目生成 rules/skills/AGENTS.md 三个 target
+       */
+      resolveHubItems(hubConfig, _hubRoot) {
+        const tools = hubConfig.tools;
+        const qoderConfig = tools[this.name];
+        const projectTargets = qoderConfig?.projectTargets ?? [];
+        if (!qoderConfig?.enabled || projectTargets.length === 0) {
+          return [];
+        }
+        const results = [];
+        for (const projectRoot of projectTargets) {
+          const base = this.expandHome(projectRoot);
+          results.push({
+            item: {
+              type: "rule",
+              relativePath: "rules",
+              absolutePath: hubPath("rules")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve11(base, ".qoder/rules"),
+              strategy: "per-project",
+              isDirectory: true
+            }
+          });
+          results.push({
+            item: {
+              type: "skill",
+              relativePath: "skills",
+              absolutePath: hubPath("skills")
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve11(base, ".qoder/skills"),
+              strategy: "per-project",
+              isDirectory: true
+            }
+          });
+          results.push({
+            item: {
+              type: "identity",
+              relativePath: "AGENTS.md",
+              absolutePath: hubPath("identity/profile.md")
+              // 锚点
+            },
+            target: {
+              tool: this.name,
+              targetPath: resolve11(base, "AGENTS.md"),
+              strategy: "per-project",
+              isDirectory: false
+            }
+          });
+        }
+        return results;
+      }
+      /**
+       * 同步目标列表（向后兼容）
+       */
+      targets(config) {
+        const projectTargets = config.projectTargets ?? [];
+        const results = [];
+        for (const projectRoot of projectTargets) {
+          const base = this.expandHome(projectRoot);
+          results.push({
+            tool: this.name,
+            targetPath: resolve11(base, ".qoder/rules"),
+            strategy: "per-project",
+            isDirectory: true
+          });
+          results.push({
+            tool: this.name,
+            targetPath: resolve11(base, ".qoder/skills"),
+            strategy: "per-project",
+            isDirectory: true
+          });
+          results.push({
+            tool: this.name,
+            targetPath: resolve11(base, "AGENTS.md"),
+            strategy: "per-project",
+            isDirectory: false
+          });
+        }
+        return results;
+      }
+      /**
+       * 重写 applyPerProject：
+       * - 目录类（rules/skills）：用 symlink，fallback 到 copy
+       * - AGENTS.md：聚合 Hub 内容生成
+       */
+      async applyPerProject(item, target) {
+        if (target.targetPath.endsWith("AGENTS.md")) {
+          this.applyAgentsMd(target);
+          return;
+        }
+        ensureDir(resolve11(target.targetPath, ".."));
+        if (target.isDirectory) {
+          const r = await createSymlink(item.absolutePath, target.targetPath, {
+            isDirectory: true,
+            force: true
+          });
+          if (!r.success) {
+            copyRecursive(item.absolutePath, target.targetPath);
+          }
+        } else {
+          copyRecursive(item.absolutePath, target.targetPath);
+        }
+      }
+      /**
+       * 生成 AGENTS.md：聚合 Hub 内容（与 Codex 相同的聚合逻辑）
+       */
+      applyAgentsMd(target) {
+        const lines = [
+          "<!-- AUTO-GENERATED by assetplex. Do not edit directly. Run `assetplex sync` to update. -->",
+          "# AGENTS.md",
+          "",
+          "> \u6B64\u6587\u4EF6\u7531 assetplex \u81EA\u52A8\u805A\u5408 Hub \u4E2D\u7684\u8EAB\u4EFD\u3001\u504F\u597D\u548C\u89C4\u5219\u6587\u4EF6\u751F\u6210\u3002",
+          ""
+        ];
+        for (const relPath of buildQoderSections()) {
+          const absPath = hubPath(relPath);
+          if (existsSync10(absPath)) {
+            const content = readFileSync6(absPath, "utf-8").trim();
+            if (content) {
+              lines.push(`## ${relPath}`, "", content, "");
+            }
+          }
+        }
+        ensureDir(resolve11(target.targetPath, ".."));
+        writeFileSync6(target.targetPath, lines.join("\n"), "utf-8");
+      }
+      /**
+       * 反向导入：从 Qoder 项目读文件
+       */
+      async import(targetPath) {
+        const content = readFileSync6(targetPath);
+        let type = "preference";
+        if (targetPath.endsWith("AGENTS.md")) type = "identity";
+        else if (targetPath.includes("skills")) type = "skill";
+        else if (targetPath.includes("rules")) type = "rule";
+        return {
+          type,
+          relativePath: basename2(targetPath),
+          absolutePath: targetPath,
+          content
+        };
+      }
+      /**
+       * 扫描 Qoder 项目目录，发现所有可导入内容
+       *
+       * Qoder 是项目级工具，从 hub.toml 读取 projectTargets 来确定扫描范围。
+       * 为每个项目扫描 .qoder/skills/、.qoder/rules/ 和项目根 AGENTS.md。
+       */
+      async scan() {
+        let projectTargets = [];
+        try {
+          const config = loadHubConfig();
+          const tools = config.tools;
+          const qoderConfig = tools.qoder;
+          if (qoderConfig?.enabled && qoderConfig.projectTargets?.length) {
+            projectTargets = qoderConfig.projectTargets;
+          }
+        } catch {
+          return [];
+        }
+        const items = [];
+        for (const projectRoot of projectTargets) {
+          const base = this.expandHome(projectRoot);
+          if (!existsSync10(base)) continue;
+          const agentsMdPath = resolve11(base, "AGENTS.md");
+          if (existsSync10(agentsMdPath)) {
+            const projectName = basename2(base) || "project";
+            try {
+              const content = readFileSync6(agentsMdPath, "utf-8");
+              if (!content.includes("AUTO-GENERATED by assetplex")) {
+                const item = this.makeDiscoveredItem(
+                  agentsMdPath,
+                  base,
+                  `identity/qoder-${projectName}.md`,
+                  "identity"
+                );
+                if (item) items.push(item);
+              }
+            } catch {
+            }
+          }
+          items.push(...this.scanDirectory(resolve11(base, ".qoder/skills"), base, "skills", "skill"));
+          items.push(...this.scanDirectory(resolve11(base, ".qoder/rules"), base, "rules", "rule"));
+        }
+        return items;
+      }
+    };
+  }
+});
+
+// src/core/adapters/registry.ts
+function registerAdapter(adapter) {
+  registry.set(adapter.name, adapter);
+}
+function getAdapter(name) {
+  return registry.get(name);
+}
+function getAllAdapters() {
+  return Array.from(registry.values());
+}
+function registerBuiltinAdapters() {
+  registerAdapter(new TraeCnAdapter());
+  registerAdapter(new ClaudeCodeAdapter());
+  registerAdapter(new CodexAdapter());
+  registerAdapter(new WorkBuddyAdapter());
+  registerAdapter(new QoderAdapter());
+}
+var registry;
+var init_registry = __esm({
+  "src/core/adapters/registry.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_trae_cn();
+    init_claude_code();
+    init_codex();
+    init_workbuddy();
+    init_qoder();
+    registry = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/scanner.ts
+async function scanAll() {
+  const adapters = getAllAdapters();
+  const results = [];
+  for (const adapter of adapters) {
+    try {
+      const status = await adapter.detect();
+      let items = [];
+      if (status.installed || adapter.name === "qoder") {
+        try {
+          items = await adapter.scan();
+        } catch (scanErr) {
+          log.warn(`[${adapter.name}] scan \u5931\u8D25: ${scanErr.message}`);
+          items = [];
+        }
+      }
+      results.push({
+        toolName: adapter.name,
+        displayName: adapter.displayName,
+        installed: status.installed,
+        configDir: status.configDir,
+        items
+      });
+    } catch (err) {
+      log.warn(`[${adapter.name}] detect \u5931\u8D25: ${err.message}`);
+      results.push({
+        toolName: adapter.name,
+        displayName: adapter.displayName,
+        installed: false,
+        configDir: "",
+        items: []
+      });
+    }
+  }
+  return results;
+}
+var init_scanner = __esm({
+  "src/core/scanner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_registry();
+    init_logger();
+  }
+});
+
+// src/core/merger.ts
+function getFileType(filepath) {
+  if (filepath.endsWith(".md")) return "md";
+  if (filepath.endsWith(".json")) return "json";
+  if (filepath.endsWith(".toml")) return "toml";
+  return "other";
+}
+function mergeMarkdown(existingContent, newContent, source) {
+  const sourceLabel = `<!-- \u4EE5\u4E0B\u5185\u5BB9\u4ECE ${source} \u5BFC\u5165\uFF0C\u5BFC\u5165\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+  return [
+    existingContent.trimEnd(),
+    "",
+    "---",
+    "",
+    sourceLabel,
+    "",
+    newContent.trimStart()
+  ].join("\n");
+}
+function mergeMcpJson(existingContent, newContent) {
+  try {
+    const existing = JSON.parse(existingContent);
+    const incoming = JSON.parse(newContent);
+    if (incoming.mcpServers && typeof incoming.mcpServers === "object") {
+      if (!existing.mcpServers) {
+        existing.mcpServers = {};
+      }
+      for (const [key, value] of Object.entries(incoming.mcpServers)) {
+        if (!(key in existing.mcpServers)) {
+          existing.mcpServers[key] = value;
+        }
+      }
+    }
+    return JSON.stringify(existing, null, 2);
+  } catch {
+    return mergeMarkdown(existingContent, newContent, "mcp-json");
+  }
+}
+function mergeToml(existingContent, newContent) {
+  try {
+    const existingJson = mcpTomlToJson(existingContent);
+    const newJson = mcpTomlToJson(newContent);
+    const mergedJson = mergeMcpJson(existingJson, newJson);
+    return mcpJsonToToml(mergedJson);
+  } catch {
+    return mergeMarkdown(existingContent, newContent, "toml");
+  }
+}
+function mergeFile(hubTargetPath, newContent, existingContent, source) {
+  if (isStructuredTarget(hubTargetPath)) {
+    return mergeStructuredMd(existingContent, newContent, source);
+  }
+  const type = getFileType(hubTargetPath);
+  switch (type) {
+    case "json":
+      return { content: mergeMcpJson(existingContent, newContent), action: "merged" };
+    case "toml":
+      return { content: mergeToml(existingContent, newContent), action: "merged" };
+    case "md":
+    default:
+      return { content: mergeMarkdown(existingContent, newContent, source), action: "merged" };
+  }
+}
+function isStructuredTarget(hubTargetPath) {
+  return hubTargetPath.startsWith("identity/") && hubTargetPath.endsWith(".md");
+}
+function parseStructuredMd(content) {
+  const fields = /* @__PURE__ */ new Map();
+  const unstructured = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(STRUCTURED_FIELD_RE);
+    if (match) {
+      const key = match[1].trim();
+      const value = match[2].trim();
+      fields.set(key, value);
+    } else {
+      unstructured.push(line);
+    }
+  }
+  return { fields, unstructured };
+}
+function mergeStructuredMd(existingContent, newContent, source) {
+  const existing = parseStructuredMd(existingContent);
+  const incoming = parseStructuredMd(newContent);
+  const mergedFields = new Map(existing.fields);
+  for (const [key, value] of incoming.fields) {
+    mergedFields.set(key, value);
+  }
+  const lines = [];
+  const sortedKeys = [...mergedFields.keys()].sort();
+  for (const key of sortedKeys) {
+    const value = mergedFields.get(key) ?? "";
+    lines.push(`**${key}**\uFF1A${value}`);
+  }
+  const existingUnstructured = existing.unstructured.map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  const incomingUnstructured = incoming.unstructured.map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  if (existingUnstructured.length > 0 || incomingUnstructured.length > 0) {
+    lines.push("");
+    if (existingUnstructured.length > 0) {
+      lines.push(...existingUnstructured);
+    }
+    if (incomingUnstructured.length > 0) {
+      if (existingUnstructured.length > 0) {
+        lines.push("");
+        lines.push("---");
+        lines.push(`<!-- \u4EE5\u4E0B\u5185\u5BB9\u4ECE ${source} \u5BFC\u5165 -->`);
+        lines.push("");
+      }
+      lines.push(...incomingUnstructured);
+    }
+  }
+  return { content: lines.join("\n") + "\n", action: "merged" };
+}
+var STRUCTURED_FIELD_RE;
+var init_merger = __esm({
+  "src/core/merger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_json_toml();
+    STRUCTURED_FIELD_RE = /^[-*\s]*\*\*(.+?)\*\*[：:]\s*(.*)$/;
+  }
+});
+
+// src/core/hub-files.ts
+var hub_files_exports = {};
+__export(hub_files_exports, {
+  HUB_CATEGORIES: () => HUB_CATEGORIES,
+  checkHubHealth: () => checkHubHealth,
+  createHubFile: () => createHubFile,
+  deleteHubFile: () => deleteHubFile,
+  listHubFiles: () => listHubFiles,
+  readHubFile: () => readHubFile,
+  writeHubFile: () => writeHubFile
+});
+import {
+  existsSync as existsSync12,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync7,
+  statSync as statSync3,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { join as join3, resolve as resolve12, dirname as dirname4, relative as relative3 } from "path";
+function listHubFiles(category) {
+  const hubRoot = getHubRoot();
+  const categoryDir = join3(hubRoot, category);
+  if (!existsSync12(categoryDir)) {
+    return [];
+  }
+  const files = [];
+  collectFiles(categoryDir, hubRoot, files);
+  return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function collectFiles(currentDir, hubRoot, out) {
+  const entries = readdirSync4(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) continue;
+      collectFiles(fullPath, hubRoot, out);
+    } else if (entry.isFile()) {
+      if (entry.name.startsWith(".")) continue;
+      const stat = statSync3(fullPath);
+      out.push({
+        relativePath: relative3(hubRoot, fullPath).replace(/\\/g, "/"),
+        absolutePath: fullPath,
+        size: stat.size,
+        modified: stat.mtime.toISOString(),
+        isDirectory: false
+      });
+    }
+  }
+}
+function readHubFile(relativePath) {
+  const hubRoot = getHubRoot();
+  const fullPath = resolve12(hubRoot, relativePath);
+  if (!fullPath.startsWith(hubRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${relativePath}`);
+  }
+  if (!existsSync12(fullPath)) {
+    return null;
+  }
+  const stat = statSync3(fullPath);
+  if (stat.isDirectory()) {
+    throw new Error(`\u8DEF\u5F84\u662F\u76EE\u5F55\u800C\u975E\u6587\u4EF6\uFF1A${relativePath}`);
+  }
+  return {
+    content: readFileSync7(fullPath, "utf-8"),
+    size: stat.size,
+    modified: stat.mtime.toISOString()
+  };
+}
+function writeHubFile(relativePath, content) {
+  const hubRoot = getHubRoot();
+  const fullPath = resolve12(hubRoot, relativePath);
+  if (!fullPath.startsWith(hubRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${relativePath}`);
+  }
+  ensureDir(dirname4(fullPath));
+  writeFileSync7(fullPath, content, "utf-8");
+}
+function deleteHubFile(relativePath) {
+  const hubRoot = getHubRoot();
+  const fullPath = resolve12(hubRoot, relativePath);
+  if (!fullPath.startsWith(hubRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${relativePath}`);
+  }
+  if (!existsSync12(fullPath)) {
+    return;
+  }
+  const stat = statSync3(fullPath);
+  if (stat.isDirectory()) {
+    throw new Error(`\u6682\u4E0D\u652F\u6301\u5220\u9664\u76EE\u5F55\uFF1A${relativePath}`);
+  }
+  unlinkSync2(fullPath);
+}
+function createHubFile(relativePath, content) {
+  const hubRoot = getHubRoot();
+  const fullPath = resolve12(hubRoot, relativePath);
+  if (!fullPath.startsWith(hubRoot)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${relativePath}`);
+  }
+  if (existsSync12(fullPath)) {
+    throw new Error(`\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${relativePath}`);
+  }
+  ensureDir(dirname4(fullPath));
+  writeFileSync7(fullPath, content, "utf-8");
+}
+function checkHubHealth() {
+  const hubRoot = getHubRoot();
+  const health = {
+    hubRoot,
+    hubExists: existsSync12(hubRoot),
+    hubTomlExists: existsSync12(join3(hubRoot, "hub.toml")),
+    fileCountByCategory: {},
+    totalFiles: 0
+  };
+  for (const cat of HUB_CATEGORIES) {
+    const files = listHubFiles(cat);
+    health.fileCountByCategory[cat] = files.length;
+    health.totalFiles += files.length;
+  }
+  return health;
+}
+var HUB_CATEGORIES;
+var init_hub_files = __esm({
+  "src/core/hub-files.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    init_fs();
+    HUB_CATEGORIES = [
+      "identity",
+      "skills",
+      "rules",
+      "preferences",
+      "mcp",
+      "commands",
+      "agents"
+    ];
+  }
+});
+
+// src/core/sync-engine.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve13 } from "path";
+function printSyncPlan(plans) {
+  for (const plan of plans) {
+    log.info("");
+    log.info(`\u5DE5\u5177: ${plan.tool} ${plan.toolInstalled ? "\u2713" : "\u2717"}`);
+    if (plan.items.length === 0) {
+      log.info("  (\u65E0\u5F85\u540C\u6B65\u6761\u76EE)");
+      continue;
+    }
+    for (const item of plan.items) {
+      const icon = item.action === "skip" ? "\xB7" : "\u2192";
+      const action = item.action.padEnd(15);
+      const target = item.target.targetPath || "(\u65E0)";
+      log.info(`  ${icon} ${action} ${target}`);
+      if (item.reason) {
+        log.info(`    \u2514 ${item.reason}`);
+      }
+    }
+  }
+}
+function printSyncResult(results) {
+  log.info("");
+  log.info("\u540C\u6B65\u7ED3\u679C");
+  log.info("=".repeat(60));
+  let totalItem = 0;
+  let totalSkip = 0;
+  let totalError = 0;
+  for (const r of results) {
+    const icon = r.success ? "\u2713" : "\u2717";
+    log.info(`${icon} ${r.tool.padEnd(15)} \u540C\u6B65 ${r.itemCount}\uFF0C\u8DF3\u8FC7 ${r.skippedCount}\uFF0C\u9519\u8BEF ${r.errors.length}\uFF08${r.durationMs}ms\uFF09`);
+    totalItem += r.itemCount;
+    totalSkip += r.skippedCount;
+    totalError += r.errors.length;
+    for (const err of r.errors) {
+      log.warn(`  \u2514 ${err}`);
+    }
+  }
+  log.info("-".repeat(60));
+  log.info(`\u603B\u8BA1\uFF1A\u540C\u6B65 ${totalItem}\uFF0C\u8DF3\u8FC7 ${totalSkip}\uFF0C\u9519\u8BEF ${totalError}`);
+}
+var FILTERED_OUT, SyncEngine;
+var init_sync_engine = __esm({
+  "src/core/sync-engine.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_registry();
+    init_paths();
+    init_logger();
+    init_fs();
+    init_scanner();
+    init_merger();
+    init_hub_files();
+    FILTERED_OUT = /* @__PURE__ */ Symbol("FILTERED_OUT");
+    SyncEngine = class {
+      constructor(hubConfig, adapters = getAllAdapters()) {
+        this.hubConfig = hubConfig;
+        this.adapters = adapters;
+      }
+      hubConfig;
+      adapters;
+      /**
+       * 计算同步计划（不执行）
+       *
+       * 算法：
+       * 1. 过滤 adapters：仅保留 enabled 且（--tool 指定或全部）
+       * 2. 对每个 adapter：
+       *    - 调用 detect() 检查工具是否安装
+       *    - 调用 resolveHubItems() 获取 (item, target) 列表
+       *    - 对每个 (item, target)：
+       *      - 检查 item.absolutePath 是否存在（不存在 → skip）
+       *      - 检查 target.targetPath 当前状态（已是正确 symlink → skip）
+       *      - 否则 → 待执行 action
+       */
+      async plan(options = {}) {
+        const hubRoot = getHubRoot();
+        const plans = [];
+        for (const adapter of this.adapters) {
+          const planForTool = await this.planForAdapter(adapter, hubRoot, options);
+          if (planForTool === FILTERED_OUT) continue;
+          plans.push(planForTool);
+        }
+        return plans;
+      }
+      /**
+       * 为单个适配器计算计划
+       */
+      async planForAdapter(adapter, hubRoot, options) {
+        const toolName = adapter.name;
+        const toolFilter = options.tools?.length ? options.tools : options.tool ? [options.tool] : void 0;
+        if (toolFilter && !toolFilter.includes(toolName)) {
+          return FILTERED_OUT;
+        }
+        if (!this.isToolEnabled(toolName)) {
+          return {
+            tool: toolName,
+            toolInstalled: false,
+            items: []
+          };
+        }
+        let status;
+        try {
+          status = await adapter.detect();
+        } catch (err) {
+          return {
+            tool: toolName,
+            toolInstalled: false,
+            items: [
+              {
+                item: { type: "preference", relativePath: "", absolutePath: "" },
+                target: {
+                  tool: toolName,
+                  targetPath: "",
+                  strategy: "symlink",
+                  isDirectory: false
+                },
+                action: "skip",
+                reason: `detect \u5931\u8D25: ${err.message}`
+              }
+            ]
+          };
+        }
+        const isQoder = toolName === "qoder";
+        if (!status.installed && !isQoder) {
+          return {
+            tool: toolName,
+            toolInstalled: false,
+            items: [
+              {
+                item: { type: "preference", relativePath: "", absolutePath: "" },
+                target: {
+                  tool: toolName,
+                  targetPath: status.configDir,
+                  strategy: "symlink",
+                  isDirectory: false
+                },
+                action: "skip",
+                reason: status.error ?? "tool not installed"
+              }
+            ]
+          };
+        }
+        const hubItems = adapter.resolveHubItems(this.hubConfig, hubRoot);
+        const items = hubItems.map(({ item, target }) => {
+          if (!item.absolutePath || !existsSync13(item.absolutePath)) {
+            return {
+              item,
+              target,
+              action: "skip",
+              reason: `Hub \u6E90\u4E0D\u5B58\u5728: ${item.relativePath || item.absolutePath}`
+            };
+          }
+          if (target.strategy === "symlink" && isSymlink(target.targetPath)) {
+            const currentTarget = readSymlinkTarget(target.targetPath);
+            if (currentTarget && resolve13(currentTarget) === resolve13(item.absolutePath)) {
+              return {
+                item,
+                target,
+                action: "skip",
+                reason: "\u5DF2\u662F\u6B63\u786E\u7B26\u53F7\u94FE\u63A5\uFF0C\u8DF3\u8FC7"
+              };
+            }
+          }
+          let warning;
+          if (existsSync13(target.targetPath) && !isSymlink(target.targetPath)) {
+            warning = "\u76EE\u6807\u8DEF\u5F84\u5DF2\u6709\u975E symlink \u6587\u4EF6\uFF0C\u540C\u6B65\u540E\u5C06\u8986\u76D6";
+          }
+          return {
+            item,
+            target,
+            action: target.strategy,
+            warning
+          };
+        });
+        return {
+          tool: toolName,
+          toolInstalled: status.installed,
+          items
+        };
+      }
+      /**
+       * 执行同步
+       */
+      async run(options = {}) {
+        const plans = await this.plan(options);
+        const results = [];
+        for (const plan of plans) {
+          const result = await this.runPlan(plan);
+          results.push(result);
+        }
+        return results;
+      }
+      /**
+       * 执行单个工具的同步计划
+       */
+      async runPlan(plan) {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        let itemCount = 0;
+        let skippedCount = 0;
+        const adapter = this.adapters.find((a) => a.name === plan.tool);
+        if (!adapter) {
+          return {
+            tool: plan.tool,
+            success: false,
+            itemCount: 0,
+            skippedCount: plan.items.length,
+            errors: [`\u9002\u914D\u5668\u672A\u6CE8\u518C: ${plan.tool}`],
+            warnings: [],
+            durationMs: Date.now() - startTime
+          };
+        }
+        for (const planItem of plan.items) {
+          if (planItem.action === "skip") {
+            skippedCount++;
+            if (planItem.reason) {
+              log.debug(`[${plan.tool}] \u8DF3\u8FC7: ${planItem.reason}`);
+            }
+            continue;
+          }
+          try {
+            await adapter.apply(planItem.item, planItem.target);
+            itemCount++;
+            log.debug(`[${plan.tool}] \u2713 ${planItem.target.targetPath}`);
+          } catch (err) {
+            const msg = `${planItem.target.targetPath}: ${err.message}`;
+            errors.push(msg);
+            log.warn(`[${plan.tool}] \u2717 ${msg}`);
+          }
+        }
+        return {
+          tool: plan.tool,
+          success: errors.length === 0,
+          itemCount,
+          skippedCount,
+          errors,
+          warnings,
+          durationMs: Date.now() - startTime
+        };
+      }
+      /**
+       * 反向导入：从工具目录读回 Hub
+       *
+       * 注意：当前 MVP 实现仅返回 HubItem 列表，不写入 Hub；
+       * 由 CLI 命令决定如何处理（询问用户确认后写入）
+       */
+      async reverseImport(options = {}) {
+        const hubRoot = getHubRoot();
+        const results = [];
+        for (const adapter of this.adapters) {
+          const toolFilter = options.tools?.length ? options.tools : options.tool ? [options.tool] : void 0;
+          if (toolFilter && !toolFilter.includes(adapter.name)) continue;
+          if (!this.isToolEnabled(adapter.name)) continue;
+          const status = await adapter.detect();
+          if (!status.installed && adapter.name !== "qoder") continue;
+          const hubItems = adapter.resolveHubItems(this.hubConfig, hubRoot);
+          const imported = [];
+          for (const { target } of hubItems) {
+            if (!target.targetPath || !existsSync13(target.targetPath)) continue;
+            try {
+              const item = await adapter.import(target.targetPath);
+              imported.push(item);
+            } catch (err) {
+              log.warn(`[${adapter.name}] import \u5931\u8D25 ${target.targetPath}: ${err.message}`);
+            }
+          }
+          results.push({ tool: adapter.name, items: imported });
+        }
+        return results;
+      }
+      /**
+       * 扫描所有工具的可导入内容（导入向导 Step 1-2 使用）
+       */
+      async scanAll() {
+        return scanAll();
+      }
+      /**
+       * 执行导入：接收用户选择的条目列表，写入 Hub（导入向导 Step 4 使用）
+       */
+      async executeImport(request) {
+        const result = {
+          success: true,
+          created: 0,
+          merged: 0,
+          overwritten: 0,
+          skipped: 0,
+          errors: 0,
+          items: []
+        };
+        for (const item of request.items) {
+          try {
+            const sourceContent = readFileSync8(item.absolutePath, "utf-8");
+            let contentToWrite = sourceContent;
+            if (item.absolutePath.endsWith("config.toml") && item.hubTargetPath.endsWith(".json")) {
+              const { mcpTomlToJson: mcpTomlToJson2 } = await Promise.resolve().then(() => (init_json_toml(), json_toml_exports));
+              contentToWrite = mcpTomlToJson2(sourceContent);
+            }
+            if (item.tool === "workbuddy" && item.absolutePath.endsWith(".mcp.json")) {
+              const { extractEnvVars: extractEnvVars2, buildEnvMap: buildEnvMap2, desinterpolateEnv: desinterpolateEnv2 } = await Promise.resolve().then(() => (init_env_interpolation(), env_interpolation_exports));
+              const varNames = extractEnvVars2(contentToWrite);
+              const envMap = buildEnvMap2(varNames);
+              if (Object.keys(envMap).length > 0) {
+                contentToWrite = desinterpolateEnv2(contentToWrite, envMap);
+              }
+            }
+            const existing = readHubFile(item.hubTargetPath);
+            if (!existing) {
+              writeHubFile(item.hubTargetPath, contentToWrite);
+              result.items.push({
+                tool: item.tool,
+                hubTargetPath: item.hubTargetPath,
+                status: "created"
+              });
+              result.created++;
+            } else if (item.strategy === "overwrite") {
+              writeHubFile(item.hubTargetPath, contentToWrite);
+              result.items.push({
+                tool: item.tool,
+                hubTargetPath: item.hubTargetPath,
+                status: "overwritten"
+              });
+              result.overwritten++;
+            } else if (item.strategy === "merge") {
+              const merged = mergeFile(item.hubTargetPath, contentToWrite, existing.content, item.tool);
+              writeHubFile(item.hubTargetPath, merged.content);
+              result.items.push({
+                tool: item.tool,
+                hubTargetPath: item.hubTargetPath,
+                status: "merged"
+              });
+              result.merged++;
+            } else {
+              result.items.push({
+                tool: item.tool,
+                hubTargetPath: item.hubTargetPath,
+                status: "skipped"
+              });
+              result.skipped++;
+            }
+          } catch (err) {
+            result.items.push({
+              tool: item.tool,
+              hubTargetPath: item.hubTargetPath,
+              status: "error",
+              message: err.message
+            });
+            result.errors++;
+            result.success = false;
+          }
+        }
+        return result;
+      }
+      /**
+       * 判断工具在 hubConfig 中是否 enabled
+       */
+      isToolEnabled(toolName) {
+        const tools = this.hubConfig.tools;
+        return tools?.[toolName]?.enabled ?? false;
+      }
+    };
+  }
+});
+
+// src/server/lib/hub-context.ts
+var HubContext, hubContext;
+var init_hub_context = __esm({
+  "src/server/lib/hub-context.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_sync_engine();
+    init_registry();
+    HubContext = class {
+      config = null;
+      engine = null;
+      adaptersRegistered = false;
+      /** 获取当前 Hub 配置（懒加载） */
+      getConfig() {
+        if (!this.config) {
+          this.config = loadHubConfig();
+        }
+        this.ensureAdaptersRegistered();
+        return this.config;
+      }
+      /** 确保内置适配器已注册（幂等） */
+      ensureAdaptersRegistered() {
+        if (!this.adaptersRegistered) {
+          registerBuiltinAdapters();
+          this.adaptersRegistered = true;
+        }
+      }
+      /** 获取 SyncEngine 实例（懒加载） */
+      getEngine() {
+        if (!this.engine) {
+          this.engine = new SyncEngine(this.getConfig(), this.getAllAdapters());
+        }
+        return this.engine;
+      }
+      /** 获取所有已注册的适配器 */
+      getAllAdapters() {
+        this.ensureAdaptersRegistered();
+        return getAllAdapters();
+      }
+      /** 按 name 查找适配器 */
+      getAdapter(name) {
+        return getAdapter(name);
+      }
+      /** 让配置/引擎缓存失效，下次访问时重新加载 */
+      reloadConfig() {
+        this.config = null;
+        this.engine = null;
+      }
+      /** 保存新配置并刷新缓存 */
+      saveConfig(config) {
+        saveHubConfig(config);
+        this.config = config;
+        this.engine = null;
+      }
+    };
+    hubContext = new HubContext();
+  }
+});
+
+// src/core/overview.ts
+async function getOverview() {
+  const health = checkHubHealth();
+  const assetStats = {
+    identity: 0,
+    skill: 0,
+    rule: 0,
+    mcp: 0
+  };
+  for (const cat of HUB_CATEGORIES) {
+    const frontendCat = CATEGORY_MAP[cat];
+    if (frontendCat) {
+      assetStats[frontendCat] = health.fileCountByCategory[cat] ?? 0;
+    }
+  }
+  const totalAssets = Object.values(assetStats).reduce((s, n) => s + n, 0);
+  const hubInitialized = health.hubExists && health.hubTomlExists && totalAssets > 0;
+  const healthScore = computeHealthScore(totalAssets);
+  const connections = await getConnections();
+  const recentActivities = getRecentActivities();
+  return {
+    assetStats,
+    connections,
+    recentActivities,
+    hubInitialized,
+    healthScore
+  };
+}
+function computeHealthScore(totalAssets) {
+  if (totalAssets === 0) return 0;
+  return Math.min(100, 60 + totalAssets * 4);
+}
+async function getConnections() {
+  const adapters = hubContext.getAllAdapters();
+  const config = hubContext.getConfig();
+  const results = [];
+  for (const adapter of adapters) {
+    try {
+      const status = await adapter.detect();
+      const toolConfig = config.tools?.[adapter.name];
+      const enabled = toolConfig?.enabled ?? false;
+      if (!status.installed) {
+        results.push({
+          toolId: adapter.name,
+          toolName: adapter.displayName,
+          status: "not_installed",
+          assetCount: 0,
+          pendingCount: 0
+        });
+        continue;
+      }
+      if (!enabled) {
+        results.push({
+          toolId: adapter.name,
+          toolName: adapter.displayName,
+          status: "not_connected",
+          assetCount: 0,
+          pendingCount: 0
+        });
+        continue;
+      }
+      results.push({
+        toolId: adapter.name,
+        toolName: adapter.displayName,
+        status: "synced",
+        assetCount: 0,
+        pendingCount: 0
+      });
+    } catch {
+      results.push({
+        toolId: adapter.name,
+        toolName: adapter.displayName,
+        status: "not_installed",
+        assetCount: 0,
+        pendingCount: 0
+      });
+    }
+  }
+  const statusOrder = { synced: 0, pending: 1, not_connected: 2, not_installed: 3 };
+  results.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+  return results;
+}
+function getRecentActivities() {
+  return [];
+}
+var CATEGORY_MAP;
+var init_overview = __esm({
+  "src/core/overview.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hub_files();
+    init_hub_context();
+    CATEGORY_MAP = {
+      identity: "identity",
+      skills: "skill",
+      rules: "rule",
+      mcp: "mcp"
+    };
+  }
+});
+
+// src/server/routes/hub.ts
+import { Hono } from "hono";
+var hubRoutes;
+var init_hub = __esm({
+  "src/server/routes/hub.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_hub_context();
+    init_hub_files();
+    init_overview();
+    hubRoutes = new Hono();
+    hubRoutes.get("/config", (c) => {
+      return c.json(hubContext.getConfig());
+    });
+    hubRoutes.put("/config", async (c) => {
+      const body = await c.req.json();
+      const config = HubConfigSchema.parse(body);
+      hubContext.saveConfig(config);
+      return c.json({ success: true });
+    });
+    hubRoutes.get("/health", (c) => {
+      return c.json(checkHubHealth());
+    });
+    hubRoutes.get("/overview", async (c) => {
+      try {
+        const data = await getOverview();
+        return c.json(data);
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : String(err) },
+          500
+        );
+      }
+    });
+  }
+});
+
+// src/server/routes/tools.ts
+import { Hono as Hono2 } from "hono";
+var toolsRoutes;
+var init_tools = __esm({
+  "src/server/routes/tools.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hub_context();
+    toolsRoutes = new Hono2();
+    toolsRoutes.get("/", async (c) => {
+      const config = hubContext.getConfig();
+      const adapters = hubContext.getAllAdapters();
+      const statuses = await Promise.all(adapters.map((adapter) => adapter.detect()));
+      const tools = adapters.map((adapter, i) => {
+        const toolConfig = config.tools[adapter.name];
+        return {
+          ...statuses[i],
+          enabled: toolConfig?.enabled ?? false
+        };
+      });
+      return c.json({ tools });
+    });
+    toolsRoutes.get("/:name", async (c) => {
+      const name = c.req.param("name");
+      const adapter = hubContext.getAdapter(name);
+      if (!adapter) {
+        return c.json({ error: `\u672A\u627E\u5230\u5DE5\u5177\u9002\u914D\u5668\uFF1A${name}` }, 404);
+      }
+      const status = await adapter.detect();
+      const config = hubContext.getConfig();
+      const toolConfig = config.tools[name];
+      return c.json({
+        ...status,
+        enabled: toolConfig?.enabled ?? false
+      });
+    });
+    toolsRoutes.post("/:name/toggle", async (c) => {
+      const name = c.req.param("name");
+      const body = await c.req.json().catch(() => ({}));
+      const enabled = body.enabled;
+      const config = hubContext.getConfig();
+      const tools = config.tools;
+      if (!tools[name]) {
+        return c.json({ error: `\u672A\u627E\u5230\u5DE5\u5177\u914D\u7F6E\uFF1A${name}` }, 404);
+      }
+      const nextEnabled = typeof enabled === "boolean" ? enabled : !tools[name].enabled;
+      tools[name].enabled = nextEnabled;
+      hubContext.saveConfig(config);
+      return c.json({ success: true, enabled: nextEnabled });
+    });
+    toolsRoutes.post("/:name/detect", async (c) => {
+      const name = c.req.param("name");
+      const adapter = hubContext.getAdapter(name);
+      if (!adapter) {
+        return c.json({ error: `\u672A\u627E\u5230\u5DE5\u5177\u9002\u914D\u5668\uFF1A${name}` }, 404);
+      }
+      const status = await adapter.detect();
+      return c.json(status);
+    });
+    toolsRoutes.get("/:name/detail", async (c) => {
+      const name = c.req.param("name");
+      const adapter = hubContext.getAdapter(name);
+      if (!adapter) {
+        return c.json({ error: `\u672A\u627E\u5230\u5DE5\u5177\u9002\u914D\u5668\uFF1A${name}` }, 404);
+      }
+      const status = await adapter.detect();
+      const config = hubContext.getConfig();
+      const toolConfig = config.tools[name];
+      const tool = {
+        ...status,
+        enabled: toolConfig?.enabled ?? false
+      };
+      let discovered;
+      if (status.installed) {
+        try {
+          const items = await adapter.scan();
+          discovered = {
+            identities: items.filter((i) => i.category === "identity").map((f) => ({ path: f.absolutePath, size: f.size })),
+            rules: items.filter((i) => i.category === "rule").map((f) => ({ path: f.absolutePath, size: f.size })),
+            skills: items.filter((i) => i.category === "skill").map((f) => ({ path: f.absolutePath, size: f.size })),
+            mcps: items.filter((i) => i.category === "mcp").map((f) => ({ path: f.absolutePath, size: f.size }))
+          };
+        } catch {
+          discovered = void 0;
+        }
+      }
+      return c.json({ tool, discovered });
+    });
+  }
+});
+
+// src/server/routes/sync.ts
+import { Hono as Hono3 } from "hono";
+function parseTools(query) {
+  const raw = query.tool;
+  const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  const toolsRaw = query.tools;
+  const fromCsv = (Array.isArray(toolsRaw) ? toolsRaw.join(",") : toolsRaw ?? "").split(",").map((t) => t.trim()).filter(Boolean);
+  const all = [...list, ...fromCsv];
+  if (all.length === 0) return {};
+  if (all.length === 1) return { tool: all[0] };
+  return { tools: all };
+}
+var syncRoutes, syncHistory;
+var init_sync = __esm({
+  "src/server/routes/sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hub_context();
+    syncRoutes = new Hono3();
+    syncHistory = [];
+    syncRoutes.get("/plan", async (c) => {
+      const filter = parseTools(c.req.query());
+      const engine = hubContext.getEngine();
+      const plans = await engine.plan(filter);
+      return c.json({ plans });
+    });
+    syncRoutes.post("/run", async (c) => {
+      const filter = parseTools(c.req.query());
+      const dryRun = c.req.query("dryRun") === "true";
+      const engine = hubContext.getEngine();
+      const results = await engine.run({ ...filter, dryRun });
+      syncHistory.unshift({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        tool: filter.tool,
+        dryRun,
+        results
+      });
+      if (syncHistory.length > 20) syncHistory.pop();
+      return c.json({ results });
+    });
+    syncRoutes.post("/reverse-import", async (c) => {
+      const filter = parseTools(c.req.query());
+      const engine = hubContext.getEngine();
+      const results = await engine.reverseImport(filter);
+      return c.json({ results });
+    });
+    syncRoutes.get("/history", (c) => {
+      return c.json({ history: syncHistory });
+    });
+    syncRoutes.get("/scan", async (c) => {
+      const engine = hubContext.getEngine();
+      const inventories = await engine.scanAll();
+      return c.json({ inventories });
+    });
+    syncRoutes.get("/diff", async (c) => {
+      const sourcePath = c.req.query("sourcePath");
+      const hubTargetPath = c.req.query("hubTargetPath");
+      if (!sourcePath || !hubTargetPath) {
+        return c.json({ error: "\u7F3A\u5C11 sourcePath \u6216 hubTargetPath \u53C2\u6570" }, 400);
+      }
+      const { existsSync: existsSync15, readFileSync: readFileSync9 } = await import("fs");
+      const { readHubFile: readHubFile2 } = await Promise.resolve().then(() => (init_hub_files(), hub_files_exports));
+      const { homedir: homedir4 } = await import("os");
+      const { resolve: pathResolve } = await import("path");
+      const home = pathResolve(homedir4());
+      const normalizedSource = pathResolve(sourcePath);
+      if (!normalizedSource.startsWith(home)) {
+        return c.json({ error: "sourcePath \u4E0D\u5728\u7528\u6237\u76EE\u5F55\u8303\u56F4\u5185" }, 403);
+      }
+      if (!existsSync15(normalizedSource)) {
+        return c.json({ error: "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728" }, 404);
+      }
+      let sourceContent;
+      try {
+        sourceContent = readFileSync9(normalizedSource, "utf-8");
+      } catch {
+        return c.json({ error: "\u65E0\u6CD5\u8BFB\u53D6\u6E90\u6587\u4EF6" }, 500);
+      }
+      let hubContent = null;
+      const hubFile = readHubFile2(hubTargetPath);
+      if (hubFile) {
+        hubContent = hubFile.content;
+      }
+      return c.json({
+        sourceContent,
+        hubContent,
+        sourcePath,
+        hubTargetPath
+      });
+    });
+    syncRoutes.post("/execute-import", async (c) => {
+      const body = await c.req.json();
+      if (!body.items || !Array.isArray(body.items)) {
+        return c.json({ error: "\u7F3A\u5C11 items \u5B57\u6BB5\u6216\u683C\u5F0F\u9519\u8BEF" }, 400);
+      }
+      const engine = hubContext.getEngine();
+      const result = await engine.executeImport(body);
+      return c.json(result);
+    });
+  }
+});
+
+// src/server/routes/files.ts
+import { Hono as Hono4 } from "hono";
+var filesRoutes;
+var init_files = __esm({
+  "src/server/routes/files.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hub_files();
+    filesRoutes = new Hono4();
+    filesRoutes.get("/", (c) => {
+      const category = c.req.query("category");
+      if (category) {
+        if (!HUB_CATEGORIES.includes(category)) {
+          return c.json(
+            { error: `\u65E0\u6548\u7684\u7C7B\u522B\uFF1A${category}\uFF0C\u652F\u6301\uFF1A${HUB_CATEGORIES.join(", ")}` },
+            400
+          );
+        }
+        return c.json({ files: listHubFiles(category) });
+      }
+      const allFiles = HUB_CATEGORIES.flatMap((cat) => listHubFiles(cat));
+      return c.json({ files: allFiles });
+    });
+    filesRoutes.get("/*", (c) => {
+      const path2 = c.req.path.replace("/api/files/", "");
+      if (!path2) {
+        return c.json({ error: "\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84" }, 400);
+      }
+      const file = readHubFile(path2);
+      if (!file) {
+        return c.json({ error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${path2}` }, 404);
+      }
+      return c.json({ path: path2, ...file });
+    });
+    filesRoutes.put("/*", async (c) => {
+      const path2 = c.req.path.replace("/api/files/", "");
+      if (!path2) {
+        return c.json({ error: "\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84" }, 400);
+      }
+      const body = await c.req.json();
+      if (typeof body.content !== "string") {
+        return c.json({ error: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u5305\u542B content \u5B57\u6BB5" }, 400);
+      }
+      writeHubFile(path2, body.content);
+      return c.json({ success: true, path: path2 });
+    });
+    filesRoutes.post("/", async (c) => {
+      const body = await c.req.json();
+      if (typeof body.path !== "string" || typeof body.content !== "string") {
+        return c.json({ error: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u5305\u542B path \u548C content \u5B57\u6BB5" }, 400);
+      }
+      try {
+        createHubFile(body.path, body.content);
+        return c.json({ success: true, path: body.path });
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : String(err) },
+          400
+        );
+      }
+    });
+    filesRoutes.delete("/*", (c) => {
+      const path2 = c.req.path.replace("/api/files/", "");
+      if (!path2) {
+        return c.json({ error: "\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84" }, 400);
+      }
+      try {
+        deleteHubFile(path2);
+        return c.json({ success: true });
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : String(err) },
+          400
+        );
+      }
+    });
+  }
+});
+
+// src/core/assets.ts
+async function listAssets(params = {}) {
+  const { category, search } = params;
+  const categoriesToScan = category ? (() => {
+    const reverse = {
+      identity: "identity",
+      skill: "skills",
+      rule: "rules",
+      mcp: "mcp"
+    };
+    return [reverse[category]];
+  })() : HUB_CATEGORIES.filter((c) => c in DIR_TO_CATEGORY);
+  const allFiles = [];
+  for (const hubCat of categoriesToScan) {
+    const frontendCat = DIR_TO_CATEGORY[hubCat];
+    if (!frontendCat) continue;
+    const files = listHubFiles(hubCat);
+    for (const f of files) {
+      allFiles.push({ file: f, category: frontendCat });
+    }
+  }
+  let assets = allFiles.map(({ file, category: category2 }) => hubFileToAsset(file, category2));
+  if (search && search.trim()) {
+    const q = search.trim().toLowerCase();
+    assets = assets.filter((a) => a.name.toLowerCase().includes(q));
+  }
+  assets.sort((a, b) => new Date(b.lastModifiedAt).getTime() - new Date(a.lastModifiedAt).getTime());
+  return { items: assets, total: assets.length };
+}
+async function getAsset(hubPath2) {
+  const fileData = readHubFile(hubPath2);
+  if (!fileData) return null;
+  const category = inferCategoryFromPath(hubPath2);
+  if (!category) return null;
+  const file = {
+    relativePath: hubPath2,
+    absolutePath: "",
+    size: fileData.size,
+    modified: fileData.modified,
+    isDirectory: false
+  };
+  const asset = hubFileToAsset(file, category);
+  return {
+    ...asset,
+    content: fileData.content
+  };
+}
+function inferCategoryFromPath(hubPath2) {
+  const firstSegment = hubPath2.split("/")[0];
+  return DIR_TO_CATEGORY[firstSegment] ?? null;
+}
+function hubFileToAsset(file, category) {
+  const name = extractName(file.relativePath, category);
+  return {
+    id: file.relativePath,
+    name,
+    category,
+    hubPath: file.relativePath,
+    source: "manual",
+    // Phase 1 默认，Phase 2 从导入记录中读取真实来源
+    lastModifiedAt: file.modified,
+    size: file.size,
+    distributions: []
+    // Phase 1 空数组，Phase 2 连接页实现时填充
+  };
+}
+function extractName(relativePath, _category) {
+  const basename3 = relativePath.split("/").pop() ?? relativePath;
+  const dotIndex = basename3.lastIndexOf(".");
+  return dotIndex > 0 ? basename3.substring(0, dotIndex) : basename3;
+}
+var DIR_TO_CATEGORY;
+var init_assets = __esm({
+  "src/core/assets.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hub_files();
+    DIR_TO_CATEGORY = {
+      identity: "identity",
+      skills: "skill",
+      rules: "rule",
+      mcp: "mcp"
+    };
+  }
+});
+
+// src/server/routes/assets.ts
+import { Hono as Hono5 } from "hono";
+var assetsRoutes;
+var init_assets2 = __esm({
+  "src/server/routes/assets.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_assets();
+    init_hub_files();
+    assetsRoutes = new Hono5();
+    assetsRoutes.get("/", async (c) => {
+      const category = c.req.query("category");
+      const search = c.req.query("search");
+      const validCategories = ["identity", "skill", "rule", "mcp"];
+      if (category && !validCategories.includes(category)) {
+        return c.json({ error: `\u65E0\u6548\u7C7B\u522B\uFF1A${category}\uFF0C\u652F\u6301\uFF1A${validCategories.join(", ")}` }, 400);
+      }
+      const result = await listAssets({ category, search });
+      return c.json(result);
+    });
+    assetsRoutes.get("/:id{.+}", async (c) => {
+      const id = c.req.param("id");
+      if (!id) return c.json({ error: "\u7F3A\u5C11\u8D44\u4EA7ID" }, 400);
+      const hubPath2 = decodeURIComponent(id);
+      const asset = await getAsset(hubPath2);
+      if (!asset) {
+        return c.json({ error: `\u8D44\u4EA7\u4E0D\u5B58\u5728\uFF1A${hubPath2}` }, 404);
+      }
+      return c.json(asset);
+    });
+    assetsRoutes.post("/", async (c) => {
+      const body = await c.req.json();
+      if (!body.name || !body.category || typeof body.content !== "string") {
+        return c.json({ error: "\u5FC5\u987B\u63D0\u4F9B name\u3001category\u3001content \u5B57\u6BB5" }, 400);
+      }
+      const validCategories = ["identity", "skill", "rule", "mcp"];
+      if (!validCategories.includes(body.category)) {
+        return c.json({ error: `\u65E0\u6548\u7C7B\u522B\uFF1A${body.category}` }, 400);
+      }
+      const dirMap = {
+        identity: "identity",
+        skill: "skills",
+        rule: "rules",
+        mcp: "mcp"
+      };
+      const ext = body.category === "mcp" ? ".json" : ".md";
+      const hubPath2 = `${dirMap[body.category]}/${body.name}${ext}`;
+      try {
+        createHubFile(hubPath2, body.content);
+        const asset = await getAsset(hubPath2);
+        return c.json({ asset }, 201);
+      } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+      }
+    });
+    assetsRoutes.put("/:id{.+}", async (c) => {
+      const id = c.req.param("id");
+      const hubPath2 = decodeURIComponent(id);
+      const body = await c.req.json();
+      if (typeof body.content !== "string") {
+        return c.json({ error: "\u5FC5\u987B\u63D0\u4F9B content \u5B57\u6BB5" }, 400);
+      }
+      try {
+        writeHubFile(hubPath2, body.content);
+        const asset = await getAsset(hubPath2);
+        return c.json({ asset });
+      } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+      }
+    });
+  }
+});
+
+// src/server/middleware/error.ts
+import { ZodError } from "zod";
+async function errorHandler(c, next) {
+  try {
+    await next();
+  } catch (err) {
+    if (err instanceof ZodError) {
+      return c.json(
+        {
+          error: "\u8BF7\u6C42\u53C2\u6570\u6821\u9A8C\u5931\u8D25",
+          details: err.errors
+        },
+        400
+      );
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 500);
+  }
+}
+var init_error = __esm({
+  "src/server/middleware/error.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/server/index.ts
+import { Hono as Hono6 } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+async function startServer(options = {}) {
+  const { port = 17521, host = "127.0.0.1", openBrowser = true } = options;
+  const app = new Hono6();
+  app.use("*", logger());
+  app.use("*", cors({ origin: [`http://localhost:${port}`, `http://${host}:${port}`] }));
+  app.use("*", errorHandler);
+  app.get("/api/health", (c) => c.json({ status: "ok", version: "0.1.0" }));
+  app.route("/api/hub", hubRoutes);
+  app.route("/api/tools", toolsRoutes);
+  app.route("/api/sync", syncRoutes);
+  app.route("/api/files", filesRoutes);
+  app.route("/api/assets", assetsRoutes);
+  app.use(
+    "/*",
+    serveStatic({
+      root: "./web/dist",
+      // SPA 回退：非静态资源路径（无文件扩展名）回退到 index.html
+      rewriteRequestPath: (path2) => {
+        if (path2.includes(".") && !path2.endsWith(".html")) {
+          return path2;
+        }
+        return "/index.html";
+      }
+    })
+  );
+  await serve({ fetch: app.fetch, port, hostname: host });
+  log.success(`AssetPlex Web UI \u8FD0\u884C\u4E2D: http://${host}:${port}`);
+  log.info("\u6309 Ctrl+C \u505C\u6B62\u670D\u52A1");
+  if (openBrowser) {
+    try {
+      const { default: open } = await import("open");
+      await open(`http://${host}:${port}`);
+    } catch {
+      log.warn("\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u8FF0\u5730\u5740");
+    }
+  }
+  return new Promise((resolve14) => {
+    process.on("SIGINT", () => {
+      log.info("Web UI \u5DF2\u505C\u6B62");
+      resolve14();
+    });
+    process.on("SIGTERM", () => {
+      log.info("Web UI \u5DF2\u505C\u6B62");
+      resolve14();
+    });
+  });
+}
+var init_server = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_hub();
+    init_tools();
+    init_sync();
+    init_files();
+    init_assets2();
+    init_error();
+  }
+});
+
+// src/cli/commands/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  uiCommand: () => uiCommand
+});
+async function uiCommand(opts) {
+  log.info("\u542F\u52A8 AssetPlex Web UI...");
+  await startServer({
+    port: opts.port ?? 17521,
+    host: opts.host ?? "127.0.0.1",
+    openBrowser: !opts.noOpen
+  });
+}
+var init_ui = __esm({
+  "src/cli/commands/ui.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_server();
+    init_logger();
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+init_logger();
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+init_esm_shims();
+init_logger();
+init_paths();
+init_config();
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/cli/templates.ts
+init_esm_shims();
+var PROFILE_TEMPLATE = `# User Profile
+
+> \u6B64\u6587\u4EF6\u7531\u7528\u6237\u624B\u5199\u3002AssetPlex \u4F1A\u81EA\u52A8\u540C\u6B65\u5230\u6240\u6709\u542F\u7528\u7684\u5DE5\u5177
+> (Claude Code \u7684 CLAUDE.md\u3001Codex \u7684 AGENTS.md\u3001TRAE CN \u7684 memory/user_profile.md \u7B49)
+
+## \u6C9F\u901A\u504F\u597D
+- \u8BED\u8A00\uFF1A\u4E2D\u6587
+- \u98CE\u683C\uFF1A\u5B9E\u7528\u3001\u5E72\u8D27\u3001\u53EF\u6536\u85CF
+
+## \u6280\u672F\u6808
+- \u4E3B\u8981\uFF1ATypeScript, React, Node.js
+- \u8F85\u52A9\uFF1APython, SQL
+
+## \u80CC\u666F
+- (\u586B\u5199\u4F60\u7684\u804C\u4E1A\u80CC\u666F)
+- (\u586B\u5199\u4F60\u7684\u8BA4\u8BC1\u6216\u4E13\u4E1A\u8EAB\u4EFD)
+
+## \u5DE5\u4F5C\u4E60\u60EF
+- \u64CD\u4F5C\u7CFB\u7EDF\uFF1A(Windows / macOS / Linux)
+- \u7F16\u8F91\u5668\uFF1A(Trae / VS Code / Cursor / \u5176\u4ED6)
+- \u7EC8\u7AEF\uFF1A(PowerShell / zsh / bash)
+`;
+var COMMUNICATION_STYLE_TEMPLATE = `# Communication Style
+
+## \u8F93\u51FA\u683C\u5F0F
+- \u4F18\u5148\u4F7F\u7528 Markdown
+- \u4EE3\u7801\u5757\u5FC5\u987B\u6709\u8BED\u8A00\u6807\u7B7E
+- \u6587\u4EF6\u8DEF\u5F84\u7528\u53CD\u5F15\u53F7\u5305\u88F9\uFF1A\`src/index.ts\`
+
+## \u98CE\u683C
+- \u76F4\u63A5\u3001\u7B80\u6D01\uFF0C\u4E0D\u7ED5\u5F2F
+- \u4E2D\u6587\u56DE\u7B54\uFF0C\u4EE3\u7801\u6CE8\u91CA\u4E5F\u7528\u4E2D\u6587
+- \u590D\u6742\u95EE\u9898\u5206\u6B65\u9AA4\u8BF4\u660E
+- \u4F18\u5148\u7ED9\u53EF\u6267\u884C\u65B9\u6848\uFF0C\u518D\u8865\u5145\u80CC\u666F
+
+## \u7981\u6B62
+- \u4E0D\u8981\u7528 emoji\uFF08\u9664\u975E\u660E\u786E\u8981\u6C42\uFF09
+- \u4E0D\u8981\u5728\u6BCF\u6BB5\u8BDD\u5F00\u5934\u8BF4"\u597D\u7684"\u3001"\u660E\u767D\u4E86"
+- \u4E0D\u8981\u91CD\u590D\u7528\u6237\u7684\u95EE\u9898
+`;
+var TECH_STACK_TEMPLATE = `# Tech Stack
+
+## \u4E3B\u8BED\u8A00
+- TypeScript (Node.js 18+)
+- Python 3.11+
+
+## \u524D\u7AEF
+- React 18+
+- Vite
+- Tailwind CSS
+
+## \u540E\u7AEF
+- Node.js + Express / Fastify
+- Python + FastAPI
+
+## \u6570\u636E\u5E93
+- PostgreSQL
+- Redis
+
+## DevOps
+- Docker
+- GitHub Actions
+
+## AI / LLM
+- OpenAI API
+- Anthropic Claude API
+- Volcano Engine (\u706B\u5C71\u5F15\u64CE)
+`;
+var CODING_STYLE_TEMPLATE = `# Coding Style
+
+## TypeScript
+- \u4E25\u683C\u6A21\u5F0F\uFF1A\`strict: true\`
+- \u4F18\u5148\u7528 \`const\` \u800C\u975E \`let\`
+- \u7981\u6B62 \`any\`\uFF0C\u5FC5\u8981\u65F6\u7528 \`unknown\` + \u7C7B\u578B\u5B88\u536B
+- \u7528 interface \u800C\u975E type \u63CF\u8FF0\u5BF9\u8C61\u5F62\u72B6
+- \u51FD\u6570\u4F18\u5148\u7528\u7BAD\u5934\u51FD\u6570
+
+## \u547D\u540D\u7EA6\u5B9A
+- \u53D8\u91CF\uFF1AcamelCase
+- \u7C7B\u578B/\u63A5\u53E3\uFF1APascalCase
+- \u5E38\u91CF\uFF1AUPPER_SNAKE_CASE
+- \u6587\u4EF6\u540D\uFF1Akebab-case
+
+## \u6CE8\u91CA
+- \u53EA\u5728"\u4E3A\u4EC0\u4E48"\u975E\u663E\u7136\u65F6\u5199\u6CE8\u91CA
+- \u4E0D\u5199"\u505A\u4EC0\u4E48"\u6CE8\u91CA\uFF08\u4EE3\u7801\u5E94\u81EA\u89E3\u91CA\uFF09
+- \u590D\u6742\u903B\u8F91\u7528\u5757\u6CE8\u91CA\uFF0C\u7B80\u5355\u6280\u5DE7\u7528\u884C\u6CE8\u91CA
+
+## \u6D4B\u8BD5
+- \u6D4B\u8BD5\u6587\u4EF6\u4E0E\u6E90\u6587\u4EF6\u540C\u76EE\u5F55\uFF1A\`foo.ts\` \u2192 \`foo.test.ts\`
+- \u7528 Vitest
+- \u4E00\u4E2A\u6D4B\u8BD5\u53EA\u6D4B\u4E00\u4EF6\u4E8B
+`;
+var GIT_WORKFLOW_TEMPLATE = `# Git Workflow
+
+## \u63D0\u4EA4\u89C4\u8303
+- \u7528 Conventional Commits: \`feat: ...\`, \`fix: ...\`, \`docs: ...\`, \`refactor: ...\`
+- \u63D0\u4EA4\u6D88\u606F\u7528\u82F1\u6587\uFF0C\u6B63\u6587\u53EF\u4E2D\u6587
+- \u5355\u6B21\u63D0\u4EA4\u4E0D\u8981\u8D85\u8FC7 200 \u884C diff
+
+## \u5206\u652F
+- main / master\uFF1A\u53D7\u4FDD\u62A4\uFF0C\u4E0D\u76F4\u63A5 push
+- feature/<name>\uFF1A\u65B0\u529F\u80FD
+- fix/<name>\uFF1Abug \u4FEE\u590D
+- chore/<name>\uFF1A\u6742\u9879
+
+## PR
+- \u6807\u9898\u7528\u82F1\u6587\uFF0C\u63CF\u8FF0\u53EF\u4E2D\u6587
+- \u5FC5\u987B\u5305\u542B "What" \u548C "Why"
+- \u4E0D\u8D85\u8FC7 500 \u884C diff\uFF08\u9664\u975E\u91CD\u6784\uFF09
+`;
+var ENV_TEMPLATE = `# Environment
+
+## \u7CFB\u7EDF
+- OS: ${process.platform}
+- Shell: ${process.env.SHELL ?? process.env.COMSPEC ?? "unknown"}
+- Home: ${process.env.HOME ?? process.env.USERPROFILE ?? "unknown"}
+
+## \u8FD0\u884C\u65F6
+- Node.js: ${process.version}
+- AssetPlex \u7248\u672C: 0.1.0
+`;
+var HUB_README_TEMPLATE = `# AssetPlex \u2014 \u4E2A\u4EBA AI \u5DE5\u5177\u914D\u7F6E\u4E2D\u5FC3
+
+\u6B64\u76EE\u5F55\u7531 [AssetPlex](https://github.com/wynter-cai/assetplex) \u7BA1\u7406\u3002
+\u4FEE\u6539\u4EFB\u610F\u6587\u4EF6\u540E\uFF0C\u8FD0\u884C \`assetplex sync\` \u540C\u6B65\u5230\u6240\u6709\u542F\u7528\u7684\u5DE5\u5177\u3002
+
+## \u76EE\u5F55\u7ED3\u6784
+- \`identity/\` \u2014 \u4F60\u7684\u4E2A\u4EBA\u8EAB\u4EFD\u753B\u50CF\uFF08\u624B\u5199 + AI \u81EA\u52A8\u7EF4\u62A4\uFF09
+- \`skills/\` \u2014 \u8DE8\u5DE5\u5177 Skills \u5E93
+- \`rules/\` \u2014 \u901A\u7528\u89C4\u5219
+- \`preferences/\` \u2014 \u4E2A\u4EBA\u504F\u597D\uFF08\u7F16\u7801\u98CE\u683C\u3001Git \u5DE5\u4F5C\u6D41\u7B49\uFF09
+- \`mcp/\` \u2014 MCP \u670D\u52A1\u5668\u96C6\u4E2D\u914D\u7F6E
+- \`commands/\` \u2014 \u81EA\u5B9A\u4E49 slash commands
+- \`agents/\` \u2014 \u5B50\u4EE3\u7406\u5B9A\u4E49
+- \`hub.toml\` \u2014 Hub \u4E3B\u914D\u7F6E
+
+## \u5E38\u7528\u547D\u4EE4
+\`\`\`bash
+assetplex sync              # \u540C\u6B65\u5230\u6240\u6709\u5DE5\u5177
+assetplex sync --dry-run    # \u9884\u89C8\u53D8\u66F4
+assetplex doctor            # \u4F53\u68C0
+assetplex profile learn     # \u8BA9 AI \u5B66\u4E60\u6700\u8FD1\u884C\u4E3A
+assetplex skill search <q>  # \u641C\u7D22\u793E\u533A skills
+\`\`\`
+`;
+
+// src/cli/commands/init.ts
+var HUB_DIRECTORIES = [
+  "identity",
+  "skills",
+  "rules/always",
+  "rules/by-glob",
+  "rules/by-project",
+  "preferences",
+  "mcp",
+  "commands",
+  "agents",
+  ".backups"
+];
+var HUB_INITIAL_FILES = [
+  {
+    path: ["hub.toml"],
+    content: generateDefaultConfigToml(),
+    overwrite: false
+  },
+  {
+    path: ["README.md"],
+    content: HUB_README_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["identity", "profile.md"],
+    content: PROFILE_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["identity", "profile.auto.md"],
+    content: [
+      "<!-- AUTO-GENERATED by assetplex profile learn. Do not edit manually. -->",
+      "# Auto-Learned Profile",
+      "",
+      "> \u6B64\u6587\u4EF6\u7531 `assetplex profile learn` \u547D\u4EE4\u7EF4\u62A4\uFF0C\u8BB0\u5F55 AI \u4ECE\u4F60\u7684\u884C\u4E3A\u4E2D\u5B66\u4E60\u5230\u7684\u4E8B\u5B9E\u3002",
+      "> \u4E0D\u8981\u624B\u52A8\u7F16\u8F91\u6B64\u6587\u4EF6\u3002\u8FD0\u884C `assetplex profile learn --dry-run` \u9884\u89C8\u5C06\u8981\u5199\u5165\u7684\u4E8B\u5B9E\u3002",
+      "",
+      "## \u6700\u8FD1\u5B66\u4E60\u5230\u7684\u4E8B\u5B9E",
+      "<!-- (\u5C1A\u65E0\u6570\u636E\uFF0C\u8FD0\u884C assetplex profile learn \u5B66\u4E60) -->",
+      "",
+      "## \u5E38\u7528\u5DE5\u4F5C\u6D41",
+      "<!-- (\u5C1A\u65E0\u6570\u636E) -->",
+      "",
+      "## \u9519\u8BEF\u6559\u8BAD\uFF08Lessons\uFF09",
+      "<!-- (\u5C1A\u65E0\u6570\u636E) -->",
+      ""
+    ].join("\n"),
+    overwrite: false
+  },
+  {
+    path: ["identity", "communication-style.md"],
+    content: COMMUNICATION_STYLE_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["identity", "tech-stack.md"],
+    content: TECH_STACK_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["identity", "env.md"],
+    content: ENV_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["preferences", "coding-style.md"],
+    content: CODING_STYLE_TEMPLATE,
+    overwrite: false
+  },
+  {
+    path: ["preferences", "git-workflow.md"],
+    content: GIT_WORKFLOW_TEMPLATE,
+    overwrite: false
+  },
+  // 初始规则文件
+  {
+    path: ["rules", "always", "global.md"],
+    content: [
+      "# Global Rules",
+      "",
+      "> \u6B64\u89C4\u5219\u6587\u4EF6\u4F1A\u540C\u6B65\u5230\u6240\u6709\u5DE5\u5177\u7684 rules/always/\uFF0C\u5BF9\u6240\u6709 AI \u52A9\u624B\u59CB\u7EC8\u751F\u6548\u3002",
+      "",
+      "## \u901A\u7528\u89C4\u5219",
+      "- \u4FEE\u6539\u4EE3\u7801\u524D\u5148\u9605\u8BFB\u76F8\u5173\u6587\u4EF6",
+      "- \u4E0D\u8981\u505A\u672A\u88AB\u8BF7\u6C42\u7684\u6539\u52A8",
+      "- \u4E0D\u8981\u6DFB\u52A0\u672A\u88AB\u8BF7\u6C42\u7684\u6CE8\u91CA\u3001\u6587\u6863\u6216\u7C7B\u578B\u6CE8\u89E3",
+      "- \u4F18\u5148\u7F16\u8F91\u73B0\u6709\u6587\u4EF6\uFF0C\u800C\u975E\u521B\u5EFA\u65B0\u6587\u4EF6",
+      "- \u7B80\u5355\u4F18\u5148\uFF0C\u907F\u514D\u8FC7\u5EA6\u8BBE\u8BA1",
+      ""
+    ].join("\n"),
+    overwrite: false
+  },
+  // MCP 单源配置
+  {
+    path: ["mcp", "mcp.sources.json"],
+    content: [
+      "{",
+      '  "$schema": "https://json-schema.org/draft-07/schema",',
+      '  "mcpServers": {',
+      "    // \u5728\u6B64\u6DFB\u52A0 MCP \u670D\u52A1\u5668\u914D\u7F6E\uFF0Cassetplex \u4F1A\u81EA\u52A8\u540C\u6B65\u5230\u5404\u5DE5\u5177\uFF1A",
+      "    // - Claude Code \u7684 ~/.claude.json",
+      "    // - Codex \u7684 ~/.codex/config.toml [mcp_servers.x]",
+      "    // - TRAE CN \u7684 ~/.trae-cn/mcp.json",
+      "    // - WorkBuddy \u7684 ~/.workbuddy/.mcp.json",
+      "  }",
+      "}",
+      ""
+    ].join("\n"),
+    overwrite: false
+  }
+];
+async function initCommand(options = {}) {
+  const hubRoot = getHubRoot();
+  log.info(`\u6B63\u5728\u521D\u59CB\u5316 AssetPlex...`);
+  log.info(`Hub \u6839\u76EE\u5F55: ${hubRoot}`);
+  if (existsSync2(hubRoot) && !options.force) {
+    const hubTomlPath = hubPath("hub.toml");
+    if (existsSync2(hubTomlPath)) {
+      log.warn(`Hub \u5DF2\u5B58\u5728\uFF1A${hubRoot}`);
+      log.warn(`\u5982\u9700\u91CD\u65B0\u521D\u59CB\u5316\uFF0C\u8BF7\u4F7F\u7528 --force \u9009\u9879`);
+      return;
+    }
+  }
+  log.info("\u521B\u5EFA\u76EE\u5F55\u7ED3\u6784...");
+  for (const dir of HUB_DIRECTORIES) {
+    const dirPath = resolve3(hubRoot, dir);
+    mkdirSync2(dirPath, { recursive: true });
+    log.debug(`  \u521B\u5EFA\u76EE\u5F55: ${dir}`);
+  }
+  log.info("\u5199\u5165\u6A21\u677F\u6587\u4EF6...");
+  let createdCount = 0;
+  let skippedCount = 0;
+  for (const file of HUB_INITIAL_FILES) {
+    const filePath = resolve3(hubRoot, ...file.path);
+    if (existsSync2(filePath) && !file.overwrite && !options.force) {
+      log.debug(`  \u8DF3\u8FC7\u5DF2\u5B58\u5728: ${file.path.join("/")}`);
+      skippedCount++;
+      continue;
+    }
+    writeFileSync2(filePath, file.content, "utf-8");
+    log.debug(`  \u5199\u5165\u6587\u4EF6: ${file.path.join("/")}`);
+    createdCount++;
+  }
+  log.success(`AssetPlex \u521D\u59CB\u5316\u5B8C\u6210\uFF01`);
+  log.info(`  \u6839\u76EE\u5F55: ${hubRoot}`);
+  log.info(`  \u521B\u5EFA\u6587\u4EF6: ${createdCount} \u4E2A`);
+  if (skippedCount > 0) {
+    log.info(`  \u8DF3\u8FC7\u5DF2\u5B58\u5728: ${skippedCount} \u4E2A`);
+  }
+  log.info("");
+  log.info("\u4E0B\u4E00\u6B65\uFF1A");
+  log.info("  1. \u7F16\u8F91 ~/.assetplex/identity/profile.md \u586B\u5199\u4F60\u7684\u4E2A\u4EBA\u753B\u50CF");
+  log.info("  2. \u8FD0\u884C `assetplex doctor` \u68C0\u6D4B\u5404 AI \u5DE5\u5177\u5B89\u88C5\u72B6\u6001");
+  log.info("  3. \u8FD0\u884C `assetplex sync` \u540C\u6B65\u5230\u6240\u6709\u5DE5\u5177");
+  log.info("  4. \u8FD0\u884C `assetplex --help` \u67E5\u770B\u6240\u6709\u547D\u4EE4");
+}
+
+// src/cli/commands/doctor.ts
+init_esm_shims();
+init_logger();
+init_paths();
+init_registry();
+import { existsSync as existsSync11 } from "fs";
+async function doctorCommand(options = {}) {
+  registerBuiltinAdapters();
+  const hubRoot = getHubRoot();
+  const hubTomlExists = existsSync11(hubPath("hub.toml"));
+  const result = {
+    hubRoot,
+    hubInitialized: hubTomlExists,
+    hubTomlExists,
+    tools: [],
+    issues: []
+  };
+  if (!hubTomlExists) {
+    result.issues.push("Hub \u672A\u521D\u59CB\u5316\u3002\u8BF7\u5148\u8FD0\u884C `assetplex init`\u3002");
+  }
+  const adapters = options.tool ? getAllAdapters().filter((a) => a.name === options.tool) : getAllAdapters();
+  for (const adapter of adapters) {
+    try {
+      const status = await adapter.detect();
+      result.tools.push(status);
+    } catch (err) {
+      result.tools.push({
+        name: adapter.name,
+        installed: false,
+        configDirExists: false,
+        configDir: "",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printDoctorReport(result);
+}
+function printDoctorReport(result) {
+  log.info("AssetPlex \u4F53\u68C0\u62A5\u544A");
+  log.info("=".repeat(60));
+  log.info(`Hub \u6839\u76EE\u5F55: ${result.hubRoot}`);
+  log.info(`Hub \u5DF2\u521D\u59CB\u5316: ${result.hubInitialized ? "\u2713" : "\u2717"}`);
+  log.info("");
+  if (result.issues.length > 0) {
+    log.warn("Hub \u95EE\u9898\uFF1A");
+    for (const issue of result.issues) {
+      log.warn(`  - ${issue}`);
+    }
+    log.info("");
+  }
+  log.info("\u5DF2\u6CE8\u518C\u5DE5\u5177\u72B6\u6001\uFF1A");
+  log.info("-".repeat(60));
+  for (const tool of result.tools) {
+    const status = tool.installed ? "\u2713 \u5DF2\u5B89\u88C5" : "\u2717 \u672A\u5B89\u88C5";
+    const version = tool.version ? ` v${tool.version}` : "";
+    const dir = tool.configDir || "(\u65E0)";
+    log.info(`  ${tool.name.padEnd(15)} ${status}${version}`);
+    log.info(`  ${" ".repeat(15)} \u914D\u7F6E\u76EE\u5F55: ${dir}`);
+    if (tool.error) {
+      log.warn(`  ${" ".repeat(15)} \u5907\u6CE8: ${tool.error}`);
+    }
+    log.info("");
+  }
+  const installedCount = result.tools.filter((t) => t.installed).length;
+  const totalCount = result.tools.length;
+  log.info("-".repeat(60));
+  log.info(`\u603B\u7ED3: ${installedCount}/${totalCount} \u4E2A\u5DE5\u5177\u5DF2\u5B89\u88C5`);
+  if (installedCount === 0) {
+    log.warn("");
+    log.warn("\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55 AI \u5DE5\u5177\uFF0C\u8BF7\u5148\u5B89\u88C5\u81F3\u5C11\u4E00\u4E2A\u5DE5\u5177\u3002");
+  } else if (!result.hubInitialized) {
+    log.warn("");
+    log.warn("Hub \u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u8FD0\u884C: assetplex init");
+  } else {
+    log.success("");
+    log.success("\u4F53\u68C0\u5B8C\u6210\uFF0C\u53EF\u8FD0\u884C `assetplex sync` \u540C\u6B65\u914D\u7F6E");
+  }
+}
+
+// src/cli/commands/sync.ts
+init_esm_shims();
+init_logger();
+init_paths();
+init_config();
+init_registry();
+init_sync_engine();
+import { existsSync as existsSync14 } from "fs";
+async function syncCommand(options = {}) {
+  if (options.watch) {
+    log.warn("--watch \u5C06\u5728 Stage 2.5 \u5B9E\u73B0");
+    return;
+  }
+  const hubRoot = getHubRoot();
+  const hubTomlPath = hubPath("hub.toml");
+  if (!existsSync14(hubTomlPath)) {
+    log.error(`Hub \u672A\u521D\u59CB\u5316\uFF1A${hubTomlPath} \u4E0D\u5B58\u5728`);
+    log.error("\u8BF7\u5148\u8FD0\u884C `assetplex init`");
+    process.exit(1);
+  }
+  let hubConfig;
+  try {
+    hubConfig = loadHubConfig(resolveHubConfigPath());
+  } catch (err) {
+    log.error(`\u52A0\u8F7D hub.toml \u5931\u8D25: ${err.message}`);
+    process.exit(1);
+  }
+  registerBuiltinAdapters();
+  const adapters = getAllAdapters();
+  log.info(`Hub \u6839\u76EE\u5F55: ${hubRoot}`);
+  log.info(`\u5DF2\u6CE8\u518C\u9002\u914D\u5668: ${adapters.length} \u4E2A`);
+  if (options.tool) {
+    log.info(`\u6307\u5B9A\u5DE5\u5177: ${options.tool}`);
+  }
+  if (options.dryRun) {
+    log.info("\u6A21\u5F0F: --dry-run\uFF08\u4EC5\u9884\u89C8\u4E0D\u5199\u5165\uFF09");
+  }
+  const engine = new SyncEngine(hubConfig, adapters);
+  if (options.dryRun) {
+    const plans = await engine.plan(options);
+    if (options.json) {
+      console.log(JSON.stringify(plans, null, 2));
+      return;
+    }
+    log.info("");
+    log.info("\u540C\u6B65\u8BA1\u5212\uFF08dry-run\uFF09");
+    log.info("=".repeat(60));
+    printSyncPlan(plans);
+    return;
+  }
+  const results = await engine.run(options);
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  printSyncResult(results);
+  const failedTools = results.filter((r) => !r.success);
+  if (failedTools.length > 0) {
+    log.warn("");
+    log.warn(`\u6709 ${failedTools.length} \u4E2A\u5DE5\u5177\u540C\u6B65\u5931\u8D25`);
+    process.exit(1);
+  } else {
+    log.success("");
+    log.success("\u540C\u6B65\u5B8C\u6210\uFF01");
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("assetplex").description("One identity, every AI agent \u2014 built for the China stack and beyond.").version("0.1.0").option("-v, --verbose", "\u542F\u7528\u8BE6\u7EC6\u65E5\u5FD7\u8F93\u51FA", () => setLogLevel("debug")).option("-q, --quiet", "\u9759\u9ED8\u6A21\u5F0F\uFF08\u4EC5\u8F93\u51FA\u9519\u8BEF\uFF09", () => setLogLevel("error"));
+program.command("init").description("\u521D\u59CB\u5316 ~/.assetplex/ \u76EE\u5F55\u4E0E\u6A21\u677F\u6587\u4EF6").option("-f, --force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u5B58\u5728\u6587\u4EF6").option("--import-existing", "\u4ECE\u73B0\u6709\u5404\u5DE5\u5177\u53CD\u5411\u5BFC\u5165\u914D\u7F6E").option("-y, --yes", "\u8DF3\u8FC7\u4EA4\u4E92\u63D0\u793A\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C").action(async (opts) => {
+  try {
+    await initCommand(opts);
+  } catch (err) {
+    log.error("\u521D\u59CB\u5316\u5931\u8D25:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("doctor").description("\u4F53\u68C0\uFF1A\u68C0\u6D4B\u5404 AI \u5DE5\u5177\u5B89\u88C5\u72B6\u6001\u3001Hub \u5B8C\u6574\u6027").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u68C0\u6D4B\u5230\u7684\u95EE\u9898").option("--json", "JSON \u8F93\u51FA\uFF08\u811A\u672C\u53CB\u597D\uFF09").option("--tool <name>", "\u4EC5\u68C0\u67E5\u6307\u5B9A\u5DE5\u5177").action(async (opts) => {
+  try {
+    await doctorCommand(opts);
+  } catch (err) {
+    log.error("\u4F53\u68C0\u5931\u8D25:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("sync").description("\u540C\u6B65 Hub \u5185\u5BB9\u5230\u6240\u6709\u542F\u7528\u7684\u5DE5\u5177").option("--tool <name>", "\u4EC5\u540C\u6B65\u5230\u6307\u5B9A\u5DE5\u5177").option("--watch", "\u76D1\u542C\u6587\u4EF6\u53D8\u5316\u81EA\u52A8\u540C\u6B65\uFF08Stage 2.5 \u5B9E\u73B0\uFF09").option("--dry-run", "\u9884\u89C8\u53D8\u66F4\u4E0D\u5199\u5165").option("--json", "JSON \u8F93\u51FA").action(async (opts) => {
+  try {
+    await syncCommand(opts);
+  } catch (err) {
+    log.error("\u540C\u6B65\u5931\u8D25:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("ui").description("\u542F\u52A8 Web UI \u53EF\u89C6\u5316\u7BA1\u7406\u754C\u9762").option("-p, --port <port>", "\u7AEF\u53E3\u53F7", "17521").option("-H, --host <host>", "\u76D1\u542C\u5730\u5740", "127.0.0.1").option("--no-open", "\u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668").action(async (opts) => {
+  try {
+    const { uiCommand: uiCommand2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+    await uiCommand2({
+      port: parseInt(opts.port, 10),
+      host: opts.host,
+      noOpen: !opts.open
+    });
+  } catch (err) {
+    log.error("\u542F\u52A8 UI \u5931\u8D25:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.parseAsync(process.argv).catch((err) => {
+  log.error("\u6267\u884C\u5931\u8D25:", err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map