@simplysm/sd-cli 14.0.18 → 14.0.21

package/src/commands/lint.ts

@@ -1,207 +1,7 @@
-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
+import { executeLint, type LintOptions } from "../utils/lint-core";
 
 //#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,
-  };
-}
-
 /**
  * ESLint를 실행한다.
  *

package/src/commands/publish.ts

@@ -770,7 +770,8 @@ export async function runPublish(options: PublishOptions): Promise<void> {
 
   // 실패한 패키지 확인
   const allPkgNames = publishPackages.map((p) => p.name);
-  const failedPkgNames = allPkgNames.filter((n) => !publishedPackages.includes(n));
+  const publishedSet = new Set(publishedPackages);
+  const failedPkgNames = allPkgNames.filter((n) => !publishedSet.has(n));
 
   if (failedPkgNames.length > 0) {
     if (publishedPackages.length > 0) {

package/src/commands/typecheck.ts

@@ -1,294 +1,9 @@
-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 타입체크 옵션
+ * TypecheckOrchestrator에 위임하는 CLI 래퍼.
+ * 타입과 executeTypecheck를 re-export하여 기존 호출자와의 호환성을 유지한다.
  */
-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 Main
-
-/**
- * BuildEngine을 사용하여 TypeScript 타입체크를 실행한다.
- *
- * sd.config.ts의 각 패키지에 대해:
- * - 라이브러리/서버 패키지 → BuildEngine.run({js:false, dts:false})
- * - client 패키지 → browser target으로 변환하여 포함
- * - scripts 패키지 → 타입체크 제외 (별도 lint만 수행)
- * 비패키지 파일 → typecheckNonPackageFiles 유틸리티
- *
- * @param options - 타입체크 실행 옵션
- * @returns 타입체크 결과 (성공 여부, 에러/경고 수, 포매팅된 출력 문자열)
- */
-export async function executeTypecheck(options: TypecheckOptions): Promise<TypecheckResult> {
-  const { targets } = options;
-  const cwd = process.cwd();
-  const logger = consola.withTag("sd:cli:typecheck");
-
-  const phaseLabel = options.lint === true ? "타입체크/린트" : "타입체크";
-
-  logger.debug(`${phaseLabel} 시작`, { targets, lint: options.lint });
-
-  const formatHost: ts.FormatDiagnosticsHost = {
-    getCanonicalFileName: (f) => f,
-    getCurrentDirectory: () => cwd,
-    getNewLine: () => ts.sys.newLine,
-  };
-
-  // sd.config.ts 로드
-  const sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
-  logger.debug("sd.config.ts 로드 완료");
-
-  // 워크스페이스 패키지 탐색 및 tests/를 설정에 병합
-  const workspacePackages = discoverWorkspacePackages(cwd);
-  const { merged, pathMap } = mergeTestsPackagesIntoConfig(sdConfig.packages, workspacePackages);
-
-  // 경로 기반 대상에서 패키지명 결정
-  const targetNames = extractTargetPackageNames(targets);
-
-  // scripts 패키지 경로 수집 (별도 lint용)
-  const scriptsPackagePaths: string[] = [];
-
-  // 타���체크할 패키지 수집 (scripts 제외), env별로 확장
-  const typecheckTasks: Array<{ name: string; dir: string; config: any; env: TypecheckEnv }> = [];
-  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}`;
-        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) {
-      typecheckTasks.push({
-        name,
-        dir: pathx.posixResolve(cwd, relPath),
-        config: typecheckConfig,
-        env,
-      });
-    }
-  }
-
-  // 비패키지 타입체크: 대상이 지정되지 않은 경우에만 (= 전체 검사)
-  const includeNonPackage = targets.length === 0;
-
-  if (typecheckTasks.length === 0 && !includeNonPackage) {
-    logger.info(`${phaseLabel} 대상 없음`);
-    return {
-      success: true,
-      errorCount: 0,
-      warningCount: 0,
-      formattedOutput: `✔ ${phaseLabel} 대상 없음.\n`,
-      scriptsPackagePaths: scriptsPackagePaths.length > 0 ? 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 (typecheckTasks.length > 0) {
-    const tasks = 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 },
-      );
-      try {
-        logger.debug(`[${label}] 타입체크 시작됨`);
-        const result = await engine.run({
-          js: false,
-          dts: false,
-          env: task.env,
-          includeTests: true,
-          ...(options.lint === true ? { lint: true } : {}),
-        });
-        logger.debug(`[${label}] 타입체크 ${result.build.success ? "완료" : "실패"}`);
-        return result;
-      } catch (err) {
-        const message = errNs.message(err);
-        const stack = err instanceof Error ? err.stack : undefined;
-        logger.error(`[${label}] 엔진 작업 실패: ${message}`);
-        if (stack != null) {
-          logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
-        }
-        return {
-          build: {
-            success: false,
-            errors: [`[${label}] ${message}`],
-            warnings: [],
-            diagnostics: [],
-          },
-        };
-      } finally {
-        await engine.stop();
-      }
-    });
-
-    const concurrency = getMaxConcurrency();
-    logger.start(`${phaseLabel} 실행 중... (${tasks.length}개 작업, 동시성: ${concurrency})`);
-    const results = await runWithConcurrency(tasks, concurrency);
-    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 (includeNonPackage) {
-    logger.debug("비패키지 타입체크 실행 중");
-    const nonPkgResult = typecheckNonPackageFiles(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 (options.lint === true) {
-    resultMeta["lintErrorCount"] = lintErrorCount;
-    resultMeta["lintWarningCount"] = lintWarningCount;
-  }
-  if (totalErrorCount > 0) {
-    logger.error(`${phaseLabel} 에러 발생`, resultMeta);
-  } else {
-    logger.info(`${phaseLabel} 완료`, resultMeta);
-  }
-
-  // 진단 출력 포매팅
-  let formattedOutput = "";
-  if (allDiagnostics.length > 0) {
-    const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
-    formattedOutput = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
-  }
-
-  // lint가 요청된 경우 lint 결과 생성
-  const lintResult = 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: scriptsPackagePaths.length > 0 ? scriptsPackagePaths : undefined,
-  };
-}
-
-//#endregion
+export {
+  executeTypecheck,
+  type TypecheckOptions,
+  type TypecheckResult,
+} from "../orchestrators/TypecheckOrchestrator";

package/src/electron/electron.ts

@@ -125,6 +125,9 @@ export class Electron {
     };
 
     const envBanner = createEnvBanner({ ELECTRON_DEV_URL: url, ...this._config.env });
+    const bannerJs =
+      "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
+      envBanner;
 
     Electron._logger.debug("esbuild context 생성 시작");
     const ctx = await esbuild.context({
@@ -132,10 +135,10 @@ export class Electron {
       outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
-      format: "cjs",
+      format: "esm",
       bundle: true,
       external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
-      banner: { js: envBanner },
+      banner: { js: bannerJs },
       plugins: [
         {
           name: "electron-restart",
@@ -264,6 +267,7 @@ export class Electron {
       name: this._npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: this._npmConfig.version,
       description: this._npmConfig.description,
+      type: "module",
       main: "electron-main.js",
       dependencies,
       devDependencies,
@@ -292,6 +296,9 @@ export class Electron {
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
     const envBanner = createEnvBanner(this._config.env);
+    const bannerJs =
+      "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
+      envBanner;
 
     Electron._logger.debug(`esbuild 번들링: ${entryPoint}`);
     await esbuild.build({
@@ -299,10 +306,10 @@ export class Electron {
       outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
-      format: "cjs",
+      format: "esm",
       bundle: true,
       external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
-      banner: { js: envBanner },
+      banner: { js: bannerJs },
     });
   }
 
@@ -341,12 +348,12 @@ export class Electron {
     try {
       fs.writeFileSync(testTarget, "test");
       fs.symlinkSync(testTarget, testLink, "file");
-      const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
-      fs.unlinkSync(testLink);
-      fs.unlinkSync(testTarget);
-      return isSymlink;
+      return fs.lstatSync(testLink).isSymbolicLink();
     } catch {
       return false;
+    } finally {
+      try { fs.unlinkSync(testLink); } catch { /* 파일 없으면 무시 */ }
+      try { fs.unlinkSync(testTarget); } catch { /* 파일 없으면 무시 */ }
     }
   }
 

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -74,6 +74,7 @@ export class DevWatchOrchestrator {
 
   // 워처
   private _copySrcWatchers: FsWatcher[] = [];
+  private _distDeleteWatchers: FsWatcher[] = [];
   private readonly _watchHookWatchers: FsWatcher[] = [];
   private readonly _watchHookChildren = new Map<string, ChildProcess>();
   private _replaceDepWatcher: WatchReplaceDepResult | undefined;
@@ -252,6 +253,7 @@ export class DevWatchOrchestrator {
 
     // 워처 종료 (watch 모드)
     shutdownTasks.push(...this._copySrcWatchers.map((w) => w.close()));
+    shutdownTasks.push(...this._distDeleteWatchers.map((w) => w.close()));
     shutdownTasks.push(...this._watchHookWatchers.map((w) => w.close()));
 
     // hook 자식 프로세스 종료
@@ -267,6 +269,7 @@ export class DevWatchOrchestrator {
 
     await Promise.all(shutdownTasks);
     this._copySrcWatchers = [];
+    this._distDeleteWatchers = [];
     this._watchHookWatchers.length = 0;
     this._replaceDepWatcher?.dispose();
 
@@ -277,6 +280,21 @@ export class DevWatchOrchestrator {
 
   private async _startWatchMode(): Promise<void> {
     this._logger.debug("watch 모드 시작");
+
+    // 라이브러리 패키지 dist 삭제 감지 워처
+    for (const pkg of this._libraryPackages) {
+      const distDir = pathx.posixResolve(pkg.dir, "dist");
+      const watcher = await FsWatcher.watch([distDir]);
+      watcher.onChange({ delay: 100 }, (changes) => {
+        for (const c of changes) {
+          if (c.event === "unlink" || c.event === "unlinkDir") {
+            this._logger.error(`[dist-delete:${pkg.name}] ${c.event}: ${c.path}\n${new Error().stack}`);
+          }
+        }
+      });
+      this._distDeleteWatchers.push(watcher);
+    }
+
     // Start copySrc watchers for library packages
     for (const pkg of this._libraryPackages) {
       if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {