@simplysm/sd-cli 13.0.100 → 14.0.1

package/src/commands/publish.ts

@@ -7,6 +7,7 @@ import { env, json } from "@simplysm/core-common";
 import "@simplysm/core-common";
 import type { SdConfig, SdPublishConfig } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
+import { validateTargets } from "../utils/package-utils";
 import { execa } from "execa";
 import { runBuild } from "./build";
 import { parseWorkspaceGlobs } from "../utils/replace-deps";
@@ -491,6 +492,9 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     return;
   }
 
+  // Validate targets
+  validateTargets(targets, sdConfig.packages);
+
   // Load package.json
   const projPkgPath = path.resolve(cwd, "package.json");
   const projPkg = await fsx.readJson<PackageJson>(projPkgPath);

package/src/commands/typecheck.ts

@@ -1,15 +1,14 @@
 import ts from "typescript";
 import path from "path";
-import os from "os";
-import { pathx, Worker, type WorkerProxy } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import type { SdConfig } from "../sd-config.types";
-import { parseRootTsconfig, type TypecheckEnv } from "../utils/tsconfig";
 import { loadSdConfig } from "../utils/sd-config";
 import { deserializeDiagnostic } from "../utils/typecheck-serialization";
-import type { DtsBuildInfo, DtsBuildResult } from "../workers/dts.worker";
-import type * as DtsWorkerModule from "../workers/dts.worker";
+import { createBuildEngine } from "../engines/index";
+import { typecheckNonPackageFiles } from "../utils/typecheck-non-package";
+import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
+import type { EngineResult } from "../engines/types";
 
 //#region Types
 
@@ -33,138 +32,23 @@ export interface TypecheckResult {
   formattedOutput: string;
 }
 
-// Package information (for classifying files under packages/*)
-interface PackageInfo {
-  name: string;
-  dir: string;
-  envs: TypecheckEnv[]; // neutral is ["node", "browser"], others are single environment
-}
-
-// Typecheck task information (internal use)
-interface TypecheckTask {
-  /** Task display name (e.g., "package: core-common [node]") */
-  displayName: string;
-  /** Information to pass to dts.worker */
-  buildInfo: DtsBuildInfo;
-}
-
 //#endregion
 
 //#region Utilities
 
-/** Regular expression for path classification */
-const PATH_PATTERNS = {
-  /** packages/{pkg}/... */
-  PACKAGE: /^packages\/([^/]+)\//,
-} as const;
+const PACKAGE_PATH_PATTERN = /^packages\/([^/]+)/;
 
 /**
- * Convert package target to typecheck environment list.
- * - node/browser: that environment only
- * - neutral: both node + browser
- * - client: treated as browser
- * @param target package build target
- * @returns list of typecheck environments
+ * Extract package names from target paths.
+ * "packages/core-common" → "core-common"
  */
-function toTypecheckEnvs(target: string | undefined): TypecheckEnv[] {
-  if (target === "node") return ["node"];
-  if (target === "browser" || target === "client") return ["browser"];
-  // neutral or unspecified: both
-  return ["node", "browser"];
-}
-
-/**
- * Extract package information from file paths.
- * Excludes packages with scripts target.
- * @internal exported for testing
- */
-export function extractPackages(
-  fileNames: string[],
-  cwd: string,
-  config: SdConfig,
-): Map<string, PackageInfo> {
-  const packages = new Map<string, PackageInfo>();
-
-  for (const fileName of fileNames) {
-    const relativePath = pathx.posix(path.relative(cwd, fileName));
-
-    // packages/{pkg}/...
-    const packageMatch = relativePath.match(PATH_PATTERNS.PACKAGE);
-    if (packageMatch) {
-      const pkgName = packageMatch[1];
-      // Exclude packages with scripts target
-      if (config.packages[pkgName]?.target === "scripts") continue;
-
-      if (!packages.has(pkgName)) {
-        packages.set(pkgName, {
-          name: pkgName,
-          dir: path.resolve(cwd, "packages", pkgName),
-          envs: toTypecheckEnvs(config.packages[pkgName]?.target),
-        });
-      }
-    }
+function extractTargetPackageNames(targets: string[]): Set<string> {
+  const names = new Set<string>();
+  for (const target of targets) {
+    const match = target.match(PACKAGE_PATH_PATTERN);
+    if (match) names.add(match[1]);
   }
-
-  return packages;
-}
-
-/**
- * Check if there are files not under packages/ in the tsconfig file list.
- */
-function hasNonPackageFiles(fileNames: string[], cwd: string): boolean {
-  return fileNames.some((f) => {
-    const relativePath = pathx.posix(path.relative(cwd, f));
-    if (!relativePath.startsWith("packages/")) return true;
-    // Also treat files directly under package root (config files) as non-package
-    return relativePath.split("/").length === 3;
-  });
-}
-
-/**
- * Create typecheck task list from package information.
- * Neutral packages are split into node/browser environments and checked separately.
- * @param packages package information map
- * @param cwd current working directory
- * @param includeNonPackage add "other" task if non-package files exist
- * @returns array of typecheck task information
- */
-function createTypecheckTasks(
-  packages: Map<string, PackageInfo>,
-  cwd: string,
-  includeNonPackage: boolean,
-): TypecheckTask[] {
-  const tasks: TypecheckTask[] = [];
-
-  // packages/* - create separate task per env
-  for (const info of packages.values()) {
-    for (const env of info.envs) {
-      const envSuffix = info.envs.length > 1 ? ` [${env}]` : "";
-      tasks.push({
-        displayName: `package: ${info.name}${envSuffix}`,
-        buildInfo: {
-          name: info.name,
-          cwd,
-          pkgDir: info.dir,
-          env,
-          emit: false, // Only typecheck (no dts generation)
-        },
-      });
-    }
-  }
-
-  // non-package files (tests/, root *.ts, etc.)
-  if (includeNonPackage) {
-    tasks.push({
-      displayName: "other",
-      buildInfo: {
-        name: "root",
-        cwd,
-        emit: false,
-      },
-    });
-  }
-
-  return tasks;
+  return names;
 }
 
 //#endregion
@@ -172,14 +56,12 @@ function createTypecheckTasks(
 //#region Main
 
 /**
- * Execute TypeScript typecheck and return results.
+ * Execute TypeScript typecheck using BuildEngine.
  *
- * - Load `tsconfig.json` to apply compiler options
- * - Load `sd.config.ts` to check package target info per package (use defaults if missing)
- * - Perform actual parallel typecheck using Worker threads
- * - Use incremental compilation (`.cache/typecheck-{env}.tsbuildinfo`)
- * - Show progress using consola logging
- * - Return results only, no stdout output or exitCode setting
+ * For each package in sd.config.ts:
+ * - Library/Server packages → BuildEngine.run({js:false, dts:false})
+ * - Scripts/Client packages → excluded
+ * Non-package files → typecheckNonPackageFiles utility
  *
  * @param options - typecheck execution options
  * @returns typecheck result (success status, error/warning counts, formatted output string)
@@ -197,51 +79,38 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
     getNewLine: () => ts.sys.newLine,
   };
 
-  // Load and parse tsconfig.json
-  let parsedConfig: ts.ParsedCommandLine;
-  try {
-    parsedConfig = parseRootTsconfig(cwd);
-  } catch (err) {
-    logger.error(errNs.message(err));
-    return { success: false, errorCount: 1, warningCount: 0, formattedOutput: "" };
-  }
-
   // Load sd.config.ts
   let sdConfig: SdConfig;
   try {
     sdConfig = await loadSdConfig({ cwd, dev: false, options: options.options });
     logger.debug("sd.config.ts loaded");
-  } catch (err) {
-    // Use defaults if sd.config.ts is missing or load fails
+  } catch {
     sdConfig = { packages: {} };
-    logger.debug("sd.config.ts load failed, using defaults", err);
+    logger.debug("sd.config.ts load failed, using defaults");
   }
 
-  // Filter fileNames if targets specified
-  const fileNames = pathx.filterByTargets(parsedConfig.fileNames, targets, cwd);
+  // Determine target package names from path-based targets
+  const targetNames = extractTargetPackageNames(targets);
 
-  if (fileNames.length === 0) {
-    logger.info("no files to typecheck");
-    return {
-      success: true,
-      errorCount: 0,
-      warningCount: 0,
-      formattedOutput: "✔ No files to typecheck.\n",
-    };
-  }
+  // Collect packages to typecheck (exclude scripts and client)
+  const typecheckPackages: Array<{ name: string; dir: string; config: any }> = [];
+  for (const [name, config] of Object.entries(sdConfig.packages)) {
+    if (config == null) continue;
+    if (config.target === "scripts" || config.target === "client") continue;
+    if (targetNames.size > 0 && !targetNames.has(name)) continue;
 
-  // Extract package information
-  const packages = extractPackages(fileNames, cwd, sdConfig);
-  logger.debug("package extraction complete", {
-    packageCount: packages.size,
-    packages: [...packages.keys()],
-  });
+    typecheckPackages.push({
+      name,
+      dir: path.join(cwd, "packages", name),
+      config,
+    });
+  }
 
-  // Create typecheck tasks
-  const nonPackage = hasNonPackageFiles(fileNames, cwd);
-  const tasks = createTypecheckTasks(packages, cwd, nonPackage);
+  // Non-package typecheck: run when no targets or when targets include non-package paths
+  const includeNonPackage = targets.length === 0 || targets.some((t) => !t.startsWith("packages/"));
 
-  if (tasks.length === 0) {
+  if (typecheckPackages.length === 0 && !includeNonPackage) {
+    logger.info("no typecheck targets");
     return {
       success: true,
       errorCount: 0,
@@ -250,89 +119,71 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
     };
   }
 
-  // Concurrency setting: use 7/8 of CPU cores (standard default for parallel build tools, reserves for OS/other processes, minimum 1, at most task count)
-  const maxConcurrency = Math.max(Math.floor((os.cpus().length * 7) / 8), 1);
-  const concurrency = Math.min(maxConcurrency, tasks.length);
-  logger.debug("concurrency configuration", { concurrency, maxConcurrency, taskCount: tasks.length });
-
-  // Create Worker pool
-  const workerPath = import.meta.resolve("../workers/dts.worker");
-  const workers: WorkerProxy<typeof DtsWorkerModule>[] = [];
-  for (let i = 0; i < concurrency; i++) {
-    workers.push(Worker.create<typeof DtsWorkerModule>(workerPath));
-  }
-
-  const allResults: { displayName: string; result: DtsBuildResult }[] = [];
-
-  try {
-    let taskIndex = 0;
+  // Create BuildEngine tasks with concurrency limit
+  const allDiagnostics: ts.Diagnostic[] = [];
+  let totalErrorCount = 0;
+  let totalWarningCount = 0;
+  const fileCache = new Map<string, string>();
+
+  if (typecheckPackages.length > 0) {
+    const tasks = typecheckPackages.map((pkg) => async (): Promise<EngineResult> => {
+      const engine = createBuildEngine(
+        { name: pkg.name, dir: pkg.dir, config: pkg.config },
+        { cwd },
+      );
+      try {
+        logger.debug(`[${pkg.name}] typecheck started`);
+        const result = await engine.run({ js: false, dts: false });
+        logger.debug(`[${pkg.name}] typecheck ${result.dts.success ? "completed" : "failed"}`);
+        return result;
+      } finally {
+        await engine.stop();
+      }
+    });
 
-    async function runNextTask(worker: WorkerProxy<typeof DtsWorkerModule>): Promise<void> {
-      while (taskIndex < tasks.length) {
-        const currentIndex = taskIndex++;
-        const task = tasks[currentIndex];
+    const concurrency = getMaxConcurrency();
+    logger.start(`Running typecheck... (${tasks.length} packages, concurrency: ${concurrency})`);
+    const results = await runWithConcurrency(tasks, concurrency);
+    logger.success("Typecheck execution completed");
 
-        logger.debug(`[${task.displayName}] typecheck started`);
-        try {
-          const result = await worker.build(task.buildInfo);
-          allResults.push({ displayName: task.displayName, result });
-          if (result.success) {
-            logger.debug(`[${task.displayName}] typecheck completed`);
-          } else {
-            logger.debug(`[${task.displayName}] typecheck failed`, { errorCount: result.errorCount });
-          }
-        } catch (err) {
-          logger.error(`Worker error: ${task.displayName}`, {
-            error: errNs.message(err),
-          });
-          allResults.push({
-            displayName: task.displayName,
-            result: {
-              success: false,
-              errors: [errNs.message(err)],
-              diagnostics: [],
-              errorCount: 1,
-              warningCount: 0,
-            },
-          });
+    // Aggregate engine results
+    for (const settled of results) {
+      if (settled.status === "fulfilled") {
+        const engineResult = settled.value;
+        const dtsDiags = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+        allDiagnostics.push(...dtsDiags);
+        // Count errors/warnings from deserialized diagnostics
+        // Use numeric category values (ts.DiagnosticCategory: Error=1, Warning=0)
+        totalErrorCount += dtsDiags.filter((d) => d.category === 1).length;
+        totalWarningCount += dtsDiags.filter((d) => d.category === 0).length;
+        if (!engineResult.dts.success && dtsDiags.length === 0) {
+          totalErrorCount += engineResult.dts.errors.length || 1;
         }
+      } else {
+        totalErrorCount += 1;
+        logger.error("Engine task failed", { error: errNs.message(settled.reason) });
       }
     }
-
-    logger.start(`Running typecheck... (${tasks.length} targets, concurrency: ${concurrency})`);
-    await Promise.all(workers.map((worker) => runNextTask(worker)));
-    logger.success("Typecheck execution completed");
-  } finally {
-    await Promise.all(workers.map((w) => w.terminate()));
   }
 
-  // Aggregate results
-  const allDiagnostics: ts.Diagnostic[] = [];
-  let totalErrorCount = 0;
-  let totalWarningCount = 0;
-  const fileCache = new Map<string, string>(); // File content cache (prevent duplicate reads of same file)
-  for (const { result } of allResults) {
-    totalErrorCount += result.errorCount;
-    totalWarningCount += result.warningCount;
-    for (const serialized of result.diagnostics) {
-      allDiagnostics.push(deserializeDiagnostic(serialized, fileCache));
-    }
+  // Non-package typecheck
+  if (includeNonPackage) {
+    logger.debug("Running non-package typecheck");
+    const nonPkgResult = typecheckNonPackageFiles(cwd);
+    totalErrorCount += nonPkgResult.errorCount;
+    totalWarningCount += nonPkgResult.warningCount;
+    const nonPkgDiags = nonPkgResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+    allDiagnostics.push(...nonPkgDiags);
   }
 
+  // Log summary
   if (totalErrorCount > 0) {
-    logger.error("typecheck errors occurred", {
-      errorCount: totalErrorCount,
-      warningCount: totalWarningCount,
-    });
-  } else if (totalWarningCount > 0) {
-    logger.info("typecheck complete (warnings present)", {
-      errorCount: totalErrorCount,
-      warningCount: totalWarningCount,
-    });
+    logger.error("typecheck errors occurred", { errorCount: totalErrorCount, warningCount: totalWarningCount });
   } else {
     logger.info("typecheck complete", { errorCount: totalErrorCount, warningCount: totalWarningCount });
   }
 
+  // Format diagnostics output
   let formattedOutput = "";
   if (allDiagnostics.length > 0) {
     const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
@@ -347,22 +198,4 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
   };
 }
 
-/**
- * Run TypeScript typecheck.
- *
- * Calls `executeTypecheck()`, outputs results to stdout, and sets `process.exitCode` if errors occur.
- *
- * @param options - typecheck execution options
- * @returns resolves when complete. If errors are found, sets `process.exitCode` to 1 and resolves (does not throw)
- */
-export async function runTypecheck(options: TypecheckOptions): Promise<void> {
-  const result = await executeTypecheck(options);
-  if (result.formattedOutput) {
-    process.stdout.write(result.formattedOutput);
-  }
-  if (!result.success) {
-    process.exitCode = 1;
-  }
-}
-
 //#endregion

package/src/commands/watch.ts

@@ -1,22 +1,23 @@
-// packages/cli/src/commands/watch.ts
 import {
-  WatchOrchestrator,
-  type WatchOrchestratorOptions,
-} from "../orchestrators/WatchOrchestrator";
+  DevWatchOrchestrator,
+  type DevWatchOrchestratorOptions,
+} from "../orchestrators/DevWatchOrchestrator";
 
 /**
- * Build library packages in watch mode.
+ * Build all packages in watch mode.
  *
  * - Load `sd.config.ts` to check build target info per package (required)
  * - `node`/`browser`/`neutral` target: build in esbuild watch mode + generate .d.ts
+ * - `server` target: build in esbuild watch mode (no runtime)
+ * - `scripts` target with watch config: run hook on file changes
  * - Auto rebuild on file changes
  * - Terminate with SIGINT/SIGTERM signals
  *
- * @param options - watch execution options
+ * @param options - watch execution options (targets, options)
  * @returns resolves on termination signal
  */
-export async function runWatch(options: WatchOrchestratorOptions): Promise<void> {
-  const orchestrator = new WatchOrchestrator(options);
+export async function runWatch(options: Omit<DevWatchOrchestratorOptions, "mode">): Promise<void> {
+  const orchestrator = new DevWatchOrchestrator({ mode: "watch", ...options });
 
   try {
     await orchestrator.initialize();

package/src/engines/NgtscEngine.ts

@@ -0,0 +1,190 @@
+import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { consola } from "consola";
+import type * as NgtscBuildWorkerModule from "../workers/ngtsc-build.worker";
+import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
+import type { RebuildManager } from "../utils/rebuild-manager";
+import type { BuildEngine, BuildOutput, BuildPackageInfo, EngineResult } from "./types";
+
+const logger = consola.withTag("sd:cli:engine:ngtsc");
+
+/**
+ * NgtscEngine options
+ */
+export interface NgtscEngineOptions {
+  cwd: string;
+  pkg: BuildPackageInfo;
+  /** ResultCollector for watch mode rebuild reporting */
+  resultCollector?: ResultCollector;
+  /** RebuildManager for watch mode batch coordination */
+  rebuildManager?: RebuildManager;
+}
+
+/**
+ * NgtscProgram-based build engine for Angular Library packages
+ *
+ * Wraps a single ngtsc-build.worker that uses NgtscProgram for AOT compilation.
+ * Angular packages are detected by the presence of angularCompilerOptions in tsconfig.json.
+ */
+export class NgtscEngine implements BuildEngine {
+  private readonly _cwd: string;
+  private readonly _pkg: BuildPackageInfo;
+  private readonly _resultCollector: ResultCollector | undefined;
+  private readonly _rebuildManager: RebuildManager | undefined;
+
+  private _worker: WorkerProxy<typeof NgtscBuildWorkerModule> | undefined;
+  private _isWatchMode = false;
+
+  constructor(options: NgtscEngineOptions) {
+    this._cwd = options.cwd;
+    this._pkg = options.pkg;
+    this._resultCollector = options.resultCollector;
+    this._rebuildManager = options.rebuildManager;
+  }
+
+  /**
+   * One-time build (production)
+   */
+  async run(output: BuildOutput): Promise<EngineResult> {
+    this._createWorker();
+
+    const result = await this._worker!.build({
+      name: this._pkg.name,
+      cwd: this._cwd,
+      pkgDir: this._pkg.dir,
+      output,
+    });
+
+    return {
+      success: result.js.success && result.dts.success,
+      js: {
+        success: result.js.success,
+        errors: result.js.errors ?? [],
+        warnings: result.js.warnings ?? [],
+      },
+      dts: {
+        success: result.dts.success,
+        errors: result.dts.errors ?? [],
+        warnings: [],
+        diagnostics: result.dts.diagnostics,
+      },
+    };
+  }
+
+  /**
+   * Start watch mode
+   * Promise resolves when initial build completes.
+   */
+  async startWatch(output: BuildOutput): Promise<void> {
+    this._isWatchMode = true;
+    this._createWorker();
+
+    return new Promise<void>((resolve) => {
+      let isInitialBuild = true;
+      const workerKey = `${this._pkg.name}:build`;
+
+      this._worker!.on("buildStart", () => {
+        if (!isInitialBuild && this._rebuildManager != null) {
+          this._rebuildManager.registerBuild(
+            workerKey,
+            `${this._pkg.name} (${this._pkg.config.target})`,
+          );
+        }
+      });
+
+      this._worker!.on("build", (data) => {
+        const event = data;
+
+        if (event.js.warnings != null && event.js.warnings.length > 0) {
+          logger.warn(`${this._pkg.name}: ${event.js.warnings.join(", ")}`);
+        }
+
+        // Report JS result
+        const buildResult: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "build",
+          status: event.js.success ? "success" : "error",
+          message: event.js.errors?.join("\n"),
+        };
+        this._resultCollector?.add(buildResult);
+
+        // Report DTS result
+        const dtsResult: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "dts",
+          status: event.dts.success ? "success" : "error",
+          message: event.dts.errors?.join("\n"),
+        };
+        this._resultCollector?.add(dtsResult);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!.on("error", (data) => {
+        const event = data as { message: string };
+        const result: BuildResult = {
+          name: this._pkg.name,
+          target: this._pkg.config.target,
+          type: "build",
+          status: "error",
+          message: event.message,
+        };
+        this._resultCollector?.add(result);
+
+        if (isInitialBuild) {
+          isInitialBuild = false;
+          resolve();
+        }
+      });
+
+      this._worker!
+        .startWatch({
+          name: this._pkg.name,
+          cwd: this._cwd,
+          pkgDir: this._pkg.dir,
+          output,
+        })
+        .catch(() => {
+          if (isInitialBuild) {
+            isInitialBuild = false;
+            resolve();
+          }
+        });
+    });
+  }
+
+  /**
+   * Stop engine and clean up resources
+   */
+  async stop(): Promise<void> {
+    const shutdownTimeout = 3000;
+
+    if (this._isWatchMode && this._worker != null) {
+      try {
+        await Promise.race([
+          this._worker.stopWatch(),
+          new Promise<void>((resolve) => setTimeout(resolve, shutdownTimeout)),
+        ]);
+      } catch {
+        // Continue even if stopWatch fails
+      }
+    }
+
+    if (this._worker != null) {
+      await this._worker.terminate();
+      this._worker = undefined;
+    }
+  }
+
+  /**
+   * Create worker instance
+   */
+  private _createWorker(): void {
+    const workerPath = import.meta.resolve("../workers/ngtsc-build.worker");
+    this._worker = Worker.create<typeof NgtscBuildWorkerModule>(workerPath);
+  }
+}