@lark-apaas/fullstack-cli 1.1.6-alpha.1 → 1.1.6-alpha.11

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -438,8 +438,7 @@ var syncCommand = {
 // src/commands/action-plugin/utils.ts
 import fs3 from "fs";
 import path3 from "path";
-import { spawnSync as spawnSync2 } from "child_process";
-var CONFIG_FILE_NAME = ".capabilityrc.json";
+import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
   if (!match) {
@@ -455,36 +454,44 @@ function parsePluginName(input) {
 function getProjectRoot() {
   return process.cwd();
 }
-function getConfigPath() {
-  return path3.join(getProjectRoot(), CONFIG_FILE_NAME);
+function getPackageJsonPath() {
+  return path3.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
   return path3.join(getProjectRoot(), "node_modules", pluginName);
 }
-function readConfig() {
-  const configPath = getConfigPath();
-  if (!fs3.existsSync(configPath)) {
-    return { plugins: {} };
+function readPackageJson() {
+  const pkgPath = getPackageJsonPath();
+  if (!fs3.existsSync(pkgPath)) {
+    throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs3.readFileSync(configPath, "utf-8");
+    const content = fs3.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
-    console.warn(`[action-plugin] Warning: Failed to parse ${CONFIG_FILE_NAME}, using empty config`);
-    return { plugins: {} };
+    throw new Error("Failed to parse package.json");
   }
 }
-function writeConfig(config) {
-  const configPath = getConfigPath();
-  fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+function writePackageJson(pkg2) {
+  const pkgPath = getPackageJsonPath();
+  fs3.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+}
+function readActionPlugins() {
+  const pkg2 = readPackageJson();
+  return pkg2.actionPlugins || {};
+}
+function writeActionPlugins(plugins) {
+  const pkg2 = readPackageJson();
+  pkg2.actionPlugins = plugins;
+  writePackageJson(pkg2);
 }
 function isPluginInstalled(pluginName) {
-  const config = readConfig();
-  return pluginName in config.plugins;
+  const plugins = readActionPlugins();
+  return pluginName in plugins;
 }
-function getInstalledPluginInfo(pluginName) {
-  const config = readConfig();
-  return config.plugins[pluginName] || null;
+function getInstalledPluginVersion(pluginName) {
+  const plugins = readActionPlugins();
+  return plugins[pluginName] || null;
 }
 function npmInstall(tgzPath) {
   console.log(`[action-plugin] Running npm install ${tgzPath}...`);
@@ -499,19 +506,6 @@ function npmInstall(tgzPath) {
     throw new Error(`npm install failed with exit code ${result.status}`);
   }
 }
-function npmUninstall(pluginName) {
-  console.log(`[action-plugin] Running npm uninstall ${pluginName}...`);
-  const result = spawnSync2("npm", ["uninstall", pluginName], {
-    cwd: getProjectRoot(),
-    stdio: "inherit"
-  });
-  if (result.error) {
-    throw new Error(`npm uninstall failed: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error(`npm uninstall failed with exit code ${result.status}`);
-  }
-}
 function getPackageVersion(pluginName) {
   const pkgJsonPath = path3.join(getPluginPath(pluginName), "package.json");
   if (!fs3.existsSync(pkgJsonPath)) {
@@ -525,6 +519,90 @@ function getPackageVersion(pluginName) {
     return null;
   }
 }
+function readPluginPackageJson(pluginPath) {
+  const pkgJsonPath = path3.join(pluginPath, "package.json");
+  if (!fs3.existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractTgzToNodeModules(tgzPath, pluginName) {
+  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
+  const targetDir = path3.join(nodeModulesPath, pluginName);
+  const scopeDir = path3.dirname(targetDir);
+  if (!fs3.existsSync(scopeDir)) {
+    fs3.mkdirSync(scopeDir, { recursive: true });
+  }
+  if (fs3.existsSync(targetDir)) {
+    fs3.rmSync(targetDir, { recursive: true });
+  }
+  const tempDir = path3.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs3.existsSync(tempDir)) {
+    fs3.rmSync(tempDir, { recursive: true });
+  }
+  fs3.mkdirSync(tempDir, { recursive: true });
+  try {
+    execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+    const extractedDir = path3.join(tempDir, "package");
+    if (fs3.existsSync(extractedDir)) {
+      fs3.renameSync(extractedDir, targetDir);
+    } else {
+      const files = fs3.readdirSync(tempDir);
+      if (files.length === 1) {
+        fs3.renameSync(path3.join(tempDir, files[0]), targetDir);
+      } else {
+        throw new Error("Unexpected tgz structure");
+      }
+    }
+    return targetDir;
+  } finally {
+    if (fs3.existsSync(tempDir)) {
+      fs3.rmSync(tempDir, { recursive: true });
+    }
+  }
+}
+function checkMissingPeerDeps(peerDeps) {
+  if (!peerDeps || Object.keys(peerDeps).length === 0) {
+    return [];
+  }
+  const missing = [];
+  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
+  for (const [depName, _version] of Object.entries(peerDeps)) {
+    const depPath = path3.join(nodeModulesPath, depName);
+    if (!fs3.existsSync(depPath)) {
+      missing.push(depName);
+    }
+  }
+  return missing;
+}
+function installMissingDeps(deps) {
+  if (deps.length === 0) {
+    return;
+  }
+  console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
+  const result = spawnSync2("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+    cwd: getProjectRoot(),
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw new Error(`npm install failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`npm install failed with exit code ${result.status}`);
+  }
+}
+function removePluginDirectory(pluginName) {
+  const pluginPath = getPluginPath(pluginName);
+  if (fs3.existsSync(pluginPath)) {
+    fs3.rmSync(pluginPath, { recursive: true });
+    console.log(`[action-plugin] Removed ${pluginName}`);
+  }
+}
 
 // src/commands/action-plugin/api-client.ts
 import { HttpClient as HttpClient2 } from "@lark-apaas/http-client";
@@ -659,35 +737,106 @@ function cleanupTempFile(tgzPath) {
   }
 }
 
+// src/commands/action-plugin/init.handler.ts
+async function installOneForInit(name, version) {
+  let tgzPath;
+  try {
+    const installedVersion = getPackageVersion(name);
+    if (installedVersion === version) {
+      return { name, version, success: true, skipped: true };
+    }
+    console.log(`[action-plugin] Installing ${name}@${version}...`);
+    const downloadResult = await downloadPlugin(name, version);
+    tgzPath = downloadResult.tgzPath;
+    const pluginDir = extractTgzToNodeModules(tgzPath, name);
+    const pluginPkg = readPluginPackageJson(pluginDir);
+    if (pluginPkg?.peerDependencies) {
+      const missingDeps = checkMissingPeerDeps(pluginPkg.peerDependencies);
+      if (missingDeps.length > 0) {
+        installMissingDeps(missingDeps);
+      }
+    }
+    console.log(`[action-plugin] \u2713 Installed ${name}@${version}`);
+    return { name, version, success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[action-plugin] \u2717 Failed to install ${name}: ${message}`);
+    return { name, version, success: false, error: message };
+  } finally {
+    if (tgzPath) {
+      cleanupTempFile(tgzPath);
+    }
+  }
+}
+async function init() {
+  console.log("[action-plugin] Reading plugins from package.json...");
+  const plugins = readActionPlugins();
+  const entries = Object.entries(plugins);
+  if (entries.length === 0) {
+    console.log("[action-plugin] No plugins found in package.json");
+    return;
+  }
+  console.log(`[action-plugin] Found ${entries.length} plugin(s) to install
+`);
+  const results = [];
+  for (const [name, version] of entries) {
+    const result = await installOneForInit(name, version);
+    results.push(result);
+  }
+  console.log("");
+  const successful = results.filter((r) => r.success && !r.skipped);
+  const skipped = results.filter((r) => r.skipped);
+  const failed = results.filter((r) => !r.success);
+  if (successful.length > 0 || skipped.length > 0) {
+    console.log(
+      `[action-plugin] \u2713 All plugins installed successfully (${successful.length + skipped.length}/${entries.length})`
+    );
+    if (skipped.length > 0) {
+      console.log(`  Skipped (already installed): ${skipped.map((r) => r.name).join(", ")}`);
+    }
+  }
+  if (failed.length > 0) {
+    console.log(`[action-plugin] \u2717 Failed to install ${failed.length} plugin(s): ${failed.map((r) => r.name).join(", ")}`);
+    process.exit(1);
+  }
+}
+
 // src/commands/action-plugin/install.handler.ts
 async function installOne(nameWithVersion) {
   let tgzPath;
   const { name, version: requestedVersion } = parsePluginName(nameWithVersion);
   try {
     console.log(`[action-plugin] Installing ${name}@${requestedVersion}...`);
-    if (isPluginInstalled(name)) {
-      const info = getInstalledPluginInfo(name);
-      if (info) {
-        const latestInfo = await getPluginVersion(name, "latest");
-        const latestVersion = latestInfo.version;
-        if (info.version === latestVersion) {
-          console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${info.version})`);
-          return { name, version: info.version, success: true, skipped: true };
-        }
-        console.log(`[action-plugin] Found newer version: ${latestVersion} (installed: ${info.version})`);
-        console.log(`[action-plugin] Updating to ${latestVersion}...`);
+    const actualVersion = getPackageVersion(name);
+    if (actualVersion && requestedVersion !== "latest") {
+      if (actualVersion === requestedVersion) {
+        console.log(`[action-plugin] Plugin ${name}@${requestedVersion} is already installed`);
+        return { name, version: actualVersion, success: true, skipped: true };
       }
     }
+    if (actualVersion && requestedVersion === "latest") {
+      const latestInfo = await getPluginVersion(name, "latest");
+      if (actualVersion === latestInfo.version) {
+        console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${actualVersion})`);
+        return { name, version: actualVersion, success: true, skipped: true };
+      }
+      console.log(`[action-plugin] Found newer version: ${latestInfo.version} (installed: ${actualVersion})`);
+    }
     const downloadResult = await downloadPlugin(name, requestedVersion);
     tgzPath = downloadResult.tgzPath;
-    npmInstall(tgzPath);
+    console.log(`[action-plugin] Extracting to node_modules...`);
+    const pluginDir = extractTgzToNodeModules(tgzPath, name);
+    const pluginPkg = readPluginPackageJson(pluginDir);
+    if (pluginPkg?.peerDependencies) {
+      const missingDeps = checkMissingPeerDeps(pluginPkg.peerDependencies);
+      if (missingDeps.length > 0) {
+        installMissingDeps(missingDeps);
+      }
+    }
     const installedVersion = getPackageVersion(name) || downloadResult.version;
-    const config = readConfig();
-    config.plugins[name] = {
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeConfig(config);
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully installed ${name}@${installedVersion}`);
     return { name, version: installedVersion, success: true };
   } catch (error) {
@@ -740,23 +889,19 @@ async function updateOne(nameWithVersion) {
       console.error(`[action-plugin] Plugin ${name} is not installed`);
       return { name, success: false, notInstalled: true };
     }
-    const currentInfo = getInstalledPluginInfo(name);
-    const oldVersion = currentInfo?.version || "unknown";
+    const oldVersion = getInstalledPluginVersion(name) || "unknown";
     console.log(`[action-plugin] Current version: ${oldVersion}`);
     const downloadResult = await downloadPlugin(name, "latest");
     tgzPath = downloadResult.tgzPath;
-    if (currentInfo && currentInfo.version === downloadResult.version) {
+    if (oldVersion === downloadResult.version) {
       console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${downloadResult.version})`);
       return { name, oldVersion, newVersion: downloadResult.version, success: true, skipped: true };
     }
     npmInstall(tgzPath);
     const installedVersion = getPackageVersion(name) || downloadResult.version;
-    const config = readConfig();
-    config.plugins[name] = {
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeConfig(config);
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully updated ${name} to ${installedVersion}`);
     return { name, oldVersion, newVersion: installedVersion, success: true };
   } catch (error) {
@@ -812,10 +957,10 @@ async function remove(nameWithVersion) {
       console.error(`[action-plugin] Plugin ${name} is not installed`);
       process.exit(1);
     }
-    npmUninstall(name);
-    const config = readConfig();
-    delete config.plugins[name];
-    writeConfig(config);
+    removePluginDirectory(name);
+    const plugins = readActionPlugins();
+    delete plugins[name];
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully removed ${name}`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -827,25 +972,22 @@ async function remove(nameWithVersion) {
 // src/commands/action-plugin/list.handler.ts
 async function list() {
   try {
-    const config = readConfig();
-    const plugins = Object.entries(config.plugins);
+    const plugins = Object.entries(readActionPlugins());
     if (plugins.length === 0) {
       console.log("[action-plugin] No plugins installed");
       console.log('[action-plugin] Use "action-plugin install <name>" to install a plugin');
       return;
     }
     console.log("[action-plugin] Installed plugins:\n");
-    const nameWidth = Math.max(30, ...plugins.map(([name]) => name.length + 2));
+    const nameWidth = Math.max(40, ...plugins.map(([name]) => name.length + 2));
     const versionWidth = 15;
-    const dateWidth = 25;
     console.log(
-      "  " + "Plugin".padEnd(nameWidth) + "Version".padEnd(versionWidth) + "Installed At"
+      "  " + "Plugin".padEnd(nameWidth) + "Version"
     );
-    console.log("  " + "-".repeat(nameWidth + versionWidth + dateWidth));
-    for (const [name, info] of plugins) {
-      const installedAt = new Date(info.installedAt).toLocaleString();
+    console.log("  " + "-".repeat(nameWidth + versionWidth));
+    for (const [name, version] of plugins) {
       console.log(
-        "  " + name.padEnd(nameWidth) + info.version.padEnd(versionWidth) + installedAt
+        "  " + name.padEnd(nameWidth) + version
       );
     }
     console.log(`
@@ -858,6 +1000,15 @@ async function list() {
 }
 
 // src/commands/action-plugin/index.ts
+var initCommand = {
+  name: "init",
+  description: "Install all plugins from package.json",
+  register(program) {
+    program.command(this.name).description(this.description).action(async () => {
+      await init();
+    });
+  }
+};
 var installCommand = {
   name: "install",
   description: "Install action plugin(s) (default: latest version)",
@@ -901,7 +1052,7 @@ var listCommand = {
 var actionPluginCommandGroup = {
   name: "action-plugin",
   description: "Manage action plugins",
-  commands: [installCommand, updateCommand, removeCommand, listCommand]
+  commands: [initCommand, installCommand, updateCommand, removeCommand, listCommand]
 };
 
 // src/commands/capability/utils.ts
@@ -917,8 +1068,8 @@ function getCapabilitiesDir() {
 function getCapabilityPath(id) {
   return path5.join(getCapabilitiesDir(), `${id}.json`);
 }
-function getPluginManifestPath(pluginID) {
-  return path5.join(getProjectRoot2(), "node_modules", pluginID, "manifest.json");
+function getPluginManifestPath(pluginKey) {
+  return path5.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
   return fs5.existsSync(getCapabilitiesDir());
@@ -950,17 +1101,17 @@ function readAllCapabilities() {
   const ids = listCapabilityIds();
   return ids.map((id) => readCapability(id));
 }
-function readPluginManifest(pluginID) {
-  const manifestPath = getPluginManifestPath(pluginID);
+function readPluginManifest(pluginKey) {
+  const manifestPath = getPluginManifestPath(pluginKey);
   if (!fs5.existsSync(manifestPath)) {
-    throw new Error(`Plugin not installed: ${pluginID} (manifest.json not found)`);
+    throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
     const content = fs5.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
-      throw new Error(`Invalid JSON in plugin manifest: ${pluginID}/manifest.json`);
+      throw new Error(`Invalid JSON in plugin manifest: ${pluginKey}/manifest.json`);
     }
     throw error;
   }
@@ -971,19 +1122,19 @@ function isDynamicSchema(schema) {
 function hasValidParamsSchema(paramsSchema) {
   return paramsSchema !== void 0 && Object.keys(paramsSchema).length > 0;
 }
-async function loadPlugin(pluginID) {
+async function loadPlugin(pluginKey) {
   try {
-    const pluginPackage = (await import(pluginID)).default;
+    const pluginPackage = (await import(pluginKey)).default;
     if (!pluginPackage || typeof pluginPackage.create !== "function") {
-      throw new Error(`Plugin ${pluginID} does not export a valid create function`);
+      throw new Error(`Plugin ${pluginKey} does not export a valid create function`);
     }
     return pluginPackage;
   } catch (error) {
     if (error.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Plugin not installed: ${pluginID}`);
+      throw new Error(`Plugin not installed: ${pluginKey}`);
     }
     throw new Error(
-      `Failed to load plugin ${pluginID}: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to load plugin ${pluginKey}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
@@ -997,16 +1148,16 @@ async function zodToJsonSchema(zodSchema) {
 }
 async function hydrateCapability(capability) {
   try {
-    const manifest = readPluginManifest(capability.pluginID);
+    const manifest = readPluginManifest(capability.pluginKey);
     if (!manifest.actions || manifest.actions.length === 0) {
-      throw new Error(`Plugin ${capability.pluginID} has no actions defined`);
+      throw new Error(`Plugin ${capability.pluginKey} has no actions defined`);
     }
     const hasDynamicSchema = manifest.actions.some(
       (action) => isDynamicSchema(action.inputSchema) || isDynamicSchema(action.outputSchema)
     );
     let pluginInstance = null;
     if (hasDynamicSchema) {
-      const plugin = await loadPlugin(capability.pluginID);
+      const plugin = await loadPlugin(capability.pluginKey);
       pluginInstance = plugin.create(capability.formValue || {});
     }
     const actions = [];
@@ -1049,7 +1200,7 @@ async function hydrateCapability(capability) {
     }
     return {
       id: capability.id,
-      pluginID: capability.pluginID,
+      pluginKey: capability.pluginKey,
       pluginVersion: capability.pluginVersion,
       name: capability.name,
       description: capability.description,
@@ -1120,126 +1271,339 @@ async function listAll(summary) {
   }
 }
 
-// src/commands/capability/migration.handler.ts
-import fs12 from "fs";
-
-// src/commands/capability/migration/mapping.ts
-var DEFAULT_MAPPING = {
-  // 飞书相关
-  "official_feishu/create_group": "@official_feishu/create_group",
-  "official_feishu/send_message": "@official_feishu/send_message",
-  "official_feishu/send_card": "@official_feishu/send_card",
-  // AI 相关
-  "ai/generate_text": "@official_ai/text_generation",
-  "ai/chat_completion": "@official_ai/chat_completion"
-  // 其他
-  // 根据实际需要添加更多映射
-};
-function mergeMapping(customMapping) {
-  if (!customMapping) {
-    return { ...DEFAULT_MAPPING };
+// src/commands/capability/index.ts
+var listCommand2 = {
+  name: "list",
+  description: "List capability configurations",
+  aliases: ["ls"],
+  register(program) {
+    program.command(this.name).alias("ls").description(this.description).option("--summary", "Return raw capability config (without hydration)").option("--id <id>", "Specify capability ID").action(async (options) => {
+      await list2(options);
+    });
   }
-  return { ...DEFAULT_MAPPING, ...customMapping };
+};
+var capabilityCommandGroup = {
+  name: "capability",
+  description: "Manage capability configurations",
+  commands: [listCommand2]
+};
+
+// src/commands/migration/version-manager.ts
+import fs6 from "fs";
+import path6 from "path";
+var PACKAGE_JSON = "package.json";
+var VERSION_FIELD = "migrationVersion";
+function getPackageJsonPath2() {
+  return path6.join(process.cwd(), PACKAGE_JSON);
 }
-function getPluginID(sourceActionID, mapping) {
-  const pluginID = mapping[sourceActionID];
-  if (!pluginID) {
-    throw new Error(
-      `Unknown sourceActionID: "${sourceActionID}". Please provide mapping via --mapping option or add to default mapping.`
-    );
+function getCurrentVersion() {
+  const pkgPath = getPackageJsonPath2();
+  if (!fs6.existsSync(pkgPath)) {
+    throw new Error("package.json not found");
   }
-  return pluginID;
+  const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+  return pkg2[VERSION_FIELD] ?? 0;
+}
+function setCurrentVersion(version) {
+  const pkgPath = getPackageJsonPath2();
+  const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+  pkg2[VERSION_FIELD] = version;
+  fs6.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
-// src/commands/capability/migration/json-migrator/index.ts
+// src/commands/migration/versions/v001_capability/json-migrator/detector.ts
+import fs8 from "fs";
+import path8 from "path";
+
+// src/commands/migration/versions/v001_capability/utils.ts
 import fs7 from "fs";
 import path7 from "path";
+var CAPABILITIES_DIR2 = "server/capabilities";
+function getProjectRoot3() {
+  return process.cwd();
+}
+function getCapabilitiesDir2() {
+  return path7.join(getProjectRoot3(), CAPABILITIES_DIR2);
+}
+function getPluginManifestPath2(pluginKey) {
+  return path7.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+}
 
-// src/commands/capability/migration/json-migrator/detector.ts
-import fs6 from "fs";
-import path6 from "path";
+// src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
-  const capabilitiesDir = getCapabilitiesDir();
-  const oldFilePath = path6.join(capabilitiesDir, "capabilities.json");
-  if (!fs6.existsSync(capabilitiesDir)) {
-    return {
-      needsMigration: false,
-      reason: "capabilities directory does not exist"
-    };
-  }
-  if (!fs6.existsSync(oldFilePath)) {
+  const capabilitiesDir = getCapabilitiesDir2();
+  const oldFilePath = path8.join(capabilitiesDir, "capabilities.json");
+  if (!fs8.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
-      reason: "capabilities.json not found (may already be migrated)"
+      reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs6.readFileSync(oldFilePath, "utf-8");
+    const content = fs8.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) {
-      return {
-        needsMigration: false,
-        reason: "capabilities.json is not array format"
-      };
-    }
-    if (parsed.length === 0) {
-      return {
-        needsMigration: false,
-        reason: "capabilities.json is empty array"
-      };
-    }
-    const firstItem = parsed[0];
-    if (!firstItem.sourceActionID) {
-      return {
-        needsMigration: false,
-        reason: "capabilities.json does not contain old format (missing sourceActionID)"
-      };
-    }
+    const capabilities = Array.isArray(parsed) ? parsed : [];
     return {
       needsMigration: true,
-      oldCapabilities: parsed,
+      oldCapabilities: capabilities,
       oldFilePath
     };
   } catch (error) {
-    if (error instanceof SyntaxError) {
+    return {
+      needsMigration: true,
+      oldCapabilities: [],
+      oldFilePath
+    };
+  }
+}
+
+// src/commands/migration/versions/v001_capability/check.ts
+async function check(options) {
+  const detection = detectJsonMigration();
+  if (!detection.needsMigration) {
+    return {
+      needsMigration: false,
+      message: detection.reason || "No migration needed"
+    };
+  }
+  const capabilityCount = detection.oldCapabilities?.length || 0;
+  return {
+    needsMigration: true,
+    message: `found ${capabilityCount} capabilities to migrate`,
+    items: [
+      `server/capabilities/capabilities.json \u2192 server/capabilities/*.json`,
+      `${capabilityCount} capabilities will be converted to new format`
+    ]
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/index.ts
+import fs9 from "fs";
+import path9 from "path";
+
+// src/commands/migration/versions/v001_capability/mapping.ts
+var DEFAULT_PLUGIN_VERSION = "1.0.0";
+var PLUGIN_MAPPING = {
+  // 飞书相关
+  "@official-plugins/send-feishu-message": {
+    sourceActionID: "official_feishu/send_message",
+    pluginVersion: "1.0.0",
+    actionName: "send_feishu_message"
+  },
+  "@official-plugins/feishu-group-create": {
+    sourceActionID: "official_feishu/create_group",
+    pluginVersion: "1.0.0",
+    actionName: "createGroup"
+  },
+  // AI 相关
+  "@official-plugins/ai-text-generate": {
+    sourceActionID: "official_ai/text_generate",
+    pluginVersion: "1.0.0",
+    actionName: "text_generate"
+  },
+  "@official-plugins/ai-image-understanding": {
+    sourceActionID: "official_ai/image_understanding",
+    pluginVersion: "1.0.0",
+    actionName: "imageUnderstanding"
+  },
+  "@official-plugins/ai-text-to-image": {
+    sourceActionID: "official_ai/image_generate",
+    pluginVersion: "1.0.0",
+    actionName: "textToImage"
+  }
+};
+function getPluginInfoBySourceActionID(sourceActionID) {
+  for (const [pluginKey, item] of Object.entries(PLUGIN_MAPPING)) {
+    if (item.sourceActionID === sourceActionID) {
       return {
-        needsMigration: false,
-        reason: "capabilities.json contains invalid JSON"
+        pluginKey,
+        pluginVersion: item.pluginVersion ?? DEFAULT_PLUGIN_VERSION,
+        actionName: item.actionName
       };
     }
-    throw error;
   }
+  throw new Error(
+    `Unknown sourceActionID: "${sourceActionID}". This sourceActionID is not in the built-in mapping. Please contact the developer to add it.`
+  );
+}
+function getActionNameByPluginKey(pluginKey) {
+  const item = PLUGIN_MAPPING[pluginKey];
+  if (!item) {
+    throw new Error(
+      `Unknown pluginKey: "${pluginKey}". This pluginKey is not in the built-in mapping. Please contact the developer to add it.`
+    );
+  }
+  return item.actionName;
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/send-feishu-message.ts
+function transformSendFeishuMessage(input) {
+  const actionInput = input;
+  const cardContent = actionInput.card_content;
+  const header = cardContent?.header;
+  const bodyElements = cardContent?.body?.elements;
+  const title = {
+    title: header?.title?.content ?? "",
+    titleColor: header?.template
+  };
+  const markdownElement = bodyElements?.find((el) => el.tag === "markdown");
+  const content = markdownElement?.content ?? "";
+  const columnSet = bodyElements?.find((el) => el.tag === "column_set");
+  const buttons = columnSet?.columns?.flatMap(
+    (column) => column.elements?.filter((el) => el.tag === "button").map((btn) => ({
+      style: btn.type,
+      text: btn.text?.content,
+      url: btn.behaviors?.[0]?.default_url
+    })) ?? []
+  ) ?? [];
+  return {
+    sender: "bot",
+    receiverUserList: actionInput.receiver_user_list ?? [],
+    receiverGroupList: actionInput.receiver_group_list ?? [],
+    title,
+    content,
+    buttons
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/feishu-group-create.ts
+function transformFeishuGroupCreate(input) {
+  const actionInput = input;
+  return {
+    owner: actionInput.owner,
+    members: actionInput.members ?? [],
+    groupName: actionInput.group_name ?? "",
+    groupDescription: actionInput.group_description ?? "",
+    welcomeMessage: actionInput.welcome_message ?? ""
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/utils.ts
+function convertToNumber(value, defaultValue) {
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const num = Number(value);
+  return isNaN(num) ? defaultValue : num;
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-text-generate.ts
+var DEFAULT_MODEL_ID = "87";
+var DEFAULT_MAX_TOKENS = 8192;
+var DEFAULT_TEMPERATURE = 0.7;
+function transformAITextGenerate(input) {
+  const actionInput = input;
+  return {
+    modelID: actionInput.model_id ?? DEFAULT_MODEL_ID,
+    prompt: actionInput.prompt ?? "",
+    modelParams: {
+      maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS),
+      temperature: convertToNumber(actionInput.temperature, DEFAULT_TEMPERATURE)
+    }
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-image-understanding.ts
+var DEFAULT_MODEL_ID2 = "87";
+var DEFAULT_MAX_TOKENS2 = 8192;
+var DEFAULT_TEMPERATURE2 = 0.7;
+function transformAIImageUnderstanding(input) {
+  const actionInput = input;
+  return {
+    prompt: actionInput.prompt ?? "",
+    images: actionInput.image_list ?? [],
+    modelID: actionInput.model_id ?? DEFAULT_MODEL_ID2,
+    modelParams: {
+      maxTokens: convertToNumber(actionInput.max_tokens, DEFAULT_MAX_TOKENS2),
+      temperature: convertToNumber(actionInput.temperature, DEFAULT_TEMPERATURE2)
+    }
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/ai-text-to-image.ts
+var DEFAULT_RATIO = "1:1";
+var DEFAULT_WATERMARK = true;
+function transformAITextToImage(input) {
+  const actionInput = input;
+  return {
+    prompt: actionInput.prompt ?? "",
+    ratio: actionInput.image_ratio ?? DEFAULT_RATIO,
+    watermark: actionInput.watermark ?? DEFAULT_WATERMARK
+  };
+}
+
+// src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/index.ts
+var TRANSFORMER_MAP = {
+  "official_feishu/send_message": transformSendFeishuMessage,
+  "official_feishu/create_group": transformFeishuGroupCreate,
+  "official_ai/text_generate": transformAITextGenerate,
+  "official_ai/image_understanding": transformAIImageUnderstanding,
+  "official_ai/image_generate": transformAITextToImage
+};
+function transformFormValue(sourceActionID, actionInput) {
+  const transformer = TRANSFORMER_MAP[sourceActionID];
+  if (!transformer) {
+    throw new Error(
+      `No formValue transformer found for sourceActionID: "${sourceActionID}". Please implement the transformer and add it to TRANSFORMER_MAP.`
+    );
+  }
+  return transformer(actionInput);
 }
 
-// src/commands/capability/migration/json-migrator/transformer.ts
-function transformCapability(old, mapping) {
-  const pluginID = getPluginID(old.sourceActionID, mapping);
+// src/commands/migration/versions/v001_capability/json-migrator/transformer.ts
+function transformCapability(old) {
+  const { pluginKey, pluginVersion } = getPluginInfoBySourceActionID(old.sourceActionID);
+  const formValue = transformFormValue(old.sourceActionID, old.actionInput);
   return {
     id: old.id,
-    pluginID,
-    pluginVersion: "latest",
+    pluginKey,
+    pluginVersion,
     name: old.name,
     description: old.desc,
     paramsSchema: old.inputSchema,
-    formValue: old.actionInput,
+    formValue,
     createdAt: old.createdAt,
     updatedAt: old.updatedAt
   };
 }
-function transformCapabilities(oldCapabilities, mapping) {
-  return oldCapabilities.map((old) => transformCapability(old, mapping));
+function transformCapabilities(oldCapabilities) {
+  return oldCapabilities.map((old) => transformCapability(old));
 }
 
-// src/commands/capability/migration/json-migrator/index.ts
+// src/commands/migration/versions/v001_capability/json-migrator/index.ts
+function loadExistingCapabilities() {
+  const capabilitiesDir = getCapabilitiesDir2();
+  if (!fs9.existsSync(capabilitiesDir)) {
+    return [];
+  }
+  const files = fs9.readdirSync(capabilitiesDir);
+  const capabilities = [];
+  for (const file of files) {
+    if (file === "capabilities.json" || !file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const filePath = path9.join(capabilitiesDir, file);
+      const content = fs9.readFileSync(filePath, "utf-8");
+      const capability = JSON.parse(content);
+      if (capability.id && capability.pluginKey) {
+        capabilities.push(capability);
+      }
+    } catch {
+    }
+  }
+  return capabilities;
+}
 async function migrateJsonFiles(options) {
   const detection = detectJsonMigration();
   if (!detection.needsMigration) {
+    const existingCapabilities = loadExistingCapabilities();
     return {
       success: true,
       skipped: true,
       reason: detection.reason,
-      count: 0,
-      capabilities: []
+      count: existingCapabilities.length,
+      capabilities: existingCapabilities
     };
   }
   const { oldCapabilities, oldFilePath } = detection;
@@ -1254,7 +1618,7 @@ async function migrateJsonFiles(options) {
   }
   let newCapabilities;
   try {
-    newCapabilities = transformCapabilities(oldCapabilities, options.mapping);
+    newCapabilities = transformCapabilities(oldCapabilities);
   } catch (error) {
     return {
       success: false,
@@ -1267,7 +1631,7 @@ async function migrateJsonFiles(options) {
   if (options.dryRun) {
     console.log(`   Would create ${newCapabilities.length} capability files:`);
     for (const cap of newCapabilities) {
-      console.log(`   - ${cap.id}.json (pluginID: ${cap.pluginID})`);
+      console.log(`   - ${cap.id}.json (pluginKey: ${cap.pluginKey})`);
     }
     return {
       success: true,
@@ -1276,48 +1640,45 @@ async function migrateJsonFiles(options) {
       capabilities: newCapabilities
     };
   }
-  const capabilitiesDir = getCapabilitiesDir();
+  const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path7.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path9.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs7.writeFileSync(filePath, content, "utf-8");
+    fs9.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
-  const backupPath = oldFilePath + ".backup";
-  fs7.renameSync(oldFilePath, backupPath);
   return {
     success: true,
     skipped: false,
     count: newCapabilities.length,
-    capabilities: newCapabilities,
-    backupPath
+    capabilities: newCapabilities
   };
 }
 
-// src/commands/capability/migration/plugin-installer/detector.ts
-import fs8 from "fs";
-function isPluginInstalled2(pluginID) {
-  const manifestPath = getPluginManifestPath(pluginID);
-  return fs8.existsSync(manifestPath);
+// src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
+import fs10 from "fs";
+function isPluginInstalled2(pluginKey) {
+  const manifestPath = getPluginManifestPath2(pluginKey);
+  return fs10.existsSync(manifestPath);
 }
 function detectPluginsToInstall(capabilities) {
-  const pluginIDs = /* @__PURE__ */ new Set();
+  const pluginKeys = /* @__PURE__ */ new Set();
   for (const cap of capabilities) {
-    pluginIDs.add(cap.pluginID);
+    pluginKeys.add(cap.pluginKey);
   }
   const toInstall = [];
   const alreadyInstalled = [];
-  for (const pluginID of pluginIDs) {
-    if (isPluginInstalled2(pluginID)) {
-      alreadyInstalled.push(pluginID);
+  for (const pluginKey of pluginKeys) {
+    if (isPluginInstalled2(pluginKey)) {
+      alreadyInstalled.push(pluginKey);
     } else {
-      toInstall.push(pluginID);
+      toInstall.push(pluginKey);
     }
   }
   return { toInstall, alreadyInstalled };
 }
 
-// src/commands/capability/migration/plugin-installer/index.ts
+// src/commands/migration/versions/v001_capability/plugin-installer/index.ts
 async function installPlugins(capabilities, options) {
   const detection = detectPluginsToInstall(capabilities);
   const result = {
@@ -1330,15 +1691,15 @@ async function installPlugins(capabilities, options) {
   }
   if (options.dryRun) {
     console.log(`   Would install ${detection.toInstall.length} plugins:`);
-    for (const pluginID of detection.toInstall) {
-      console.log(`   - ${pluginID}`);
+    for (const pluginKey of detection.toInstall) {
+      console.log(`   - ${pluginKey}`);
     }
     result.installed = detection.toInstall;
     return result;
   }
   console.log(`   \u2B07 Installing ${detection.toInstall.length} plugins...`);
-  for (const pluginID of detection.toInstall) {
-    console.log(`     - ${pluginID}`);
+  for (const pluginKey of detection.toInstall) {
+    console.log(`     - ${pluginKey}`);
   }
   try {
     const originalExit = process.exit;
@@ -1353,9 +1714,9 @@ async function installPlugins(capabilities, options) {
       await install(detection.toInstall);
       result.installed = detection.toInstall;
     } catch (error) {
-      for (const pluginID of detection.toInstall) {
+      for (const pluginKey of detection.toInstall) {
         result.failed.push({
-          pluginID,
+          pluginKey,
           error: error instanceof Error ? error.message : String(error)
         });
       }
@@ -1363,9 +1724,9 @@ async function installPlugins(capabilities, options) {
       process.exit = originalExit;
     }
   } catch (error) {
-    for (const pluginID of detection.toInstall) {
+    for (const pluginKey of detection.toInstall) {
       result.failed.push({
-        pluginID,
+        pluginKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
@@ -1373,14 +1734,13 @@ async function installPlugins(capabilities, options) {
   return result;
 }
 
-// src/commands/capability/migration/code-migrator/index.ts
-import fs10 from "fs";
-import path9 from "path";
-import * as ts4 from "typescript";
+// src/commands/migration/versions/v001_capability/code-migrator/index.ts
+import path11 from "path";
+import { Project } from "ts-morph";
 
-// src/commands/capability/migration/code-migrator/scanner.ts
-import fs9 from "fs";
-import path8 from "path";
+// src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
+import fs11 from "fs";
+import path10 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -1395,9 +1755,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
+    const fullPath = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -1413,14 +1773,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path8.join(getProjectRoot2(), "server");
-  if (!fs9.existsSync(serverDir)) {
+  const serverDir = path10.join(getProjectRoot3(), "server");
+  if (!fs11.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -1428,178 +1788,154 @@ function scanFilesToMigrate() {
   return allFiles.filter(hasCapabilityImport);
 }
 
-// src/commands/capability/migration/code-migrator/analyzers/import-analyzer.ts
-import * as ts from "typescript";
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/import-analyzer.ts
 function extractCapabilityId(importPath) {
   const match = importPath.match(/capabilities\/([^/]+)$/);
-  if (match) {
-    return match[1];
-  }
-  return null;
+  return match ? match[1] : null;
 }
 function isCapabilityImport(importPath) {
   return importPath.includes("capabilities/") || importPath.includes("capabilities\\");
 }
 function analyzeImports(sourceFile) {
   const imports = [];
-  function visit(node) {
-    if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpecifier)) {
-        const importPath = moduleSpecifier.text;
-        if (isCapabilityImport(importPath)) {
-          const capabilityId = extractCapabilityId(importPath);
-          if (capabilityId && node.importClause) {
-            const importClause = node.importClause;
-            let importName = null;
-            if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-              for (const element of importClause.namedBindings.elements) {
-                importName = element.name.text;
-                imports.push({
-                  importName,
-                  capabilityId,
-                  start: node.getStart(),
-                  end: node.getEnd(),
-                  text: node.getText()
-                });
-              }
-            } else if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
-              importName = importClause.namedBindings.name.text;
-              imports.push({
-                importName,
-                capabilityId,
-                start: node.getStart(),
-                end: node.getEnd(),
-                text: node.getText()
-              });
-            } else if (importClause.name) {
-              importName = importClause.name.text;
-              imports.push({
-                importName,
-                capabilityId,
-                start: node.getStart(),
-                end: node.getEnd(),
-                text: node.getText()
-              });
-            }
-          }
-        }
-      }
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (!isCapabilityImport(moduleSpecifier)) {
+      continue;
+    }
+    const capabilityId = extractCapabilityId(moduleSpecifier);
+    if (!capabilityId) {
+      continue;
+    }
+    const namedImports = importDecl.getNamedImports();
+    for (const namedImport of namedImports) {
+      const importName = namedImport.getAliasNode()?.getText() || namedImport.getName();
+      imports.push({
+        importName,
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      imports.push({
+        importName: namespaceImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        importName: defaultImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
   return imports;
 }
 
-// src/commands/capability/migration/code-migrator/analyzers/call-site-analyzer.ts
-import * as ts2 from "typescript";
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/call-site-analyzer.ts
+import { SyntaxKind } from "ts-morph";
 function analyzeCallSites(sourceFile, imports) {
   const callSites = [];
   const importMap = /* @__PURE__ */ new Map();
   for (const imp of imports) {
     importMap.set(imp.importName, imp.capabilityId);
   }
-  function visit(node) {
-    if (ts2.isCallExpression(node)) {
-      const expression = node.expression;
-      if (ts2.isIdentifier(expression)) {
-        const functionName = expression.text;
-        const capabilityId = importMap.get(functionName);
-        if (capabilityId) {
-          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-          callSites.push({
-            functionName,
-            capabilityId,
-            start: node.getStart(),
-            end: node.getEnd(),
-            line: line + 1,
-            // 转为 1-based
-            text: node.getText()
-          });
-        }
-      } else if (ts2.isPropertyAccessExpression(expression)) {
-        const objectName = expression.expression;
-        if (ts2.isIdentifier(objectName)) {
-          const capabilityId = importMap.get(objectName.text);
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+  for (const callExpr of callExpressions) {
+    const expression = callExpr.getExpression();
+    if (expression.getKind() === SyntaxKind.Identifier) {
+      const functionName = expression.getText();
+      const capabilityId = importMap.get(functionName);
+      if (capabilityId) {
+        callSites.push({
+          functionName,
+          capabilityId,
+          start: callExpr.getStart(),
+          end: callExpr.getEnd(),
+          line: callExpr.getStartLineNumber(),
+          text: callExpr.getText()
+        });
+      }
+    } else if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind.Identifier) {
+          const objectName = objectExpr.getText();
+          const capabilityId = importMap.get(objectName);
           if (capabilityId) {
-            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             callSites.push({
-              functionName: `${objectName.text}.${expression.name.text}`,
+              functionName: `${objectName}.${propAccess.getName()}`,
               capabilityId,
-              start: node.getStart(),
-              end: node.getEnd(),
-              line: line + 1,
-              text: node.getText()
+              start: callExpr.getStart(),
+              end: callExpr.getEnd(),
+              line: callExpr.getStartLineNumber(),
+              text: callExpr.getText()
             });
           }
         }
       }
     }
-    ts2.forEachChild(node, visit);
   }
-  visit(sourceFile);
   return callSites;
 }
 
-// src/commands/capability/migration/code-migrator/analyzers/class-analyzer.ts
-import * as ts3 from "typescript";
-function hasDecorator(node, decoratorName) {
-  const decorators = ts3.getDecorators(node);
-  if (!decorators) {
-    return false;
-  }
+// src/commands/migration/versions/v001_capability/code-migrator/analyzers/class-analyzer.ts
+function hasDecorator(classDecl, decoratorName) {
+  const decorators = classDecl.getDecorators();
   return decorators.some((decorator) => {
-    const expression = decorator.expression;
-    if (ts3.isIdentifier(expression)) {
-      return expression.text === decoratorName;
-    }
-    if (ts3.isCallExpression(expression) && ts3.isIdentifier(expression.expression)) {
-      return expression.expression.text === decoratorName;
-    }
-    return false;
+    const name = decorator.getName();
+    return name === decoratorName;
   });
 }
 function analyzeClass(sourceFile) {
+  const classes = sourceFile.getClasses();
   let classInfo;
-  function visit(node) {
-    if (ts3.isClassDeclaration(node) && node.name) {
-      const isInjectable = hasDecorator(node, "Injectable");
-      const isController = hasDecorator(node, "Controller");
-      if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
-        return;
-      }
-      const info = {
-        name: node.name.text,
-        isInjectable,
-        isController,
-        constructorParamCount: 0
-      };
-      for (const member of node.members) {
-        if (ts3.isConstructorDeclaration(member)) {
-          info.constructorParamCount = member.parameters.length;
-          info.constructorStart = member.getStart();
-          info.constructorEnd = member.getEnd();
-          if (member.parameters.length > 0) {
-            const lastParam = member.parameters[member.parameters.length - 1];
-            info.constructorParamsEnd = lastParam.getEnd();
-          } else {
-            const constructorText = member.getText();
-            const parenIndex = constructorText.indexOf("(");
-            if (parenIndex !== -1) {
-              info.constructorParamsEnd = member.getStart() + parenIndex + 1;
-            }
-          }
-          break;
-        }
-      }
-      if (isInjectable || isController || !classInfo) {
-        classInfo = info;
+  for (const classDecl of classes) {
+    const name = classDecl.getName();
+    if (!name) continue;
+    const isInjectable = hasDecorator(classDecl, "Injectable");
+    const isController = hasDecorator(classDecl, "Controller");
+    if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
+      continue;
+    }
+    const info = {
+      name,
+      isInjectable,
+      isController,
+      constructorParamCount: 0
+    };
+    const classBody = classDecl.getChildSyntaxListOrThrow();
+    info.classBodyStart = classBody.getStart();
+    const constructors = classDecl.getConstructors();
+    if (constructors.length > 0) {
+      const ctor = constructors[0];
+      info.constructorParamCount = ctor.getParameters().length;
+      info.constructorStart = ctor.getStart();
+      info.constructorEnd = ctor.getEnd();
+      const params = ctor.getParameters();
+      if (params.length > 0) {
+        const lastParam = params[params.length - 1];
+        info.constructorParamsEnd = lastParam.getEnd();
+      } else {
+        info.constructorParamsEnd = ctor.getStart();
       }
     }
-    ts3.forEachChild(node, visit);
+    if (isInjectable || isController || !classInfo) {
+      classInfo = info;
+    }
   }
-  visit(sourceFile);
   return classInfo;
 }
 function canAutoMigrate(classInfo) {
@@ -1618,120 +1954,208 @@ function canAutoMigrate(classInfo) {
   return { canMigrate: true };
 }
 
-// src/commands/capability/migration/code-migrator/transformers/import-transformer.ts
-var CAPABILITY_SERVICE_IMPORT = `import { CapabilityService } from '@lark-apaas/nestjs-core';`;
-function hasCapabilityServiceImport(content) {
-  return /import\s+.*CapabilityService.*from\s+['"]@lark-apaas\/nestjs-core['"]/.test(content);
-}
-function findImportInsertPosition(content) {
-  const importRegex = /^import\s+.*?from\s+['"][^'"]+['"];?\s*$/gm;
-  let lastMatch = null;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    lastMatch = match;
-  }
-  if (lastMatch) {
-    return lastMatch.index + lastMatch[0].length;
-  }
-  return 0;
-}
-function transformImports(content, imports) {
-  const sortedImports = [...imports].sort((a, b) => b.start - a.start);
-  let result = content;
-  for (const imp of sortedImports) {
-    const before = result.substring(0, imp.start);
-    const after = result.substring(imp.end);
-    const trimmedAfter = after.replace(/^\r?\n/, "");
-    result = before + trimmedAfter;
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/import-transformer.ts
+var CORE_MODULE = "@lark-apaas/fullstack-nestjs-core";
+var NESTJS_COMMON_MODULE = "@nestjs/common";
+function hasCapabilityServiceImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === CORE_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "CapabilityService")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasInjectImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === NESTJS_COMMON_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "Inject")) {
+        return true;
+      }
+    }
   }
+  return false;
+}
+function transformImports(sourceFile, capabilityImports) {
   let importAdded = false;
-  if (!hasCapabilityServiceImport(result)) {
-    const insertPos = findImportInsertPosition(result);
-    if (insertPos > 0) {
-      result = result.substring(0, insertPos) + "\n" + CAPABILITY_SERVICE_IMPORT + result.substring(insertPos);
+  let importsRemoved = 0;
+  const importPaths = new Set(capabilityImports.map((imp) => {
+    const match = imp.text.match(/from\s+['"]([^'"]+)['"]/);
+    return match ? match[1] : "";
+  }));
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (importPaths.has(moduleSpecifier)) {
+      importDecl.remove();
+      importsRemoved++;
+    }
+  }
+  if (!hasCapabilityServiceImport(sourceFile)) {
+    const existingCoreImport = sourceFile.getImportDeclaration(CORE_MODULE);
+    if (existingCoreImport) {
+      const namedImports = existingCoreImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("CapabilityService")) {
+        existingCoreImport.addNamedImport("CapabilityService");
+      }
+      if (!existingNames.includes("migrationAdaptor")) {
+        existingCoreImport.addNamedImport("migrationAdaptor");
+      }
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: CORE_MODULE,
+        namedImports: ["CapabilityService", "migrationAdaptor"]
+      });
+    }
+    importAdded = true;
+  }
+  if (!hasInjectImport(sourceFile)) {
+    const existingNestImport = sourceFile.getImportDeclaration(NESTJS_COMMON_MODULE);
+    if (existingNestImport) {
+      const namedImports = existingNestImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("Inject")) {
+        existingNestImport.addNamedImport("Inject");
+      }
     } else {
-      result = CAPABILITY_SERVICE_IMPORT + "\n" + result;
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: NESTJS_COMMON_MODULE,
+        namedImports: ["Inject"]
+      });
     }
     importAdded = true;
   }
-  return { content: result, importAdded };
+  return { importAdded, importsRemoved };
 }
 
-// src/commands/capability/migration/code-migrator/transformers/injection-transformer.ts
-var INJECTION_PARAM = "private readonly capabilityService: CapabilityService";
-function hasCapabilityServiceInjection(content) {
-  return /capabilityService\s*:\s*CapabilityService/.test(content);
-}
-function addInjection(content, classInfo) {
-  if (hasCapabilityServiceInjection(content)) {
-    return { content, injectionAdded: false };
-  }
-  if (classInfo.constructorParamsEnd === void 0) {
-    return { content, injectionAdded: false };
-  }
-  let result = content;
-  const insertPos = classInfo.constructorParamsEnd;
-  if (classInfo.constructorParamCount > 0) {
-    const afterParams = content.substring(insertPos);
-    const beforeParams = content.substring(0, insertPos);
-    result = beforeParams + ",\n    " + INJECTION_PARAM + afterParams;
-  } else {
-    const constructorMatch = content.match(/constructor\s*\(\s*/);
-    if (constructorMatch && constructorMatch.index !== void 0) {
-      const paramStart = constructorMatch.index + constructorMatch[0].length;
-      const before = content.substring(0, paramStart);
-      const after = content.substring(paramStart);
-      result = before + INJECTION_PARAM + after;
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/injection-transformer.ts
+import { Scope } from "ts-morph";
+var PARAM_NAME = "capabilityService";
+var PARAM_TYPE = "CapabilityService";
+function hasCapabilityServiceInjection(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const constructors = classDecl.getConstructors();
+    for (const ctor of constructors) {
+      const params = ctor.getParameters();
+      for (const param of params) {
+        if (param.getName() === PARAM_NAME) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function findInjectableClass(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const decorators = classDecl.getDecorators();
+    const isInjectable = decorators.some((d) => d.getName() === "Injectable");
+    const isController = decorators.some((d) => d.getName() === "Controller");
+    if (isInjectable || isController) {
+      return classDecl;
     }
   }
-  return { content: result, injectionAdded: result !== content };
+  return void 0;
+}
+function addInjection(sourceFile) {
+  if (hasCapabilityServiceInjection(sourceFile)) {
+    return { injectionAdded: false };
+  }
+  const classDecl = findInjectableClass(sourceFile);
+  if (!classDecl) {
+    return { injectionAdded: false };
+  }
+  const constructors = classDecl.getConstructors();
+  if (constructors.length > 0) {
+    const ctor = constructors[0];
+    ctor.addParameter({
+      name: PARAM_NAME,
+      type: PARAM_TYPE,
+      scope: Scope.Private,
+      isReadonly: true,
+      decorators: [{ name: "Inject", arguments: [] }]
+    });
+  } else {
+    classDecl.addConstructor({
+      parameters: [{
+        name: PARAM_NAME,
+        type: PARAM_TYPE,
+        scope: Scope.Private,
+        isReadonly: true,
+        decorators: [{ name: "Inject", arguments: [] }]
+      }]
+    });
+  }
+  return { injectionAdded: true };
 }
 
-// src/commands/capability/migration/code-migrator/transformers/call-site-transformer.ts
-function generateNewCall(capabilityId, originalCall) {
-  const parenIndex = originalCall.indexOf("(");
-  if (parenIndex === -1) {
-    return originalCall;
-  }
-  const argsStart = parenIndex + 1;
-  const argsEnd = originalCall.lastIndexOf(")");
-  if (argsEnd === -1 || argsEnd <= argsStart) {
-    return `this.capabilityService.load('${capabilityId}').call('run', {})`;
-  }
-  const args = originalCall.substring(argsStart, argsEnd).trim();
-  if (!args) {
-    return `this.capabilityService.load('${capabilityId}').call('run', {})`;
-  }
-  return `this.capabilityService.load('${capabilityId}').call('run', ${args})`;
-}
-function transformCallSites(content, callSites) {
-  const sortedCallSites = [...callSites].sort((a, b) => b.start - a.start);
-  let result = content;
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/call-site-transformer.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+var DEFAULT_ACTION_NAME = "run";
+function generateNewCallText(capabilityId, actionName, args) {
+  const argsText = args.trim() || "{}";
+  return `migrationAdaptor(this.capabilityService.load('${capabilityId}').call('${actionName}', ${argsText}))`;
+}
+function transformCallSites(sourceFile, imports) {
+  const importMap = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    importMap.set(imp.importName, {
+      capabilityId: imp.capabilityId,
+      actionName: imp.actionName ?? DEFAULT_ACTION_NAME
+    });
+  }
   let replacedCount = 0;
-  for (const callSite of sortedCallSites) {
-    const newCall = generateNewCall(callSite.capabilityId, callSite.text);
-    const before = result.substring(0, callSite.start);
-    const after = result.substring(callSite.end);
-    result = before + newCall + after;
-    replacedCount++;
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  const sortedCalls = [...callExpressions].sort((a, b) => b.getStart() - a.getStart());
+  for (const callExpr of sortedCalls) {
+    const expression = callExpr.getExpression();
+    let importInfo;
+    if (expression.getKind() === SyntaxKind2.Identifier) {
+      const functionName = expression.getText();
+      importInfo = importMap.get(functionName);
+    } else if (expression.getKind() === SyntaxKind2.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind2.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind2.Identifier) {
+          const objectName = objectExpr.getText();
+          importInfo = importMap.get(objectName);
+        }
+      }
+    }
+    if (importInfo) {
+      const args = callExpr.getArguments();
+      const argsText = args.map((arg) => arg.getText()).join(", ");
+      const newCallText = generateNewCallText(importInfo.capabilityId, importInfo.actionName, argsText);
+      callExpr.replaceWithText(newCallText);
+      replacedCount++;
+    }
   }
-  return { content: result, replacedCount };
+  return { replacedCount };
 }
 
-// src/commands/capability/migration/code-migrator/index.ts
-function analyzeFile(filePath) {
-  const content = fs10.readFileSync(filePath, "utf-8");
-  const sourceFile = ts4.createSourceFile(
-    filePath,
-    content,
-    ts4.ScriptTarget.Latest,
-    true
-  );
+// src/commands/migration/versions/v001_capability/code-migrator/index.ts
+function analyzeFile(project, filePath, actionNameMap) {
+  const sourceFile = project.addSourceFileAtPath(filePath);
   const imports = analyzeImports(sourceFile);
+  for (const imp of imports) {
+    const actionName = actionNameMap.get(imp.capabilityId);
+    if (actionName) {
+      imp.actionName = actionName;
+    }
+  }
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path9.relative(getProjectRoot2(), filePath);
+  const relativePath = path11.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -1741,8 +2165,8 @@ function analyzeFile(filePath) {
     manualMigrationReason: reason
   };
 }
-function migrateFile(analysis, dryRun) {
-  const absolutePath = path9.join(getProjectRoot2(), analysis.filePath);
+function migrateFile(project, analysis, dryRun) {
+  const absolutePath = path11.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -1754,42 +2178,19 @@ function migrateFile(analysis, dryRun) {
     };
   }
   try {
-    let content = fs10.readFileSync(absolutePath, "utf-8");
-    const callResult = transformCallSites(content, analysis.callSites);
-    content = callResult.content;
-    const sourceFile = ts4.createSourceFile(
-      analysis.filePath,
-      content,
-      ts4.ScriptTarget.Latest,
-      true
-    );
-    const newImports = analyzeImports(sourceFile);
-    const importResult = transformImports(content, newImports);
-    content = importResult.content;
-    let injectionAdded = false;
-    if (analysis.classInfo) {
-      const newSourceFile = ts4.createSourceFile(
-        analysis.filePath,
-        content,
-        ts4.ScriptTarget.Latest,
-        true
-      );
-      const newClassInfo = analyzeClass(newSourceFile);
-      if (newClassInfo) {
-        const injectionResult = addInjection(content, newClassInfo);
-        content = injectionResult.content;
-        injectionAdded = injectionResult.injectionAdded;
-      }
-    }
+    const sourceFile = project.getSourceFileOrThrow(absolutePath);
+    const callResult = transformCallSites(sourceFile, analysis.imports);
+    const importResult = transformImports(sourceFile, analysis.imports);
+    const injectionResult = addInjection(sourceFile);
     if (!dryRun) {
-      fs10.writeFileSync(absolutePath, content, "utf-8");
+      sourceFile.saveSync();
     }
     return {
       filePath: analysis.filePath,
       success: true,
-      importsRemoved: analysis.imports.length,
+      importsRemoved: importResult.importsRemoved,
       callSitesReplaced: callResult.replacedCount,
-      injectionAdded
+      injectionAdded: injectionResult.injectionAdded
     };
   } catch (error) {
     return {
@@ -1802,20 +2203,39 @@ function migrateFile(analysis, dryRun) {
     };
   }
 }
-async function migrateCode(options) {
+function buildActionNameMap(capabilities) {
+  const map = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    try {
+      const actionName = getActionNameByPluginKey(cap.pluginKey);
+      map.set(cap.id, actionName);
+    } catch {
+      map.set(cap.id, "run");
+    }
+  }
+  return map;
+}
+async function migrateCode(options, capabilities) {
   const result = {
     autoMigrated: [],
     manualRequired: []
   };
+  const actionNameMap = buildActionNameMap(capabilities);
   const filesToMigrate = scanFilesToMigrate();
   if (filesToMigrate.length === 0) {
     console.log("   No files need code migration.\n");
     return result;
   }
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      allowJs: true
+    }
+  });
   const analyses = [];
   for (const filePath of filesToMigrate) {
     try {
-      const analysis = analyzeFile(filePath);
+      const analysis = analyzeFile(project, filePath, actionNameMap);
       analyses.push(analysis);
     } catch (error) {
       console.error(`   \u2717 Failed to analyze ${filePath}: ${error}`);
@@ -1833,7 +2253,7 @@ async function migrateCode(options) {
     });
   }
   for (const analysis of autoMigratable) {
-    const migrationResult = migrateFile(analysis, options.dryRun);
+    const migrationResult = migrateFile(project, analysis, options.dryRun);
     result.autoMigrated.push(migrationResult);
   }
   return result;
@@ -1848,12 +2268,50 @@ function getSuggestion(analysis) {
   return "Manual review required";
 }
 
-// src/commands/capability/migration/report-generator.ts
-import fs11 from "fs";
-import path10 from "path";
+// src/commands/migration/versions/v001_capability/cleanup.ts
+import fs12 from "fs";
+import path12 from "path";
+function cleanupOldFiles(capabilities, dryRun) {
+  const deletedFiles = [];
+  const errors = [];
+  const capabilitiesDir = getCapabilitiesDir2();
+  const oldJsonPath = path12.join(capabilitiesDir, "capabilities.json");
+  if (fs12.existsSync(oldJsonPath)) {
+    try {
+      if (!dryRun) {
+        fs12.unlinkSync(oldJsonPath);
+      }
+      deletedFiles.push("capabilities.json");
+    } catch (error) {
+      errors.push(`Failed to delete capabilities.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  for (const cap of capabilities) {
+    const tsFilePath = path12.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs12.existsSync(tsFilePath)) {
+      try {
+        if (!dryRun) {
+          fs12.unlinkSync(tsFilePath);
+        }
+        deletedFiles.push(`${cap.id}.ts`);
+      } catch (error) {
+        errors.push(`Failed to delete ${cap.id}.ts: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    deletedFiles,
+    errors
+  };
+}
+
+// src/commands/migration/versions/v001_capability/report-generator.ts
+import fs13 from "fs";
+import path13 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
-  const { jsonMigration, pluginInstallation, codeMigration } = result;
+  const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
   console.log("\u{1F4CA} Migration Summary");
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   if (!jsonMigration.skipped) {
@@ -1878,6 +2336,9 @@ function printSummary(result) {
     console.log(`   Files need manual work:  ${codeMigration.manualRequired.length}`);
   }
   console.log(`   Total call sites fixed:  ${totalCallSites}`);
+  if (cleanup.deletedFiles.length > 0) {
+    console.log(`   Old files cleaned up:    ${cleanup.deletedFiles.length}`);
+  }
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
   const hasErrors = pluginInstallation.failed.length > 0 || failedMigrations.length > 0;
   const hasManual = codeMigration.manualRequired.length > 0;
@@ -1898,7 +2359,7 @@ function printSummary(result) {
   console.log("");
 }
 async function generateReport(result) {
-  const { jsonMigration, pluginInstallation, codeMigration } = result;
+  const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
   const lines = [];
   lines.push("# Capability \u8FC1\u79FB\u62A5\u544A");
   lines.push("");
@@ -1911,34 +2372,28 @@ async function generateReport(result) {
   } else {
     lines.push("### 1.1 \u5DF2\u8FC1\u79FB\u7684 Capabilities");
     lines.push("");
-    lines.push("| ID | pluginID |");
-    lines.push("|----|----------|");
+    lines.push("| ID | pluginKey |");
+    lines.push("|----|-----------|");
     for (const cap of jsonMigration.capabilities) {
-      lines.push(`| ${cap.id} | ${cap.pluginID} |`);
+      lines.push(`| ${cap.id} | ${cap.pluginKey} |`);
     }
     lines.push("");
-    if (jsonMigration.backupPath) {
-      lines.push("### 1.2 \u5907\u4EFD\u6587\u4EF6");
-      lines.push("");
-      lines.push(`- \`${jsonMigration.backupPath}\``);
-      lines.push("");
-    }
   }
   lines.push("## 2. \u63D2\u4EF6\u5B89\u88C5");
   lines.push("");
   if (pluginInstallation.installed.length === 0 && pluginInstallation.alreadyInstalled.length === 0) {
     lines.push("\u65E0\u63D2\u4EF6\u9700\u8981\u5B89\u88C5\u3002");
   } else {
-    lines.push("| pluginID | \u72B6\u6001 |");
-    lines.push("|----------|------|");
-    for (const pluginID of pluginInstallation.alreadyInstalled) {
-      lines.push(`| ${pluginID} | \u5DF2\u5B89\u88C5 |`);
+    lines.push("| pluginKey | \u72B6\u6001 |");
+    lines.push("|-----------|------|");
+    for (const pluginKey of pluginInstallation.alreadyInstalled) {
+      lines.push(`| ${pluginKey} | \u5DF2\u5B89\u88C5 |`);
     }
-    for (const pluginID of pluginInstallation.installed) {
-      lines.push(`| ${pluginID} | \u65B0\u5B89\u88C5 |`);
+    for (const pluginKey of pluginInstallation.installed) {
+      lines.push(`| ${pluginKey} | \u65B0\u5B89\u88C5 |`);
     }
     for (const failed of pluginInstallation.failed) {
-      lines.push(`| ${failed.pluginID} | \u274C \u5931\u8D25: ${failed.error} |`);
+      lines.push(`| ${failed.pluginKey} | \u274C \u5931\u8D25: ${failed.error} |`);
     }
   }
   lines.push("");
@@ -1983,7 +2438,30 @@ async function generateReport(result) {
       lines.push("");
     }
   }
-  lines.push("## 4. \u9A8C\u8BC1\u6E05\u5355");
+  lines.push("## 4. \u6E05\u7406\u8001\u6587\u4EF6");
+  lines.push("");
+  if (cleanup.deletedFiles.length === 0 && cleanup.errors.length === 0) {
+    lines.push("\u65E0\u6587\u4EF6\u9700\u8981\u6E05\u7406\u3002");
+  } else {
+    if (cleanup.deletedFiles.length > 0) {
+      lines.push("### 4.1 \u5DF2\u5220\u9664\u7684\u6587\u4EF6");
+      lines.push("");
+      for (const file of cleanup.deletedFiles) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+    if (cleanup.errors.length > 0) {
+      lines.push("### 4.2 \u6E05\u7406\u5931\u8D25");
+      lines.push("");
+      for (const err of cleanup.errors) {
+        lines.push(`- \u274C ${err}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("");
+  lines.push("## 5. \u9A8C\u8BC1\u6E05\u5355");
   lines.push("");
   lines.push("- [ ] \u8FD0\u884C `git diff` \u68C0\u67E5\u4EE3\u7801\u53D8\u66F4");
   lines.push("- [ ] \u8FD0\u884C `npm run typecheck` \u68C0\u67E5\u7C7B\u578B");
@@ -1991,40 +2469,74 @@ async function generateReport(result) {
   if (codeMigration.manualRequired.length > 0) {
     lines.push("- [ ] \u5904\u7406\u624B\u52A8\u8FC1\u79FB\u9879");
   }
-  lines.push("- [ ] \u5220\u9664\u5907\u4EFD\u6587\u4EF6\uFF08\u786E\u8BA4\u65E0\u8BEF\u540E\uFF09");
   lines.push("");
-  const reportPath = path10.join(getProjectRoot2(), REPORT_FILE);
-  fs11.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path13.join(getProjectRoot3(), REPORT_FILE);
+  fs13.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${REPORT_FILE}`);
 }
 
-// src/commands/capability/migration/index.ts
-async function runMigration(options = {}) {
+// src/commands/migration/versions/v001_capability/migration-runner.ts
+async function runCapabilityMigration(options = {}) {
   const fullOptions = {
-    dryRun: options.dryRun ?? false,
-    skipInstall: options.skipInstall ?? false,
-    skipCode: options.skipCode ?? false,
-    mapping: mergeMapping(options.mapping)
+    dryRun: options.dryRun ?? false
   };
   console.log("\u{1F50D} Analyzing project...\n");
   if (fullOptions.dryRun) {
     console.log("\u{1F4CB} Running in dry-run mode (no files will be modified)\n");
   }
+  let jsonResult = {
+    success: false,
+    skipped: true,
+    reason: "Not executed",
+    count: 0,
+    capabilities: []
+  };
+  let pluginResult = {
+    installed: [],
+    alreadyInstalled: [],
+    failed: []
+  };
+  let codeResult = {
+    autoMigrated: [],
+    manualRequired: []
+  };
+  let cleanupResult = {
+    success: true,
+    deletedFiles: [],
+    errors: []
+  };
   console.log("\u{1F4C1} Step 1: JSON File Migration");
-  const jsonResult = await migrateJsonFiles(fullOptions);
-  if (jsonResult.skipped) {
-    console.log(`   \u25CB Skipped: ${jsonResult.reason}
+  try {
+    jsonResult = await migrateJsonFiles(fullOptions);
+    if (jsonResult.skipped) {
+      console.log(`   \u25CB Skipped: ${jsonResult.reason}
 `);
-  } else if (jsonResult.success) {
-    console.log(`   \u2713 Migrated ${jsonResult.count} capabilities`);
-    if (jsonResult.backupPath) {
-      console.log(`   \u2713 Backed up: capabilities.json \u2192 capabilities.json.backup`);
+    } else if (jsonResult.success) {
+      console.log(`   \u2713 Created ${jsonResult.count} capability files
+`);
+    } else {
+      console.log(`   \u2717 Failed: ${jsonResult.reason}
+`);
+      return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
     }
-    console.log("");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u2717 Error: ${errorMsg}
+`);
+    jsonResult = {
+      success: false,
+      skipped: false,
+      reason: errorMsg,
+      count: 0,
+      capabilities: []
+    };
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+  }
+  if (jsonResult.skipped) {
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
   }
-  let pluginResult = { installed: [], alreadyInstalled: [], failed: [] };
-  if (!fullOptions.skipInstall) {
-    console.log("\u{1F4E6} Step 2: Plugin Installation");
+  console.log("\u{1F4E6} Step 2: Plugin Installation");
+  try {
     pluginResult = await installPlugins(jsonResult.capabilities, fullOptions);
     if (pluginResult.alreadyInstalled.length > 0) {
       console.log(`   \u2713 Already installed: ${pluginResult.alreadyInstalled.join(", ")}`);
@@ -2033,18 +2545,27 @@ async function runMigration(options = {}) {
       console.log(`   \u2713 Installed: ${pluginResult.installed.join(", ")}`);
     }
     if (pluginResult.failed.length > 0) {
-      console.log(`   \u2717 Failed: ${pluginResult.failed.map((f) => f.pluginID).join(", ")}`);
+      console.log(`   \u26A0 Failed (will continue): ${pluginResult.failed.map((f) => f.pluginKey).join(", ")}`);
+      for (const f of pluginResult.failed) {
+        console.log(`     - ${f.pluginKey}: ${f.error}`);
+      }
     }
     console.log("");
-  } else {
-    console.log("\u{1F4E6} Step 2: Plugin Installation");
-    console.log("   \u25CB Skipped (--skip-install)\n");
-  }
-  let codeResult = { autoMigrated: [], manualRequired: [] };
-  if (!fullOptions.skipCode) {
-    console.log("\u{1F527} Step 3: Code Migration");
-    console.log("   Scanning server/ directory...\n");
-    codeResult = await migrateCode(fullOptions);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u26A0 Error (will continue): ${errorMsg}
+`);
+    pluginResult = {
+      installed: [],
+      alreadyInstalled: [],
+      failed: [{ pluginKey: "unknown", error: errorMsg }]
+    };
+  }
+  console.log("\u{1F527} Step 3: Code Migration");
+  console.log("   Scanning server/ directory...\n");
+  try {
+    codeResult = await migrateCode(fullOptions, jsonResult.capabilities);
+    let hasCodeError = false;
     for (const file of codeResult.autoMigrated) {
       if (file.success) {
         console.log(`   \u2713 ${file.filePath}`);
@@ -2055,6 +2576,7 @@ async function runMigration(options = {}) {
         console.log(`     - Replaced ${file.callSitesReplaced} call sites`);
       } else {
         console.log(`   \u2717 ${file.filePath}: ${file.error}`);
+        hasCodeError = true;
       }
     }
     if (codeResult.manualRequired.length > 0) {
@@ -2065,93 +2587,414 @@ async function runMigration(options = {}) {
       }
     }
     console.log("");
-  } else {
-    console.log("\u{1F527} Step 3: Code Migration");
-    console.log("   \u25CB Skipped (--skip-code)\n");
+    if (hasCodeError) {
+      console.log("   \u2717 Code migration failed, aborting...\n");
+      return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u2717 Error: ${errorMsg}
+`);
+    codeResult = {
+      autoMigrated: [],
+      manualRequired: []
+    };
+    return buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
   }
-  const result = {
-    jsonMigration: jsonResult,
-    pluginInstallation: pluginResult,
-    codeMigration: codeResult
-  };
+  console.log("\u{1F9F9} Step 4: Cleanup Old Files");
+  try {
+    cleanupResult = cleanupOldFiles(jsonResult.capabilities, fullOptions.dryRun);
+    if (cleanupResult.deletedFiles.length > 0) {
+      for (const file of cleanupResult.deletedFiles) {
+        console.log(`   \u2713 Deleted: ${file}`);
+      }
+    } else {
+      console.log("   \u25CB No files to clean up");
+    }
+    if (cleanupResult.errors.length > 0) {
+      for (const err of cleanupResult.errors) {
+        console.log(`   \u26A0 ${err}`);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.log(`   \u26A0 Error: ${errorMsg}
+`);
+    cleanupResult = {
+      success: false,
+      deletedFiles: [],
+      errors: [errorMsg]
+    };
+  }
+  const result = buildResult(jsonResult, pluginResult, codeResult, cleanupResult);
   printSummary(result);
   if (!fullOptions.dryRun) {
     await generateReport(result);
   }
   return result;
 }
+function buildResult(jsonMigration, pluginInstallation, codeMigration, cleanup) {
+  return {
+    jsonMigration,
+    pluginInstallation,
+    codeMigration,
+    cleanup
+  };
+}
 
-// src/commands/capability/migration.handler.ts
-async function migration(options = {}) {
+// src/commands/migration/versions/v001_capability/run.ts
+async function run3(options) {
   try {
-    let customMapping;
-    if (options.mapping) {
-      if (!fs12.existsSync(options.mapping)) {
-        console.error(`[capability] Mapping file not found: ${options.mapping}`);
-        process.exit(1);
-      }
-      try {
-        const content = fs12.readFileSync(options.mapping, "utf-8");
-        customMapping = JSON.parse(content);
-      } catch (error) {
-        console.error(`[capability] Failed to parse mapping file: ${error}`);
-        process.exit(1);
+    const migrationOptions = {
+      dryRun: options.dryRun ?? false
+    };
+    const result = await runCapabilityMigration(migrationOptions);
+    const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
+    const jsonFailed = !jsonMigration.success && !jsonMigration.skipped;
+    const codeFailed = codeMigration.autoMigrated.some((f) => !f.success);
+    if (jsonFailed) {
+      return {
+        success: false,
+        message: jsonMigration.reason || "JSON migration failed",
+        error: new Error(jsonMigration.reason || "Unknown error")
+      };
+    }
+    if (codeFailed) {
+      return {
+        success: false,
+        message: "Code migration failed",
+        error: new Error("Some files failed to migrate")
+      };
+    }
+    const messages = [];
+    if (jsonMigration.success) {
+      messages.push(`${jsonMigration.count} capabilities migrated`);
+    }
+    if (pluginInstallation.installed.length > 0) {
+      messages.push(`${pluginInstallation.installed.length} plugins installed`);
+    }
+    if (codeMigration.autoMigrated.length > 0) {
+      const successCount = codeMigration.autoMigrated.filter((f) => f.success).length;
+      if (successCount > 0) {
+        messages.push(`${successCount} files auto-migrated`);
       }
     }
-    const migrationOptions = {
-      dryRun: options.dryRun,
-      skipInstall: options.skipInstall,
-      skipCode: options.skipCode,
-      mapping: customMapping
+    if (cleanup.deletedFiles.length > 0) {
+      messages.push(`${cleanup.deletedFiles.length} old files cleaned up`);
+    }
+    if (codeMigration.manualRequired.length > 0) {
+      messages.push(`${codeMigration.manualRequired.length} files need manual migration`);
+    }
+    if (pluginInstallation.failed.length > 0) {
+      messages.push(`${pluginInstallation.failed.length} plugins failed to install`);
+    }
+    return {
+      success: true,
+      message: messages.join(", ") || "No migration needed"
     };
-    await runMigration(migrationOptions);
   } catch (error) {
-    console.error(`[capability] Migration failed: ${error}`);
-    process.exit(1);
+    const err = error instanceof Error ? error : new Error(String(error));
+    return {
+      success: false,
+      message: err.message,
+      error: err
+    };
   }
 }
 
-// src/commands/capability/index.ts
-var listCommand2 = {
-  name: "list",
-  description: "List capability configurations",
-  aliases: ["ls"],
-  register(program) {
-    program.command(this.name).alias("ls").description(this.description).option("--summary", "Return raw capability config (without hydration)").option("--id <id>", "Specify capability ID").action(async (options) => {
-      await list2(options);
-    });
-  }
+// src/commands/migration/versions/v001_capability/index.ts
+var v001CapabilityMigration = {
+  version: 1,
+  name: "capability",
+  description: "Migrate capability configurations from old format (capabilities.json array) to new format (individual JSON files)",
+  check,
+  run: run3
 };
+
+// src/commands/migration/versions/index.ts
+var versionedMigrations = [
+  v001CapabilityMigration
+  // 未来新增的迁移脚本在此添加，如:
+  // v002ConfigMigration,
+  // v003RoutesMigration,
+];
+function getPendingMigrations(currentVersion) {
+  return versionedMigrations.filter((m) => m.version > currentVersion).sort((a, b) => a.version - b.version);
+}
+function getLatestVersion() {
+  if (versionedMigrations.length === 0) return 0;
+  return Math.max(...versionedMigrations.map((m) => m.version));
+}
+
+// src/commands/migration/runner.ts
+function log(message) {
+  console.log(`[migration] ${message}`);
+}
+async function executeSingle(migration, options) {
+  const { version, name } = migration;
+  const versionTag = `v${version}`;
+  try {
+    log(`Checking [${versionTag}] ${name}...`);
+    const checkResult = await migration.check(options);
+    if (!checkResult.needsMigration) {
+      log(`[${versionTag}] ${name}: no migration needed`);
+      return {
+        name,
+        status: "skipped",
+        message: checkResult.message || "No migration needed"
+      };
+    }
+    log(`[${versionTag}] ${name}: needs migration (${checkResult.message})`);
+    if (checkResult.items && checkResult.items.length > 0) {
+      for (const item of checkResult.items) {
+        console.log(`    - ${item}`);
+      }
+    }
+    if (options.dryRun) {
+      return {
+        name,
+        status: "skipped",
+        message: `Dry-run: ${checkResult.message}`
+      };
+    }
+    log(`Running [${versionTag}] ${name} migration...`);
+    const runResult = await migration.run(options);
+    if (runResult.success) {
+      log(`\u2713 [${versionTag}] ${name}: completed (${runResult.message})`);
+      return {
+        name,
+        status: "completed",
+        message: runResult.message
+      };
+    } else {
+      log(`\u2717 [${versionTag}] ${name}: failed`);
+      if (runResult.error) {
+        console.log(`    Error: ${runResult.error.message}`);
+      }
+      return {
+        name,
+        status: "failed",
+        message: runResult.message,
+        error: runResult.error
+      };
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    log(`\u2717 [${versionTag}] ${name}: failed`);
+    console.log(`    Error: ${err.message}`);
+    return {
+      name,
+      status: "failed",
+      message: err.message,
+      error: err
+    };
+  }
+}
+function printSummary2(summary, dryRun) {
+  console.log("");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(dryRun ? "Dry-run Summary:" : "Migration Summary:");
+  if (dryRun) {
+    const needsMigration = summary.skipped.filter((s) => s.message.startsWith("Dry-run:")).length;
+    const noAction = summary.skipped.filter((s) => !s.message.startsWith("Dry-run:")).length;
+    console.log(`  Needs migration: ${needsMigration}`);
+    console.log(`  No action needed: ${noAction}`);
+  } else {
+    console.log(`  \u2713 Completed: ${summary.completed.length}`);
+    console.log(`  \u25CB Skipped:   ${summary.skipped.length} (no migration needed)`);
+    console.log(`  \u2717 Failed:    ${summary.failed.length}`);
+  }
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+}
+async function runMigrations(options) {
+  const currentVersion = getCurrentVersion();
+  const latestVersion = getLatestVersion();
+  console.log("");
+  log(`Current version: ${currentVersion || "0 (not set)"}`);
+  if (currentVersion >= latestVersion) {
+    log("All migrations are up to date.");
+    return {
+      needsMigration: false,
+      completed: [],
+      skipped: [],
+      failed: []
+    };
+  }
+  const pendingMigrations = getPendingMigrations(currentVersion);
+  if (options.dryRun) {
+    log("Dry-run mode enabled, no changes will be made.");
+  } else {
+    log("Applying migrations...");
+  }
+  console.log("");
+  const summary = {
+    needsMigration: false,
+    completed: [],
+    skipped: [],
+    failed: []
+  };
+  let hasAnyMigration = false;
+  for (const migration of pendingMigrations) {
+    const result = await executeSingle(migration, options);
+    switch (result.status) {
+      case "completed":
+        summary.completed.push(result);
+        hasAnyMigration = true;
+        if (!options.dryRun) {
+          setCurrentVersion(migration.version);
+        }
+        break;
+      case "skipped":
+        summary.skipped.push(result);
+        if (result.message.startsWith("Dry-run:")) {
+          hasAnyMigration = true;
+        }
+        break;
+      case "failed":
+        summary.failed.push(result);
+        hasAnyMigration = true;
+        log("Migration aborted due to failure.");
+        printSummary2(summary, !!options.dryRun);
+        return summary;
+    }
+    console.log("");
+  }
+  summary.needsMigration = hasAnyMigration;
+  if (currentVersion === 0 && !hasAnyMigration && !options.dryRun) {
+    log(`All migrations skipped. Project is up to date.`);
+    log(`Updated migrationVersion to ${latestVersion}.`);
+    setCurrentVersion(latestVersion);
+  } else if (!options.dryRun && summary.completed.length > 0) {
+    log(`Migration complete. Updated to version ${getCurrentVersion()}.`);
+  }
+  printSummary2(summary, !!options.dryRun);
+  return summary;
+}
+async function checkMigrations(options) {
+  const currentVersion = getCurrentVersion();
+  const latestVersion = getLatestVersion();
+  console.log("");
+  log(`Current version: ${currentVersion || "0 (not set)"}`);
+  if (currentVersion >= latestVersion) {
+    log("All migrations are up to date.");
+    return {
+      needsMigration: false,
+      completed: [],
+      skipped: [],
+      failed: []
+    };
+  }
+  log("Checking pending migrations...");
+  console.log("");
+  const pendingMigrations = getPendingMigrations(currentVersion);
+  const summary = {
+    needsMigration: false,
+    completed: [],
+    skipped: [],
+    failed: []
+  };
+  let needsCount = 0;
+  let noActionCount = 0;
+  for (const migration of pendingMigrations) {
+    const { version, name } = migration;
+    const versionTag = `v${version}`;
+    try {
+      const checkResult = await migration.check(options);
+      if (checkResult.needsMigration) {
+        needsCount++;
+        console.log(`  ${versionTag} (${name}): needs migration`);
+        if (checkResult.items && checkResult.items.length > 0) {
+          for (const item of checkResult.items) {
+            console.log(`    - ${item}`);
+          }
+        }
+        summary.skipped.push({
+          name,
+          status: "skipped",
+          message: `Needs migration: ${checkResult.message}`
+        });
+      } else {
+        noActionCount++;
+        console.log(`  ${versionTag} (${name}): no migration needed`);
+        summary.skipped.push({
+          name,
+          status: "skipped",
+          message: checkResult.message || "No migration needed"
+        });
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.log(`  ${versionTag} (${name}): check failed`);
+      console.log(`    Error: ${err.message}`);
+      summary.failed.push({
+        name,
+        status: "failed",
+        message: err.message,
+        error: err
+      });
+    }
+  }
+  console.log("");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("Check Summary:");
+  console.log(`  Needs migration: ${needsCount}`);
+  console.log(`  No action needed: ${noActionCount}`);
+  if (summary.failed.length > 0) {
+    console.log(`  Check failed: ${summary.failed.length}`);
+  }
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (needsCount > 0) {
+    console.log("");
+    log("Run 'fullstack-cli migration' to apply.");
+  }
+  summary.needsMigration = needsCount > 0;
+  if (needsCount === 0 && summary.failed.length === 0) {
+    setCurrentVersion(latestVersion);
+    console.log("");
+    log(`Updated migrationVersion to ${latestVersion}.`);
+  }
+  return summary;
+}
+
+// src/commands/migration/index.ts
 var migrationCommand = {
   name: "migration",
-  description: "Execute capability migration",
+  description: "Run versioned migration scripts",
   register(program) {
-    program.command(this.name).description(this.description).option("--dry-run", "Preview mode, do not modify files").option("--skip-install", "Skip plugin installation step").option("--skip-code", "Skip code migration step").option("--mapping <file>", "Custom sourceActionID to pluginID mapping file").action(async (options) => {
-      await migration(options);
+    const migrationCmd = program.command(this.name).description("Run all pending migrations based on current migrationVersion").option("--dry-run", "Preview mode, only run check() without executing run()").action(async (options) => {
+      const summary = await runMigrations(options);
+      if (summary.failed.length > 0) {
+        process.exit(1);
+      }
+    });
+    migrationCmd.command("check").description("Check pending migrations without applying them").action(async () => {
+      const summary = await checkMigrations({});
+      if (summary.failed.length > 0) {
+        process.exit(2);
+      } else if (summary.needsMigration) {
+        process.exit(1);
+      }
     });
   }
 };
-var capabilityCommandGroup = {
-  name: "capability",
-  description: "Manage capability configurations",
-  commands: [listCommand2, migrationCommand]
-};
 
 // src/commands/index.ts
 var commands = [
   genDbSchemaCommand,
   syncCommand,
   actionPluginCommandGroup,
-  capabilityCommandGroup
+  capabilityCommandGroup,
+  migrationCommand
 ];
 
 // src/index.ts
-var envPath = path11.join(process.cwd(), ".env");
-if (fs13.existsSync(envPath)) {
+var envPath = path14.join(process.cwd(), ".env");
+if (fs14.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path11.dirname(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(fs13.readFileSync(path11.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path14.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(fs14.readFileSync(path14.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();