@simplysm/sd-cli 14.0.8 → 14.0.9

package/src/sd-cli-entry.ts

@@ -16,22 +16,12 @@ import fs from "fs";
 import { fileURLToPath } from "url";
 import { EventEmitter } from "node:events";
 import { consola, LogLevels } from "consola";
+import { SdCliReporter } from "./utils/SdCliReporter";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 100;
 
-// consola 타임스탬프에 밀리초 포함
-for (const reporter of consola.options.reporters) {
-  const r = reporter as { formatDate?: (date: Date, opts: { date?: boolean }) => string };
-  if (typeof r.formatDate === "function") {
-    const orig = r.formatDate.bind(r);
-    r.formatDate = (date: Date, opts: { date?: boolean }) => {
-      const base = orig(date, opts);
-      if (base === "") return "";
-      return `${base}.${String(date.getMilliseconds()).padStart(3, "0")}`;
-    };
-  }
-}
+consola.options.reporters = [new SdCliReporter()];
 
 const COMMAND_NAMES = ["check", "watch", "dev", "build", "publish", "replace-deps"];
 

package/src/utils/SdCliReporter.ts

@@ -0,0 +1,177 @@
+import type { ConsolaReporter, LogObject, ConsolaOptions } from "consola";
+import { formatWithOptions } from "node:util";
+import { sep } from "node:path";
+
+// -- Constants ----------------------------------------------------------------
+
+const TYPE_ICONS: Record<string, string> = {
+  error: "✖",
+  fatal: "✖",
+  ready: "✔",
+  warn: "⚠",
+  info: "ℹ",
+  success: "✔",
+  debug: "⚙",
+  trace: "→",
+  fail: "✖",
+  start: "◐",
+  log: "",
+};
+
+type AnsiColor = "gray" | "red" | "green" | "yellow" | "cyan" | "magenta";
+
+const TYPE_COLORS: Record<string, AnsiColor | undefined> = {
+  info: "cyan",
+  fail: "red",
+  success: "green",
+  ready: "green",
+  start: "magenta",
+};
+
+const LEVEL_COLORS: Record<number, AnsiColor | undefined> = {
+  0: "red",
+  1: "yellow",
+};
+
+const ANSI_CODES: Record<AnsiColor, string> = {
+  gray: "\x1b[90m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+const ANSI_RESET = "\x1b[0m";
+
+// -- Helpers ------------------------------------------------------------------
+
+function colorize(color: AnsiColor, text: string, enabled: boolean): string {
+  if (!enabled) return text;
+  return `${ANSI_CODES[color]}${text}${ANSI_RESET}`;
+}
+
+function writeStream(data: string, stream: NodeJS.WritableStream): void {
+  const s = stream as NodeJS.WritableStream & { __write?: typeof stream.write };
+  const write = s.__write ?? s.write;
+  write.call(stream, data);
+}
+
+function detectColorSupport(): boolean {
+  if (process.env["NO_COLOR"] != null) return false;
+  if (process.env["FORCE_COLOR"] != null) return true;
+  if (process.stdout.isTTY === true) return true;
+  // 워커 스레드에서는 process.stdout.isTTY가 없음. Windows 터미널은 ANSI 지원.
+  return process.platform === "win32";
+}
+
+// -- Reporter -----------------------------------------------------------------
+
+interface FormatOpts {
+  date?: boolean;
+  colors: boolean;
+  compact?: boolean | number;
+  errorLevel?: number;
+}
+
+/**
+ * sd-cli 전용 consola reporter.
+ * 모든 로그를 `[tag] icon message     time` 형식으로 통일한다.
+ */
+export class SdCliReporter implements ConsolaReporter {
+  log(logObj: LogObject, ctx: { options: ConsolaOptions }): void {
+    const opts: FormatOpts = {
+      ...ctx.options.formatOptions,
+      colors: detectColorSupport(),
+    };
+
+    const line = this._formatLogObj(logObj, opts);
+    const stream =
+      logObj.level < 2
+        ? ctx.options.stderr ?? process.stderr
+        : ctx.options.stdout ?? process.stdout;
+
+    writeStream(line + "\n", stream);
+  }
+
+  private _formatLogObj(logObj: LogObject, opts: FormatOpts): string {
+    const formattedArgs = this._formatArgs(logObj.args, opts);
+    const [message, ...additional] = formattedArgs.split("\n");
+
+    if (logObj.type === "box") {
+      return this._formatBox(logObj, formattedArgs);
+    }
+
+    // Build: [tag] icon message time
+    const tag = logObj.tag !== "" ? colorize("gray", `[${logObj.tag}]`, opts.colors) : "";
+    const icon = this._formatIcon(logObj, opts.colors);
+    const date = this._formatDate(logObj.date, opts);
+    const coloredDate = date !== "" ? colorize("gray", date, opts.colors) : "";
+
+    let fullLine = [tag, icon, message, coloredDate].filter(Boolean).join(" ");
+
+    if (additional.length > 0) {
+      fullLine += "\n" + additional.join("\n");
+    }
+
+    if (logObj.type === "trace") {
+      const err = new Error("Trace: " + logObj.message);
+      fullLine += this._formatStack(err.stack ?? "", err.message);
+    }
+
+    const isBadge = (logObj as LogObject & { badge?: boolean }).badge ?? logObj.level < 2;
+    return isBadge ? "\n" + fullLine + "\n" : fullLine;
+  }
+
+  private _formatArgs(args: unknown[], opts: FormatOpts): string {
+    const processed = args.map((arg) => {
+      if (arg != null && typeof arg === "object" && typeof (arg as Error).stack === "string") {
+        return this._formatError(arg as Error, opts);
+      }
+      return arg;
+    });
+    return formatWithOptions({ colors: opts.colors, compact: opts.compact }, ...processed);
+  }
+
+  private _formatError(err: Error, opts: FormatOpts): string {
+    const message = err.message;
+    const stack = err.stack != null ? this._formatStack(err.stack, message, opts) : "";
+    const level = opts.errorLevel ?? 0;
+    const prefix = level > 0 ? `${"  ".repeat(level)}[cause]: ` : "";
+    const cause =
+      err.cause instanceof Error
+        ? "\n\n" + this._formatError(err.cause, { ...opts, errorLevel: level + 1 })
+        : "";
+    return prefix + message + "\n" + stack + cause;
+  }
+
+  private _formatStack(stack: string, message: string, opts?: FormatOpts): string {
+    const cwd = process.cwd() + sep;
+    const indent = "  ".repeat((opts?.errorLevel ?? 0) + 1);
+    const lines = stack
+      .split("\n")
+      .splice(message.split("\n").length)
+      .map((l) => l.trim().replace("file://", "").replace(cwd, ""));
+    return `\n${indent}` + lines.map((l) => `  ${l}`).join(`\n${indent}`);
+  }
+
+  private _formatIcon(logObj: LogObject, useColors: boolean): string {
+    const icon = TYPE_ICONS[logObj.type] ?? "";
+    if (icon === "") return "";
+    const color: AnsiColor = TYPE_COLORS[logObj.type] ?? LEVEL_COLORS[logObj.level] ?? "gray";
+    return colorize(color, icon, useColors);
+  }
+
+  private _formatDate(date: Date, opts: FormatOpts): string {
+    if (!opts.date) return "";
+    const base = date.toLocaleTimeString();
+    return `${base}.${String(date.getMilliseconds()).padStart(3, "0")}`;
+  }
+
+  private _formatBox(logObj: LogObject, message: string): string {
+    const tag = logObj.tag !== "" ? `[${logObj.tag}]` : "";
+    const title = (logObj as LogObject & { title?: string }).title;
+    const lines = [tag, title, ...message.split("\n")].filter(Boolean);
+    return "\n" + lines.map((l) => ` > ${l}`).join("\n") + "\n";
+  }
+}

package/src/utils/angular-compiler.ts

@@ -2,6 +2,7 @@ import path from "path";
 import { createHash } from "crypto";
 import ts from "typescript";
 import { consola } from "consola";
+import { pathx } from "@simplysm/core-node";
 import { NgtscProgram, OptimizeFor } from "./angular-build";
 import { collectHmrCandidates } from "./hmr-candidates.js";
 
@@ -67,7 +68,7 @@ export class AngularSourceFileCache extends Map<string, ts.SourceFile> {
 
   invalidate(files: Iterable<string>): void {
     for (const file of files) {
-      const normalized = file.replace(/\\/g, "/");
+      const normalized = pathx.posix(file);
       this.delete(normalized);
       this.modifiedFiles.add(normalized);
     }
@@ -312,7 +313,7 @@ export class AngularCompiler {
         }
         const sf = node.getSourceFile();
         let relativePath = path.relative(host.getCurrentDirectory(), sf.fileName);
-        relativePath = relativePath.replace(/\\/g, "/");
+        relativePath = pathx.posix(relativePath);
 
         const updateId = encodeURIComponent(
           `${host.getCanonicalFileName(relativePath)}@${node.name?.text}`,
@@ -352,6 +353,7 @@ export class AngularCompiler {
     angularCompiler: NgCompiler,
     sourceFileCache?: AngularSourceFileCache,
   ): Set<ts.SourceFile> {
+    logger.debug("affected 파일 탐색 시작");
     const affectedFiles = new Set<ts.SourceFile>();
 
     while (true) {
@@ -393,7 +395,7 @@ export class AngularCompiler {
       // modifiedFiles의 경로를 정규화한 Set 생성 (Windows backslash 대응)
       const normalizedModifiedFiles = new Set<string>();
       for (const f of sourceFileCache.modifiedFiles) {
-        normalizedModifiedFiles.add(f.replace(/\\/g, "/"));
+        normalizedModifiedFiles.add(pathx.posix(f));
       }
 
       for (const sourceFile of builderProgram.getSourceFiles()) {
@@ -402,7 +404,7 @@ export class AngularCompiler {
         }
         const resourceDependencies = angularCompiler.getResourceDependencies(sourceFile);
         for (const resourceDep of resourceDependencies) {
-          if (normalizedModifiedFiles.has(resourceDep.replace(/\\/g, "/"))) {
+          if (normalizedModifiedFiles.has(pathx.posix(resourceDep))) {
             this._diagnosticCache.delete(sourceFile);
             affectedFiles.add(sourceFile);
             break;
@@ -411,6 +413,7 @@ export class AngularCompiler {
       }
     }
 
+    logger.debug(`affected 파일 탐색 완료 (${affectedFiles.size}개)`);
     return affectedFiles;
   }
 
@@ -420,6 +423,7 @@ export class AngularCompiler {
     affectedFiles: ReadonlySet<ts.SourceFile>;
     templateUpdates?: Map<string, string>;
   }> {
+    logger.debug("증분 업데이트 시작");
     const sourceFileCache = this._options.sourceFileCache;
     if (sourceFileCache == null) {
       throw new Error("sourceFileCache가 없으면 incremental rebuild를 수행할 수 없습니다");
@@ -432,6 +436,7 @@ export class AngularCompiler {
     if (this._ngtscProgram == null || this._builderProgram == null) {
       throw new Error("initialize()를 먼저 호출해야 합니다");
     }
+    logger.debug("emitAffectedFiles 시작");
 
     const compilerOptions = this._builderProgram.getCompilerOptions();
 
@@ -519,6 +524,7 @@ export class AngularCompiler {
     }
 
     // 7. sourceFilter 적용 후 yield
+    logger.debug(`emitAffectedFiles 완료 (${emitResults.length}개 파일)`);
     for (const result of emitResults) {
       if (options?.sourceFilter != null && !options.sourceFilter(result.sourceFileName)) {
         continue;
@@ -531,6 +537,7 @@ export class AngularCompiler {
     if (this._ngtscProgram == null || this._builderProgram == null) {
       throw new Error("initialize()를 먼저 호출해야 합니다");
     }
+    logger.debug("진단 수집 시작");
 
     const angularCompiler = this._ngtscProgram.compiler;
     const builderProgram = this._builderProgram;

package/src/utils/build-env.ts

@@ -1,11 +1,12 @@
 import path from "path";
 import fs from "fs/promises";
+import { pathx } from "@simplysm/core-node";
 
 /**
  * Get version from root package.json
  */
 export async function getVersion(cwd: string): Promise<string> {
-  const pkgJsonPath = path.join(cwd, "package.json");
+  const pkgJsonPath = pathx.posix(path.join(cwd, "package.json"));
   const pkgJsonContent = await fs.readFile(pkgJsonPath, "utf-8");
   const pkgJson = JSON.parse(pkgJsonContent) as { version?: string };
   return pkgJson.version ?? "0.0.0";

package/src/utils/copy-public.ts

@@ -13,18 +13,18 @@ import {
  * @param includeDev Whether to include public-dev/ (true only in dev mode)
  */
 export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Promise<void> {
-  const distDir = path.join(pkgDir, "dist");
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
   await fsx.mkdir(distDir);
 
   // Copy public/
-  const publicDir = path.join(pkgDir, "public");
+  const publicDir = pathx.posix(path.join(pkgDir, "public"));
   if (await fsx.exists(publicDir)) {
     const files = await fsx.glob("**/*", { cwd: publicDir, absolute: true });
     await Promise.all(
       files.map(async (file) => {
-        const relativePath = path.relative(publicDir, file);
-        const distPath = path.join(distDir, relativePath);
-        await fsx.mkdir(path.dirname(distPath));
+        const relativePath = pathx.posix(path.relative(publicDir, file));
+        const distPath = pathx.posix(path.join(distDir, relativePath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(file, distPath);
       }),
     );
@@ -32,14 +32,14 @@ export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Prom
 
   // Copy public-dev/ (overlay: overwrites public/)
   if (includeDev) {
-    const publicDevDir = path.join(pkgDir, "public-dev");
+    const publicDevDir = pathx.posix(path.join(pkgDir, "public-dev"));
     if (await fsx.exists(publicDevDir)) {
       const files = await fsx.glob("**/*", { cwd: publicDevDir, absolute: true });
       await Promise.all(
         files.map(async (file) => {
-          const relativePath = path.relative(publicDevDir, file);
-          const distPath = path.join(distDir, relativePath);
-          await fsx.mkdir(path.dirname(distPath));
+          const relativePath = pathx.posix(path.relative(publicDevDir, file));
+          const distPath = pathx.posix(path.join(distDir, relativePath));
+          await fsx.mkdir(pathx.posix(path.dirname(distPath)));
           await fsx.copy(file, distPath);
         }),
       );
@@ -59,9 +59,9 @@ export async function watchPublicFiles(
   pkgDir: string,
   includeDev: boolean,
 ): Promise<FsWatcher | undefined> {
-  const distDir = path.join(pkgDir, "dist");
-  const publicDir = path.join(pkgDir, "public");
-  const publicDevDir = path.join(pkgDir, "public-dev");
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
+  const publicDir = pathx.posix(path.join(pkgDir, "public"));
+  const publicDevDir = pathx.posix(path.join(pkgDir, "public-dev"));
 
   // Initial copy
   await copyPublicFiles(pkgDir, includeDev);
@@ -69,10 +69,10 @@ export async function watchPublicFiles(
   // Collect watch target paths
   const watchPaths: string[] = [];
   if (await fsx.exists(publicDir)) {
-    watchPaths.push(path.join(publicDir, "**/*"));
+    watchPaths.push(pathx.posix(path.join(publicDir, "**/*")));
   }
   if (includeDev && (await fsx.exists(publicDevDir))) {
-    watchPaths.push(path.join(publicDevDir, "**/*"));
+    watchPaths.push(pathx.posix(path.join(publicDevDir, "**/*")));
   }
 
   if (watchPaths.length === 0) {
@@ -91,22 +91,22 @@ export async function watchPublicFiles(
         sourceDir = publicDir;
       }
 
-      const relPath = path.relative(sourceDir, filePath);
-      const distPath = path.join(distDir, relPath);
+      const relPath = pathx.posix(path.relative(sourceDir, filePath));
+      const distPath = pathx.posix(path.join(distDir, relPath));
 
       if (event === "unlink") {
         // If deleted from public, don't delete if same file exists in public-dev
         if (sourceDir === publicDir && includeDev) {
-          const devOverride = path.join(publicDevDir, relPath);
+          const devOverride = pathx.posix(path.join(publicDevDir, relPath));
           if (await fsx.exists(devOverride)) {
             continue;
           }
         }
         // If deleted from public-dev, restore from public if it exists (fallback restore)
         if (sourceDir === publicDevDir && includeDev) {
-          const publicFallback = path.join(publicDir, relPath);
+          const publicFallback = pathx.posix(path.join(publicDir, relPath));
           if (await fsx.exists(publicFallback)) {
-            await fsx.mkdir(path.dirname(distPath));
+            await fsx.mkdir(pathx.posix(path.dirname(distPath)));
             await fsx.copy(publicFallback, distPath);
             continue;
           }
@@ -115,12 +115,12 @@ export async function watchPublicFiles(
       } else if (event === "add" || event === "change") {
         // If changed in public, skip if same file exists in public-dev (overlay takes priority)
         if (sourceDir === publicDir && includeDev) {
-          const devOverride = path.join(publicDevDir, relPath);
+          const devOverride = pathx.posix(path.join(publicDevDir, relPath));
           if (await fsx.exists(devOverride)) {
             continue;
           }
         }
-        await fsx.mkdir(path.dirname(distPath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(filePath, distPath);
       }
     }

package/src/utils/copy-src.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import { fsx, FsWatcher } from "@simplysm/core-node";
+import { fsx, pathx, FsWatcher } from "@simplysm/core-node";
 
 /**
  * Copy files matching glob patterns from src/ to dist/
@@ -9,16 +9,16 @@ import { fsx, FsWatcher } from "@simplysm/core-node";
  * @param patterns Array of glob patterns (relative to src/)
  */
 export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<void> {
-  const srcDir = path.join(pkgDir, "src");
-  const distDir = path.join(pkgDir, "dist");
+  const srcDir = pathx.posix(path.join(pkgDir, "src"));
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
 
   for (const pattern of patterns) {
     const files = await fsx.glob(pattern, { cwd: srcDir, absolute: true });
     await Promise.all(
       files.map(async (file) => {
-        const relativePath = path.relative(srcDir, file);
-        const distPath = path.join(distDir, relativePath);
-        await fsx.mkdir(path.dirname(distPath));
+        const relativePath = pathx.posix(path.relative(srcDir, file));
+        const distPath = pathx.posix(path.join(distDir, relativePath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(file, distPath);
       }),
     );
@@ -34,25 +34,25 @@ export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<
  * @returns FsWatcher instance (call close() on shutdown)
  */
 export async function watchCopySrcFiles(pkgDir: string, patterns: string[]): Promise<FsWatcher> {
-  const srcDir = path.join(pkgDir, "src");
-  const distDir = path.join(pkgDir, "dist");
+  const srcDir = pathx.posix(path.join(pkgDir, "src"));
+  const distDir = pathx.posix(path.join(pkgDir, "dist"));
 
   // Initial copy
   await copySrcFiles(pkgDir, patterns);
 
   // Start watch
-  const watchPaths = patterns.map((p) => path.join(srcDir, p));
+  const watchPaths = patterns.map((p) => pathx.posix(path.join(srcDir, p)));
   const watcher = await FsWatcher.watch(watchPaths);
 
   watcher.onChange({ delay: 300 }, async (changes) => {
     for (const { event, path: filePath } of changes) {
-      const relPath = path.relative(srcDir, filePath);
-      const distPath = path.join(distDir, relPath);
+      const relPath = pathx.posix(path.relative(srcDir, filePath));
+      const distPath = pathx.posix(path.join(distDir, relPath));
 
       if (event === "unlink") {
         await fsx.rm(distPath);
       } else if (event === "add" || event === "change") {
-        await fsx.mkdir(path.dirname(distPath));
+        await fsx.mkdir(pathx.posix(path.dirname(distPath)));
         await fsx.copy(filePath, distPath);
       }
     }

package/src/utils/diagnostic-utils.ts

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { pathx } from "@simplysm/core-node";
 
 /**
  * 워크스페이스 스코프 진단 필터.
@@ -8,8 +9,8 @@ import ts from "typescript";
 export function isWorkspaceDiagnostic(diagnostic: ts.Diagnostic, cwd: string): boolean {
   if (diagnostic.file == null) return true;
 
-  const normalized = diagnostic.file.fileName.replace(/\\/g, "/");
-  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalized = pathx.posix(diagnostic.file.fileName);
+  const normalizedCwd = pathx.posix(cwd).replace(/\/$/, "");
   return normalized.startsWith(normalizedCwd + "/") && !normalized.includes("/node_modules/");
 }
 

package/src/utils/esbuild-config.ts

@@ -15,6 +15,7 @@ const logger = consola.withTag("sd:cli:esbuild-config");
  * - Skip writing if content matches existing file to preserve timestamps
  */
 export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[]): Promise<boolean> {
+  logger.debug(`변경된 출력 파일 쓰기 시작 (${outputFiles.length}개)`);
   let hasChanges = false;
   await Promise.all(
     outputFiles.map(async (file) => {
@@ -40,6 +41,7 @@ export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[])
       await fs.writeFile(file.path, finalText);
     }),
   );
+  logger.debug(`변경된 출력 파일 쓰기 완료 (변경: ${String(hasChanges)})`);
   return hasChanges;
 }
 

package/src/utils/lint-with-program.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import type ts from "typescript";
 import { ESLint } from "eslint";
+import { pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 
 const logger = consola.withTag("sd:cli:lint-with-program");
@@ -58,11 +59,12 @@ export class LintWithProgramRunner {
    * Includes all workspace source files (cwd scope), excludes .d.ts, node_modules, and Angular shims.
    */
   private _extractFiles(program: ts.Program): string[] {
-    const normalizedCwd = this._cwd.replace(/\\/g, "/");
+    logger.debug(`[${this._pkgName}] 린트 대상 파일 추출 시작`);
+    const normalizedCwd = pathx.posix(this._cwd);
     const files: string[] = [];
 
     for (const sf of program.getSourceFiles()) {
-      const fileName = sf.fileName.replace(/\\/g, "/");
+      const fileName = pathx.posix(sf.fileName);
 
       // Must be within workspace root
       if (!fileName.startsWith(normalizedCwd + "/")) {
@@ -87,6 +89,7 @@ export class LintWithProgramRunner {
       files.push(sf.fileName);
     }
 
+    logger.debug(`[${this._pkgName}] 린트 대상 파일 추출 완료 (${files.length}개)`);
     return files;
   }
 
@@ -103,7 +106,7 @@ export class LintWithProgramRunner {
 
     // When affectedFiles is provided, intersect with extracted files
     if (affectedFiles != null) {
-      files = files.filter((f) => affectedFiles.has(f.replace(/\\/g, "/")));
+      files = files.filter((f) => affectedFiles.has(pathx.posix(f)));
     }
 
     if (files.length === 0) {
@@ -127,6 +130,7 @@ export class LintWithProgramRunner {
 
     // Create new ESLint instance when cache policy changes or on first call
     if (this._eslint == null || this._lastUseCache !== useCache) {
+      logger.debug(`[${this._pkgName}] ESLint 인스턴스 생성 (cache: ${String(useCache)})`);
       // ESLint Flat Config serializes languageOptions via languageOptionsToJSON(),
       // which recurses into parserOptions and throws on ts.Program methods.
       // Adding toJSON() to parserOptions returns a serializable representation