@simplysm/sd-cli 13.0.69 → 13.0.71

package/src/commands/add-client.ts

@@ -10,7 +10,7 @@ import { findPackageRoot } from "../utils/package-utils";
 //#region Types
 
 /**
- * Add-client 명령 옵션
+ * Add-client command options
  */
 export interface AddClientOptions {}
 
@@ -22,56 +22,56 @@ export interface AddClientOptions {}
 //#region Main
 
 /**
- * 클라이언트 패키지를 프로젝트에 추가한다.
+ * Add client package to the project.
  *
- * 1. 프로젝트 루트 확인 (sd.config.ts 존재)
- * 2. 대화형 프롬프트 (이름 접미사, 라우터 사용 여부)
- * 3. 패키지 디렉토리 중복 확인
- * 4. Handlebars 템플릿 렌더링
- * 5. sd.config.ts에 패키지 항목 추가 (ts-morph)
- * 6. eslint.config.ts에 tailwind 설정 추가 (첫 클라이언트인 경우)
+ * 1. Verify project root (sd.config.ts exists)
+ * 2. Interactive prompt (name suffix, router usage)
+ * 3. Check for duplicate package directory
+ * 4. Render Handlebars template
+ * 5. Add package entry to sd.config.ts (ts-morph)
+ * 6. Add tailwind configuration to eslint.config.ts (if first client)
  * 7. pnpm install
  */
 export async function runAddClient(_options: AddClientOptions): Promise<void> {
   const cwd = process.cwd();
   const logger = consola.withTag("sd:cli:add-client");
 
-  // 1. 프로젝트 루트 확인
+  // 1. Verify project root
   if (!fs.existsSync(path.join(cwd, "sd.config.ts"))) {
-    consola.error("sd.config.ts를 찾을 수 없습니다. 프로젝트 루트에서 실행해주세요.");
+    consola.error("Cannot find sd.config.ts. Please run from the project root.");
     process.exitCode = 1;
     return;
   }
 
-  // 프로젝트명
+  // Project name
   const projectName = path.basename(cwd);
 
-  // 2. 대화형 프롬프트
+  // 2. Interactive prompt
   const clientSuffix = await input({
-    message: "클라이언트 이름을 입력하세요 (client-___):",
+    message: "Enter client name suffix (client-___):",
     validate: (value) => {
-      if (!value.trim()) return "이름을 입력해주세요.";
-      if (!/^[a-z][a-z0-9-]*$/.test(value)) return "소문자, 숫자, 하이픈만 사용 가능합니다.";
+      if (!value.trim()) return "Please enter a name.";
+      if (!/^[a-z][a-z0-9-]*$/.test(value)) return "Only lowercase letters, numbers, and hyphens are allowed.";
       return true;
     },
   });
 
   const useRouter = await confirm({
-    message: "라우터를 사용하시겠습니까?",
+    message: "Do you want to use router?",
     default: true,
   });
 
   const clientName = `client-${clientSuffix}`;
 
-  // 3. 패키지 디렉토리 중복 확인
+  // 3. Check for duplicate package directory
   const packageDir = path.join(cwd, "packages", clientName);
   if (fs.existsSync(packageDir)) {
-    consola.error(`packages/${clientName} 디렉토리가 이미 존재합니다.`);
+    consola.error(`packages/${clientName} directory already exists.`);
     process.exitCode = 1;
     return;
   }
 
-  // 4. 템플릿 렌더링
+  // 4. Render template
   const pkgRoot = findPackageRoot(import.meta.dirname);
   const templateDir = path.join(pkgRoot, "templates", "add-client");
 
@@ -86,39 +86,39 @@ export async function runAddClient(_options: AddClientOptions): Promise<void> {
     __CLIENT__: clientName,
   };
 
-  logger.info(`${clientName} 패키지 생성 중...`);
+  logger.info(`Creating ${clientName} package...`);
   await renderTemplateDir(templateDir, path.join(cwd, "packages"), context, dirReplacements);
-  logger.success(`packages/${clientName} 생성 완료`);
+  logger.success(`packages/${clientName} created successfully`);
 
-  // 5. sd.config.ts 업데이트
+  // 5. Update sd.config.ts
   const sdConfigPath = path.join(cwd, "sd.config.ts");
   const added = addPackageToSdConfig(sdConfigPath, clientName, { target: "client" });
   if (added) {
-    logger.success("sd.config.ts 업데이트 완료");
+    logger.success("sd.config.ts updated successfully");
   } else {
-    consola.warn(`"${clientName}"이(가) sd.config.ts에 이미 존재합니다.`);
+    consola.warn(`"${clientName}" already exists in sd.config.ts.`);
   }
 
-  // 6. eslint.config.ts tailwind 설정 추가 (첫 클라이언트인 경우)
+  // 6. Add tailwind configuration to eslint.config.ts (if first client)
   const eslintConfigPath = path.join(cwd, "eslint.config.ts");
   if (fs.existsSync(eslintConfigPath)) {
     const tailwindAdded = addTailwindToEslintConfig(eslintConfigPath, clientName);
     if (tailwindAdded) {
-      logger.success("eslint.config.ts에 tailwind 설정 추가");
+      logger.success("Added tailwind configuration to eslint.config.ts");
     }
   }
 
   // 7. pnpm install
-  logger.info("pnpm install 실행 중...");
+  logger.info("Running pnpm install...");
   await execa("pnpm", ["install"], { cwd });
-  logger.success("pnpm install 완료");
+  logger.success("pnpm install completed");
 
-  // 완료
+  // Done
   consola.box(
     [
-      `클라이언트 "${clientName}"이(가) 추가되었습니다!`,
+      `Client "${clientName}" has been added!`,
       "",
-      `  pnpm dev ${clientName}    개발 서버 실행`,
+      `  pnpm dev ${clientName}    Run development server`,
     ].join("\n"),
   );
 }

