@simplysm/sd-cli 13.0.100 → 14.0.1

package/src/sd-cli-entry.ts

@@ -5,15 +5,12 @@
 import "@simplysm/core-common";
 import yargs, { type Argv } from "yargs";
 import { hideBin } from "yargs/helpers";
-import { runLint } from "./commands/lint";
-import { runTypecheck } from "./commands/typecheck";
 import { runCheck, type CheckType } from "./commands/check";
 import { runWatch } from "./commands/watch";
 import { runDev } from "./commands/dev";
 import { runBuild } from "./commands/build";
 import { runPublish } from "./commands/publish";
 import { runReplaceDeps } from "./commands/replace-deps";
-import { runDevice } from "./commands/device";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
@@ -23,7 +20,7 @@ import { consola, LogLevels } from "consola";
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 100;
 
-const COMMAND_NAMES = ["lint", "typecheck", "check", "watch", "dev", "build", "device", "init", "publish", "replace-deps"];
+const COMMAND_NAMES = ["check", "watch", "dev", "build", "publish", "replace-deps"];
 
 async function collectYargsHelp(argv: string[]): Promise<string> {
   const lines: string[] = [];
@@ -82,68 +79,6 @@ export function createCliParser(argv: string[]): Argv {
         process.env["SD_DEBUG"] = "true";
       }
     })
