@simplysm/sd-cli 14.0.11 → 14.0.12

package/src/engines/types.ts

@@ -4,7 +4,7 @@ import type { TypecheckEnv } from "../utils/tsconfig";
 import type { LintWithProgramResult } from "../utils/lint-with-program";
 
 /**
- * Package information
+ * 패키지 정보
  */
 export interface PackageInfo {
   name: string;
@@ -13,36 +13,36 @@ export interface PackageInfo {
 }
 
 /**
- * PackageInfo narrowed for build packages (node/browser/neutral)
+ * 빌드 패키지(node/browser/neutral)로 좁혀진 PackageInfo
  */
 export type BuildPackageInfo = PackageInfo & { config: SdBuildPackageConfig };
 
 /**
- * PackageInfo narrowed for server packages
+ * 서버 패키지로 좁혀진 PackageInfo
  */
 export type ServerPackageInfo = PackageInfo & { config: SdServerPackageConfig };
 
 /**
- * PackageInfo narrowed for client packages
+ * 클라이언트 패키지로 좁혀진 PackageInfo
  */
 export type ClientPackageInfo = PackageInfo & { config: SdClientPackageConfig };
 
 /**
- * Build output control flags
+ * 빌드 출력 제어 플래그
  */
 export interface BuildOutput {
   js: boolean;
   dts: boolean;
-  /** When true, run ESLint using the ts.Program created during typecheck. */
+  /** true일 때, 타입체크 중 생성된 ts.Program으로 ESLint를 실행한다. */
   lint?: boolean;
-  /** Typecheck environment. When set, adjusts compilerOptions via getCompilerOptionsForEnv(). */
+  /** 타입체크 환경. 설정 시 getCompilerOptionsForEnv()를 통해 compilerOptions를 조정한다. */
   env?: TypecheckEnv;
-  /** Include tests/ files in typecheck scope. Only used by check command. */
+  /** 타입체크 범위에 tests/ 파일을 포함한다. check 커맨드에서만 사용된다. */
   includeTests?: boolean;
 }
 
 /**
- * BuildEngine.run() return value
+ * BuildEngine.run() 반환값
  */
 export interface EngineResult {
   success: boolean;
@@ -52,33 +52,33 @@ export interface EngineResult {
     warnings: string[];
     diagnostics: SerializedDiagnostic[];
   };
-  /** Lint result (present when BuildOutput.lint is true) */
+  /** 린트 결과 (BuildOutput.lint가 true일 때 존재) */
   lint?: LintWithProgramResult;
 }
 
 /**
- * Build engine interface
+ * 빌드 엔진 인터페이스
  *
- * Common contract for all build engines.
- * typecheck (diagnostics) is always included — not optional.
+ * 모든 빌드 엔진의 공통 계약.
+ * 타입체크(diagnostics)는 항상 포함되며 선택사항이 아니다.
  */
 export interface BuildEngine {
   /**
-   * One-time build (for production builds)
-   * Creates workers, runs build, returns combined result.
-   * Call stop() after to clean up resources.
+   * 일회성 빌드 (프로덕션)
+   * Worker를 생성하고, 빌드를 실행하고, 결합된 결과를 반환한다.
+   * 호출 후 stop()으로 리소스를 정리한다.
    */
   run(output: BuildOutput): Promise<EngineResult>;
 
   /**
-   * Start watch mode
-   * Promise resolves when initial build is complete.
-   * Subsequent rebuilds are reported via injected ResultCollector.
+   * 워치 모드 시작
+   * 초기 빌드가 완료되면 Promise가 resolve된다.
+   * 이후 리빌드는 주입된 ResultCollector를 통해 보고된다.
    */
   startWatch(output: BuildOutput): Promise<void>;
 
   /**
-   * Stop engine and clean up resources (workers, esbuild contexts)
+   * 엔진을 중지하고 리소스(Worker, esbuild context 등)를 정리한다
    */
   stop(): Promise<void>;
 }

package/src/infra/ResultCollector.ts

@@ -1,5 +1,5 @@
 /**
- * Build result status
+ * 빌드 결과 상태
  */
 export interface BuildResult {
   name: string;
@@ -11,17 +11,17 @@ export interface BuildResult {
 }
 
 /**
- * Class that collects and manages build results
+ * 빌드 결과를 수집·관리하는 클래스
  *
- * Manages build results from multiple Builders at a central location and
- * provides filtering and output functionality by status.
+ * 여러 Builder의 빌드 결과를 중앙에서 관리하며,
+ * 상태별 필터링 및 출력 기능을 제공한다.
  */
 export class ResultCollector {
   private readonly _results = new Map<string, BuildResult>();
 
   /**
-   * Add result
-   * @param result build result
+   * 결과를 추가한다
+   * @param result 빌드 결과
    */
   add(result: BuildResult): void {
     const key = `${result.name}:${result.type}`;
@@ -29,15 +29,15 @@ export class ResultCollector {
   }
 
   /**
-   * Get result by key
-   * @param key result key (e.g., "core-common:build")
+   * 키로 결과를 조회한다
+   * @param key 결과 키 (예: "core-common:build")
    */
   get(key: string): BuildResult | undefined {
     return this._results.get(key);
   }
 
   /**
-   * Return internal Map (for backward compatibility)
+   * 내부 Map을 반환한다 (외부 접근용)
    */
   toMap(): Map<string, BuildResult> {
     return this._results;

package/src/infra/SignalHandler.ts

@@ -1,8 +1,8 @@
 /**
- * Class that handles process termination signals
+ * 프로세스 종료 시그널을 처리하는 클래스
  *
- * Detects SIGINT (Ctrl+C) and SIGTERM signals and
- * provides a Promise that waits until termination.
+ * SIGINT(Ctrl+C) 및 SIGTERM 시그널을 감지하고,
+ * 종료까지 대기하는 Promise를 제공한다.
  */
 export class SignalHandler {
   private _terminateResolver: (() => void) | null = null;
@@ -26,22 +26,22 @@ export class SignalHandler {
   }
 
   /**
-   * Wait until termination signal is received
+   * 종료 시그널이 수신될 때까지 대기한다
    */
   waitForTermination(): Promise<void> {
     return this._terminatePromise;
   }
 
   /**
-   * Check if terminated
+   * 종료 여부를 확인한다
    */
   isTerminated(): boolean {
     return this._terminated;
   }
 
   /**
-   * Request termination programmatically
-   * (used when triggering termination from tests or externally)
+   * 프로그래밍 방식으로 종료를 요청한다
+   * (테스트나 외부에서 종료를 트리거할 때 사용)
    */
   requestTermination(): void {
     if (!this._terminated) {

package/src/infra/WorkerManager.ts

@@ -1,19 +1,19 @@
 import { Worker, type WorkerProxy, type WorkerModule } from "@simplysm/core-node";
 
 /**
- * Class that manages Worker lifecycle
+ * Worker 생명주기를 관리하는 클래스
  *
- * Centrally manages Worker creation, lookup, and termination
- * to prevent resource leaks and provide consistent Worker management.
+ * Worker 생성, 조회, 종료를 중앙에서 관리하여
+ * 리소스 누수를 방지하고 일관된 Worker 관리를 제공한다.
  */
 export class WorkerManager {
   private readonly _workers = new Map<string, WorkerProxy<WorkerModule>>();
 
   /**
-   * Create a new Worker
-   * @param id Worker identifier (e.g., "core-common:build")
-   * @param workerPath Worker file path
-   * @returns Created WorkerProxy
+   * 새 Worker를 생성한다
+   * @param id Worker 식별자 (예: "core-common:build")
+   * @param workerPath Worker 파일 경로
+   * @returns 생성된 WorkerProxy
    */
   create<TModule extends WorkerModule>(id: string, workerPath: string): WorkerProxy<TModule> {
     const worker = Worker.create<TModule>(workerPath);
@@ -22,16 +22,16 @@ export class WorkerManager {
   }
 
   /**
-   * Lookup Worker by ID
-   * @param id Worker identifier
+   * ID로 Worker를 조회한다
+   * @param id Worker 식별자
    */
   get<TModule extends WorkerModule>(id: string): WorkerProxy<TModule> | undefined {
     return this._workers.get(id) as WorkerProxy<TModule> | undefined;
   }
 
   /**
-   * Terminate and remove a specific Worker
-   * @param id Worker identifier
+   * 특정 Worker를 종료하고 제거한다
+   * @param id Worker 식별자
    */
   async terminate(id: string): Promise<void> {
     const worker = this._workers.get(id);
@@ -42,7 +42,7 @@ export class WorkerManager {
   }
 
   /**
-   * Terminate all Workers
+   * 모든 Worker를 종료한다
    */
   async terminateAll(): Promise<void> {
     await Promise.all([...this._workers.values()].map((w) => w.terminate()));
@@ -50,14 +50,14 @@ export class WorkerManager {
   }
 
   /**
-   * Number of managed Workers
+   * 관리 중인 Worker 수
    */
   get size(): number {
     return this._workers.size;
   }
 
   /**
-   * List of all Worker IDs
+   * 모든 Worker ID 목록
    */
   get ids(): string[] {
     return [...this._workers.keys()];

package/src/orchestrators/BuildOrchestrator.ts

@@ -21,17 +21,17 @@ import { Electron } from "../electron/electron";
 //#region Types
 
 /**
- * Build Orchestrator options
+ * BuildOrchestrator 옵션
  */
 export interface BuildOrchestratorOptions {
-  /** Package filter for build (empty array includes all packages) */
+  /** 빌드 대상 패키지 필터 (빈 배열이면 전체) */
   targets: string[];
-  /** Additional options to pass to sd.config.ts */
+  /** sd.config.ts에 전달할 추가 옵션 */
   options: string[];
 }
 
 /**
- * Build result
+ * 빌드 결과
  */
 interface BuildStepResult {
   name: string;
@@ -44,14 +44,14 @@ interface BuildStepResult {
 }
 
 /**
- * Package classification result
+ * 패키지 분류 결과
  */
 interface ClassifiedPackages {
-  /** node/browser/neutral target (JS + dts) */
+  /** node/browser/neutral 대상 (JS + DTS) */
   buildPackages: Array<{ name: string; config: SdBuildPackageConfig }>;
-  /** server target (JS build, no dts) */
+  /** server 대상 (JS 빌드, DTS 없음) */
   serverPackages: Array<{ name: string; config: SdServerPackageConfig }>;
-  /** client target (Vite production build, no dts) */
+  /** client 대상 (Vite 프로덕션 빌드, DTS 없음) */
   clientPackages: Array<{ name: string; config: SdClientPackageConfig }>;
 }
 
@@ -60,11 +60,11 @@ interface ClassifiedPackages {
 //#region Utilities
 
 /**
- * Classify packages by target
- * - node/browser/neutral: buildPackages (JS + dts)
- * - server: serverPackages (JS build, no dts)
- * - client: clientPackages (Vite production build, no dts)
- * - scripts: excluded
+ * 패키지를 target별로 분류
+ * - node/browser/neutral: buildPackages (JS + DTS)
+ * - server: serverPackages (JS 빌드, DTS 없음)
+ * - client: clientPackages (Vite 프로덕션 빌드, DTS 없음)
+ * - scripts: 제외
  */
 export function classifyPackages(
   packages: Record<
@@ -97,7 +97,7 @@ export function classifyPackages(
 }
 
 /**
- * Delete dist folders
+ * dist 폴더 삭제
  */
 async function cleanDistFolders(cwd: string, packageNames: string[]): Promise<void> {
   await Promise.all(packageNames.map((name) => fsx.rm(pathx.posixResolve(cwd, "packages", name, "dist"))));
@@ -108,14 +108,14 @@ async function cleanDistFolders(cwd: string, packageNames: string[]): Promise<vo
 //#region BuildOrchestrator
 
 /**
- * Orchestrator for coordinating production builds
+ * 프로덕션 빌드를 조율하는 Orchestrator
  *
- * Classifies packages based on sd.config.ts and executes builds.
- * - Clean dist folders (clean build)
- * - Run lint + build concurrently
- * - node/browser/neutral targets: esbuild JS build + dts generation
- * - server targets: esbuild JS build
- * - client targets: Vite production build
+ * sd.config.ts 기반으로 패키지를 분류하고 빌드를 실행한다.
+ * - dist 폴더 정리 (클린 빌드)
+ * - lint + 빌드 동시 실행
+ * - 라이브러리 패키지: TscEngine/NgtscEngine으로 JS + DTS 빌드
+ * - 서버 패키지: BuildEngine으로 JS 빌드
+ * - 클라이언트 패키지: ViteEngine으로 Vite 프로덕션 빌드
  */
 export class BuildOrchestrator {
   private readonly _cwd: string;
@@ -183,12 +183,12 @@ export class BuildOrchestrator {
   }
 
   /**
-   * Execute build
-   * - Clean
-   * - Lint + Build (concurrent)
-   * - Output results
+   * 빌드 실행
+   * - 클린
+   * - lint + 빌드 (동시 실행)
+   * - 결과 출력
    *
-   * @returns whether errors occurred (true: errors present)
+   * @returns 에러 발생 여부 (true: 에러 있음)
    */
   async start(): Promise<boolean> {
     if (this._allPackageNames.length === 0) {
@@ -198,15 +198,15 @@ export class BuildOrchestrator {
     const classified = this._classified!;
     const baseEnv = this._baseEnv!;
 
-    // Collect results
+    // 결과 수집
     const results: BuildStepResult[] = [];
-    // Track errors (wrapped in object to allow mutation tracking in callbacks)
+    // 에러 추적 (콜백에서 변경 추적을 위해 객체로 래핑)
     const state = { hasError: false };
 
-    // File cache (for diagnostics output)
+    // 파일 캐시 (진단 출력용)
     const fileCache = new Map<string, string>();
 
-    // formatHost (for diagnostics output)
+    // formatHost (진단 출력용)
     const formatHost: ts.FormatDiagnosticsHost = {
       getCanonicalFileName: (f) => f,
       getCurrentDirectory: () => this._cwd,
@@ -221,10 +221,10 @@ export class BuildOrchestrator {
     // Phase 2: 빌드
     const concurrency = getMaxConcurrency();
 
-    // Create list of build tasks
+    // 빌드 태스크 목록 생성
     const buildTasks: Array<() => Promise<void>> = [];
 
-    // buildPackages: JS build + dts generation via BuildEngine
+    // 라이브러리 패키지: BuildEngine으로 JS + DTS 빌드
     for (const { name, config } of classified.buildPackages) {
       const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
@@ -276,7 +276,7 @@ export class BuildOrchestrator {
       });
     }
 
-    // serverPackages: JS build + typecheck via BuildEngine
+    // 서버 패키지: BuildEngine으로 JS 빌드 + 타입체크
     for (const { name, config } of classified.serverPackages) {
       const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
@@ -322,7 +322,7 @@ export class BuildOrchestrator {
       });
     }
 
-    // clientPackages: Vite production build via ViteEngine (no dts)
+    // 클라이언트 패키지: ViteEngine으로 Vite 프로덕션 빌드 (DTS 없음)
     for (const { name, config } of classified.clientPackages) {
       const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
@@ -471,11 +471,11 @@ export class BuildOrchestrator {
   }
 
   /**
-   * Shutdown Orchestrator (no resources to clean up currently)
+   * Orchestrator 종료 (현재 정리할 리소스 없음)
    */
   async shutdown(): Promise<void> {
-    // Production builds are one-time operations, so there are no resources to clean up at shutdown
-    // Workers are cleaned up with terminate() within each build task
+    // 프로덕션 빌드는 일회성 작업이므로 종료 시 정리할 리소스가 없음
+    // Worker는 각 빌드 태스크 내에서 terminate()로 정리됨
     await Promise.resolve();
   }
 }