package/src/commands/add-server.ts

@@ -10,7 +10,7 @@ import { findPackageRoot } from "../utils/package-utils";
 //#region Types
 
 /**
- * Add-server 명령 옵션
+ * Add-server command options
  */
 export interface AddServerOptions {}
 
@@ -19,13 +19,13 @@ export interface AddServerOptions {}
 //#region Utilities
 
 /**
- * sd.config.ts를 읽어서 target이 "client"인 패키지명 목록을 반환한다.
+ * Reads sd.config.ts and returns a list of package names with target "client".
  */
 function findClientPackages(sdConfigPath: string): string[] {
   const content = fs.readFileSync(sdConfigPath, "utf-8");
   const clients: string[] = [];
 
-  // 간단한 패턴 매칭으로 client 패키지 찾기
+  // Find client packages using simple pattern matching
   const regex = /"([^"]+)":\s*\{[^}]*target:\s*"client"/g;
   let match: RegExpExecArray | null;
   while ((match = regex.exec(content)) != null) {
@@ -39,62 +39,62 @@ function findClientPackages(sdConfigPath: string): string[] {
 //#region Main
 
 /**
- * 서버 패키지를 프로젝트에 추가한다.
+ * Adds a server package to the project.
  *
- * 1. 프로젝트 루트 확인
- * 2. 대화형 프롬프트 (이름 접미사, 클라이언트 선택)
- * 3. 패키지 디렉토리 중복 확인
- * 4. Handlebars 템플릿 렌더링
- * 5. sd.config.ts에 서버 패키지 항목 추가
- * 6. 선택된 클라이언트의 server 필드 업데이트
- * 7. pnpm install
+ * 1. Verify project root
+ * 2. Interactive prompts (name suffix, client selection)
+ * 3. Check for duplicate package directory
+ * 4. Render Handlebars template
+ * 5. Add server package entry to sd.config.ts
+ * 6. Update server field in selected clients
+ * 7. Run pnpm install
  */
 export async function runAddServer(_options: AddServerOptions): Promise<void> {
   const cwd = process.cwd();
   const logger = consola.withTag("sd:cli:add-server");
 
-  // 1. 프로젝트 루트 확인
+  // 1. Verify project root
   const sdConfigPath = path.join(cwd, "sd.config.ts");
   if (!fs.existsSync(sdConfigPath)) {
-    consola.error("sd.config.ts를 찾을 수 없습니다. 프로젝트 루트에서 실행해주세요.");
+    consola.error("Cannot find sd.config.ts. Please run this from the project root.");
     process.exitCode = 1;
     return;
   }
 
   const projectName = path.basename(cwd);
 
-  // 2. 대화형 프롬프트
+  // 2. Interactive prompts
   const serverSuffix = await input({
-    message: '서버 이름 접미사 (비워두면 "server"):',
+    message: 'Server name suffix (leave empty for "server"):',
     validate: (value) => {
-      if (value.trim() === "") return true; // 빈 값 허용
-      if (!/^[a-z][a-z0-9-]*$/.test(value)) return "소문자, 숫자, 하이픈만 사용 가능합니다.";
+      if (value.trim() === "") return true; // Allow empty value
+      if (!/^[a-z][a-z0-9-]*$/.test(value)) return "Only lowercase letters, numbers, and hyphens are allowed.";
       return true;
     },
   });
 
   const serverName = serverSuffix.trim() === "" ? "server" : `server-${serverSuffix}`;
 
-  // 클라이언트 선택 (기존 클라이언트가 있는 경우)
+  // Client selection (if existing clients are present)
   const clientPackages = findClientPackages(sdConfigPath);
   let selectedClients: string[] = [];
 
   if (clientPackages.length > 0) {
     selectedClients = await checkbox({
-      message: "이 서버가 서비스할 클라이언트를 선택하세요:",
+      message: "Select the clients this server will serve:",
       choices: clientPackages.map((name) => ({ name, value: name })),
     });
   }
 
-  // 3. 패키지 디렉토리 중복 확인
+  // 3. Check for duplicate package directory
   const packageDir = path.join(cwd, "packages", serverName);
   if (fs.existsSync(packageDir)) {
-    consola.error(`packages/${serverName} 디렉토리가 이미 존재합니다.`);
+    consola.error(`packages/${serverName} directory already exists.`);
     process.exitCode = 1;
     return;
   }
 
-  // 4. 템플릿 렌더링
+  // 4. Render template
   const pkgRoot = findPackageRoot(import.meta.dirname);
   const templateDir = path.join(pkgRoot, "templates", "add-server");
 
@@ -108,31 +108,31 @@ export async function runAddServer(_options: AddServerOptions): Promise<void> {
     __SERVER__: serverName,
   };
 
-  logger.info(`${serverName} 패키지 생성 중...`);
+  logger.info(`Creating ${serverName} package...`);
   await renderTemplateDir(templateDir, path.join(cwd, "packages"), context, dirReplacements);
-  logger.success(`packages/${serverName} 생성 완료`);
+  logger.success(`packages/${serverName} created successfully`);
 
-  // 5. sd.config.ts에 서버 패키지 추가
+  // 5. Add server package to sd.config.ts
   const added = addPackageToSdConfig(sdConfigPath, serverName, { target: "server" });
   if (added) {
-    logger.success("sd.config.ts에 서버 패키지 추가 완료");
+    logger.success("Server package added to sd.config.ts");
   } else {
-    consola.warn(`"${serverName}"이(가) sd.config.ts에 이미 존재합니다.`);
+    consola.warn(`"${serverName}" already exists in sd.config.ts.`);
   }
 
-  // 6. 선택된 클라이언트의 server 필드 업데이트
+  // 6. Update server field in selected clients
   for (const clientName of selectedClients) {
     setClientServerInSdConfig(sdConfigPath, clientName, serverName);
-    logger.info(`${clientName}의 서버를 "${serverName}"으로 설정`);
+    logger.info(`Set ${clientName} server to "${serverName}"`);
   }
 
-  // 7. pnpm install
-  logger.info("pnpm install 실행 중...");
+  // 7. Run pnpm install
+  logger.info("Running pnpm install...");
   await execa("pnpm", ["install"], { cwd });
-  logger.success("pnpm install 완료");
+  logger.success("pnpm install completed");
 
-  // 완료
-  consola.box(`서버 "${serverName}"이(가) 추가되었습니다!`);
+  // Done
+  consola.box(`Server "${serverName}" has been added!`);
 }
 
 //#endregion

package/src/commands/build.ts

@@ -4,17 +4,17 @@ import {
 } from "../orchestrators/BuildOrchestrator";
 
 /**
- * 프로덕션 빌드를 실행한다.
+ * Run production build.
  *
- * - `sd.config.ts`를 로드하여 패키지별 빌드 타겟 정보 확인 (필수)
- * - lint 실행
- * - dist 폴더 정리 (clean build)
- * - `node`/`browser`/`neutral` 타겟: esbuild JS 빌드 + dts 생성 (타입체크 포함)
- * - `client` 타겟: Vite production 빌드 + typecheck (dts 불필요)
- * - 하나라도 실패하면 `process.exitCode = 1` 설정
+ * - Load `sd.config.ts` to check build target info per package (required)
+ * - Run lint
+ * - Clean dist folder (clean build)
+ * - `node`/`browser`/`neutral` target: esbuild JS build + dts generation (with type check)
+ * - `client` target: Vite production build + typecheck (dts not needed)
+ * - Set `process.exitCode = 1` if any step fails
  *
- * @param options - build 실행 옵션
- * @returns 완료 시 resolve
+ * @param options - build execution options
+ * @returns resolves on completion
  */
 export async function runBuild(options: BuildOrchestratorOptions): Promise<void> {
   const orchestrator = new BuildOrchestrator(options);

package/src/commands/check.ts

@@ -83,7 +83,7 @@ export async function runCheck(options: CheckOptions): Promise<void> {
   const { targets, types } = options;
   const logger = consola.withTag("sd:cli:check");
 
-  logger.debug("check 시작", { targets, types });
+  logger.debug("start check", { targets, types });
 
   const tasks: Promise<CheckResult>[] = [];
 
@@ -129,11 +129,11 @@ export async function runCheck(options: CheckOptions): Promise<void> {
     tasks.push(spawnVitest(targets));
   }
 
-  logger.start(`check 실행 중... (${types.join(", ")})`);
+  logger.start(`running check... (${types.join(", ")})`);
   const results = await Promise.allSettled(tasks);
-  logger.success("check 실행 완료");
+  logger.success("check completed");
 
-  // 결과 수집
+  // Collect results
   const checkResults: CheckResult[] = results.map((r) => {
     if (r.status === "fulfilled") return r.value;
     return {
@@ -145,7 +145,7 @@ export async function runCheck(options: CheckOptions): Promise<void> {
     };
   });
 
-  // 섹션별 출력 (typecheck → lint → test 순서 보장)
+  // Output by section (guarantee order: typecheck → lint → test)
   const order = ["TYPECHECK", "LINT", "TEST"];
   checkResults.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
 

package/src/commands/dev.ts

@@ -1,17 +1,17 @@
 import { DevOrchestrator, type DevOrchestratorOptions } from "../orchestrators/DevOrchestrator";
 
 /**
- * Client 및 Server 패키지를 개발 모드로 실행한다.
+ * Run Client and Server packages in development mode.
  *
- * - `sd.config.ts`를 로드하여 패키지별 빌드 타겟 정보 확인 (필수)
- * - `client` 타겟: Vite dev server 시작
- * - `server` 타겟: Server Build Worker + Server Runtime Worker
- * - Server-Client 프록시 연결 지원
- * - Capacitor 초기화 지원
- * - SIGINT/SIGTERM 시그널로 종료
+ * - Load `sd.config.ts` to check build target info per package (required)
+ * - `client` target: Start Vite dev server
+ * - `server` target: Server Build Worker + Server Runtime Worker
+ * - Support Server-Client proxy connections
+ * - Support Capacitor initialization
+ * - Terminate with SIGINT/SIGTERM signals
  *
- * @param options - dev 실행 옵션
- * @returns 종료 시그널 수신 시 resolve
+ * @param options - dev execution options
+ * @returns resolves on termination signal
  */
 export async function runDev(options: DevOrchestratorOptions): Promise<void> {
   const orchestrator = new DevOrchestrator(options);

package/src/commands/device.ts

@@ -9,14 +9,14 @@ import { Electron } from "../electron/electron";
 //#region Types
 
 /**
- * Device 명령 옵션
+ * Device command options
  */
 export interface DeviceOptions {
-  /** 패키지 이름 (필수) */
+  /** Package name (required) */
   package: string;
-  /** 개발 서버 URL (선택, 미지정 시 sd.config.ts의 server 설정 사용) */
+  /** Development server URL (optional, uses server config from sd.config.ts if not specified) */
   url?: string;
-  /** sd.config.ts에 전달할 추가 옵션 */
+  /** Additional options to pass to sd.config.ts */
   options: string[];
 }
 
@@ -25,42 +25,42 @@ export interface DeviceOptions {
 //#region Main
 
 /**
- * Android 디바이스에서 앱을 실행한다.
+ * Runs an app on an Android device.
  *
- * - 연결된 Android 디바이스에서 앱 실행
- * - 개발 서버 URL을 WebView에 연결하여 Hot Reload 지원
+ * - Runs app on connected Android device
+ * - Connects development server URL to WebView to support Hot Reload
  *
- * @param options - device 실행 옵션
- * @returns 완료 시 resolve
+ * @param options - device execution options
+ * @returns resolves when complete
  */
 export async function runDevice(options: DeviceOptions): Promise<void> {
   const { package: packageName, url } = options;
   const cwd = process.cwd();
   const logger = consola.withTag("sd:cli:device");
 
-  logger.debug("device 시작", { package: packageName, url });
+  logger.debug("device start", { package: packageName, url });
 
-  // sd.config.ts 로드
+  // Load sd.config.ts
   let sdConfig: SdConfig;
   try {
     sdConfig = await loadSdConfig({ cwd, dev: true, opt: options.options });
-    logger.debug("sd.config.ts 로드 완료");
+    logger.debug("sd.config.ts loaded");
   } catch (err) {
-    logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+    logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
     process.exitCode = 1;
     return;
   }
 
-  // 패키지 설정 확인
+  // Verify package config
   const pkgConfig = sdConfig.packages[packageName];
   if (pkgConfig == null) {
-    logger.error(`패키지를 찾을 수 없습니다: ${packageName}`);
+    logger.error(`Package not found: ${packageName}`);
     process.exitCode = 1;
     return;
   }
 
   if (pkgConfig.target !== "client") {
-    logger.error(`client 타겟 패키지만 지원합니다: ${packageName} (현재: ${pkgConfig.target})`);
+    logger.error(`Only client target packages are supported: ${packageName} (current: ${pkgConfig.target})`);
     process.exitCode = 1;
     return;
   }
@@ -69,40 +69,40 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
   const pkgDir = path.join(cwd, "packages", packageName);
 
   if (clientConfig.electron != null) {
-    // Electron 개발 실행
+    // Run Electron development
     let serverUrl = url;
     if (serverUrl == null) {
       if (typeof clientConfig.server === "number") {
         serverUrl = `http://localhost:${clientConfig.server}/${packageName}/`;
       } else {
         logger.error(
-          `--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`,
+          `--url option is required. server is set to package name: ${clientConfig.server}`,
         );
         process.exitCode = 1;
         return;
       }
     }
 
-    logger.debug("개발 서버 URL", { serverUrl });
+    logger.debug("development server URL", { serverUrl });
 
-    logger.start(`${packageName} (electron) 실행 중...`);
+    logger.start(`Running ${packageName} (electron)...`);
     try {
       const electron = await Electron.create(pkgDir, clientConfig.electron);
       await electron.run(serverUrl);
-      logger.success("Electron 실행 완료");
+      logger.success("Electron execution completed");
     } catch (err) {
-      logger.error(`Electron 실행 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`Failed to run Electron: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
     }
   } else if (clientConfig.capacitor != null) {
-    // Capacitor 디바이스 실행 (기존 로직)
+    // Run Capacitor device (existing logic)
     let serverUrl = url;
     if (serverUrl == null) {
       if (typeof clientConfig.server === "number") {
         serverUrl = `http://localhost:${clientConfig.server}/${packageName}/capacitor/`;
       } else {
         logger.error(
-          `--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`,
+          `--url option is required. server is set to package name: ${clientConfig.server}`,
         );
         process.exitCode = 1;
         return;
@@ -111,28 +111,28 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
       serverUrl = `${serverUrl}/${packageName}/capacitor/`;
     }
 
-    logger.debug("개발 서버 URL", { serverUrl });
+    logger.debug("development server URL", { serverUrl });
 
     const capPath = path.join(pkgDir, ".capacitor");
     if (!(await fsExists(capPath))) {
       logger.error(
-        `Capacitor 프로젝트가 초기화되지 않았습니다. 먼저 'pnpm watch ${packageName}'를 실행하세요.`,
+        `Capacitor project is not initialized. First run 'pnpm watch ${packageName}'.`,
       );
       process.exitCode = 1;
       return;
     }
 
-    logger.start(`${packageName} (device) 실행 중...`);
+    logger.start(`Running ${packageName} (device)...`);
     try {
       const cap = await Capacitor.create(pkgDir, clientConfig.capacitor);
       await cap.runOnDevice(serverUrl);
-      logger.success("디바이스 실행 완료");
+      logger.success("Device execution completed");
     } catch (err) {
-      logger.error(`디바이스 실행 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`Failed to run device: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
     }
   } else {
-    logger.error(`electron 또는 capacitor 설정이 없습니다: ${packageName}`);
+    logger.error(`No electron or capacitor config found: ${packageName}`);
     process.exitCode = 1;
   }
 }

package/src/commands/init.ts

@@ -8,7 +8,7 @@ import { findPackageRoot } from "../utils/package-utils";
 //#region Types
 
 /**
- * Init 명령 옵션
+ * Init command options
  */
 export interface InitOptions {}
 
@@ -17,7 +17,7 @@ export interface InitOptions {}
 //#region Utilities
 
 /**
- * npm 스코프 이름 유효성 검증
+ * Validates npm scope name validity
  */
 function isValidScopeName(name: string): boolean {
   return /^[a-z][a-z0-9-]*$/.test(name);
@@ -28,65 +28,65 @@ function isValidScopeName(name: string): boolean {
 //#region Main
 
 /**
- * 새 Simplysm 프로젝트를 현재 디렉토리에 초기화한다.
+ * Initializes a new Simplysm project in the current directory.
  *
- * 1. 디렉토리 비어있는지 확인
- * 2. 프로젝트명(폴더명) 검증
- * 3. Handlebars 템플릿 렌더링
- * 4. pnpm install 실행
+ * 1. Check if directory is empty
+ * 2. Validate project name (folder name)
+ * 3. Render Handlebars template
+ * 4. Run pnpm install
  */
 export async function runInit(_options: InitOptions): Promise<void> {
   const cwd = process.cwd();
   const logger = consola.withTag("sd:cli:init");
 
-  // 1. 디렉토리 비어있는지 확인 (dotfile/dotfolder 제외)
+  // 1. Check if directory is empty (exclude dotfiles/dotfolders)
   const entries = fs.readdirSync(cwd).filter((e) => !e.startsWith("."));
   if (entries.length > 0) {
-    consola.error("디렉토리가 비어있지 않습니다. 빈 디렉토리에서 실행해주세요.");
+    consola.error("Directory is not empty. Please run this from an empty directory.");
     process.exitCode = 1;
     return;
   }
 
-  // 2. 프로젝트명 검증
+  // 2. Validate project name
   const projectName = path.basename(cwd);
   if (!isValidScopeName(projectName)) {
     consola.error(
-      `프로젝트 이름 "${projectName}"이(가) 유효하지 않습니다. 소문자, 숫자, 하이픈만 사용 가능합니다.`,
+      `Project name "${projectName}" is not valid. Only lowercase letters, numbers, and hyphens are allowed.`,
     );
     process.exitCode = 1;
     return;
   }
 
-  // 3. 템플릿 렌더링
+  // 3. Render template
   const pkgRoot = findPackageRoot(import.meta.dirname);
   const templateDir = path.join(pkgRoot, "templates", "init");
 
   const context = { projectName };
 
-  logger.info("프로젝트 파일 생성 중...");
+  logger.info("Creating project files...");
   await renderTemplateDir(templateDir, cwd, context);
-  logger.success("프로젝트 파일 생성 완료");
+  logger.success("Project files created successfully");
 
-  // 4. pnpm install
-  logger.info("pnpm install 실행 중...");
+  // 4. Run pnpm install
+  logger.info("Running pnpm install...");
   await execa("pnpm", ["install"], { cwd });
-  logger.success("pnpm install 완료");
+  logger.success("pnpm install completed");
 
-  // 5. git 초기화
-  logger.info("git 저장소 초기화 중...");
+  // 5. Initialize git repository
+  logger.info("Initializing git repository...");
   await execa("git", ["init"], { cwd });
   await execa("git", ["add", "."], { cwd });
   await execa("git", ["commit", "-m", "init"], { cwd });
-  logger.success("git 저장소 초기화 완료");
+  logger.success("git repository initialized");
 
-  // 6. 완료 메시지
+  // 6. Completion message
   consola.box(
     [
-      "프로젝트가 생성되었습니다!",
+      "Project created!",
       "",
-      "다음 단계:",
-      "  sd-cli add client    클라이언트 패키지 추가",
-      "  sd-cli add server    서버 패키지 추가",
+      "Next steps:",
+      "  sd-cli add client    Add a client package",
+      "  sd-cli add server    Add a server package",
     ].join("\n"),
   );
 }