-    .command(
-      "lint [targets..]",
-      "Run ESLint + Stylelint",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Paths to lint (e.g., packages/core-common, tests/orm)",
-            default: [],
-          })
-          .options({
-            fix: {
-              type: "boolean",
-              describe: "Auto-fix issues",
-              default: false,
-            },
-            timing: {
-              type: "boolean",
-              describe: "Print execution time per rule",
-              default: false,
-            },
-          }),
-      async (args) => {
-        await runLint({
-          targets: args.targets,
-          fix: args.fix,
-          timing: args.timing,
-        });
-      },
-    )
-    .command(
-      "typecheck [targets..]",
-      "Run TypeScript type checking",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Paths to typecheck (e.g., packages/core-common, tests/orm)",
-            default: [],
-          })
-          .options({
-            opt: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runTypecheck({
-          targets: args.targets,
-          options: args.opt,
-        });
-      },
-    )
     .command(
       "check [targets..]",
       "Run Typecheck, Lint, Test in parallel",
@@ -154,7 +89,7 @@ export function createCliParser(argv: string[]): Argv {
           .positional("targets", {
             type: "string",
             array: true,
-            describe: "Paths to check (e.g., packages/core-common, tests/orm)",
+            describe: "Packages to check (e.g., core-common, storage)",
             default: [],
           })
           .options({
@@ -163,11 +98,17 @@ export function createCliParser(argv: string[]): Argv {
               describe: "Check types to run (comma-separated: typecheck,lint,test)",
               default: "typecheck,lint,test",
             },
+            fix: {
+              type: "boolean",
+              describe: "Auto-fix lint issues",
+              default: false,
+            },
           }),
       async (args) => {
         await runCheck({
           targets: args.targets,
           types: args.type.split(",").map((t) => t.trim()) as CheckType[],
+          fix: args.fix,
         });
       },
     )
@@ -181,7 +122,7 @@ export function createCliParser(argv: string[]): Argv {
           .positional("targets", {
             type: "string",
             array: true,
-            describe: "Packages to watch (e.g., solid, solid-demo)",
+            describe: "Packages to watch (e.g., core-common, storage)",
             default: [],
           })
           .options({
@@ -202,7 +143,7 @@ export function createCliParser(argv: string[]): Argv {
     )
     .command(
       "dev [targets..]",
-      "Run Client and Server packages in dev mode",
+      "Run Server packages in dev mode",
       (cmd) =>
         cmd
           .version(false)
@@ -210,7 +151,7 @@ export function createCliParser(argv: string[]): Argv {
           .positional("targets", {
             type: "string",
             array: true,
-            describe: "Packages to run (e.g., solid-demo)",
+            describe: "Packages to run (e.g., service-server)",
             default: [],
           })
           .options({
@@ -239,7 +180,7 @@ export function createCliParser(argv: string[]): Argv {
           .positional("targets", {
             type: "string",
             array: true,
-            describe: "Packages to build (e.g., solid, core-common)",
+            describe: "Packages to build (e.g., core-common, storage)",
             default: [],
           })
           .options({
@@ -258,50 +199,6 @@ export function createCliParser(argv: string[]): Argv {
         });
       },
     )
-    .command(
-      "device",
-      "Run app on Android device",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .options({
-            package: {
-              type: "string",
-              alias: "p",
-              describe: "Package name",
-              demandOption: true,
-            },
-            url: {
-              type: "string",
-              alias: "u",
-              describe: "Development server URL (if not specified, use server config from sd.config.ts)",
-            },
-            opt: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runDevice({
-          package: args.package,
-          url: args.url,
-          options: args.opt,
-        });
-      },
-    )
-    .command(
-      "init",
-      "Initialize new project",
-      (cmd) => cmd.version(false).hide("help"),
-      async () => {
-        const { runInit } = await import("./commands/init.js");
-        await runInit({});
-      },
-    )
     .command(
       "publish [targets..]",
       "Publish packages",
@@ -312,7 +209,7 @@ export function createCliParser(argv: string[]): Argv {
           .positional("targets", {
             type: "string",
             array: true,
-            describe: "Packages to publish (e.g., solid, core-common)",
+            describe: "Packages to publish (e.g., core-common, storage)",
             default: [],
           })
           .options({

package/src/sd-config.types.ts

@@ -66,6 +66,8 @@ export interface SdBuildPackageConfig {
   publish?: SdPublishConfig;
   /** glob patterns for files to copy from src/ to dist/ (relative path based on src/) */
   copySrc?: string[];
+  /** watch hook configuration (when set, hook runs alongside build engine in watch mode) */
+  watch?: SdWatchHookConfig;
 }
 
 /**

package/src/utils/angular-build.ts

@@ -0,0 +1,157 @@
+/**
+ * Angular Build Adapter
+ *
+ * @angular/build/private API를 단일 모듈에 격리한다.
+ * Angular 버전 변경 시 이 파일만 수정하면 된다.
+ */
+import { consola } from "consola";
+
+// ── Re-exports: Build ──
+export { buildApplicationInternal } from "@angular/build/private";
+export { ResultKind } from "@angular/build/private";
+export type {
+  Result,
+  ResultFile,
+  ExternalResultMetadata,
+} from "@angular/build/private";
+
+// ── Re-exports: Dev Server ──
+export { serveWithVite, normalizeDevServerOptions } from "@angular/build/private";
+export type { NormalizedDevServerOptions } from "@angular/build/private";
+
+// ── Re-exports: Public types ──
+export type {
+  ApplicationBuilderOptions,
+  DevServerBuilderOptions,
+  BuildOutputFile,
+  BuildOutputFileType,
+  BuildOutputAsset,
+  DevServerBuilderOutput,
+} from "@angular/build";
+
+// ── Re-exports: IndexHtmlGenerator ──
+export { IndexHtmlGenerator } from "@angular/build/private";
+export type {
+  IndexHtmlGeneratorOptions,
+  IndexHtmlGeneratorProcessOptions,
+  IndexHtmlTransform,
+} from "@angular/build/private";
+
+// ── Re-exports: Angular Compiler (Library) ──
+export { NgtscProgram, OptimizeFor } from "@angular/compiler-cli";
+
+// ── Angular Library Host Extensions ──
+// NgtscProgram은 ts.CompilerHost를 받지만, 아래 메서드가 있으면 duck-typing으로 호출한다.
+// @angular/build/src/tools/angular/angular-host의 AngularCompilerHost에서 추출한 인터페이스.
+// 내부 경로가 exports 필드에 의해 차단되므로 자체 정의한다.
+
+export interface AngularLibraryHostExtensions {
+  /** 템플릿/스타일 파일을 읽는다 */
+  readResource(fileName: string): string | Promise<string>;
+  /** 인라인 스타일을 변환한다 (SCSS → CSS 등) */
+  transformResource(
+    data: string,
+    context: {
+      type: string;
+      containingFile: string;
+      resourceFile: string | null;
+    },
+  ): Promise<{ content: string } | null>;
+  /** 변경된 리소스 파일 목록을 반환한다 (incremental compilation용) */
+  getModifiedResourceFiles?(): Set<string> | undefined;
+}
+
+// ── Re-exports: Utilities ──
+export { checkPort, emitFilesToDisk } from "@angular/build/private";
+
+// ── BuilderContext Factory ──
+
+export interface AngularBuilderContextOptions {
+  workspaceRoot: string;
+  projectName: string;
+  /** 패키지 디렉토리 상대 경로 (workspaceRoot 기준) */
+  projectRoot: string;
+  /** 소스 디렉토리 (기본값: "src") */
+  sourceRoot?: string;
+  /** ApplicationBuilderOptions */
+  buildOptions: Record<string, unknown>;
+  signal?: AbortSignal;
+}
+
+const angularLogger = consola.withTag("sd:cli:angular");
+
+type TeardownCallback = () => Promise<void> | void;
+
+/**
+ * Angular CLI 없이 동작하는 BuilderContext를 생성한다.
+ * buildApplicationInternal()과 serveWithVite()가 실제 호출하는 필드만 구현한다.
+ */
+export function createAngularBuilderContext(options: AngularBuilderContextOptions) {
+  const teardowns: TeardownCallback[] = [];
+
+  const context = {
+    // ── Properties ──
+    workspaceRoot: options.workspaceRoot,
+    target: {
+      project: options.projectName,
+      target: "build",
+      configuration: "",
+    },
+    logger: {
+      info: (message: string) => angularLogger.info(message),
+      warn: (message: string) => angularLogger.warn(message),
+      error: (message: string) => angularLogger.error(message),
+      createChild: () => context.logger,
+    },
+    signal: options.signal,
+
+    // ── Methods (build) ──
+    addTeardown(fn: TeardownCallback) {
+      teardowns.push(fn);
+    },
+    getProjectMetadata(_projectName: string) {
+      return Promise.resolve({
+        root: options.projectRoot,
+        sourceRoot: options.sourceRoot ?? "src",
+      });
+    },
+
+    // ── Methods (dev server) ──
+    getTargetOptions(_target: unknown) {
+      return Promise.resolve(options.buildOptions);
+    },
+    getBuilderNameForTarget(_target: unknown) {
+      return Promise.resolve("@angular/build:application");
+    },
+    validateOptions<T = Record<string, unknown>>(
+      opts: Record<string, unknown>,
+      _builderName: string,
+    ): Promise<T> {
+      return Promise.resolve(opts as T);
+    },
+
+    // ── Stub (미사용) ──
+    id: 0,
+    builder: { builderName: "@angular/build:application", description: "", optionSchema: {} },
+    currentDirectory: options.workspaceRoot,
+    scheduleTarget() {
+      return Promise.reject(new Error("Not supported: scheduleTarget"));
+    },
+    scheduleBuilder() {
+      return Promise.reject(new Error("Not supported: scheduleBuilder"));
+    },
+    reportRunning() {},
+    reportStatus() {},
+    reportProgress() {},
+
+    // ── Teardown 실행 ──
+    async disposeTeardowns() {
+      for (const fn of teardowns.reverse()) {
+        await fn();
+      }
+      teardowns.length = 0;
+    },
+  };
+
+  return context;
+}

package/src/utils/concurrency.ts

@@ -0,0 +1,43 @@
+import os from "os";
+
+/**
+ * Run task functions with limited concurrency.
+ * Uses a shared index pattern — each worker consumes the next available task.
+ *
+ * @param tasks Array of async task functions to execute
+ * @param concurrency Maximum number of tasks running simultaneously
+ * @returns Array of PromiseSettledResult in the same order as input tasks
+ */
+export async function runWithConcurrency<T>(
+  tasks: Array<() => Promise<T>>,
+  concurrency: number,
+): Promise<PromiseSettledResult<T>[]> {
+  if (tasks.length === 0) return [];
+
+  const results: PromiseSettledResult<T>[] = new Array(tasks.length);
+  let index = 0;
+
+  async function worker(): Promise<void> {
+    while (index < tasks.length) {
+      const currentIndex = index++;
+      try {
+        const value = await tasks[currentIndex]();
+        results[currentIndex] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[currentIndex] = { status: "rejected", reason };
+      }
+    }
+  }
+
+  const workerCount = Math.min(concurrency, tasks.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
+/**
+ * Get max concurrency based on CPU cores.
+ * Uses 7/8 of available cores (minimum 1).
+ */
+export function getMaxConcurrency(): number {
+  return Math.max(Math.floor((os.cpus().length * 7) / 8), 1);
+}

package/src/utils/esbuild-config.ts

@@ -3,8 +3,6 @@ import { readFileSync, existsSync } from "fs";
 import fs from "fs/promises";
 import { createRequire } from "module";
 import type esbuild from "esbuild";
-import { solidPlugin } from "esbuild-plugin-solid";
-import type { TypecheckEnv } from "./tsconfig";
 import { consola } from "consola";
 
 const logger = consola.withTag("sd:cli:esbuild-config");
@@ -45,18 +43,6 @@ export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[])
   return hasChanges;
 }
 
-/**
- * esbuild options for Library build
- * - bundle: false (transpile individual files)
- * - platform: node or browser depending on target
- */
-export interface LibraryEsbuildOptions {
-  pkgDir: string;
-  entryPoints: string[];
-  target: "node" | "browser" | "neutral";
-  compilerOptions: Record<string, unknown>;
-}
-
 /**
  * esbuild options for Server build
  * - bundle: true (single bundle with all dependencies)
@@ -64,7 +50,6 @@ export interface LibraryEsbuildOptions {
 export interface ServerEsbuildOptions {
   pkgDir: string;
   entryPoints: string[];
-  compilerOptions: Record<string, unknown>;
   env?: Record<string, string>;
   /** External modules to exclude from bundle */
   external?: string[];
@@ -72,48 +57,6 @@ export interface ServerEsbuildOptions {
   dev?: boolean;
 }
 
-/**
- * Detect solid-js dependency in package.json
- */
-function hasSolidDependency(pkgDir: string): boolean {
-  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  const allDeps = { ...pkgJson.dependencies, ...pkgJson.peerDependencies };
-  return "solid-js" in allDeps;
-}
-
-/**
- * Create esbuild config for Library build
- *
- * Used to build library packages with node/browser/neutral targets
- * - bundle: false (transpile each file individually)
- * - platform: node if target is node, otherwise browser
- * - target: node20 if target is node, otherwise chrome84
- */
-export function createLibraryEsbuildOptions(options: LibraryEsbuildOptions): esbuild.BuildOptions {
-  const plugins: esbuild.Plugin[] = [];
-
-  if (hasSolidDependency(options.pkgDir)) {
-    plugins.unshift(solidPlugin());
-  }
-
-  return {
-    entryPoints: options.entryPoints,
-    outdir: path.join(options.pkgDir, "dist"),
-    format: "esm",
-    sourcemap: true,
-    sourcesContent: false,
-    platform: options.target === "node" ? "node" : "browser",
-    target: options.target === "node" ? "node20" : "chrome84",
-    bundle: false,
-    write: false,
-    tsconfigRaw: {
-      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
-    },
-    logLevel: "silent",
-    plugins,
-  };
-}
-
 /**
  * Create esbuild config for Server build
  *
@@ -144,75 +87,11 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     },
     external: options.external,
     define,
-    tsconfigRaw: {
-      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
-    },
+    tsconfig: path.join(options.pkgDir, "tsconfig.json"),
     logLevel: "silent",
   };
 }
 
-// TypeScript ScriptTarget enum → esbuild target string
-const TARGET_MAP: Record<number, string> = {
-  0: "es3", 1: "es5", 2: "es2015", 3: "es2016", 4: "es2017",
-  5: "es2018", 6: "es2019", 7: "es2020", 8: "es2021", 9: "es2022",
-  10: "es2023", 11: "es2024", 99: "esnext",
-};
-
-// TypeScript JsxEmit enum → esbuild jsx string
-const JSX_MAP: Record<number, string> = {
-  1: "preserve", 2: "react", 3: "react-native", 4: "react-jsx", 5: "react-jsxdev",
-};
-
-// TypeScript ModuleKind enum → string
-const MODULE_MAP: Record<number, string> = {
-  0: "none", 1: "commonjs", 2: "amd", 3: "umd", 4: "system",
-  5: "es2015", 6: "es2020", 7: "es2022", 99: "esnext",
-  100: "node16", 199: "nodenext",
-};
-
-// TypeScript ModuleResolutionKind enum → string
-const MODULE_RESOLUTION_MAP: Record<number, string> = {
-  1: "node10", 2: "node16", 3: "nodenext", 100: "bundler",
-};
-
-/**
- * Convert TypeScript's ts.CompilerOptions to esbuild-compatible tsconfigRaw compilerOptions.
- *
- * TypeScript uses numeric enum values (e.g., target: 99) while esbuild expects
- * string values (e.g., "esnext"). This converts known enum fields and passes
- * everything else through as-is.
- */
-function toEsbuildTsconfigRaw(
-  compilerOptions: Record<string, unknown>,
-): esbuild.TsconfigRaw["compilerOptions"] {
-  const result = { ...compilerOptions };
-
-  if (typeof result["target"] === "number") {
-    result["target"] = TARGET_MAP[result["target"]] ?? "esnext";
-  }
-  if (typeof result["jsx"] === "number") {
-    result["jsx"] = JSX_MAP[result["jsx"]];
-  }
-  if (typeof result["module"] === "number") {
-    result["module"] = MODULE_MAP[result["module"]];
-  }
-  if (typeof result["moduleResolution"] === "number") {
-    result["moduleResolution"] = MODULE_RESOLUTION_MAP[result["moduleResolution"]];
-  }
-
-  return result as esbuild.TsconfigRaw["compilerOptions"];
-}
-
-/**
- * Extract TypecheckEnv from build target
- *
- * Neutral is treated as browser for builds.
- * (neutral packages are Node/browser universal, but we treat as browser for build)
- */
-export function getTypecheckEnvFromTarget(target: "node" | "browser" | "neutral"): TypecheckEnv {
-  return target === "node" ? "node" : "browser";
-}
-
 //#region Optional Peer Deps
 
 interface PkgJson {