@simplysm/sd-cli 14.0.42 → 14.0.43

package/src/esbuild/esbuild-client-config.ts

@@ -4,12 +4,13 @@ import { createRequire } from "module";
 import esbuild from "esbuild";
 import browserslistToEsbuild from "browserslist-to-esbuild";
 import type { AcceptedPlugin } from "postcss";
+import { AngularSourceFileCache } from "../angular/angular-compiler.js";
+import { createClientTransformStylesheet } from "../angular/client-transform-stylesheet.js";
 import {
-  createCompilerPlugin,
-  SourceFileCache,
-  type CompilerPluginOptions,
-  type BundleStylesheetOptions,
-} from "@angular/build/private";
+  createAngularCompilerPlugin,
+  type AngularCompilerPluginOptions,
+} from "./esbuild-angular-compiler-plugin.js";
+import { MemoryLoadResultCache } from "./load-result-cache.js";
 import { createScssPlugin } from "./esbuild-scss-plugin";
 import { createPostcssPlugin } from "./esbuild-postcss-plugin";
 
@@ -42,9 +43,21 @@ export interface CreateClientEsbuildOptions {
   legacyModule?: boolean;
 }
 
+export class ClientSourceFileCache extends AngularSourceFileCache {
+  readonly typeScriptFileCache = new Map<string, string | Uint8Array>();
+  readonly loadResultCache = new MemoryLoadResultCache();
+
+  override invalidate(files: Iterable<string>): void {
+    for (const file of files) {
+      this.loadResultCache.invalidate(file);
+    }
+    super.invalidate(files);
+  }
+}
+
 export interface ClientEsbuildResult {
   context: esbuild.BuildContext;
-  sourceFileCache: InstanceType<typeof SourceFileCache>;
+  sourceFileCache: ClientSourceFileCache;
 }
 
 export async function createClientEsbuildContext(
@@ -61,53 +74,56 @@ export async function createClientEsbuildContext(
     esbuildTarget = browserslistToEsbuild(queries);
   }
 
-  // SourceFileCache 생성 (LMDB 디스크 캐시)
+  // ClientSourceFileCache 생성
+  const sourceFileCache = new ClientSourceFileCache();
+
+  // SCSS 스타일시트 변환용 공유 상태
+  const stylesheetDependencies = new Map<string, Set<string>>();
+  const stylesheetErrors: string[] = [];
+
+  // PostCSS 플러그인 로딩 (튜플 → 인스턴스) — transformStylesheet와 createPostcssPlugin 양쪽에 사용
+  let loadedPostcssPlugins: AcceptedPlugin[] | undefined;
+  if (options.postcssPlugins != null && options.postcssPlugins.length > 0) {
+    const req = createRequire(path.join(options.pkgDir, "package.json"));
+    loadedPostcssPlugins = options.postcssPlugins.map(([name, pluginOpts]) => {
+      const pluginFn = req(name);
+      const fn = pluginFn.default ?? pluginFn;
+      return pluginOpts != null ? fn(pluginOpts) : fn;
+    });
+  }
+
+  // transformStylesheet 콜백 생성
   const cachePath = path.join(options.pkgDir, ".angular", "cache");
-  const sourceFileCache = new SourceFileCache(cachePath);
+  const transformStylesheet = createClientTransformStylesheet({
+    loadPaths: [
+      path.join(options.pkgDir, "node_modules"),
+      path.join(options.cwd, "node_modules"),
+    ],
+    postcssPlugins: loadedPostcssPlugins,
+    scssErrors: stylesheetErrors,
+    scssDependencies: stylesheetDependencies,
+    cacheDir: path.join(cachePath, "scss"),
+  });
 
-  // CompilerPluginOptions
-  const pluginOptions: CompilerPluginOptions = {
+  // AngularCompilerPluginOptions
+  const pluginOptions: AngularCompilerPluginOptions = {
     tsconfig: options.tsconfig ?? path.join(options.pkgDir, "tsconfig.json"),
     sourcemap: isDev,
     advancedOptimizations: !isDev,
     thirdPartySourcemaps: isDev,
     incremental: isDev,
     sourceFileCache,
+    typeScriptFileCache: sourceFileCache.typeScriptFileCache,
     loadResultCache: sourceFileCache.loadResultCache,
     templateUpdates: options.templateUpdates,
     includeTestMetadata: isDev,
+    persistentCachePath: cachePath,
+    transformStylesheet,
+    stylesheetDependencies,
+    stylesheetErrors,
   };
 
-  // BundleStylesheetOptions
-  const styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string } = {
-    workspaceRoot: options.cwd,
-    optimization: !isDev,
-    inlineFonts: false,
-    sourcemap: isDev ? "linked" : false,
-    outputNames: { bundles: "[name]", media: "media/[name]" },
-    includePaths: [],
-    target: esbuildTarget,
-    cacheOptions: {
-      enabled: true,
-      path: cachePath,
-      basePath: cachePath,
-    },
-    postcssConfiguration: undefined,
-    inlineStyleLanguage: "scss",
-  };
-
-  const angularPlugin = createCompilerPlugin(pluginOptions, styleOptions);
-
-  // PostCSS 플러그인 로딩 (튜플 → 인스턴스)
-  let loadedPostcssPlugins: AcceptedPlugin[] | undefined;
-  if (options.postcssPlugins != null && options.postcssPlugins.length > 0) {
-    const req = createRequire(path.join(options.pkgDir, "package.json"));
-    loadedPostcssPlugins = options.postcssPlugins.map(([name, pluginOpts]) => {
-      const pluginFn = req(name);
-      const fn = pluginFn.default ?? pluginFn;
-      return pluginOpts != null ? fn(pluginOpts) : fn;
-    });
-  }
+  const angularPlugin = createAngularCompilerPlugin(pluginOptions);
 
   // SCSS side-effect import 처리 플러그인
   const scssPlugin = createScssPlugin({
@@ -172,7 +188,7 @@ export async function createClientEsbuildContext(
     metafile: true,
     write: true,
     sourcemap: isDev ? "linked" : false,
-    logLevel: isDev ? "warning" : "silent",
+    logLevel: "silent",
     tsconfig: options.tsconfig ?? path.join(options.pkgDir, "tsconfig.json"),
     define,
     banner: hmrBanner != null ? { js: hmrBanner } : undefined,

package/src/esbuild/esbuild-tsc-plugin.ts

@@ -1,9 +1,11 @@
 import type esbuild from "esbuild";
 import type ts from "typescript";
 import { err as errNs } from "@simplysm/core-common";
-import { parseTsconfig, type TypecheckEnv } from "../utils/tsconfig";
-import { runTscPackageBuild, type TscPackageBuildResult } from "../utils/tsc-build";
+import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
+import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
+import type { LintWithProgramResult } from "../lint/lint-with-program";
+import type { TypecheckEnv } from "../utils/tsconfig";
 
 export interface TscPluginOptions {
   pkgDir: string;
@@ -11,6 +13,7 @@ export interface TscPluginOptions {
   output: { dts: boolean };
   env?: TypecheckEnv;
   includeTests?: boolean;
+  lint?: boolean;
 }
 
 export interface TscPluginResult {
@@ -19,6 +22,7 @@ export interface TscPluginResult {
   getAffectedFiles(): ReadonlySet<string> | undefined;
   getDiagnostics(): SerializedDiagnostic[];
   getErrors(): string[] | undefined;
+  getLintResult(): LintWithProgramResult | undefined;
   resetBuilderProgram(): void;
 }
 
@@ -28,43 +32,48 @@ export function createTscPlugin(options: TscPluginOptions): TscPluginResult {
   let lastAffectedFiles: ReadonlySet<string> | undefined;
   let lastDiagnostics: SerializedDiagnostic[] = [];
   let lastErrors: string[] | undefined;
-  let lastBuilderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
+  let lastLintResult: LintWithProgramResult | undefined;
 
-  // onStart에서 생성한 tsc Promise (onEnd에서 await)
-  let tscPromise: Promise<TscPackageBuildResult> | undefined;
+  // SdTsCompiler 인스턴스 (lazy 생성, resetBuilderProgram 시 재생성)
+  let compiler: SdTsCompiler | undefined;
+
+  // onStart에서 생성한 compile Promise (onEnd에서 await)
+  let compilePromise: Promise<ISdTsCompilerResult> | undefined;
 
   const plugin: esbuild.Plugin = {
     name: "sd-tsc",
     setup(build) {
       build.onStart(() => {
         // microtask로 tsc 스케줄링 (await하지 않음)
-        tscPromise = Promise.resolve().then(() => {
-          const parsedConfig = parseTsconfig(options.pkgDir);
-          return runTscPackageBuild({
-            pkgDir: options.pkgDir,
-            cwd: options.cwd,
-            output: { js: false, dts: options.output.dts },
-            parsedConfig,
-            env: options.env,
-            includeTests: options.includeTests,
-            oldBuilderProgram: lastBuilderProgram,
-          });
+        compilePromise = Promise.resolve().then(() => {
+          if (compiler == null) {
+            compiler = new SdTsCompiler({
+              pkgDir: options.pkgDir,
+              cwd: options.cwd,
+              output: { js: false, dts: options.output.dts },
+              env: options.env,
+              includeTests: options.includeTests,
+              lint: options.lint,
+            });
+          }
+          return compiler.compileAsync();
         });
       });
 
       build.onEnd(async () => {
         try {
-          const tscResult = await tscPromise!;
-          lastProgram = tscResult.program;
-          lastAffectedFiles = tscResult.affectedFiles;
-          lastDiagnostics = tscResult.diagnostics;
-          lastErrors = tscResult.errors;
-          lastBuilderProgram = tscResult.builderProgram;
+          const result = await compilePromise!;
+          lastProgram = result.program;
+          lastAffectedFiles = result.affectedFiles;
+          lastDiagnostics = result.diagnostics;
+          lastErrors = result.errors;
+          lastLintResult = result.lint;
         } catch (err) {
           lastProgram = undefined;
           lastAffectedFiles = undefined;
           lastDiagnostics = [];
           lastErrors = [errNs.message(err)];
+          lastLintResult = undefined;
         }
       });
     },
@@ -76,8 +85,9 @@ export function createTscPlugin(options: TscPluginOptions): TscPluginResult {
     getAffectedFiles: () => lastAffectedFiles,
     getDiagnostics: () => lastDiagnostics,
     getErrors: () => lastErrors,
+    getLintResult: () => lastLintResult,
     resetBuilderProgram: () => {
-      lastBuilderProgram = undefined;
+      compiler = undefined;
     },
   };
 }

package/src/esbuild/file-reference-tracker.ts

@@ -0,0 +1,61 @@
+import { normalize } from "path";
+
+/**
+ * 리소스 파일 의존성을 추적하여 증분 빌드 시 전이적 무효화를 지원한다.
+ *
+ * referencedFile → Set<containingFile> 역방향 맵을 유지한다.
+ * containingFile이 referencedFile을 참조하므로, referencedFile이 변경되면
+ * containingFile도 재컴파일 대상에 포함되어야 한다.
+ */
+export class FileReferenceTracker {
+  private readonly _referencingFiles = new Map<string, Set<string>>();
+
+  /** 추적 중인 모든 참조 파일(키)의 이터레이터 */
+  get referencedFiles(): IterableIterator<string> {
+    return this._referencingFiles.keys();
+  }
+
+  /**
+   * containingFile이 referencedFiles를 참조한다는 의존성을 등록한다.
+   * 자기 참조(containingFile === referencedFile)는 무시한다.
+   */
+  add(containingFile: string, referencedFiles: Iterable<string>): void {
+    const normalizedContaining = normalize(containingFile);
+    for (const file of referencedFiles) {
+      const normalizedRef = normalize(file);
+      if (normalizedRef === normalizedContaining) {
+        continue;
+      }
+      let referencing = this._referencingFiles.get(normalizedRef);
+      if (referencing == null) {
+        referencing = new Set([normalizedContaining]);
+        this._referencingFiles.set(normalizedRef, referencing);
+      } else {
+        referencing.add(normalizedContaining);
+      }
+    }
+  }
+
+  /**
+   * 변경된 파일 집합에 대해 전이적으로 영향받는 파일을 확장하여 반환한다.
+   * 확장이 없으면 원본 Set을 그대로 반환한다.
+   * 확장된 참조 레코드는 stale로 간주하여 정리한다.
+   */
+  update(changed: Set<string>): Set<string> {
+    let allChanged: Set<string> | undefined;
+
+    for (const modifiedFile of changed) {
+      const normalizedModified = normalize(modifiedFile);
+      const referencing = this._referencingFiles.get(normalizedModified);
+      if (referencing != null) {
+        allChanged ??= new Set(changed);
+        for (const referencingFile of referencing) {
+          allChanged.add(referencingFile);
+        }
+        this._referencingFiles.delete(normalizedModified);
+      }
+    }
+
+    return allChanged ?? changed;
+  }
+}

package/src/esbuild/lmdb-cache-store.ts

@@ -0,0 +1,46 @@
+import { open, type Database } from "lmdb";
+
+/**
+ * lmdb 기반 persistent key-value 캐시 스토어.
+ * JavaScriptTransformer의 JS 변환 결과를 디스크에 캐싱하여
+ * 프로세스 재시작 후에도 캐시를 재사용한다.
+ *
+ * @angular/build의 CacheStore 인터페이스와 구조적으로 호환된다.
+ */
+export class LmdbCacheStore<V = unknown> {
+  private readonly _cachePath: string;
+  private _db: Database | undefined;
+
+  constructor(cachePath: string) {
+    this._cachePath = cachePath;
+  }
+
+  private _ensureDb(): Database {
+    this._db ??= open({
+      path: this._cachePath,
+      compression: true,
+    });
+    return this._db;
+  }
+
+  get(key: string): V | undefined {
+    return this._ensureDb().get(key) as V | undefined;
+  }
+
+  has(key: string): boolean {
+    return this._ensureDb().doesExist(key);
+  }
+
+  async set(key: string, value: V): Promise<this> {
+    await this._ensureDb().put(key, value);
+    return this;
+  }
+
+  async close(): Promise<void> {
+    try {
+      await this._db?.close();
+    } catch {
+      // close 실패는 치명적이지 않음
+    }
+  }
+}

package/src/esbuild/load-result-cache.ts

@@ -0,0 +1,85 @@
+import path from "path";
+import type { OnLoadResult, PluginBuild } from "esbuild";
+
+export interface LoadResultCache {
+  get(path: string): OnLoadResult | undefined;
+  put(path: string, result: OnLoadResult): void | Promise<void>;
+  invalidate(path: string): boolean;
+  readonly watchFiles: readonly string[];
+}
+
+export function createCachedLoad(
+  cache: LoadResultCache | undefined,
+  callback: Parameters<PluginBuild["onLoad"]>[1],
+): Parameters<PluginBuild["onLoad"]>[1] {
+  if (cache == null) {
+    return callback;
+  }
+
+  return async (args) => {
+    const loadCacheKey = `${args.namespace}:${args.path}`;
+    let result: OnLoadResult | null | undefined = cache.get(loadCacheKey);
+
+    if (result == null) {
+      result = (await callback(args)) ?? null;
+
+      // null/undefined는 캐싱하지 않는다
+      if (result != null) {
+        // file namespace일 때 watchFiles에 요청 경로를 자동 추가
+        if (args.namespace === "file") {
+          result.watchFiles ??= [];
+          result.watchFiles.push(args.path);
+        }
+
+        await cache.put(loadCacheKey, result);
+      }
+    }
+
+    return result;
+  };
+}
+
+export class MemoryLoadResultCache implements LoadResultCache {
+  private readonly _loadResults = new Map<string, OnLoadResult>();
+  private readonly _fileDependencies = new Map<string, Set<string>>();
+
+  get(key: string): OnLoadResult | undefined {
+    return this._loadResults.get(key);
+  }
+
+  put(key: string, result: OnLoadResult): void {
+    this._loadResults.set(key, result);
+
+    if (result.watchFiles != null) {
+      for (const watchFile of result.watchFiles) {
+        const normalizedWatchFile = path.normalize(watchFile);
+        let affected = this._fileDependencies.get(normalizedWatchFile);
+        if (affected == null) {
+          affected = new Set();
+          this._fileDependencies.set(normalizedWatchFile, affected);
+        }
+        affected.add(key);
+      }
+    }
+  }
+
+  invalidate(filePath: string): boolean {
+    const affectedKeys = this._fileDependencies.get(filePath);
+    let found = false;
+
+    if (affectedKeys != null) {
+      for (const affected of affectedKeys) {
+        if (this._loadResults.delete(affected)) {
+          found = true;
+        }
+      }
+      this._fileDependencies.delete(filePath);
+    }
+
+    return found;
+  }
+
+  get watchFiles(): string[] {
+    return [...this._fileDependencies.keys()];
+  }
+}

package/src/index.ts

@@ -3,3 +3,8 @@ export * from "./sd-config.types";
 
 // Angular Vite Plugin
 export { sdAngularPlugin, type SdAngularPluginOptions } from "./angular/vite-angular-plugin";
+
+// TypeScript Compiler
+export { SdTsCompiler } from "./ts-compiler/SdTsCompiler";
+export type { ISdTsCompilerOptions } from "./ts-compiler/sd-ts-compiler-options";
+export type { ISdTsCompilerResult } from "./ts-compiler/sd-ts-compiler-result";

package/src/lint/lint-core.ts

@@ -130,13 +130,13 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
   }
 
   // ESLint 설정 로드
-  logger.start("ESLint 설정 로딩 중");
+  logger.debug("ESLint 설정 로딩 중");
   const ignorePatterns = await loadIgnorePatterns(cwd);
   logger.debug("무시 패턴 로드 완료", { ignorePatternCount: ignorePatterns.length });
-  logger.success(`ESLint 설정 로드 완료 (${ignorePatterns.length}개 무시 패턴)`);
+  logger.debug(`ESLint 설정 로드 완료 (${ignorePatterns.length}개 무시 패턴)`);
 
   // 린트 대상 파일 수집
-  logger.start("린트 대상 파일 수집 중");
+  logger.debug("린트 대상 파일 수집 중");
   let files = await fsx.glob("**/*.{ts,js,mjs,cjs}", {
     cwd,
     ignore: ignorePatterns,
@@ -145,19 +145,19 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
   });
   files = pathx.filterByTargets(files, targets, cwd);
   logger.debug("파일 수집 완료", { fileCount: files.length });
-  logger.success(`린트 대상 파일 수집 완료 (${files.length}개 파일)`);
+  logger.debug(`린트 대상 파일 수집 완료 (${files.length}개 파일)`);
 
   // 린트 실행
   let eslint: ESLint | undefined;
   let eslintResults: ESLint.LintResult[] | undefined;
   if (files.length > 0) {
-    logger.start(`린트 실행 중... (${files.length}개 파일)`);
+    logger.debug(`린트 실행 중... (${files.length}개 파일)`);
     eslint = new ESLint({
       cwd,
       fix,
     });
     eslintResults = await eslint.lintFiles(files);
-    logger.success("린트 실행 완료");
+    logger.debug("린트 실행 완료");
 
     // 자동 수정 적용
     if (fix) {
@@ -180,7 +180,7 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
   if (errorCount > 0) {
     logger.error("린트 에러 발생", { errorCount, warningCount });
   } else {
-    logger.info("린트 완료", { errorCount, warningCount });
+    logger.success("린트 완료", { errorCount, warningCount });
   }
 
   // 포매터 출력 수집

package/src/orchestrators/BaseOrchestrator.ts

@@ -102,9 +102,9 @@ export abstract class BaseOrchestrator {
     this._replaceDepWatcher = undefined;
 
     if (!this._hasPackages) return;
-    process.stdout.write("⏳ 종료 중...\n");
+    this._logger.start("종료 중...");
     await this._shutdownMode();
-    process.stdout.write("✔ 종료 완료\n");
+    this._logger.success("종료 완료");
   }
 
   protected abstract _initializeMode(

package/src/orchestrators/BuildOrchestrator.ts

@@ -1,4 +1,3 @@
-import ts from "typescript";
 import { fsx, pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type {
@@ -9,10 +8,8 @@ import type {
 } from "../sd-config.types";
 import { loadAndValidateConfig } from "../utils/orchestrator-utils";
 import { getVersion } from "../utils/build-env";
-import { deserializeDiagnostic } from "../typecheck/typecheck-serialization";
 import { copySrcFiles } from "../utils/copy-src";
 import { formatBuildMessages } from "../utils/output-utils";
-import { formatDiagnosticsOutput } from "../utils/diagnostic-utils";
 import { createBuildEngine } from "../engines/engine-factory";
 import type { BuildOutput, BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "../engines/types";
 import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
@@ -43,7 +40,6 @@ interface BuildStepResult {
   success: boolean;
   errors?: string[];
   warnings?: string[];
-  diagnostics?: ts.Diagnostic[];
 }
 
 /**
@@ -174,7 +170,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     ];
 
     if (this._allPackageNames.length === 0) {
-      process.stdout.write("✔ 빌드할 패키지가 없습니다.\n");
+      this._logger.info("빌드할 패키지가 없습니다.");
       return;
     }
 
@@ -252,8 +248,6 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
         hasUntrackedError.value = true;
       }
     }
-    this._logger.success("빌드 실행 완료");
-
     return { results, hasUntrackedError: hasUntrackedError.value };
   }
 
@@ -282,9 +276,6 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     try {
       const engineResult = await engine.run(params.output);
 
-      const diagnostics = engineResult.build.diagnostics.map((d) =>
-        deserializeDiagnostic(d, params.fileCache),
-      );
       return {
         name: params.name,
         target: params.target,
@@ -293,7 +284,6 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
         errors: engineResult.build.errors.length > 0 ? engineResult.build.errors : undefined,
         warnings:
           engineResult.build.warnings.length > 0 ? engineResult.build.warnings : undefined,
-        diagnostics,
       };
     } finally {
       await engine.stop();
@@ -316,7 +306,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
           name,
           target: config.target,
           config,
-          output: { js: true, dts: true, lint: false },
+          output: { js: true, dts: true, lint: false, includeTests: false },
           fileCache,
         });
         results.push(result);
@@ -349,7 +339,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
           name,
           target: "server",
           config: { ...config, env: { ...baseEnv, ...config.env } },
-          output: { js: true, dts: false, lint: false },
+          output: { js: true, dts: false, lint: false, includeTests: false },
           fileCache,
         });
         results.push(result);
@@ -385,7 +375,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
           name,
           target: "client",
           config: { ...config, env: { ...baseEnv, ...config.env } },
-          output: { js: true, dts: false, lint: false },
+          output: { js: true, dts: false, lint: false, includeTests: false },
           engineOptions: { outDir, base: isNativeBuild ? "" : undefined },
           fileCache,
         });
@@ -462,7 +452,6 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     results: BuildStepResult[],
     hasUntrackedError: boolean,
   ): boolean {
-    const allDiagnostics: ts.Diagnostic[] = [];
     for (const result of results) {
       const typeLabel = result.type === "lint" ? "lint" : result.target;
 
@@ -477,14 +466,6 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
           this._logger.error(`[${result.name}] (${typeLabel}) 실패`);
         }
       }
-      if (result.diagnostics != null) {
-        allDiagnostics.push(...result.diagnostics);
-      }
-    }
-
-    const diagnosticMessage = formatDiagnosticsOutput(allDiagnostics, this._cwd);
-    if (diagnosticMessage !== "") {
-      process.stdout.write(diagnosticMessage);
     }
 
     const errorCount = results.filter((r) => !r.success).length;
@@ -493,7 +474,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     if (hasError) {
       this._logger.error("빌드 에러 발생", { errorCount, warningCount });
     } else {
-      this._logger.info("빌드 완료", { errorCount, warningCount });
+      this._logger.success("빌드 완료", { errorCount, warningCount });
     }
 
     return hasError;

package/src/orchestrators/DevOrchestrator.ts

@@ -6,7 +6,7 @@ import type {
   SdServerPackageConfig,
 } from "../sd-config.types";
 import { filterPackagesByTargets, classifyDevPackages } from "../utils/package-classify";
-import { printErrors, printServers } from "../utils/output-utils";
+import { printDiagnostics, printServers } from "../utils/output-utils";
 import { createBuildEngine } from "../engines/engine-factory";
 import type { BuildEngine, ClientPackageInfo, ServerPackageInfo } from "../engines/types";
 import { Capacitor } from "../capacitor/capacitor";
@@ -130,14 +130,14 @@ export class DevOrchestrator extends BaseOrchestrator implements OrchestratorLif
     for (const [name, engine] of this._clientEngines) {
       initialBuildPromises.push({
         name: `${name} (client)`,
-        promise: engine.startWatch({ js: true, dts: false, lint: false }),
+        promise: engine.startWatch({ js: true, dts: false, lint: false, includeTests: false }),
       });
     }
 
     for (const [name, engine] of this._serverEngines) {
       initialBuildPromises.push({
         name: `${name} (server)`,
-        promise: engine.startWatch({ js: true, dts: false, lint: false }),
+        promise: engine.startWatch({ js: true, dts: false, lint: false, includeTests: false }),
       });
     }
 
@@ -217,7 +217,7 @@ export class DevOrchestrator extends BaseOrchestrator implements OrchestratorLif
     this._logger.debug(`배치 완료 (${completedKeys.join(", ")})`);
     const serverBuildKeys = this._serverPackages.map((p) => `${p.name}:build`);
     if (!completedKeys.some((k) => serverBuildKeys.includes(k))) {
-      printErrors(this._resultCollector.toMap());
+      printDiagnostics(this._resultCollector.toMap());
       return;
     }
 
@@ -259,7 +259,7 @@ export class DevOrchestrator extends BaseOrchestrator implements OrchestratorLif
     }
     await Promise.all(restartPromises);
     this._logger.debug("서버 재시작 완료");
-    printErrors(this._resultCollector.toMap());
+    printDiagnostics(this._resultCollector.toMap());
   }
 
   private _schedulePrintServers(): void {