@simplysm/sd-cli 14.0.19 → 14.0.22

package/src/orchestrators/TypecheckOrchestrator.ts

@@ -0,0 +1,364 @@
+import ts from "typescript";
+import { err as errNs } from "@simplysm/core-common";
+import { pathx } from "@simplysm/core-node";
+import { consola } from "consola";
+import { loadSdConfig } from "../utils/sd-config";
+import { deserializeDiagnostic } from "../utils/typecheck-serialization";
+import { createBuildEngine } from "../engines/index";
+import { typecheckNonPackageFiles } from "../utils/typecheck-non-package";
+import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
+import { discoverWorkspacePackages, mergeTestsPackagesIntoConfig } from "../utils/package-utils";
+import type { EngineResult } from "../engines/types";
+import type { TypecheckEnv } from "../utils/tsconfig";
+import { toTypecheckEnvs } from "../utils/tsconfig";
+
+//#region Types
+
+/**
+ * TypeScript 타입체크 옵션
+ */
+export interface TypecheckOptions {
+  /** 타입체크 대상 경로 필터 (예: `packages/core-common`, `tests/orm`). 빈 배열이면 전체 대상. */
+  targets: string[];
+  /** sd.config.ts에 전달할 추가 옵션 */
+  options: string[];
+  /** true이면 엔진에 lint: true를 전달하고 lint 결과를 수집한다 */
+  lint?: boolean;
+}
+
+/**
+ * TypeScript 타입체크 실행 결과
+ */
+export interface TypecheckResult {
+  success: boolean;
+  errorCount: number;
+  warningCount: number;
+  formattedOutput: string;
+  /** lint 결과 (TypecheckOptions.lint가 true일 때 존재) */
+  lint?: {
+    success: boolean;
+    errorCount: number;
+    warningCount: number;
+    formattedOutput: string;
+  };
+  /** 건너뛴 scripts 패키지 경로 (별도 lint용) */
+  scriptsPackagePaths?: string[];
+}
+
+//#endregion
+
+//#region Utilities
+
+const TARGET_PATH_PATTERN = /^(?:packages|tests)\/([^/]+)/;
+
+/**
+ * 대상 경로에서 패키지명을 추출한다.
+ * "packages/core-common" → "core-common"
+ * "tests/orm" → "orm"
+ */
+function extractTargetPackageNames(targets: string[]): Set<string> {
+  const names = new Set<string>();
+  for (const target of targets) {
+    const match = target.match(TARGET_PATH_PATTERN);
+    if (match) names.add(match[1]);
+  }
+  return names;
+}
+
+//#endregion
+
+//#region TypecheckOrchestrator
+
+/**
+ * 타입체크를 조율하는 Orchestrator
+ *
+ * BuildOrchestrator/DevWatchOrchestrator와 동일한 initialize() → start() → shutdown() 생명주기를 따른다.
+ * sd.config.ts 기반으로 패키지를 분류하고, BuildEngine을 사용하여 타입체크를 실행한다.
+ */
+export class TypecheckOrchestrator {
+  private readonly _cwd: string;
+  private readonly _options: TypecheckOptions;
+  private readonly _logger = consola.withTag("sd:cli:typecheck");
+
+  // initialize()에서 설정되는 내부 상태
+  private readonly _typecheckTasks: Array<{ name: string; dir: string; config: any; env: TypecheckEnv }> =
+    [];
+  private readonly _scriptsPackagePaths: string[] = [];
+  private _includeNonPackage = false;
+
+  constructor(options: TypecheckOptions) {
+    this._cwd = process.cwd();
+    this._options = options;
+  }
+
+  /**
+   * Initialize Orchestrator
+   * - Load sd.config.ts
+   * - Discover workspace packages and merge tests
+   * - Classify packages into typecheck tasks
+   * - Collect scripts package paths
+   */
+  async initialize(): Promise<void> {
+    const { targets } = this._options;
+    const phaseLabel = this._options.lint === true ? "타입체크/린트" : "타입체크";
+
+    this._logger.debug(`${phaseLabel} 시작`, { targets, lint: this._options.lint });
+
+    // sd.config.ts 로드
+    const sdConfig = await loadSdConfig({ cwd: this._cwd, dev: false, opt: this._options.options });
+    this._logger.debug("sd.config.ts 로드 완료");
+
+    // 워크스페이스 패키지 탐색 및 tests/를 설정에 병합
+    const workspacePackages = discoverWorkspacePackages(this._cwd);
+    const { merged, pathMap } = mergeTestsPackagesIntoConfig(
+      sdConfig.packages,
+      workspacePackages,
+    );
+
+    // 경로 기반 대상에서 패키지명 결정
+    const targetNames = extractTargetPackageNames(targets);
+
+    // 타입체크할 패키지 수집 (scripts 제외), env별로 확장
+    for (const [name, config] of Object.entries(merged)) {
+      if (config == null) continue;
+      if (config.target === "scripts") {
+        if (targets.length === 0 || targetNames.has(name)) {
+          const relPath = pathMap.get(name) ?? `packages/${name}`;
+          this._scriptsPackagePaths.push(relPath);
+        }
+        continue;
+      }
+      if (targets.length > 0 && !targetNames.has(name)) continue;
+
+      const relPath = pathMap.get(name) ?? `packages/${name}`;
+      // 클라이언트 패키지의 경우 browser 타겟을 사용하여 createBuildEngine이 ViteEngine 대신 NgtscEngine으로 라우팅되도록 함
+      const typecheckConfig =
+        config.target === "client" ? { target: "browser" as const } : config;
+      const envs = toTypecheckEnvs(config.target);
+      for (const env of envs) {
+        this._typecheckTasks.push({
+          name,
+          dir: pathx.posixResolve(this._cwd, relPath),
+          config: typecheckConfig,
+          env,
+        });
+      }
+    }
+
+    // 비패키지 타입체크: 대상이 지정되지 않은 경우에만 (= 전체 검사)
+    this._includeNonPackage = targets.length === 0;
+  }
+
+  /**
+   * 타입체크 실행
+   * - 엔진 생성 및 동시성 제어된 실행
+   * - 비패키지 타입체크
+   * - 결과 집계 및 포맷 출력 생성
+   *
+   * @returns 타입체크 결과
+   */
+  async start(): Promise<TypecheckResult> {
+    const phaseLabel = this._options.lint === true ? "타입체크/린트" : "타입체크";
+    const formatHost: ts.FormatDiagnosticsHost = {
+      getCanonicalFileName: (f) => f,
+      getCurrentDirectory: () => this._cwd,
+      getNewLine: () => ts.sys.newLine,
+    };
+
+    if (this._typecheckTasks.length === 0 && !this._includeNonPackage) {
+      this._logger.info(`${phaseLabel} 대상 없음`);
+      return {
+        success: true,
+        errorCount: 0,
+        warningCount: 0,
+        formattedOutput: `✔ ${phaseLabel} 대상 없음.\n`,
+        scriptsPackagePaths:
+          this._scriptsPackagePaths.length > 0 ? this._scriptsPackagePaths : undefined,
+      };
+    }
+
+    // 동시성 제한이 있는 BuildEngine 작업 생성
+    const allDiagnostics: ts.Diagnostic[] = [];
+    let totalErrorCount = 0;
+    let totalWarningCount = 0;
+    const fileCache = new Map<string, string>();
+
+    // Lint 결과 집계
+    let lintErrorCount = 0;
+    let lintWarningCount = 0;
+    let lintSuccess = true;
+    const lintOutputs: string[] = [];
+
+    if (this._typecheckTasks.length > 0) {
+      const tasks = this._typecheckTasks.map((task) => async (): Promise<EngineResult> => {
+        const label = `${task.name}:${task.env}`;
+        const engine = createBuildEngine(
+          { name: task.name, dir: task.dir, config: task.config },
+          { cwd: this._cwd },
+        );
+        try {
+          this._logger.debug(`[${label}] 타입체크 시작됨`);
+          const result = await engine.run({
+            js: false,
+            dts: false,
+            env: task.env,
+            includeTests: true,
+            ...(this._options.lint === true ? { lint: true } : {}),
+          });
+          this._logger.debug(
+            `[${label}] 타입체크 ${result.build.success ? "완료" : "실패"}`,
+          );
+          return result;
+        } catch (err) {
+          const message = errNs.message(err);
+          const stack = err instanceof Error ? err.stack : undefined;
+          this._logger.error(`[${label}] 엔진 작업 실패: ${message}`);
+          if (stack != null) {
+            this._logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
+          }
+          return {
+            build: {
+              success: false,
+              errors: [`[${label}] ${message}`],
+              warnings: [],
+              diagnostics: [],
+            },
+          };
+        } finally {
+          await engine.stop();
+        }
+      });
+
+      const concurrency = getMaxConcurrency();
+      this._logger.start(
+        `${phaseLabel} 실행 중... (${tasks.length}개 작업, 동시성: ${concurrency})`,
+      );
+      const results = await runWithConcurrency(tasks, concurrency);
+      this._logger.success(`${phaseLabel} 실행 완료`);
+
+      // 엔진 결과 집계 (모든 task는 catch로 인해 항상 fulfilled)
+      for (const settled of results) {
+        if (settled.status !== "fulfilled") continue;
+        const engineResult = settled.value;
+        const buildDiags = engineResult.build.diagnostics.map((d) =>
+          deserializeDiagnostic(d, fileCache),
+        );
+        allDiagnostics.push(...buildDiags);
+        // 역직렬화된 진단 정보에서 에러/경고 수 집계
+        // 숫자 카테고리 값 사용 (ts.DiagnosticCategory: Error=1, Warning=0)
+        totalErrorCount += buildDiags.filter((d) => d.category === 1).length;
+        totalWarningCount += buildDiags.filter((d) => d.category === 0).length;
+        if (!engineResult.build.success && buildDiags.length === 0) {
+          for (const errMsg of engineResult.build.errors) {
+            allDiagnostics.push({
+              category: 1,
+              code: 0,
+              messageText: errMsg,
+              file: undefined,
+              start: undefined,
+              length: undefined,
+            });
+          }
+          totalErrorCount += engineResult.build.errors.length || 1;
+        }
+
+        // Lint 결과 수집
+        if (engineResult.lint != null) {
+          lintErrorCount += engineResult.lint.errorCount;
+          lintWarningCount += engineResult.lint.warningCount;
+          if (!engineResult.lint.success) lintSuccess = false;
+          if (engineResult.lint.formattedOutput !== "") {
+            lintOutputs.push(engineResult.lint.formattedOutput);
+          }
+        }
+      }
+    }
+
+    // 비패키지 타입체크
+    if (this._includeNonPackage) {
+      this._logger.debug("비패키지 타입체크 실행 중");
+      const nonPkgResult = typecheckNonPackageFiles(this._cwd);
+      totalErrorCount += nonPkgResult.errorCount;
+      totalWarningCount += nonPkgResult.warningCount;
+      const nonPkgDiags = nonPkgResult.diagnostics.map((d) =>
+        deserializeDiagnostic(d, fileCache),
+      );
+      allDiagnostics.push(...nonPkgDiags);
+    }
+
+    // 요약 로그
+    const resultMeta: Record<string, number> = {
+      errorCount: totalErrorCount,
+      warningCount: totalWarningCount,
+    };
+    if (this._options.lint === true) {
+      resultMeta["lintErrorCount"] = lintErrorCount;
+      resultMeta["lintWarningCount"] = lintWarningCount;
+    }
+    if (totalErrorCount > 0) {
+      this._logger.error(`${phaseLabel} 에러 발생`, resultMeta);
+    } else {
+      this._logger.info(`${phaseLabel} 완료`, resultMeta);
+    }
+
+    // 진단 출력 포매팅
+    let formattedOutput = "";
+    if (allDiagnostics.length > 0) {
+      const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+      formattedOutput = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
+    }
+
+    // lint가 요청된 경우 lint 결과 생성
+    const lintResult =
+      this._options.lint === true
+        ? {
+            success: lintSuccess,
+            errorCount: lintErrorCount,
+            warningCount: lintWarningCount,
+            formattedOutput: lintOutputs.join("\n"),
+          }
+        : undefined;
+
+    return {
+      success: totalErrorCount === 0,
+      errorCount: totalErrorCount,
+      warningCount: totalWarningCount,
+      formattedOutput,
+      lint: lintResult,
+      scriptsPackagePaths:
+        this._scriptsPackagePaths.length > 0 ? this._scriptsPackagePaths : undefined,
+    };
+  }
+
+  /**
+   * Orchestrator 종료 (현재 정리할 리소스 없음)
+   */
+  async shutdown(): Promise<void> {
+    // 타입체크는 일회성 작업이므로 종료 시 정리할 리소스가 없음
+    // 엔진은 각 작업 내에서 stop()으로 정리됨
+    await Promise.resolve();
+  }
+}
+
+//#endregion
+
+//#region Convenience Function
+
+/**
+ * TypecheckOrchestrator의 전체 생명주기를 래핑한 편의 함수.
+ * initialize() → start() → shutdown() 순서로 호출한다.
+ *
+ * @param options - 타입체크 실행 옵션
+ * @returns 타입체크 결과
+ */
+export async function executeTypecheck(options: TypecheckOptions): Promise<TypecheckResult> {
+  const orchestrator = new TypecheckOrchestrator(options);
+  await orchestrator.initialize();
+  try {
+    return await orchestrator.start();
+  } finally {
+    await orchestrator.shutdown();
+  }
+}
+
+//#endregion

