@h-ai/cli 0.1.0-alpha.53 → 0.1.0-alpha.54

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { generateConfigFile } from './chunk-U4PA632G.js';
+import { generateConfigFile } from './chunk-FVDXJYMO.js';
 import './chunk-WUYLYCW2.js';
 import './chunk-2H7UOFLK.js';
 import process3 from 'process';
@@ -1076,7 +1076,7 @@ async function createProject(options) {
     });
     await generateFromTemplates(projectPath, context);
     if (resolvedOptions.appType !== "fullstack") {
-      const { generateConfigFile: generateConfigFile2, generateEnvExample } = await import('./cli-config-templates-GSXKLGU5.js');
+      const { generateConfigFile: generateConfigFile2, generateEnvExample } = await import('./cli-config-templates-WGN2I23J.js');
       const configs = resolvedOptions.moduleConfigs;
       const isApiWorkspace = resolvedOptions.appType === "api";
       const configDir = isApiWorkspace ? path2.join(projectPath, "apps", `${resolvedOptions.name}-service`, "config") : path2.join(projectPath, "config");
@@ -2118,6 +2118,69 @@ async function addModule(options) {
     throw error;
   }
 }
+
+// messages/en-US.json
+var en_US_default = {
+  cli_invalidGenerateName: "Use a name starting with a letter, with only letters, digits, hyphens or underscores",
+  cli_generateOutsideWorkspace: "Generated files must remain inside the workspace, including symbolic link targets",
+  cli_generateExists: "File already exists: {path}. Use --force to overwrite it",
+  cli_deploy_module_missing: "Deploy module not found. Install @h-ai/deploy first:",
+  cli_deploy_load_credentials: "Loading credentials...",
+  cli_deploy_credentials_failed: "Failed to load credentials: {message}",
+  cli_deploy_credentials_loaded: "Loaded {count} credentials",
+  cli_deploy_load_config: "Loading deploy config...",
+  cli_deploy_config_missing: "Deploy config not found: {path}",
+  cli_deploy_config_hint: "Run: hai add deploy to generate config template",
+  cli_deploy_config_loaded: "Deploy config loaded",
+  cli_deploy_scanning: "Scanning application...",
+  cli_deploy_scan_failed: "Scan failed: {message}",
+  cli_deploy_scanned: "Scanned: {name} (SvelteKit: {sveltekit}, Services: {services})",
+  cli_deploy_none: "none",
+  cli_deploy_initializing: "Initializing deploy module...",
+  cli_deploy_init_failed: "Init failed: {message}",
+  cli_deploy_initialized: "Deploy module initialized",
+  cli_deploy_deploying: "Deploying application...",
+  cli_deploy_failed: "Deploy failed: {message}",
+  cli_deploy_success: "Deployment successful!",
+  cli_deploy_url: "  URL: {url}",
+  cli_deploy_id: "  ID: {id}",
+  cli_deploy_env: "  Env: {names}",
+  cli_deploy_command_failed: "Deploy command failed"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  cli_invalidGenerateName: "\u540D\u79F0\u5FC5\u987B\u4EE5\u5B57\u6BCD\u5F00\u5934\uFF0C\u4E14\u4EC5\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u77ED\u6A2A\u7EBF\u6216\u4E0B\u5212\u7EBF",
+  cli_generateOutsideWorkspace: "\u751F\u6210\u6587\u4EF6\u5FC5\u987B\u4F4D\u4E8E\u5DE5\u4F5C\u76EE\u5F55\u5185\uFF0C\u7B26\u53F7\u94FE\u63A5\u76EE\u6807\u4E5F\u4E0D\u5F97\u8D8A\u754C",
+  cli_generateExists: "\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A{path}\u3002\u4F7F\u7528 --force \u624D\u53EF\u8986\u76D6",
+  cli_deploy_module_missing: "\u672A\u627E\u5230\u90E8\u7F72\u6A21\u5757\uFF0C\u8BF7\u5148\u5B89\u88C5 @h-ai/deploy\uFF1A",
+  cli_deploy_load_credentials: "\u6B63\u5728\u52A0\u8F7D\u51ED\u8BC1\u2026",
+  cli_deploy_credentials_failed: "\u52A0\u8F7D\u51ED\u8BC1\u5931\u8D25\uFF1A{message}",
+  cli_deploy_credentials_loaded: "\u5DF2\u52A0\u8F7D {count} \u9879\u51ED\u8BC1",
+  cli_deploy_load_config: "\u6B63\u5728\u52A0\u8F7D\u90E8\u7F72\u914D\u7F6E\u2026",
+  cli_deploy_config_missing: "\u672A\u627E\u5230\u90E8\u7F72\u914D\u7F6E\uFF1A{path}",
+  cli_deploy_config_hint: "\u8FD0\u884C hai add deploy \u751F\u6210\u90E8\u7F72\u914D\u7F6E\u6A21\u677F",
+  cli_deploy_config_loaded: "\u90E8\u7F72\u914D\u7F6E\u5DF2\u52A0\u8F7D",
+  cli_deploy_scanning: "\u6B63\u5728\u626B\u63CF\u5E94\u7528\u2026",
+  cli_deploy_scan_failed: "\u626B\u63CF\u5931\u8D25\uFF1A{message}",
+  cli_deploy_scanned: "\u5DF2\u626B\u63CF\uFF1A{name}\uFF08SvelteKit\uFF1A{sveltekit}\uFF0C\u670D\u52A1\uFF1A{services}\uFF09",
+  cli_deploy_none: "\u65E0",
+  cli_deploy_initializing: "\u6B63\u5728\u521D\u59CB\u5316\u90E8\u7F72\u6A21\u5757\u2026",
+  cli_deploy_init_failed: "\u521D\u59CB\u5316\u5931\u8D25\uFF1A{message}",
+  cli_deploy_initialized: "\u90E8\u7F72\u6A21\u5757\u5DF2\u521D\u59CB\u5316",
+  cli_deploy_deploying: "\u6B63\u5728\u90E8\u7F72\u5E94\u7528\u2026",
+  cli_deploy_failed: "\u90E8\u7F72\u5931\u8D25\uFF1A{message}",
+  cli_deploy_success: "\u90E8\u7F72\u6210\u529F\uFF01",
+  cli_deploy_url: "  \u5730\u5740\uFF1A{url}",
+  cli_deploy_id: "  \u6807\u8BC6\uFF1A{id}",
+  cli_deploy_env: "  \u73AF\u5883\u53D8\u91CF\uFF1A{names}",
+  cli_deploy_command_failed: "\u90E8\u7F72\u547D\u4EE4\u5931\u8D25"
+};
+
+// src/cli-i18n.ts
+var cliM = core.i18n.createMessageGetter({ "en-US": en_US_default, "zh-CN": zh_CN_default });
+
+// src/commands/cli-deploy.ts
 async function deployCommand(options) {
   const spinner = ora();
   const cwd = options.cwd ?? process3.cwd();
@@ -2126,67 +2189,68 @@ async function deployCommand(options) {
   try {
     let deployModule;
     try {
-      deployModule = await import('./src-QNEJJ3BV.js');
+      deployModule = await import('./src-6ZBWDBUB.js');
     } catch {
-      core.logger.error(chalk.red("Deploy module not found. Install @h-ai/deploy first:"));
+      core.logger.error(chalk.red(cliM("cli_deploy_module_missing")));
       core.logger.info(chalk.cyan("  pnpm add @h-ai/deploy"));
-      return;
+      throw new Error(cliM("cli_deploy_module_missing"));
     }
     const { deploy } = deployModule;
-    spinner.start("Loading credentials...");
+    spinner.start(cliM("cli_deploy_load_credentials"));
     const credResult = deploy.credentials.load();
     if (!credResult.success) {
-      spinner.fail(chalk.red(`Failed to load credentials: ${credResult.error.message}`));
-      return;
+      throw new Error(cliM("cli_deploy_credentials_failed", { params: { message: credResult.error.message } }));
     }
-    spinner.succeed(`Loaded ${credResult.data.length} credentials`);
-    spinner.start("Loading deploy config...");
+    spinner.succeed(cliM("cli_deploy_credentials_loaded", { params: { count: credResult.data.length } }));
+    spinner.start(cliM("cli_deploy_load_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;
+      spinner.fail(chalk.red(cliM("cli_deploy_config_missing", { params: { path: configPath } })));
+      core.logger.info(chalk.cyan(cliM("cli_deploy_config_hint")));
+      throw new Error(cliM("cli_deploy_config_missing", { params: { path: configPath } }));
     }
     const configContent = readFileSync(configPath, "utf-8");
     const rawConfig = interpolateEnvFallback(configContent);
     const deployConfig = parse(rawConfig);
-    spinner.succeed("Deploy config loaded");
-    spinner.start("Scanning application...");
+    spinner.succeed(cliM("cli_deploy_config_loaded"));
+    spinner.start(cliM("cli_deploy_scanning"));
     const scanResult = await deploy.scan(appDir);
     if (!scanResult.success) {
-      spinner.fail(chalk.red(`Scan failed: ${scanResult.error.message}`));
-      return;
+      throw new Error(cliM("cli_deploy_scan_failed", { params: { message: scanResult.error.message } }));
     }
     const scan = scanResult.data;
-    spinner.succeed(`Scanned: ${scan.appName} (SvelteKit: ${scan.isSvelteKit}, Services: ${scan.requiredServices.join(", ") || "none"})`);
-    spinner.start("Initializing deploy module...");
+    spinner.succeed(cliM("cli_deploy_scanned", { params: { name: scan.appName, sveltekit: String(scan.isSvelteKit), services: scan.requiredServices.join(", ") || cliM("cli_deploy_none") } }));
+    spinner.start(cliM("cli_deploy_initializing"));
     const initResult = await deploy.init(deployConfig);
     if (!initResult.success) {
-      spinner.fail(chalk.red(`Init failed: ${initResult.error.message}`));
-      return;
+      throw new Error(cliM("cli_deploy_init_failed", { params: { message: initResult.error.message } }));
     }
     closeDeploy = () => deploy.close();
-    spinner.succeed("Deploy module initialized");
-    spinner.start("Deploying application...");
+    spinner.succeed(cliM("cli_deploy_initialized"));
+    spinner.start(cliM("cli_deploy_deploying"));
     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}`));
-      return;
+      if (deployResult.error.ext?.recovery) {
+        core.logger.warn(deployResult.error.suggestion ?? cliM("cli_deploy_command_failed"), {
+          recovery: deployResult.error.ext.recovery
+        });
+      }
+      throw new Error(cliM("cli_deploy_failed", { params: { message: deployResult.error.message } }));
     }
-    spinner.succeed(chalk.green("Deployment successful!"));
+    spinner.succeed(chalk.green(cliM("cli_deploy_success")));
     core.logger.info("");
-    core.logger.info(chalk.cyan(`  URL: ${deployResult.data.url}`));
-    core.logger.info(chalk.gray(`  ID:  ${deployResult.data.deploymentId}`));
+    core.logger.info(chalk.cyan(cliM("cli_deploy_url", { params: { url: deployResult.data.url } })));
+    core.logger.info(chalk.gray(cliM("cli_deploy_id", { params: { id: deployResult.data.deploymentId } })));
     if (deployResult.data.envVarsSet.length > 0) {
-      core.logger.info(chalk.gray(`  Env: ${deployResult.data.envVarsSet.join(", ")}`));
+      core.logger.info(chalk.gray(cliM("cli_deploy_env", { params: { names: deployResult.data.envVarsSet.join(", ") } })));
     }
     core.logger.info("");
   } catch (error) {
-    spinner.fail(chalk.red("Deploy command failed"));
+    spinner.fail(chalk.red(cliM("cli_deploy_command_failed")));
     core.logger.error(error instanceof Error ? error.message : String(error));
     throw error;
   } finally {
@@ -2195,6 +2259,7 @@ async function deployCommand(options) {
         await closeDeploy();
       } catch (error) {
         core.logger.error("Failed to close deploy module", { error });
+        process3.exitCode = 1;
       }
     }
   }
@@ -2244,24 +2309,41 @@ async function generate(options) {
     if (!generator) {
       throw new Error(`\u672A\u77E5\u7684\u751F\u6210\u5668\u7C7B\u578B: ${resolvedOptions.type}`);
     }
+    if (!/^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/i.test(resolvedOptions.name))
+      throw new Error(cliM("cli_invalidGenerateName"));
     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;
+      throw new Error(cliM("cli_generateOutsideWorkspace"));
     }
     const context = createTemplateContext(resolvedOptions.name, {
       projectName: project?.name
     });
     spinner.start(`\u751F\u6210 ${generator.description}...`);
-    const files = await generator.generate(resolvedOptions.name, context, outputDir);
+    const files = await generator.generate(context, outputDir);
+    const realCwd = await fse.realpath(resolvedCwd);
+    for (const file of files) {
+      if (!resolvedOptions.force && await fse.pathExists(file.path))
+        throw new Error(cliM("cli_generateExists", { params: { path: file.path } }));
+      let ancestor = file.path;
+      while (!await fse.pathExists(ancestor))
+        ancestor = path2.dirname(ancestor);
+      const realAncestor = await fse.realpath(ancestor);
+      const relative = path2.relative(realCwd, realAncestor);
+      if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative))
+        throw new Error(cliM("cli_generateOutsideWorkspace"));
+    }
+    for (const file of files) {
+      await fse.ensureDir(path2.dirname(file.path));
+      await fse.writeFile(file.path, file.content, { encoding: "utf-8", flag: resolvedOptions.force ? "w" : "wx" });
+    }
     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(chalk.cyan(`  ${path2.relative(cwd, file.path)}`));
     });
     core.logger.info("", {});
   } catch (error) {
@@ -2305,76 +2387,72 @@ async function resolveGenerateOptions(options) {
     cwd: options.cwd ?? "."
   };
 }
-async function generatePage(_name, context, outputDir) {
+async function generatePage(context, outputDir) {
   const files = [];
   const pageDir = path2.join(outputDir, context.kebabCase);
-  const pageContent = `<script lang="ts">
-  /**
-   * ${context.pascalCase} \u9875\u9762
-   */
-</script>
-
+  const pageContent = `<!-- ${context.pascalCase} \u9875\u9762 -->
 <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>
-  
+<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);
+  files.push({ path: pagePath, content: pageContent });
   const serverContent = `/**
  * ${context.pascalCase} \u9875\u9762\u670D\u52A1\u7AEF
  */
-import type { PageServerLoad, Actions } from './$types'
+import type { Actions, PageServerLoad } from './$types'
 
-export const load: PageServerLoad = async ({ locals }) => {
+export const load: PageServerLoad = async () => {
   return {
     // \u9875\u9762\u6570\u636E
   }
 }
 
 export const actions: Actions = {
-  default: async ({ request, locals }) => {
+  default: async () => {
     // \u8868\u5355\u5904\u7406
   },
 }
 `;
   const serverPath = path2.join(pageDir, "+page.server.ts");
-  await writeFile(serverPath, serverContent);
-  files.push(serverPath);
+  files.push({ path: serverPath, content: serverContent });
   return files;
 }
-async function generateComponent(_name, context, outputDir) {
+async function generateComponent(context, outputDir) {
   const files = [];
-  const componentContent = `<script lang="ts">
+  const componentContent = `<script lang='ts'>
+  import type { Snippet } from 'svelte'
+
   /**
    * ${context.pascalCase} \u7EC4\u4EF6
    */
-  
+
   interface Props {
     /** \u81EA\u5B9A\u4E49 class */
     class?: string
+    /** \u5B50\u5185\u5BB9\uFF08Svelte 5 snippet\uFF09 */
+    children?: Snippet
   }
-  
-  let { class: className = '' }: Props = $props()
+
+  const { class: className = '', children }: Props = $props()
 </script>
 
 <div class={className}>
   <!-- \u7EC4\u4EF6\u5185\u5BB9 -->
-  <slot />
+  {@render children?.()}
 </div>
 `;
   const componentPath = path2.join(outputDir, `${context.pascalCase}.svelte`);
-  await writeFile(componentPath, componentContent);
-  files.push(componentPath);
+  files.push({ path: componentPath, content: componentContent });
   return files;
 }
-async function generateApi(_name, context, outputDir) {
+async function generateApi(context, outputDir) {
   const files = [];
   const apiDir = path2.join(outputDir, context.kebabCase);
   const serverContent = `/**
@@ -2382,44 +2460,35 @@ async function generateApi(_name, context, outputDir) {
  */
 import type { RequestHandler } from './$types'
 import { kit } from '@h-ai/kit'
+import { z } from 'zod'
+
+/** \u793A\u4F8B\u8F93\u5165\uFF1B\u6DFB\u52A0\u4E1A\u52A1\u903B\u8F91\u524D\u6269\u5C55\u5B57\u6BB5\u548C\u7EA6\u675F\u3002 */
+const InputSchema = z.object({
+  /** \u4E1A\u52A1\u540D\u79F0\uFF08\u975E\u7A7A\uFF09 */
+  name: z.string().min(1),
+})
 
 /**
  * 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()
-  }
-}
+export const GET: RequestHandler = kit.handler(async ({ locals }) => {
+  return kit.response.ok({ items: [] }, locals.requestId)
+})
 
 /**
  * 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()
-  }
-}
+export const POST: RequestHandler = kit.handler(async ({ request, locals }) => {
+  const body = await kit.validate.body(request, InputSchema)
+  // \u6821\u9A8C\u901A\u8FC7\u540E\u518D\u6267\u884C\u4E1A\u52A1\u64CD\u4F5C\uFF1B\u793A\u4F8B\u4EC5\u56DE\u4F20\u6570\u636E\uFF0C\u4E0D\u6267\u884C\u5199\u5165\u3002
+  return kit.response.ok(body, locals.requestId)
+})
 `;
   const serverPath = path2.join(apiDir, "+server.ts");
-  await writeFile(serverPath, serverContent);
-  files.push(serverPath);
+  files.push({ path: serverPath, content: serverContent });
   return files;
 }
-async function generateModel(_name, context, outputDir) {
+async function generateModel(context, outputDir) {
   const files = [];
   const modelContent = `/**
  * ${context.pascalCase} \u6A21\u578B
@@ -2430,9 +2499,13 @@ import { z } from 'zod'
  * ${context.pascalCase} Schema
  */
 export const ${context.camelCase}Schema = z.object({
+  /** \u8BB0\u5F55\u552F\u4E00\u6807\u8BC6 */
   id: z.string(),
+  /** \u663E\u793A\u540D\u79F0 */
   name: z.string().min(1),
+  /** \u521B\u5EFA\u65F6\u95F4 */
   createdAt: z.date(),
+  /** \u6700\u540E\u4FEE\u6539\u65F6\u95F4 */
   updatedAt: z.date(),
 })
 
@@ -2458,39 +2531,35 @@ export type Create${context.pascalCase} = z.infer<typeof create${context.pascalC
 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);
+  files.push({ path: modelPath, content: modelContent });
   return files;
 }
-async function generateMigration(_name, context, outputDir) {
+async function generateMigration(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'
+import { reldb } 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
-    )
-  \`)
+/** \u5347\u7EA7\uFF1A\u8C03\u7528\u524D\u521D\u59CB\u5316 reldb\uFF0C\u8C03\u7528\u65B9\u5FC5\u987B\u68C0\u67E5\u8FD4\u56DE\u7684 HaiResult\u3002 */
+export function up() {
+  return reldb.ddl.createTable('hai_app_${context.snakeCase}', {
+    id: { type: 'TEXT', primaryKey: true },
+    name: { type: 'TEXT', notNull: true },
+    created_at: { type: 'TIMESTAMP', notNull: true },
+    updated_at: { type: 'TIMESTAMP', notNull: true },
+  })
 }
 
-export const down: MigrationFn = async (db) => {
-  // \u56DE\u6EDA\u903B\u8F91
-  await db.run('DROP TABLE IF EXISTS ${context.snakeCase}')
+/** \u56DE\u6EDA\u4F1A\u5220\u9664\u6574\u5F20\u8868\uFF1B\u7531\u5E94\u7528\u786E\u8BA4\u6570\u636E\u53EF\u5220\u9664\u540E\u663E\u5F0F\u8C03\u7528\u3002 */
+export function down() {
+  return reldb.ddl.dropTable('hai_app_${context.snakeCase}')
 }
 `;
   const migrationPath = path2.join(outputDir, `${timestamp}_${context.snakeCase}.ts`);
-  await writeFile(migrationPath, migrationContent);
-  files.push(migrationPath);
+  files.push({ path: migrationPath, content: migrationContent });
   return files;
 }
 var MODULE_CONFIG_MAP = {