@h-ai/cli 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1645 @@
+#!/usr/bin/env node
+import { generateConfigFile } from './chunk-LANIDJC7.js';
+import './chunk-YV7WPUI6.js';
+import './chunk-2H7UOFLK.js';
+import process3 from 'process';
+import { core } from '@h-ai/core';
+import { cac } from 'cac';
+import chalk from 'chalk';
+import path2, { resolve } from 'path';
+import fse from 'fs-extra';
+import ora from 'ora';
+import prompts from 'prompts';
+import Handlebars from 'handlebars';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { existsSync, readFileSync } from 'fs';
+import { parse } from 'yaml';
+
+function toCamelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toLowerCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+function createTemplateContext(name, extra = {}) {
+  return {
+    camelCase: toCamelCase(name),
+    pascalCase: toPascalCase(name),
+    kebabCase: toKebabCase(name),
+    snakeCase: toSnakeCase(name),
+    ...extra
+  };
+}
+async function writeFile(filePath, content) {
+  await fse.ensureDir(path2.dirname(filePath));
+  await fse.writeFile(filePath, content, "utf-8");
+}
+async function fileExists(filePath) {
+  try {
+    await fse.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(cwd) {
+  if (await fileExists(path2.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(path2.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function registerHelpers() {
+  Handlebars.registerHelper("if_eq", function(a, b, options) {
+    return a === b ? options.fn(this) : options.inverse(this);
+  });
+  Handlebars.registerHelper("date", () => {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  });
+  Handlebars.registerHelper("year", () => {
+    return (/* @__PURE__ */ new Date()).getFullYear();
+  });
+  Handlebars.registerHelper("upper", (str) => {
+    return str.toUpperCase();
+  });
+  Handlebars.registerHelper("lower", (str) => {
+    return str.toLowerCase();
+  });
+}
+registerHelpers();
+var FEATURE_ROUTE_DIRS = {
+  iam: ["routes-shared"],
+  storage: ["routes"],
+  ai: ["routes"],
+  payment: ["routes"],
+  vecdb: ["routes"],
+  datapipe: ["routes"],
+  reach: ["routes"],
+  scheduler: ["routes"],
+  audit: ["routes"]
+};
+var FEATURE_APP_ROUTE_DIRS = {
+  iam: ["admin", "h5"]
+};
+function getTemplatesRoot() {
+  const currentDir = path2.dirname(fileURLToPath(import.meta.url));
+  const distPath = path2.resolve(currentDir, "..", "templates");
+  if (fse.pathExistsSync(distPath)) {
+    return distPath;
+  }
+  return path2.resolve(currentDir, "..", "..", "templates");
+}
+async function copyStaticDir(src, dest, excludePaths) {
+  if (!await fse.pathExists(src)) {
+    return;
+  }
+  await fse.copy(src, dest, {
+    overwrite: true,
+    filter: (filePath) => {
+      if (filePath.endsWith(".hbs")) {
+        return false;
+      }
+      if (excludePaths && excludePaths.length > 0) {
+        const rel = path2.relative(src, filePath);
+        return !excludePaths.some((p) => rel === p || rel.startsWith(`${p}${path2.sep}`));
+      }
+      return true;
+    }
+  });
+}
+async function findHbsFiles(dir) {
+  if (!await fse.pathExists(dir)) {
+    return [];
+  }
+  const results = [];
+  async function walk(current) {
+    const entries = await fse.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.name.endsWith(".hbs")) {
+        results.push(path2.relative(dir, fullPath));
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+function buildTemplateContext(options) {
+  const featureMap = {};
+  for (const f of options.features) {
+    featureMap[f] = true;
+  }
+  if (featureMap.iam) {
+    featureMap.db = true;
+    featureMap.cache = true;
+    featureMap.crypto = true;
+  }
+  if (featureMap.audit || featureMap.scheduler || featureMap.payment) {
+    featureMap.db = true;
+  }
+  const isApi = options.appType === "api";
+  const isCapacitorApp = options.appType === "android-app";
+  return {
+    projectName: options.name,
+    appType: options.appType,
+    features: featureMap,
+    hasUi: !isApi,
+    hasI18n: !isApi,
+    isCapacitorApp,
+    defaultLocale: options.moduleConfigs?.core?.defaultLocale ?? "zh-CN",
+    packageManager: options.packageManager
+  };
+}
+async function generateFromTemplates(projectPath, context) {
+  const root = getTemplatesRoot();
+  await copyStaticDir(path2.join(root, "base"), projectPath);
+  const appDir = path2.join(root, "apps", context.appType);
+  if (await fse.pathExists(appDir)) {
+    const appExcludes = context.hasI18n ? [] : ["messages"];
+    await copyStaticDir(appDir, projectPath, appExcludes);
+  }
+  for (const featureId of Object.keys(context.features)) {
+    if (!context.features[featureId]) {
+      continue;
+    }
+    if (!/^[a-z0-9-]+$/.test(featureId)) {
+      continue;
+    }
+    const featureDir = path2.join(root, "features", featureId);
+    if (!await fse.pathExists(featureDir)) {
+      continue;
+    }
+    const sharedDirs = FEATURE_ROUTE_DIRS[featureId] || [];
+    for (const dirName of sharedDirs) {
+      const routesSrc = path2.join(featureDir, dirName);
+      if (await fse.pathExists(routesSrc)) {
+        await copyStaticDir(routesSrc, path2.join(projectPath, "src", "routes"));
+      }
+    }
+    const appSpecificTypes = FEATURE_APP_ROUTE_DIRS[featureId] || [];
+    if (appSpecificTypes.includes(context.appType)) {
+      const appRouteSrc = path2.join(featureDir, `routes-${context.appType}`);
+      if (await fse.pathExists(appRouteSrc)) {
+        await copyStaticDir(appRouteSrc, path2.join(projectPath, "src", "routes"));
+      }
+    }
+  }
+  await renderDynamicFiles(root, projectPath, context);
+  if (context.hasI18n) {
+    const i18nDir = path2.join(root, "i18n");
+    if (await fse.pathExists(i18nDir)) {
+      await fse.copy(i18nDir, projectPath, { overwrite: true });
+    }
+  }
+  await fse.ensureDir(path2.join(projectPath, "static"));
+}
+async function renderDynamicFiles(templatesRoot, projectPath, context) {
+  const rootDirs = [
+    path2.join(templatesRoot, "base"),
+    path2.join(templatesRoot, "apps", context.appType)
+  ];
+  for (const dir of rootDirs) {
+    await renderHbsInDir(dir, projectPath, context);
+  }
+  const routesDest = path2.join(projectPath, "src", "routes");
+  for (const featureId of Object.keys(context.features)) {
+    if (!context.features[featureId]) {
+      continue;
+    }
+    const featureDir = path2.join(templatesRoot, "features", featureId);
+    if (!await fse.pathExists(featureDir)) {
+      continue;
+    }
+    const sharedDirs = FEATURE_ROUTE_DIRS[featureId] || [];
+    for (const dirName of sharedDirs) {
+      await renderHbsInDir(path2.join(featureDir, dirName), routesDest, context);
+    }
+    const appSpecificTypes = FEATURE_APP_ROUTE_DIRS[featureId] || [];
+    if (appSpecificTypes.includes(context.appType)) {
+      await renderHbsInDir(
+        path2.join(featureDir, `routes-${context.appType}`),
+        routesDest,
+        context
+      );
+    }
+  }
+}
+async function renderHbsInDir(dir, destRoot, context) {
+  const hbsFiles = await findHbsFiles(dir);
+  for (const relPath of hbsFiles) {
+    const srcPath = path2.join(dir, relPath);
+    const outRelPath = relPath.replace(/\.hbs$/, "");
+    const destPath = path2.join(destRoot, outRelPath);
+    const template = await fse.readFile(srcPath, "utf-8");
+    const compiled = Handlebars.compile(template, { noEscape: true });
+    const rendered = compiled(context);
+    await fse.ensureDir(path2.dirname(destPath));
+    await fse.writeFile(destPath, rendered, "utf-8");
+  }
+}
+
+// src/commands/create.ts
+var APP_TYPES = {
+  "admin": {
+    name: "\u7BA1\u7406\u540E\u53F0",
+    description: "\u4F01\u4E1A\u7EA7\u7BA1\u7406\u7CFB\u7EDF\uFF0C\u542B IAM\u3001\u6570\u636E\u5E93\u3001\u5B8C\u6574 UI",
+    defaultFeatures: ["iam", "db", "cache", "crypto"]
+  },
+  "website": {
+    name: "\u4F01\u4E1A\u5B98\u7F51",
+    description: "SSR/SSG \u4F01\u4E1A\u5B98\u7F51\uFF0CSEO \u53CB\u597D\u3001\u54CD\u5E94\u5F0F\u5E03\u5C40",
+    defaultFeatures: ["db", "cache"]
+  },
+  "h5": {
+    name: "H5 \u5E94\u7528",
+    description: "\u79FB\u52A8\u7AEF H5 \u5E94\u7528\uFF0C\u89E6\u6478\u4F18\u5316\u3001PWA \u652F\u6301",
+    defaultFeatures: ["db", "cache"]
+  },
+  "api": {
+    name: "API \u670D\u52A1",
+    description: "\u7EAF API \u540E\u7AEF\u670D\u52A1\uFF0CRESTful \u8DEF\u7531\u3001\u65E0 UI",
+    defaultFeatures: ["db", "cache"]
+  },
+  "android-app": {
+    name: "Android \u5E94\u7528",
+    description: "Android \u539F\u751F\u5E94\u7528\uFF08Capacitor + SvelteKit SPA\uFF09\uFF0C\u53EF\u6253\u5305\u4E3A APK",
+    defaultFeatures: ["iam", "db", "cache", "crypto", "api-client", "capacitor"]
+  }
+};
+var FEATURES = {
+  "iam": {
+    id: "iam",
+    name: "\u8EAB\u4EFD\u4E0E\u8BBF\u95EE\u7BA1\u7406",
+    description: "Session/JWT \u4F1A\u8BDD\u7BA1\u7406\u3001RBAC \u6743\u9650\u63A7\u5236",
+    packages: ["@h-ai/iam"],
+    dependencies: ["crypto", "db", "cache"]
+  },
+  "db": {
+    id: "db",
+    name: "\u6570\u636E\u5E93",
+    description: "\u591A\u6570\u636E\u5E93\u652F\u6301 (SQLite/PostgreSQL/MySQL)",
+    packages: ["@h-ai/reldb"]
+  },
+  "cache": {
+    id: "cache",
+    name: "\u7F13\u5B58",
+    description: "Redis / \u5185\u5B58\u7F13\u5B58",
+    packages: ["@h-ai/cache"]
+  },
+  "ai": {
+    id: "ai",
+    name: "AI \u96C6\u6210",
+    description: "LLM \u9002\u914D\u5668\u3001MCP \u534F\u8BAE\u3001\u6280\u80FD\u7CFB\u7EDF\u3001\u6D41\u5F0F\u54CD\u5E94",
+    packages: ["@h-ai/ai"]
+  },
+  "storage": {
+    id: "storage",
+    name: "\u6587\u4EF6\u5B58\u50A8",
+    description: "\u672C\u5730\u5B58\u50A8\u3001S3/OSS/COS \u4E91\u5B58\u50A8",
+    packages: ["@h-ai/storage"]
+  },
+  "crypto": {
+    id: "crypto",
+    name: "\u52A0\u5BC6\u6A21\u5757",
+    description: "\u56FD\u5BC6 SM2/SM3/SM4\u3001Argon2 \u5BC6\u7801\u54C8\u5E0C",
+    packages: ["@h-ai/crypto"]
+  },
+  "audit": {
+    id: "audit",
+    name: "\u5BA1\u8BA1\u65E5\u5FD7",
+    description: "\u64CD\u4F5C\u5BA1\u8BA1\u3001\u5B89\u5168\u8FFD\u8E2A",
+    packages: ["@h-ai/audit"],
+    dependencies: ["db"]
+  },
+  "reach": {
+    id: "reach",
+    name: "\u89E6\u8FBE\u670D\u52A1",
+    description: "\u90AE\u4EF6\u3001\u77ED\u4FE1\u3001\u5FAE\u4FE1\u7B49\u6D88\u606F\u89E6\u8FBE",
+    packages: ["@h-ai/reach"]
+  },
+  "payment": {
+    id: "payment",
+    name: "\u7EDF\u4E00\u652F\u4ED8",
+    description: "\u5FAE\u4FE1\u652F\u4ED8\u3001\u652F\u4ED8\u5B9D\u3001Stripe \u7EDF\u4E00\u63A5\u5165",
+    packages: ["@h-ai/payment"],
+    dependencies: ["db"]
+  },
+  "vecdb": {
+    id: "vecdb",
+    name: "\u5411\u91CF\u6570\u636E\u5E93",
+    description: "\u5411\u91CF\u68C0\u7D22\u4E0E\u76F8\u4F3C\u5EA6\u641C\u7D22\uFF08LanceDB / pgvector / Qdrant\uFF09",
+    packages: ["@h-ai/vecdb"]
+  },
+  "datapipe": {
+    id: "datapipe",
+    name: "\u6570\u636E\u5904\u7406\u7BA1\u9053",
+    description: "\u6587\u672C\u6E05\u6D17\u3001\u5206\u5757\u4E0E\u53EF\u7EC4\u5408\u5904\u7406\u6D41\u6C34\u7EBF",
+    packages: ["@h-ai/datapipe"]
+  },
+  "scheduler": {
+    id: "scheduler",
+    name: "\u4EFB\u52A1\u8C03\u5EA6",
+    description: "Cron \u4EFB\u52A1\u6CE8\u518C\u3001\u6267\u884C\u4E0E\u65E5\u5FD7\u8FFD\u8E2A",
+    packages: ["@h-ai/scheduler"],
+    dependencies: ["db"]
+  },
+  "deploy": {
+    id: "deploy",
+    name: "\u81EA\u52A8\u5316\u90E8\u7F72",
+    description: "\u7EDF\u4E00\u90E8\u7F72\u7F16\u6392\u4E0E\u591A\u5E73\u53F0\u53D1\u5E03\u652F\u6301",
+    packages: ["@h-ai/deploy"]
+  },
+  "api-client": {
+    id: "api-client",
+    name: "HTTP \u5BA2\u6237\u7AEF",
+    description: "\u7EDF\u4E00 API \u8C03\u7528\u3001\u9519\u8BEF\u5904\u7406\u4E0E\u6D41\u5F0F\u8BF7\u6C42\u652F\u6301",
+    packages: ["@h-ai/api-client"]
+  },
+  "capacitor": {
+    id: "capacitor",
+    name: "\u79FB\u52A8\u7AEF\u80FD\u529B",
+    description: "Capacitor \u539F\u751F\u6865\u63A5\u80FD\u529B\uFF08\u504F\u79FB\u52A8\u5E94\u7528\uFF09",
+    packages: ["@h-ai/capacitor"]
+  }
+};
+var SELECTABLE_FEATURES = [
+  "iam",
+  "db",
+  "cache",
+  "ai",
+  "storage",
+  "crypto",
+  "audit",
+  "reach",
+  "payment",
+  "vecdb",
+  "datapipe",
+  "scheduler",
+  "deploy",
+  "api-client",
+  "capacitor"
+];
+var PROJECT_TEMPLATES = {
+  minimal: {
+    name: "minimal",
+    description: "\u6700\u5C0F\u6A21\u677F \u2014 \u4EC5\u6838\u5FC3\u529F\u80FD",
+    features: []
+  },
+  default: {
+    name: "default",
+    description: "\u6807\u51C6\u6A21\u677F \u2014 IAM + \u6570\u636E\u5E93 + \u7F13\u5B58",
+    features: ["iam", "db", "cache", "crypto"]
+  },
+  full: {
+    name: "full",
+    description: "\u5B8C\u6574\u6A21\u677F \u2014 \u6240\u6709\u529F\u80FD",
+    features: [
+      "iam",
+      "db",
+      "cache",
+      "crypto",
+      "ai",
+      "storage",
+      "audit",
+      "reach",
+      "payment",
+      "vecdb",
+      "datapipe",
+      "scheduler",
+      "deploy",
+      "api-client",
+      "capacitor"
+    ]
+  },
+  custom: {
+    name: "custom",
+    description: "\u81EA\u5B9A\u4E49 \u2014 \u9009\u62E9\u9700\u8981\u7684\u529F\u80FD",
+    features: []
+  }
+};
+async function createProject(options) {
+  const spinner = ora();
+  try {
+    const resolvedOptions = await resolveOptions(options);
+    if (!/^[a-z0-9-]+$/.test(resolvedOptions.name)) {
+      core.logger.error(chalk.red(`\u9879\u76EE\u540D\u79F0\u4E0D\u5408\u6CD5: "${resolvedOptions.name}"\uFF0C\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u8FDE\u5B57\u7B26`));
+      return;
+    }
+    const projectPath = path2.resolve(resolvedOptions.cwd ?? ".", resolvedOptions.name);
+    if (await fileExists(projectPath)) {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: `\u76EE\u5F55 ${resolvedOptions.name} \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6\uFF1F`,
+        initial: false
+      });
+      if (!overwrite) {
+        core.logger.info(chalk.yellow("\u5DF2\u53D6\u6D88"));
+        return;
+      }
+      await fse.remove(projectPath);
+    }
+    spinner.start("\u521B\u5EFA\u9879\u76EE\u76EE\u5F55...");
+    await fse.ensureDir(projectPath);
+    spinner.succeed();
+    spinner.start("\u751F\u6210\u9879\u76EE\u6587\u4EF6...");
+    const context = buildTemplateContext({
+      name: resolvedOptions.name,
+      appType: resolvedOptions.appType,
+      features: resolvedOptions.features,
+      moduleConfigs: resolvedOptions.moduleConfigs,
+      packageManager: resolvedOptions.packageManager
+    });
+    await generateFromTemplates(projectPath, context);
+    const { generateConfigFile: generateConfigFile2 } = await import('./config-templates-S5RI2MC6.js');
+    const configs = resolvedOptions.moduleConfigs;
+    for (const featureId of resolvedOptions.features) {
+      const configKey = getFeatureConfigKey(featureId);
+      if (configKey) {
+        const content = generateConfigFile2(configKey, configs);
+        await writeFile(path2.join(projectPath, "config", `_${configKey}.yml`), content);
+      }
+    }
+    await writeFile(
+      path2.join(projectPath, "config", "_core.yml"),
+      generateConfigFile2("core", configs)
+    );
+    const { generateEnvExample } = await import('./config-templates-S5RI2MC6.js');
+    await writeFile(
+      path2.join(projectPath, ".env.example"),
+      generateEnvExample(resolvedOptions.features, configs)
+    );
+    const { generateSkillFiles } = await import('./skill-templates-N5DU5FNX.js');
+    await generateSkillFiles(projectPath, resolvedOptions.features, resolvedOptions.appType);
+    const appTypeLabel = APP_TYPES[resolvedOptions.appType].name;
+    await writeFile(
+      path2.join(projectPath, "README.md"),
+      generateReadme(resolvedOptions.name, appTypeLabel, resolvedOptions.packageManager)
+    );
+    spinner.succeed();
+    if (resolvedOptions.git) {
+      spinner.start("\u521D\u59CB\u5316 Git \u4ED3\u5E93...");
+      execSync("git init", { cwd: projectPath, stdio: "ignore" });
+      spinner.succeed();
+    }
+    if (resolvedOptions.install) {
+      spinner.start(`\u5B89\u88C5\u4F9D\u8D56 (${resolvedOptions.packageManager})...`);
+      const installCmd = getInstallCommand(resolvedOptions.packageManager);
+      execSync(installCmd, { cwd: projectPath, stdio: "ignore" });
+      spinner.succeed();
+    }
+    printCompletionMessage(resolvedOptions);
+  } catch (error) {
+    spinner.fail();
+    core.logger.error(chalk.red("\u521B\u5EFA\u9879\u76EE\u5931\u8D25:"), { error });
+    throw error;
+  }
+}
+async function resolveOptions(options) {
+  core.logger.info("", {});
+  core.logger.info(chalk.bold.cyan("  \u{1F680} hai Agent Framework"));
+  core.logger.info(chalk.gray("     AI-Native \xB7 Configuration-Driven \xB7 Security-First"));
+  core.logger.info("", {});
+  const onCancel = () => {
+    core.logger.info(chalk.red("\n\u5DF2\u53D6\u6D88"));
+    process3.exit(1);
+  };
+  let projectName = options.name;
+  if (!projectName) {
+    const { name } = await prompts({
+      type: "text",
+      name: "name",
+      message: "\u9879\u76EE\u540D\u79F0:",
+      initial: "my-app",
+      validate: (value) => {
+        if (!value.trim())
+          return "\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        if (!/^[a-z0-9-]+$/.test(value))
+          return "\u9879\u76EE\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u8FDE\u5B57\u7B26";
+        return true;
+      }
+    }, { onCancel });
+    projectName = name;
+  }
+  let resolvedAppType = options.appType;
+  if (!resolvedAppType) {
+    const { appType } = await prompts({
+      type: "select",
+      name: "appType",
+      message: "\u5E94\u7528\u7C7B\u578B:",
+      choices: Object.entries(APP_TYPES).map(([key, t]) => ({
+        title: `${chalk.bold(t.name.padEnd(10))} ${chalk.gray(t.description)}`,
+        value: key
+      })),
+      initial: 0
+    }, { onCancel });
+    resolvedAppType = appType;
+  }
+  const selectedAppType = resolvedAppType || "admin";
+  let selectedTemplate = options.template;
+  if (!selectedTemplate) {
+    const { template } = await prompts({
+      type: "select",
+      name: "template",
+      message: "\u9009\u62E9\u6A21\u677F:",
+      choices: Object.values(PROJECT_TEMPLATES).map((t) => ({
+        title: `${chalk.bold(t.name.padEnd(10))} ${chalk.gray(t.description)}`,
+        value: t.name
+      })),
+      initial: 1
+    }, { onCancel });
+    selectedTemplate = template;
+  }
+  let selectedFeatures = [];
+  const appTypeDefaults = APP_TYPES[selectedAppType].defaultFeatures;
+  if (selectedTemplate === "custom" && !options.features) {
+    const featureChoices = SELECTABLE_FEATURES.map((id) => ({
+      title: `${chalk.bold(FEATURES[id].name.padEnd(10))} ${chalk.gray(FEATURES[id].description)}`,
+      value: id,
+      selected: appTypeDefaults.includes(id)
+    }));
+    const { features } = await prompts({
+      type: "multiselect",
+      name: "features",
+      message: "\u9009\u62E9\u529F\u80FD (\u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4):",
+      choices: featureChoices,
+      hint: "- \u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4",
+      instructions: false
+    }, { onCancel });
+    selectedFeatures = features || [];
+    selectedFeatures = resolveFeatureDependencies(selectedFeatures);
+  } else if (selectedTemplate === "custom" && options.features) {
+    selectedFeatures = resolveFeatureDependencies(options.features);
+  } else {
+    const templateFeatures = PROJECT_TEMPLATES[selectedTemplate]?.features || [];
+    const merged = /* @__PURE__ */ new Set([...templateFeatures, ...appTypeDefaults]);
+    selectedFeatures = resolveFeatureDependencies(Array.from(merged));
+  }
+  const moduleConfigs = options.moduleConfigs ?? await promptModuleConfigs(selectedFeatures, projectName);
+  let addExamples = options.examples;
+  if (addExamples === void 0) {
+    const { examples } = await prompts({
+      type: "confirm",
+      name: "examples",
+      message: "\u662F\u5426\u6DFB\u52A0\u793A\u4F8B\u4EE3\u7801?",
+      initial: true
+    }, { onCancel });
+    addExamples = examples;
+  }
+  const detected = await detectPackageManager(options.cwd ?? ".");
+  let packageManager = options.packageManager;
+  if (!packageManager) {
+    const { pm } = await prompts({
+      type: "select",
+      name: "pm",
+      message: "\u5305\u7BA1\u7406\u5668:",
+      choices: [
+        { title: "pnpm (\u63A8\u8350)", value: "pnpm" },
+        { title: "npm", value: "npm" },
+        { title: "yarn", value: "yarn" }
+      ],
+      initial: detected === "pnpm" ? 0 : detected === "npm" ? 1 : 2
+    }, { onCancel });
+    packageManager = pm;
+  }
+  let install = options.install;
+  if (install === void 0) {
+    const { doInstall } = await prompts({
+      type: "confirm",
+      name: "doInstall",
+      message: "\u662F\u5426\u5B89\u88C5\u4F9D\u8D56?",
+      initial: true
+    }, { onCancel });
+    install = doInstall;
+  }
+  let git = options.git;
+  if (git === void 0) {
+    const { initGit } = await prompts({
+      type: "confirm",
+      name: "initGit",
+      message: "\u662F\u5426\u521D\u59CB\u5316 Git?",
+      initial: true
+    }, { onCancel });
+    git = initGit;
+  }
+  return {
+    name: projectName,
+    appType: selectedAppType,
+    template: selectedTemplate ?? "default",
+    features: selectedFeatures,
+    moduleConfigs,
+    examples: addExamples ?? true,
+    install: install ?? true,
+    packageManager: packageManager || "pnpm",
+    git: git ?? true,
+    verbose: options.verbose ?? false,
+    cwd: options.cwd ?? "."
+  };
+}
+function resolveFeatureDependencies(features) {
+  const result = new Set(features);
+  for (const featureId of features) {
+    const feature = FEATURES[featureId];
+    if (feature?.dependencies) {
+      for (const dep of feature.dependencies) {
+        result.add(dep);
+      }
+    }
+  }
+  return Array.from(result);
+}
+async function promptModuleConfigs(features, projectName) {
+  const configs = {};
+  const onCancel = () => {
+    core.logger.info(chalk.red("\n\u5DF2\u53D6\u6D88"));
+    process3.exit(1);
+  };
+  core.logger.info("");
+  core.logger.info(chalk.bold("  \u2699 \u6A21\u5757\u914D\u7F6E"));
+  core.logger.info(chalk.gray("     \u8BBE\u7F6E\u5173\u952E\u914D\u7F6E\u9879\uFF08\u56DE\u8F66\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF09"));
+  core.logger.info("");
+  configs.core = await promptCoreConfig(projectName, onCancel);
+  if (features.includes("db")) {
+    configs.db = await promptDbConfig(projectName, onCancel);
+  }
+  if (features.includes("cache")) {
+    configs.cache = await promptCacheConfig(onCancel);
+  }
+  if (features.includes("iam")) {
+    configs.iam = await promptIamConfig(onCancel);
+  }
+  if (features.includes("storage")) {
+    configs.storage = await promptStorageConfig(onCancel);
+  }
+  if (features.includes("ai")) {
+    configs.ai = await promptAiConfig(onCancel);
+  }
+  return configs;
+}
+async function promptCoreConfig(projectName, onCancel) {
+  core.logger.info(chalk.cyan("  [core] \u5E94\u7528\u57FA\u7840\u914D\u7F6E"));
+  const { defaultLocale } = await prompts({
+    type: "select",
+    name: "defaultLocale",
+    message: "\u9ED8\u8BA4\u8BED\u8A00:",
+    choices: [
+      { title: "\u4E2D\u6587 (zh-CN)", value: "zh-CN" },
+      { title: "English (en-US)", value: "en-US" }
+    ],
+    initial: 0
+  }, { onCancel });
+  return { name: projectName, defaultLocale };
+}
+async function promptDbConfig(projectName, onCancel) {
+  core.logger.info(chalk.cyan("  [db] \u6570\u636E\u5E93\u914D\u7F6E"));
+  const { type } = await prompts({
+    type: "select",
+    name: "type",
+    message: "\u6570\u636E\u5E93\u7C7B\u578B:",
+    choices: [
+      { title: "SQLite (\u96F6\u914D\u7F6E\uFF0C\u9002\u5408\u5F00\u53D1)", value: "sqlite" },
+      { title: "PostgreSQL", value: "postgresql" },
+      { title: "MySQL", value: "mysql" }
+    ],
+    initial: 0
+  }, { onCancel });
+  if (type === "sqlite") {
+    const { database } = await prompts({
+      type: "text",
+      name: "database",
+      message: "SQLite \u6570\u636E\u5E93\u8DEF\u5F84:",
+      initial: "./data/app.db"
+    }, { onCancel });
+    return { type, database };
+  }
+  const answers = await prompts([
+    { type: "text", name: "host", message: `${type === "postgresql" ? "PostgreSQL" : "MySQL"} \u4E3B\u673A:`, initial: "localhost" },
+    { type: "number", name: "port", message: "\u7AEF\u53E3:", initial: type === "postgresql" ? 5432 : 3306 },
+    { type: "text", name: "database", message: "\u6570\u636E\u5E93\u540D\u79F0:", initial: projectName }
+  ], { onCancel });
+  return { type, host: answers.host, port: answers.port, database: answers.database };
+}
+async function promptCacheConfig(onCancel) {
+  core.logger.info(chalk.cyan("  [cache] \u7F13\u5B58\u914D\u7F6E"));
+  const { type } = await prompts({
+    type: "select",
+    name: "type",
+    message: "\u7F13\u5B58\u7C7B\u578B:",
+    choices: [
+      { title: "\u5185\u5B58\u7F13\u5B58 (\u96F6\u914D\u7F6E\uFF0C\u9002\u5408\u5F00\u53D1)", value: "memory" },
+      { title: "Redis", value: "redis" }
+    ],
+    initial: 0
+  }, { onCancel });
+  if (type === "memory")
+    return { type };
+  const answers = await prompts([
+    { type: "text", name: "host", message: "Redis \u4E3B\u673A:", initial: "localhost" },
+    { type: "number", name: "port", message: "Redis \u7AEF\u53E3:", initial: 6379 }
+  ], { onCancel });
+  return { type, host: answers.host, port: answers.port };
+}
+async function promptIamConfig(onCancel) {
+  core.logger.info(chalk.cyan("  [iam] \u8BA4\u8BC1\u6388\u6743\u914D\u7F6E"));
+  const answers = await prompts([
+    { type: "confirm", name: "loginPassword", message: "\u542F\u7528\u5BC6\u7801\u767B\u5F55?", initial: true },
+    { type: "confirm", name: "loginOtp", message: "\u542F\u7528 OTP \u9A8C\u8BC1\u7801\u767B\u5F55?", initial: false }
+  ], { onCancel });
+  return { loginPassword: answers.loginPassword, loginOtp: answers.loginOtp };
+}
+async function promptStorageConfig(onCancel) {
+  core.logger.info(chalk.cyan("  [storage] \u6587\u4EF6\u5B58\u50A8\u914D\u7F6E"));
+  const { type } = await prompts({
+    type: "select",
+    name: "type",
+    message: "\u5B58\u50A8\u7C7B\u578B:",
+    choices: [
+      { title: "\u672C\u5730\u5B58\u50A8 (\u96F6\u914D\u7F6E\uFF0C\u9002\u5408\u5F00\u53D1)", value: "local" },
+      { title: "S3 / MinIO / OSS", value: "s3" }
+    ],
+    initial: 0
+  }, { onCancel });
+  if (type === "local") {
+    const { localPath } = await prompts({
+      type: "text",
+      name: "localPath",
+      message: "\u5B58\u50A8\u8DEF\u5F84:",
+      initial: "./data/uploads"
+    }, { onCancel });
+    return { type, localPath };
+  }
+  return { type };
+}
+async function promptAiConfig(onCancel) {
+  core.logger.info(chalk.cyan("  [ai] AI \u96C6\u6210\u914D\u7F6E"));
+  const { defaultProvider } = await prompts({
+    type: "select",
+    name: "defaultProvider",
+    message: "AI Provider:",
+    choices: [
+      { title: "OpenAI", value: "openai" },
+      { title: "Anthropic (Claude)", value: "anthropic" },
+      { title: "\u5176\u4ED6 (OpenAI \u517C\u5BB9)", value: "custom" }
+    ],
+    initial: 0
+  }, { onCancel });
+  const defaultModel = defaultProvider === "openai" ? "gpt-4o-mini" : defaultProvider === "anthropic" ? "claude-3-sonnet" : "";
+  const { model } = await prompts({
+    type: "text",
+    name: "model",
+    message: "\u9ED8\u8BA4\u6A21\u578B:",
+    initial: defaultModel
+  }, { onCancel });
+  return { defaultProvider, model };
+}
+function getFeatureConfigKey(featureId) {
+  const map = {
+    db: "db",
+    cache: "cache",
+    iam: "iam",
+    storage: "storage",
+    ai: "ai",
+    deploy: "deploy",
+    vecdb: "vecdb",
+    reach: "reach",
+    scheduler: "scheduler",
+    audit: "audit",
+    payment: "payment"
+  };
+  return map[featureId] ?? null;
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    default:
+      return "npm install";
+  }
+}
+function generateReadme(name, appTypeLabel, pm) {
+  return `# ${name}
+
+\u57FA\u4E8E hai Agent Framework \u6784\u5EFA\u7684${appTypeLabel}\u5E94\u7528\u3002
+
+## \u5F00\u53D1
+
+\`\`\`bash
+${pm} install
+${pm} dev
+\`\`\`
+
+## \u6784\u5EFA
+
+\`\`\`bash
+${pm} build
+${pm} preview
+\`\`\`
+
+## \u6587\u6863
+
+- [hai Agent Framework](https://github.com/hai-series/hai-framework)
+- [SvelteKit](https://kit.svelte.dev/)
+- [Svelte 5](https://svelte.dev/)
+`;
+}
+function printCompletionMessage(options) {
+  core.logger.info("", {});
+  core.logger.info(chalk.green("\u2714 \u9879\u76EE\u521B\u5EFA\u6210\u529F\uFF01"));
+  core.logger.info("", {});
+  if (options.features.length > 0) {
+    core.logger.info(chalk.bold("\u5DF2\u542F\u7528\u529F\u80FD:"));
+    for (const featureId of options.features) {
+      const feature = FEATURES[featureId];
+      if (feature) {
+        core.logger.info(chalk.gray(`  \u2022 ${feature.name} (${featureId})`));
+      }
+    }
+    core.logger.info("", {});
+  }
+  core.logger.info("\u4E0B\u4E00\u6B65\uFF1A");
+  core.logger.info(chalk.cyan(`  cd ${options.name}`));
+  if (!options.install) {
+    core.logger.info(chalk.cyan(`  ${options.packageManager} install`));
+  }
+  core.logger.info(chalk.cyan(`  ${options.packageManager} dev`));
+  core.logger.info("", {});
+}
+async function detectProject(cwd) {
+  const pkgPath = path2.join(cwd, "package.json");
+  if (!await fileExists(pkgPath)) {
+    return null;
+  }
+  try {
+    const pkg = await fse.readJson(pkgPath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const haiPackages = Object.keys(deps).filter((name) => name.startsWith("@h-ai/"));
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      description: pkg.description,
+      isHaiProject: haiPackages.length > 0,
+      haiPackages
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/add.ts
+var MODULE_MAP = {
+  // iam 依赖 crypto（password hash）/ db（user 存储）/ cache（session 缓存）
+  "iam": { packages: ["@h-ai/iam"], deps: ["crypto", "db", "cache"], configKey: "iam", description: "\u8EAB\u4EFD\u4E0E\u8BBF\u95EE\u7BA1\u7406" },
+  // 'db' 和 'reldb' 都映射到 @h-ai/reldb，兼容用户习惯（hai add db 和 hai add reldb 均可）
+  "db": { packages: ["@h-ai/reldb"], configKey: "db", description: "\u6570\u636E\u5E93" },
+  "reldb": { packages: ["@h-ai/reldb"], configKey: "db", description: "\u6570\u636E\u5E93" },
+  "cache": { packages: ["@h-ai/cache"], configKey: "cache", description: "\u7F13\u5B58" },
+  "ai": { packages: ["@h-ai/ai"], configKey: "ai", description: "AI \u96C6\u6210" },
+  "storage": { packages: ["@h-ai/storage"], configKey: "storage", description: "\u6587\u4EF6\u5B58\u50A8" },
+  "crypto": { packages: ["@h-ai/crypto"], description: "\u52A0\u5BC6\u6A21\u5757" },
+  "kit": { packages: ["@h-ai/kit"], description: "SvelteKit \u96C6\u6210\u5DE5\u5177" },
+  "ui": { packages: ["@h-ai/ui"], description: "UI \u7EC4\u4EF6\u5E93" },
+  "deploy": { packages: ["@h-ai/deploy"], configKey: "deploy", description: "\u81EA\u52A8\u5316\u90E8\u7F72" },
+  "vecdb": { packages: ["@h-ai/vecdb"], configKey: "vecdb", description: "\u5411\u91CF\u6570\u636E\u5E93" },
+  "datapipe": { packages: ["@h-ai/datapipe"], description: "\u6570\u636E\u5904\u7406\u7BA1\u9053" },
+  "reach": { packages: ["@h-ai/reach"], configKey: "reach", description: "\u6D88\u606F\u63A8\u9001" },
+  "scheduler": { packages: ["@h-ai/scheduler"], deps: ["db"], configKey: "scheduler", description: "\u4EFB\u52A1\u8C03\u5EA6" },
+  "audit": { packages: ["@h-ai/audit"], deps: ["db"], configKey: "audit", description: "\u5BA1\u8BA1\u65E5\u5FD7" },
+  "payment": { packages: ["@h-ai/payment"], configKey: "payment", description: "\u652F\u4ED8" },
+  "capacitor": { packages: ["@h-ai/capacitor"], description: "\u79FB\u52A8\u7AEF\u80FD\u529B" },
+  "api-client": { packages: ["@h-ai/api-client"], description: "HTTP \u5BA2\u6237\u7AEF" }
+};
+async function addModule(options) {
+  const spinner = ora();
+  const cwd = options.cwd ?? ".";
+  try {
+    const project = await detectProject(cwd);
+    if (!project) {
+      core.logger.error(chalk.red("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\uFF08\u627E\u4E0D\u5230 package.json\uFF09"));
+      return;
+    }
+    let moduleName = options.module;
+    if (!moduleName) {
+      const installed = new Set(project.haiPackages);
+      const choices = Object.entries(MODULE_MAP).filter(([, def]) => !def.packages.every((p) => installed.has(p))).map(([key, def]) => ({
+        title: `${chalk.bold(key.padEnd(10))} ${chalk.gray(def.description)}`,
+        value: key
+      }));
+      if (choices.length === 0) {
+        core.logger.info(chalk.green("\u6240\u6709\u6A21\u5757\u5DF2\u5B89\u88C5\uFF01"));
+        return;
+      }
+      const { selected } = await prompts({
+        type: "select",
+        name: "selected",
+        message: "\u9009\u62E9\u8981\u6DFB\u52A0\u7684\u6A21\u5757:",
+        choices
+      });
+      if (!selected)
+        return;
+      moduleName = selected;
+    }
+    const moduleDef = MODULE_MAP[moduleName];
+    if (!moduleDef) {
+      core.logger.error(chalk.red(`\u672A\u77E5\u6A21\u5757: ${moduleName}`));
+      core.logger.info(`\u53EF\u7528\u6A21\u5757: ${Object.keys(MODULE_MAP).join(", ")}`);
+      return;
+    }
+    const { generateProjectAiSupport, resolveSkillNamesForPackages } = await import('./skill-templates-N5DU5FNX.js');
+    if (moduleDef.packages.every((p) => project.haiPackages.includes(p))) {
+      const generatedFiles2 = await generateProjectAiSupport(
+        cwd,
+        resolveSkillNamesForPackages(project.haiPackages),
+        {
+          overwriteSkills: false,
+          overwriteBridgeFiles: false
+        }
+      );
+      if (generatedFiles2.length > 0) {
+        core.logger.info(chalk.yellow(`\u6A21\u5757 ${moduleName} \u5DF2\u5B89\u88C5\uFF0C\u5DF2\u8865\u5168 AI \u652F\u6301\u6587\u4EF6`));
+        for (const generatedFile of generatedFiles2) {
+          core.logger.info(chalk.gray(`  + ${generatedFile} (AI support)`));
+        }
+      } else {
+        core.logger.info(chalk.yellow(`\u6A21\u5757 ${moduleName} \u5DF2\u5B89\u88C5`));
+      }
+      return;
+    }
+    const allPackages = new Set(moduleDef.packages);
+    if (moduleDef.deps) {
+      for (const dep of moduleDef.deps) {
+        const depDef = MODULE_MAP[dep];
+        if (depDef) {
+          for (const pkg2 of depDef.packages) {
+            allPackages.add(pkg2);
+          }
+        }
+      }
+    }
+    spinner.start("\u66F4\u65B0 package.json...");
+    const pkgPath = path2.join(cwd, "package.json");
+    const pkg = await fse.readJson(pkgPath);
+    if (!pkg.dependencies)
+      pkg.dependencies = {};
+    for (const pkgName of allPackages) {
+      if (!pkg.dependencies[pkgName]) {
+        pkg.dependencies[pkgName] = "workspace:*";
+      }
+    }
+    await fse.writeJson(pkgPath, pkg, { spaces: 2 });
+    spinner.succeed();
+    if (moduleDef.configKey) {
+      const configDir = path2.join(cwd, "config");
+      const configPath = path2.join(configDir, `_${moduleDef.configKey}.yml`);
+      if (!await fileExists(configPath)) {
+        spinner.start(`\u751F\u6210\u914D\u7F6E\u6587\u4EF6 config/_${moduleDef.configKey}.yml...`);
+        const content = generateConfigFile(moduleDef.configKey);
+        await writeFile(configPath, content);
+        spinner.succeed();
+      } else {
+        core.logger.info(chalk.gray(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: config/_${moduleDef.configKey}.yml`));
+      }
+    }
+    if (moduleDef.deps) {
+      for (const dep of moduleDef.deps) {
+        const depDef = MODULE_MAP[dep];
+        if (depDef?.configKey) {
+          const depConfigPath = path2.join(cwd, "config", `_${depDef.configKey}.yml`);
+          if (!await fileExists(depConfigPath)) {
+            const content = generateConfigFile(depDef.configKey);
+            await writeFile(depConfigPath, content);
+            core.logger.info(chalk.gray(`  + config/_${depDef.configKey}.yml (\u4F9D\u8D56)`));
+          }
+        }
+      }
+    }
+    const skillPackages = [...project.haiPackages, ...allPackages];
+    const generatedFiles = await generateProjectAiSupport(
+      cwd,
+      resolveSkillNamesForPackages(skillPackages),
+      {
+        overwriteSkills: false,
+        overwriteBridgeFiles: false
+      }
+    );
+    if (generatedFiles.length > 0) {
+      for (const generatedFile of generatedFiles) {
+        core.logger.info(chalk.gray(`  + ${generatedFile} (AI support)`));
+      }
+    }
+    const doInstall = options.install !== false;
+    if (doInstall) {
+      spinner.start("\u5B89\u88C5\u4F9D\u8D56...");
+      const { execSync: execSync2 } = await import('child_process');
+      const pm = await detectPackageManager(cwd);
+      execSync2(`${pm} install`, { cwd, stdio: "ignore" });
+      spinner.succeed();
+    }
+    core.logger.info("");
+    core.logger.info(chalk.green(`\u2714 \u6A21\u5757 ${moduleName} \u6DFB\u52A0\u6210\u529F\uFF01`));
+    core.logger.info("");
+    core.logger.info("\u5DF2\u6DFB\u52A0\u7684\u5305:");
+    for (const pkg2 of allPackages) {
+      core.logger.info(chalk.cyan(`  ${pkg2}`));
+    }
+    core.logger.info("");
+  } catch (error) {
+    spinner.fail();
+    core.logger.error(chalk.red("\u6DFB\u52A0\u6A21\u5757\u5931\u8D25:"), { error });
+    throw error;
+  }
+}
+async function deployCommand(options) {
+  const spinner = ora();
+  const cwd = options.cwd ?? process3.cwd();
+  const appDir = resolve(cwd, options.appDir ?? ".");
+  try {
+    let deployModule;
+    try {
+      deployModule = await import('./src-XJ6YXNAF.js');
+    } catch {
+      core.logger.error(chalk.red("Deploy module not found. Install @h-ai/deploy first:"));
+      core.logger.info(chalk.cyan("  pnpm add @h-ai/deploy"));
+      return;
+    }
+    const { deploy, loadCredentials, scanApp } = deployModule;
+    spinner.start("Loading credentials...");
+    const credResult = loadCredentials();
+    if (!credResult.success) {
+      spinner.fail(chalk.red(`Failed to load credentials: ${credResult.error.message}`));
+      return;
+    }
+    spinner.succeed(`Loaded ${credResult.data.length} credentials`);
+    spinner.start("Loading deploy config...");
+    const configPath = resolve(appDir, "config", "_deploy.yml");
+    if (!existsSync(configPath)) {
+      spinner.fail(chalk.red(`Deploy config not found: ${configPath}`));
+      core.logger.info(chalk.cyan("  Run: hai add deploy  to generate config template"));
+      return;
+    }
+    const configContent = readFileSync(configPath, "utf-8");
+    const rawConfig = interpolateEnvFallback(configContent);
+    const deployConfig = parse(rawConfig);
+    spinner.succeed("Deploy config loaded");
+    spinner.start("Scanning application...");
+    const scanResult = await scanApp(appDir);
+    if (!scanResult.success) {
+      spinner.fail(chalk.red(`Scan failed: ${scanResult.error.message}`));
+      return;
+    }
+    const scan = scanResult.data;
+    spinner.succeed(`Scanned: ${scan.appName} (SvelteKit: ${scan.isSvelteKit}, Services: ${scan.requiredServices.join(", ") || "none"})`);
+    spinner.start("Initializing deploy module...");
+    const initResult = await deploy.init(deployConfig);
+    if (!initResult.success) {
+      spinner.fail(chalk.red(`Init failed: ${initResult.error.message}`));
+      return;
+    }
+    spinner.succeed("Deploy module initialized");
+    spinner.start("Deploying application...");
+    const deployResult = await deploy.deployApp(appDir, {
+      projectName: options.projectName,
+      skipProvision: options.skipProvision,
+      skipBuild: options.skipBuild
+    });
+    if (!deployResult.success) {
+      spinner.fail(chalk.red(`Deploy failed: ${deployResult.error.message}`));
+      await deploy.close();
+      return;
+    }
+    spinner.succeed(chalk.green("Deployment successful!"));
+    core.logger.info("");
+    core.logger.info(chalk.cyan(`  URL: ${deployResult.data.url}`));
+    core.logger.info(chalk.gray(`  ID:  ${deployResult.data.deploymentId}`));
+    if (deployResult.data.envVarsSet.length > 0) {
+      core.logger.info(chalk.gray(`  Env: ${deployResult.data.envVarsSet.join(", ")}`));
+    }
+    core.logger.info("");
+    await deploy.close();
+  } catch (error) {
+    spinner.fail(chalk.red("Deploy command failed"));
+    core.logger.error(error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+function interpolateEnvFallback(content) {
+  return content.replace(/\$\{([^:}]+)(?::([^}]*))?\}/g, (_match, key, defaultValue) => {
+    return process3.env[key] ?? defaultValue ?? "";
+  });
+}
+var GENERATORS = {
+  page: {
+    description: "SvelteKit \u9875\u9762",
+    defaultPath: "src/routes",
+    generate: generatePage
+  },
+  component: {
+    description: "Svelte \u7EC4\u4EF6",
+    defaultPath: "src/lib/components",
+    generate: generateComponent
+  },
+  api: {
+    description: "API \u7AEF\u70B9",
+    defaultPath: "src/routes/api",
+    generate: generateApi
+  },
+  model: {
+    description: "\u6570\u636E\u6A21\u578B",
+    defaultPath: "src/lib/models",
+    generate: generateModel
+  },
+  migration: {
+    description: "\u6570\u636E\u5E93\u8FC1\u79FB",
+    defaultPath: "migrations",
+    generate: generateMigration
+  }
+};
+async function generate(options) {
+  const spinner = ora();
+  const cwd = options.cwd ?? ".";
+  try {
+    const project = await detectProject(cwd);
+    if (!project?.isHaiProject) {
+      core.logger.warn(chalk.yellow("\u8B66\u544A: \u5F53\u524D\u76EE\u5F55\u4E0D\u662F hai \u9879\u76EE"));
+    }
+    const resolvedOptions = await resolveGenerateOptions(options);
+    const generator = GENERATORS[resolvedOptions.type];
+    if (!generator) {
+      throw new Error(`\u672A\u77E5\u7684\u751F\u6210\u5668\u7C7B\u578B: ${resolvedOptions.type}`);
+    }
+    const outputDir = path2.resolve(cwd, resolvedOptions.output || generator.defaultPath);
+    const resolvedCwd = path2.resolve(cwd);
+    if (!outputDir.startsWith(resolvedCwd + path2.sep) && outputDir !== resolvedCwd) {
+      core.logger.error(chalk.red(`\u8F93\u51FA\u8DEF\u5F84 "${resolvedOptions.output}" \u8D85\u51FA\u5DE5\u4F5C\u76EE\u5F55\u8303\u56F4`));
+      return;
+    }
+    const context = createTemplateContext(resolvedOptions.name, {
+      projectName: project?.name
+    });
+    spinner.start(`\u751F\u6210 ${generator.description}...`);
+    const files = await generator.generate(resolvedOptions.name, context, outputDir);
+    spinner.succeed();
+    core.logger.info("", {});
+    core.logger.info(chalk.green("\u2714 \u751F\u6210\u5B8C\u6210\uFF01"));
+    core.logger.info("", {});
+    core.logger.info("\u521B\u5EFA\u7684\u6587\u4EF6:");
+    files.forEach((file) => {
+      core.logger.info(chalk.cyan(`  ${path2.relative(cwd, file)}`));
+    });
+    core.logger.info("", {});
+  } catch (error) {
+    spinner.fail();
+    core.logger.error(chalk.red("\u751F\u6210\u5931\u8D25:"), { error });
+    throw error;
+  }
+}
+async function resolveGenerateOptions(options) {
+  const questions = [];
+  if (!options.type) {
+    questions.push({
+      type: "select",
+      name: "type",
+      message: "\u9009\u62E9\u751F\u6210\u7C7B\u578B:",
+      choices: Object.entries(GENERATORS).map(([key, value]) => ({
+        title: `${key} - ${value.description}`,
+        value: key
+      }))
+    });
+  }
+  if (!options.name) {
+    questions.push({
+      type: "text",
+      name: "name",
+      message: "\u540D\u79F0:",
+      validate: (value) => {
+        if (!value.trim())
+          return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        return true;
+      }
+    });
+  }
+  const answers = questions.length > 0 ? await prompts(questions) : {};
+  return {
+    type: options.type || answers.type,
+    name: options.name || answers.name,
+    output: options.output ?? "",
+    force: options.force ?? false,
+    verbose: options.verbose ?? false,
+    cwd: options.cwd ?? "."
+  };
+}
+async function generatePage(_name, context, outputDir) {
+  const files = [];
+  const pageDir = path2.join(outputDir, context.kebabCase);
+  const pageContent = `<script lang="ts">
+  /**
+   * ${context.pascalCase} \u9875\u9762
+   */
+</script>
+
+<svelte:head>
+  <title>${context.pascalCase}</title>
+</svelte:head>
+
+<div class="container mx-auto p-4">
+  <h1 class="text-2xl font-bold mb-4">${context.pascalCase}</h1>
+  
+  <!-- \u9875\u9762\u5185\u5BB9 -->
+</div>
+`;
+  const pagePath = path2.join(pageDir, "+page.svelte");
+  await writeFile(pagePath, pageContent);
+  files.push(pagePath);
+  const serverContent = `/**
+ * ${context.pascalCase} \u9875\u9762\u670D\u52A1\u7AEF
+ */
+import type { PageServerLoad, Actions } from './$types'
+
+export const load: PageServerLoad = async ({ locals }) => {
+  return {
+    // \u9875\u9762\u6570\u636E
+  }
+}
+
+export const actions: Actions = {
+  default: async ({ request, locals }) => {
+    // \u8868\u5355\u5904\u7406
+  },
+}
+`;
+  const serverPath = path2.join(pageDir, "+page.server.ts");
+  await writeFile(serverPath, serverContent);
+  files.push(serverPath);
+  return files;
+}
+async function generateComponent(_name, context, outputDir) {
+  const files = [];
+  const componentContent = `<script lang="ts">
+  /**
+   * ${context.pascalCase} \u7EC4\u4EF6
+   */
+  
+  interface Props {
+    /** \u81EA\u5B9A\u4E49 class */
+    class?: string
+  }
+  
+  let { class: className = '' }: Props = $props()
+</script>
+
+<div class={className}>
+  <!-- \u7EC4\u4EF6\u5185\u5BB9 -->
+  <slot />
+</div>
+`;
+  const componentPath = path2.join(outputDir, `${context.pascalCase}.svelte`);
+  await writeFile(componentPath, componentContent);
+  files.push(componentPath);
+  return files;
+}
+async function generateApi(_name, context, outputDir) {
+  const files = [];
+  const apiDir = path2.join(outputDir, context.kebabCase);
+  const serverContent = `/**
+ * ${context.pascalCase} API
+ */
+import type { RequestHandler } from './$types'
+import { kit } from '@h-ai/kit'
+
+/**
+ * GET ${context.kebabCase}
+ */
+export const GET: RequestHandler = async ({ locals }) => {
+  try {
+    const { requestId } = locals
+    
+    return kit.response.ok({ message: 'Hello from ${context.kebabCase}' }, requestId)
+  }
+  catch (error) {
+    return kit.response.internalError()
+  }
+}
+
+/**
+ * POST ${context.kebabCase}
+ */
+export const POST: RequestHandler = async ({ request, locals }) => {
+  try {
+    const { requestId } = locals
+    const body = await request.json()
+    
+    // \u5904\u7406\u8BF7\u6C42
+    
+    return kit.response.ok({ success: true }, requestId)
+  }
+  catch (error) {
+    return kit.response.internalError()
+  }
+}
+`;
+  const serverPath = path2.join(apiDir, "+server.ts");
+  await writeFile(serverPath, serverContent);
+  files.push(serverPath);
+  return files;
+}
+async function generateModel(_name, context, outputDir) {
+  const files = [];
+  const modelContent = `/**
+ * ${context.pascalCase} \u6A21\u578B
+ */
+import { z } from 'zod'
+
+/**
+ * ${context.pascalCase} Schema
+ */
+export const ${context.camelCase}Schema = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+})
+
+/**
+ * \u521B\u5EFA ${context.pascalCase} Schema
+ */
+export const create${context.pascalCase}Schema = ${context.camelCase}Schema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+})
+
+/**
+ * \u66F4\u65B0 ${context.pascalCase} Schema
+ */
+export const update${context.pascalCase}Schema = create${context.pascalCase}Schema.partial()
+
+/**
+ * ${context.pascalCase} \u7C7B\u578B
+ */
+export type ${context.pascalCase} = z.infer<typeof ${context.camelCase}Schema>
+export type Create${context.pascalCase} = z.infer<typeof create${context.pascalCase}Schema>
+export type Update${context.pascalCase} = z.infer<typeof update${context.pascalCase}Schema>
+`;
+  const modelPath = path2.join(outputDir, `${context.kebabCase}.ts`);
+  await writeFile(modelPath, modelContent);
+  files.push(modelPath);
+  return files;
+}
+async function generateMigration(_name, context, outputDir) {
+  const files = [];
+  const timestamp = Date.now();
+  const migrationContent = `/**
+ * \u8FC1\u79FB: ${context.pascalCase}
+ * \u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+import type { MigrationFn } from '@h-ai/reldb'
+
+export const up: MigrationFn = async (db) => {
+  // \u5347\u7EA7\u903B\u8F91
+  await db.run(\`
+    CREATE TABLE IF NOT EXISTS ${context.snakeCase} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  \`)
+}
+
+export const down: MigrationFn = async (db) => {
+  // \u56DE\u6EDA\u903B\u8F91
+  await db.run('DROP TABLE IF EXISTS ${context.snakeCase}')
+}
+`;
+  const migrationPath = path2.join(outputDir, `${timestamp}_${context.snakeCase}.ts`);
+  await writeFile(migrationPath, migrationContent);
+  files.push(migrationPath);
+  return files;
+}
+var MODULE_CONFIG_MAP = {
+  "@h-ai/core": { configKey: "core", label: "Core" },
+  "@h-ai/reldb": { configKey: "db", label: "Database" },
+  "@h-ai/cache": { configKey: "cache", label: "Cache" },
+  "@h-ai/iam": { configKey: "iam", label: "IAM" },
+  "@h-ai/storage": { configKey: "storage", label: "Storage" },
+  "@h-ai/ai": { configKey: "ai", label: "AI" },
+  "@h-ai/vecdb": { configKey: "vecdb", label: "VecDB" },
+  "@h-ai/reach": { configKey: "reach", label: "Reach" },
+  "@h-ai/scheduler": { configKey: "scheduler", label: "Scheduler" },
+  "@h-ai/audit": { configKey: "audit", label: "Audit" },
+  "@h-ai/payment": { configKey: "payment", label: "Payment" },
+  "@h-ai/deploy": { configKey: "deploy", label: "Deploy" }
+};
+async function validateProject(cwd) {
+  const project = await detectProject(cwd);
+  if (!project) {
+    return null;
+  }
+  const existing = [];
+  const missing = [];
+  for (const pkg of project.haiPackages) {
+    const mapping = MODULE_CONFIG_MAP[pkg];
+    if (!mapping)
+      continue;
+    const configPath = path2.join(cwd, "config", `_${mapping.configKey}.yml`);
+    if (await fileExists(configPath)) {
+      existing.push(mapping.configKey);
+    } else {
+      missing.push({ pkg, configKey: mapping.configKey, label: mapping.label });
+    }
+  }
+  return { existing, missing, project };
+}
+async function initProject(options) {
+  const spinner = ora();
+  const cwd = options.cwd ?? ".";
+  try {
+    spinner.start("\u68C0\u6D4B\u9879\u76EE...");
+    const result = await validateProject(cwd);
+    if (!result) {
+      spinner.fail(chalk.red("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\uFF08\u627E\u4E0D\u5230 package.json\uFF09"));
+      return;
+    }
+    const { project, existing, missing } = result;
+    spinner.succeed(`\u68C0\u6D4B\u5230\u9879\u76EE: ${chalk.cyan(project.name)}`);
+    core.logger.info("");
+    core.logger.info(chalk.bold("\u9879\u76EE\u72B6\u6001:"));
+    core.logger.info(`  \u540D\u79F0: ${chalk.cyan(project.name)}`);
+    core.logger.info(`  \u7248\u672C: ${project.version}`);
+    core.logger.info(`  \u5DF2\u5B89\u88C5\u6A21\u5757: ${project.haiPackages.length > 0 ? project.haiPackages.map((p) => chalk.cyan(p)).join(", ") : chalk.gray("\u65E0")}`);
+    core.logger.info("");
+    if (existing.length > 0) {
+      core.logger.info(chalk.bold("\u5DF2\u6709\u914D\u7F6E:"));
+      for (const key of existing) {
+        core.logger.info(chalk.green(`  \u2714 config/_${key}.yml`));
+      }
+    }
+    if (missing.length === 0 && !options.force) {
+      core.logger.info("");
+      core.logger.info(chalk.green("\u2714 \u6240\u6709\u914D\u7F6E\u6587\u4EF6\u5DF2\u5C31\u7EEA\uFF01"));
+      return;
+    }
+    if (missing.length > 0) {
+      core.logger.info("");
+      core.logger.info(chalk.bold("\u7F3A\u5931\u914D\u7F6E:"));
+      for (const item of missing) {
+        core.logger.info(chalk.yellow(`  \u2718 config/_${item.configKey}.yml (${item.label})`));
+      }
+      core.logger.info("");
+      spinner.start("\u751F\u6210\u7F3A\u5931\u914D\u7F6E\u6587\u4EF6...");
+      let generated = 0;
+      for (const item of missing) {
+        const configPath = path2.join(cwd, "config", `_${item.configKey}.yml`);
+        const content = generateConfigFile(item.configKey);
+        await writeFile(configPath, content);
+        generated++;
+      }
+      spinner.succeed(`\u5DF2\u751F\u6210 ${generated} \u4E2A\u914D\u7F6E\u6587\u4EF6`);
+    }
+    if (options.force && existing.length > 0) {
+      core.logger.info("");
+      spinner.start("\u5F3A\u5236\u91CD\u65B0\u751F\u6210\u6240\u6709\u914D\u7F6E\u6587\u4EF6...");
+      let regenerated = 0;
+      for (const pkg of project.haiPackages) {
+        const mapping = MODULE_CONFIG_MAP[pkg];
+        if (!mapping)
+          continue;
+        const configPath = path2.join(cwd, "config", `_${mapping.configKey}.yml`);
+        const content = generateConfigFile(mapping.configKey);
+        await writeFile(configPath, content);
+        regenerated++;
+      }
+      spinner.succeed(`\u5DF2\u91CD\u65B0\u751F\u6210 ${regenerated} \u4E2A\u914D\u7F6E\u6587\u4EF6`);
+    }
+    const coreConfigPath = path2.join(cwd, "config", "_core.yml");
+    if (!await fileExists(coreConfigPath)) {
+      spinner.start("\u751F\u6210\u6838\u5FC3\u914D\u7F6E config/_core.yml...");
+      const content = generateConfigFile("core");
+      await writeFile(coreConfigPath, content);
+      spinner.succeed();
+    }
+    core.logger.info("");
+    core.logger.info(chalk.green("\u2714 \u9879\u76EE\u914D\u7F6E\u521D\u59CB\u5316\u5B8C\u6210\uFF01"));
+    core.logger.info("");
+    core.logger.info(chalk.gray("\u4E0B\u4E00\u6B65:"));
+    core.logger.info(chalk.gray("  1. \u7F16\u8F91 config/ \u4E2D\u7684\u914D\u7F6E\u6587\u4EF6"));
+    core.logger.info(chalk.gray("  2. \u8FD0\u884C pnpm dev \u542F\u52A8\u5F00\u53D1\u670D\u52A1"));
+    core.logger.info("");
+  } catch (error) {
+    spinner.fail();
+    core.logger.error(chalk.red("\u521D\u59CB\u5316\u5931\u8D25:"), { error });
+    throw error;
+  }
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+var cli = cac("hai");
+cli.option("-v, --verbose", "\u663E\u793A\u8BE6\u7EC6\u8F93\u51FA");
+cli.option("-C, --cwd <path>", "\u5DE5\u4F5C\u76EE\u5F55");
+cli.command("create [name]", "\u521B\u5EFA\u65B0\u7684 hai \u9879\u76EE").option("--type <type>", "\u5E94\u7528\u7C7B\u578B (admin, website, h5, api)").option("-t, --template <template>", "\u9879\u76EE\u6A21\u677F (minimal, default, full, custom)").option("-f, --features <features>", "\u529F\u80FD\u5217\u8868 (\u9017\u53F7\u5206\u9694: iam,db,cache,ai,storage,crypto)").option("--examples", "\u6DFB\u52A0\u793A\u4F8B\u4EE3\u7801").option("--no-examples", "\u4E0D\u6DFB\u52A0\u793A\u4F8B\u4EE3\u7801").option("--no-install", "\u4E0D\u5B89\u88C5\u4F9D\u8D56").option("-p, --package-manager <pm>", "\u5305\u7BA1\u7406\u5668 (pnpm, npm, yarn)").option("--no-git", "\u4E0D\u521D\u59CB\u5316 Git").action(async (name, options) => {
+  try {
+    const features = typeof options.features === "string" ? options.features.split(",").map((f) => f.trim()) : void 0;
+    await createProject({
+      name: name ?? "",
+      appType: options.type,
+      template: options.template,
+      features,
+      examples: options.examples,
+      install: options.install,
+      packageManager: options.packageManager,
+      git: options.git,
+      verbose: options.verbose,
+      cwd: options.cwd
+    });
+  } catch {
+    process3.exit(1);
+  }
+});
+cli.command("add [module]", "\u5411\u73B0\u6709\u9879\u76EE\u6DFB\u52A0\u6A21\u5757").option("--no-install", "\u4E0D\u5B89\u88C5\u4F9D\u8D56").action(async (module, options) => {
+  try {
+    await addModule({
+      module,
+      install: options.install,
+      verbose: options.verbose,
+      cwd: options.cwd
+    });
+  } catch {
+    process3.exit(1);
+  }
+});
+cli.command("init", "\u521D\u59CB\u5316/\u6821\u9A8C\u9879\u76EE\u914D\u7F6E").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u751F\u6210\u914D\u7F6E").action(async (options) => {
+  try {
+    await initProject({
+      force: options.force,
+      verbose: options.verbose,
+      cwd: options.cwd
+    });
+  } catch {
+    process3.exit(1);
+  }
+});
+cli.command("generate [type] [name]", "\u751F\u6210\u4EE3\u7801").alias("g").option("-o, --output <path>", "\u8F93\u51FA\u8DEF\u5F84").option("-f, --force", "\u8986\u76D6\u73B0\u6709\u6587\u4EF6").action(async (type, name, options) => {
+  try {
+    await generate({
+      type,
+      name: name ?? "",
+      output: options.output,
+      force: options.force,
+      verbose: options.verbose,
+      cwd: options.cwd
+    });
+  } catch {
+    process3.exit(1);
+  }
+});
+cli.command("deploy [appDir]", "\u90E8\u7F72\u5E94\u7528\u5230\u4E91\u5E73\u53F0").option("--project-name <name>", "\u9879\u76EE\u540D\u79F0\uFF08\u9ED8\u8BA4\u4ECE package.json \u8BFB\u53D6\uFF09").option("--skip-provision", "\u8DF3\u8FC7\u57FA\u7840\u8BBE\u65BD\u5F00\u901A").option("--skip-build", "\u8DF3\u8FC7\u6784\u5EFA").action(async (appDir, options) => {
+  try {
+    await deployCommand({
+      appDir,
+      projectName: options.projectName,
+      skipProvision: options.skipProvision,
+      skipBuild: options.skipBuild,
+      verbose: options.verbose,
+      cwd: options.cwd
+    });
+  } catch {
+    process3.exit(1);
+  }
+});
+cli.command("g:page <name>", "\u751F\u6210\u9875\u9762").action(async (name, options) => {
+  await generate({ type: "page", name, cwd: options.cwd });
+});
+cli.command("g:component <name>", "\u751F\u6210\u7EC4\u4EF6").action(async (name, options) => {
+  await generate({ type: "component", name, cwd: options.cwd });
+});
+cli.command("g:api <name>", "\u751F\u6210 API").action(async (name, options) => {
+  await generate({ type: "api", name, cwd: options.cwd });
+});
+cli.command("g:model <name>", "\u751F\u6210\u6570\u636E\u6A21\u578B").action(async (name, options) => {
+  await generate({ type: "model", name, cwd: options.cwd });
+});
+cli.version(VERSION);
+cli.help();
+var parsed = cli.parse();
+if (!cli.matchedCommand && !parsed.options.help && !parsed.options.version) {
+  core.logger.info("", {});
+  core.logger.info(chalk.cyan("hai Agent Framework CLI"));
+  core.logger.info("", {});
+  cli.outputHelp();
+}
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map