package/src/sd-cli.ts

@@ -8,6 +8,7 @@
  */
 
 import { cpx } from "@simplysm/core-node";
+import { consola } from "consola";
 import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -34,8 +35,12 @@ if (isDev) {
     if (process.argv[2] !== "replace-deps" && sdConfig.replaceDeps != null) {
       await setupReplaceDeps(process.cwd(), sdConfig.replaceDeps);
     }
-  } catch {
+  } catch (err: unknown) {
     // sd.config.ts가 없거나 replaceDeps가 설정되지 않으면 건너뜀
+    const code = err instanceof Error && "code" in err ? (err as NodeJS.ErrnoException).code : undefined;
+    if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
+      consola.warn("[sd-cli] replaceDeps 사전 설정 실패:", err instanceof Error ? err.message : err);
+    }
   }
 
   // Phase 2: 실제 CLI를 새 프로세스로 실행 (모듈 캐시 초기화)

package/src/utils/lint-core.ts

@@ -0,0 +1,205 @@
+import { ESLint } from "eslint";
+import { createJiti } from "jiti";
+import path from "path";
+import { fsx, pathx } from "@simplysm/core-node";
+import { env, SdError } from "@simplysm/core-common";
+import { consola } from "consola";
+
+//#region Types
+
+/**
+ * ESLint 실행 옵션
+ */
+export interface LintOptions {
+  /** 린트 대상 경로 필터 (예: `packages/core-common`). 빈 배열이면 전체 대상 */
+  targets: string[];
+  /** 자동 수정 활성화 */
+  fix: boolean;
+  /** ESLint 규칙별 실행 시간 측정 활성화 (TIMING 환경변수 설정) */
+  timing: boolean;
+}
+
+/**
+ * executeLint()의 반환 타입
+ */
+export interface LintResult {
+  /** 린트 에러가 없으면 true */
+  success: boolean;
+  /** ESLint 전체 에러 수 */
+  errorCount: number;
+  /** ESLint 전체 경고 수 */
+  warningCount: number;
+  /** 포매터 출력 문자열 (stdout에 출력할 내용) */
+  formattedOutput: string;
+}
+
+//#endregion
+
+//#region Utilities
+
+/** ESLint 설정 파일 검색 순서 */
+const ESLINT_CONFIG_FILES = [
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.js",
+  "eslint.config.mjs",
+] as const;
+
+/**
+ * ESLint 설정 객체가 ignores 속성만 가지고 있는지 확인하는 타입 가드
+ */
+function isGlobalIgnoresConfig(item: unknown): item is { ignores: string[] } {
+  if (item == null || typeof item !== "object") return false;
+  if (!("ignores" in item)) return false;
+  if ("files" in item) return false; // files가 있으면 globalIgnores가 아님
+  const ignores = (item as { ignores: unknown }).ignores;
+  if (!Array.isArray(ignores)) return false;
+  return ignores.every((i) => typeof i === "string");
+}
+
+/**
+ * eslint.config.ts/js에서 globalIgnores 패턴을 추출한다.
+ * ignores만 있고 files가 없는 설정 객체가 globalIgnores이다.
+ * @internal 테스트용으로 export
+ */
+export async function loadIgnorePatterns(cwd: string): Promise<string[]> {
+  let configPath: string | undefined;
+  for (const f of ESLINT_CONFIG_FILES) {
+    const p = path.join(cwd, f);
+    if (await fsx.exists(p)) {
+      configPath = p;
+      break;
+    }
+  }
+
+  if (configPath == null) {
+    throw new SdError(
+      `ESLint 설정 파일을 찾을 수 없습니다 (cwd: ${cwd}): ${ESLINT_CONFIG_FILES.join(", ")}`,
+    );
+  }
+
+  const jiti = createJiti(import.meta.url);
+  const configModule = await jiti.import<{ default: Record<string, unknown>[] } | undefined>(
+    configPath,
+  );
+
+  let configs: unknown;
+  if (Array.isArray(configModule)) {
+    configs = configModule;
+  } else if (
+    configModule != null &&
+    typeof configModule === "object" &&
+    "default" in configModule
+  ) {
+    configs = configModule.default;
+  } else {
+    throw new SdError(`ESLint 설정 파일의 형식이 올바르지 않습니다: ${configPath}`);
+  }
+
+  if (!Array.isArray(configs)) {
+    throw new SdError(`ESLint 설정이 배열이 아닙니다: ${configPath}`);
+  }
+
+  return configs.filter(isGlobalIgnoresConfig).flatMap((item) => item.ignores);
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * ESLint를 실행하고 결과를 반환한다.
+ *
+ * - `eslint.config.ts/js`에서 globalIgnores 패턴을 추출하여 glob 필터링에 적용
+ * - consola를 사용하여 진행 상황 표시
+ * - 캐시 활성화 (`.cache/eslint.cache`에 저장, 설정 변경 시 자동 무효화)
+ * - stdout 출력이나 process.exitCode 설정 없음 (호출자가 결정)
+ *
+ * @param options - 린트 실행 옵션
+ * @returns 린트 결과 (성공 여부, 에러/경고 수, 포매터 출력)
+ */
+export async function executeLint(options: LintOptions): Promise<LintResult> {
+  const { targets, fix, timing } = options;
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:lint");
+
+  logger.debug("린트 시작", { targets, fix, timing });
+
+  // TIMING 환경변수 설정
+  if (timing) {
+    env("TIMING", "1");
+  }
+
+  // ESLint 설정 로드
+  logger.start("ESLint 설정 로딩 중");
+  const ignorePatterns = await loadIgnorePatterns(cwd);
+  logger.debug("무시 패턴 로드 완료", { ignorePatternCount: ignorePatterns.length });
+  logger.success(`ESLint 설정 로드 완료 (${ignorePatterns.length}개 무시 패턴)`);
+
+  // 린트 대상 파일 수집
+  logger.start("린트 대상 파일 수집 중");
+  let files = await fsx.glob("**/*.{ts,js,mjs,cjs}", {
+    cwd,
+    ignore: ignorePatterns,
+    nodir: true,
+    absolute: true,
+  });
+  files = pathx.filterByTargets(files, targets, cwd);
+  logger.debug("파일 수집 완료", { fileCount: files.length });
+  logger.success(`린트 대상 파일 수집 완료 (${files.length}개 파일)`);
+
+  // 린트 실행
+  let eslint: ESLint | undefined;
+  let eslintResults: ESLint.LintResult[] | undefined;
+  if (files.length > 0) {
+    logger.start(`린트 실행 중... (${files.length}개 파일)`);
+    eslint = new ESLint({
+      cwd,
+      fix,
+      cache: true,
+      cacheLocation: path.join(cwd, ".cache", "eslint.cache"),
+    });
+    eslintResults = await eslint.lintFiles(files);
+    logger.success("린트 실행 완료");
+
+    // 자동 수정 적용
+    if (fix) {
+      logger.debug("자동 수정 적용 중...");
+      await ESLint.outputFixes(eslintResults);
+      logger.debug("자동 수정 적용 완료");
+    }
+  }
+
+  // 파일이 없거나 린트가 실행되지 않은 경우 성공 결과 반환
+  if (files.length === 0 || eslintResults == null || eslint == null) {
+    logger.info("린트할 파일 없음");
+    return { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" };
+  }
+
+  // 결과 집계
+  let errorCount = eslintResults.sum((r) => r.errorCount);
+  let warningCount = eslintResults.sum((r) => r.warningCount);
+
+  if (errorCount > 0) {
+    logger.error("린트 에러 발생", { errorCount, warningCount });
+  } else {
+    logger.info("린트 완료", { errorCount, warningCount });
+  }
+
+  // 포매터 출력 수집
+  let formattedOutput = "";
+  const formatter = await eslint.loadFormatter("stylish");
+  const resultText = await formatter.format(eslintResults);
+  if (resultText) {
+    formattedOutput += resultText;
+  }
+
+  return {
+    success: errorCount === 0,
+    errorCount,
+    warningCount,
+    formattedOutput,
+  };
+}
+
+//#endregion

package/src/utils/lint-utils.ts

@@ -1,5 +1,5 @@
 import { Worker } from "@simplysm/core-node";
-import type { LintOptions, LintResult } from "../commands/lint";
+import type { LintOptions, LintResult } from "./lint-core";
 import type * as LintWorkerModule from "../workers/lint.worker";
 
 /**

package/src/utils/output-utils.ts

@@ -18,7 +18,7 @@ export function formatBuildMessages(name: string, label: string, messages: strin
  * 에러만 출력한다.
  * @param results 패키지별 빌드 결과 상태
  */
-export function printErrors(results: Map<string, BuildResult>): void {
+export function printErrors(results: ReadonlyMap<string, BuildResult>): void {
   for (const result of results.values()) {
     if (result.status === "error") {
       const typeLabel = result.type === "lint" ? "lint" : result.target;
@@ -37,8 +37,8 @@ export function printErrors(results: Map<string, BuildResult>): void {
  * @param serverClientsMap 서버별 연결된 클라이언트 목록
  */
 export function printServers(
-  results: Map<string, BuildResult>,
-  serverClientsMap?: Map<string, string[]>,
+  results: ReadonlyMap<string, BuildResult>,
+  serverClientsMap?: ReadonlyMap<string, string[]>,
 ): void {
   // 서버 정보 수집
   const servers = [...results.values()].filter((r) => r.status === "running" && r.port != null);