@simplysm/sd-cli 14.0.8 → 14.0.10

package/tests/commands/typecheck.spec.ts

@@ -86,8 +86,7 @@ function createMockEngine() {
   const engine = {
     run: vi.fn().mockResolvedValue({
       success: true,
-      js: { success: true, errors: [], warnings: [] },
-      dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+      build: { success: true, errors: [], warnings: [], diagnostics: [] },
 
     }),
     startWatch: vi.fn(),
@@ -161,7 +160,7 @@ describe("executeTypecheck", () => {
       }),
       expect.any(Object),
     );
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("excludes scripts packages from typecheck", async () => {
@@ -217,8 +216,7 @@ describe("executeTypecheck", () => {
       const engine = {
         run: vi.fn().mockResolvedValue({
           success: false,
-          js: { success: true, errors: [], warnings: [] },
-          dts: { success: false, errors: [], warnings: [], diagnostics: [engineDiag] },
+          build: { success: false, errors: [], warnings: [], diagnostics: [engineDiag] },
     
         }),
         startWatch: vi.fn(),
@@ -260,8 +258,7 @@ describe("executeTypecheck", () => {
           active--;
           return {
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
       
           };
         }),
@@ -341,8 +338,8 @@ describe("executeTypecheck", () => {
 
     const runCalls = mockEngines.map((e) => e.run.mock.calls[0][0]);
     expect(runCalls).toEqual([
-      { js: false, dts: false, env: "node" },
-      { js: false, dts: false, env: "browser" },
+      { js: false, dts: false, env: "node", includeTests: true },
+      { js: false, dts: false, env: "browser", includeTests: true },
     ]);
   });
 
@@ -352,7 +349,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("creates 1 task (browser) for browser target", async () => {
@@ -361,7 +358,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "browser" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "browser", includeTests: true });
   });
 
   it("creates 1 task (node) for server target", async () => {
@@ -370,7 +367,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("passes env to engine.run() for each task", async () => {
@@ -454,8 +451,7 @@ describe("executeTypecheck", () => {
       const engine = {
         run: vi.fn().mockResolvedValue({
           success: false,
-          js: { success: true, errors: [], warnings: [] },
-          dts: { success: false, errors: [], warnings: [], diagnostics: [diag] },
+          build: { success: false, errors: [], warnings: [], diagnostics: [diag] },
     
         }),
         startWatch: vi.fn(),
@@ -511,8 +507,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: false, errorCount: 2, warningCount: 1, formattedOutput: "lint errors from pkg" },
           }),
           startWatch: vi.fn(),
@@ -567,8 +562,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
           }),
           startWatch: vi.fn(),
@@ -663,8 +657,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: false, errorCount: 2, warningCount: 1, formattedOutput: "lint err" },
           }),
           startWatch: vi.fn(),
@@ -718,8 +711,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: ["[core-node:node] Something went wrong"],
               warnings: [],
@@ -741,7 +733,7 @@ describe("executeTypecheck", () => {
     });
 
     // Acceptance: Scenario "복수 엔진이 문자열 에러를 반환"
-    it("복수 엔진이 각각 dts.errors에 메시지를 반환하면 모든 에러 메시지가 formattedOutput에 포함된다", async () => {
+    it("복수 엔진이 각각 build.errors에 메시지를 반환하면 모든 에러 메시지가 formattedOutput에 포함된다", async () => {
       setupDefaults({
         "pkg-a": { target: "node" },
         "pkg-b": { target: "node" },
@@ -758,8 +750,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: [errorMessages[idx]],
               warnings: [],
@@ -780,16 +771,15 @@ describe("executeTypecheck", () => {
       expect(result.formattedOutput).toContain("[pkg-b:node] Error in package B");
     });
 
-    // Unit: 단일 엔진이 dts.errors에 복수 메시지를 반환하면 각각 합성 Diagnostic으로 변환된다
-    it("단일 엔진이 dts.errors에 복수 메시지를 담으면 errorCount가 메시지 수와 일치한다", async () => {
+    // Unit: 단일 엔진이 build.errors에 복수 메시지를 반환하면 각각 합성 Diagnostic으로 변환된다
+    it("단일 엔진이 build.errors에 복수 메시지를 담으면 errorCount가 메시지 수와 일치한다", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
       mocks.createBuildEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: ["Error message 1", "Error message 2", "Error message 3"],
               warnings: [],
@@ -821,8 +811,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: false, errors: [], warnings: [], diagnostics: [diag] },
+            build: { success: false, errors: [], warnings: [], diagnostics: [diag] },
           }),
           startWatch: vi.fn(),
           stop: vi.fn().mockResolvedValue(undefined),

package/tests/electron/electron.spec.ts

@@ -1,3 +1,4 @@
+import path from "path";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
 //#region Mocks
@@ -25,6 +26,10 @@ vi.mock("@simplysm/core-node", () => ({
     exec: mockCpxExec,
     execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
+  pathx: {
+    posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
+    posix: (p: string) => p.replace(/\\/g, "/"),
+  },
 }));
 
 // cpx mock (was execa)

package/tests/engines/base-engine.spec.ts

@@ -46,8 +46,7 @@ function createMockPkg(overrides: Partial<BuildPackageInfo> = {}): BuildPackageI
 
 function setupDefaultBuildResult(): void {
   mockWorker.build.mockResolvedValue({
-    js: { success: true, errors: undefined, warnings: undefined },
-    dts: { success: true, errors: undefined, diagnostics: [] },
+    build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
     lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
   });
   mockWorker.terminate.mockResolvedValue(undefined);
@@ -78,7 +77,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -101,7 +100,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -114,7 +113,7 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
-    it("reports build and dts results separately to ResultCollector", async () => {
+    it("reports build result to ResultCollector", async () => {
       const mockResultCollector = { add: vi.fn() };
 
       mockWorker.startWatch.mockImplementation(() => {
@@ -122,8 +121,7 @@ describe("BaseEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true, errors: undefined },
-          dts: { success: false, errors: ["type error"] },
+          build: { success: false, errors: ["type error"] },
         });
       });
 
@@ -137,13 +135,10 @@ describe("BaseEngine", () => {
 
       const addCalls = mockResultCollector.add.mock.calls;
       const buildResult = addCalls.find((c: any[]) => c[0].type === "build");
-      const dtsResult = addCalls.find((c: any[]) => c[0].type === "dts");
 
       expect(buildResult).toBeDefined();
-      expect(buildResult![0].status).toBe("success");
+      expect(buildResult![0].status).toBe("error");
       expect(buildResult![0].target).toBe("node");
-      expect(dtsResult).toBeDefined();
-      expect(dtsResult![0].status).toBe("error");
 
       await engine.stop();
     });
@@ -157,7 +152,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -182,7 +177,7 @@ describe("BaseEngine", () => {
         "test-pkg (node)",
       );
 
-      buildHandler?.({ js: { success: true }, dts: { success: true } });
+      buildHandler?.({ build: { success: true } });
       expect(mockResolver).toHaveBeenCalled();
 
       await engine.stop();
@@ -209,7 +204,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -229,7 +224,7 @@ describe("BaseEngine", () => {
       )?.[1];
 
       buildStartHandler?.({});
-      buildHandler?.({ js: { success: true }, dts: { success: true } });
+      buildHandler?.({ build: { success: true } });
 
       // The resolver should have been called, which resolves the RebuildManager promise
       expect(resolverFn).toBeDefined();
@@ -237,7 +232,7 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
-    it("does not call registerBuild on initial buildStart (only on rebuilds)", async () => {
+    it("calls registerBuild on initial buildStart as well as rebuilds", async () => {
       const mockRebuildManager = { registerBuild: vi.fn(() => vi.fn()) };
 
       mockWorker.startWatch.mockImplementation(() => {
@@ -251,7 +246,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -262,8 +257,8 @@ describe("BaseEngine", () => {
 
       await engine.startWatch({ js: true, dts: true });
 
-      // registerBuild should NOT have been called for the initial build
-      expect(mockRebuildManager.registerBuild).not.toHaveBeenCalled();
+      // registerBuild should be called for ALL builds including initial
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalledOnce();
 
       await engine.stop();
     });
@@ -276,8 +271,7 @@ describe("BaseEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
         });
       });
 

package/tests/engines/engine-lint-integration.spec.ts

@@ -48,8 +48,7 @@ function createMockPkg(): BuildPackageInfo {
 beforeEach(() => {
   vi.clearAllMocks();
   mockWorker.build.mockResolvedValue({
-    js: { success: true },
-    dts: { success: true, diagnostics: [] },
+    build: { success: true, diagnostics: [] },
     lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
   });
   mockWorker.terminate.mockResolvedValue(undefined);
@@ -72,8 +71,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
   describe("Scenario: EngineResult includes lint field", () => {
     it("run() returns EngineResult with lint field when worker provides it", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true },
-        dts: { success: true, diagnostics: [] },
+        build: { success: true, diagnostics: [] },
         lint: { success: false, errorCount: 3, warningCount: 1, formattedOutput: "lint errors" },
       });
 
@@ -92,8 +90,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
 
     it("run() returns EngineResult without lint when lint is not in output", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true },
-        dts: { success: true, diagnostics: [] },
+        build: { success: true, diagnostics: [] },
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -114,8 +111,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
           lint: { success: false, errorCount: 2, warningCount: 0, formattedOutput: "errors" },
         });
       });
@@ -150,8 +146,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
         });
       });
 

package/tests/engines/ngtsc-engine.spec.ts

@@ -63,8 +63,7 @@ describe("NgtscEngine", () => {
     // Acceptance: Scenario "run()으로 one-time 빌드를 수행한다"
     it("creates worker, calls build, and returns EngineResult with js/dts", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -80,17 +79,15 @@ describe("NgtscEngine", () => {
         }),
       );
       expect(result.success).toBe(true);
-      expect(result.js.success).toBe(true);
-      expect(result.dts.success).toBe(true);
-      expect(result.dts.diagnostics).toEqual([]);
+      expect(result.build.success).toBe(true);
+      expect(result.build.diagnostics).toEqual([]);
       await engine.stop();
     });
 
     // Acceptance: Scenario "run()에서 dts: false면 .d.ts를 생략한다"
     it("passes dts:false output flag to worker", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -105,10 +102,10 @@ describe("NgtscEngine", () => {
     // Acceptance: Scenario "TypeScript + Angular diagnostics를 통합 수집한다"
     it("includes diagnostics in result from worker", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: {
+        build: {
           success: false,
           errors: ["type error"],
+          warnings: undefined,
           diagnostics: [{ code: 2322, category: 1, messageText: "Type error" }],
         },
       });
@@ -116,19 +113,19 @@ describe("NgtscEngine", () => {
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
       const result = await engine.run({ js: true, dts: true });
 
-      expect(result.dts.success).toBe(false);
-      expect(result.dts.diagnostics).toHaveLength(1);
-      expect(result.dts.diagnostics[0].code).toBe(2322);
+      expect(result.build.success).toBe(false);
+      expect(result.build.diagnostics).toHaveLength(1);
+      expect(result.build.diagnostics[0].code).toBe(2322);
       await engine.stop();
     });
 
     // Acceptance: Scenario "타입 에러가 있어도 빌드 결과를 반환한다"
-    it("returns result even when dts has errors", async () => {
+    it("returns result even when build has errors", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: {
+        build: {
           success: false,
           errors: ["TS2322: Type error"],
+          warnings: undefined,
           diagnostics: [{ code: 2322, category: 1, messageText: "Type error" }],
         },
       });
@@ -137,40 +134,36 @@ describe("NgtscEngine", () => {
       const result = await engine.run({ js: true, dts: true });
 
       expect(result.success).toBe(false);
-      expect(result.js.success).toBe(true);
-      expect(result.dts.success).toBe(false);
-      expect(result.dts.errors).toContain("TS2322: Type error");
+      expect(result.build.success).toBe(false);
+      expect(result.build.errors).toContain("TS2322: Type error");
       await engine.stop();
     });
 
-    // Unit: JS-only failure reflects in overall success
-    it("reflects JS build failure in result", async () => {
+    // Unit: build failure reflects in overall success
+    it("reflects build failure in result", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: false, errors: ["ngtsc compilation error"], warnings: undefined },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: false, errors: ["ngtsc compilation error"], warnings: undefined, diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
       const result = await engine.run({ js: true, dts: true });
 
       expect(result.success).toBe(false);
-      expect(result.js.success).toBe(false);
-      expect(result.js.errors).toEqual(["ngtsc compilation error"]);
-      expect(result.dts.success).toBe(true);
+      expect(result.build.success).toBe(false);
+      expect(result.build.errors).toEqual(["ngtsc compilation error"]);
       await engine.stop();
     });
 
     // Unit: warnings are mapped through
     it("maps worker warnings to EngineResult", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: ["deprecation warning"] },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: true, errors: undefined, warnings: ["deprecation warning"], diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
       const result = await engine.run({ js: true, dts: true });
 
-      expect(result.js.warnings).toEqual(["deprecation warning"]);
+      expect(result.build.warnings).toEqual(["deprecation warning"]);
       await engine.stop();
     });
   });
@@ -179,8 +172,7 @@ describe("NgtscEngine", () => {
     // Acceptance: Scenario "stop()으로 리소스를 정리한다"
     it("terminates worker on stop", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -198,8 +190,7 @@ describe("NgtscEngine", () => {
     // Unit: run mode doesn't call stopWatch
     it("skips stopWatch in run mode", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true, errors: undefined, warnings: undefined },
-        dts: { success: true, errors: undefined, diagnostics: [] },
+        build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
       });
 
       const engine = new NgtscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -219,8 +210,7 @@ describe("NgtscEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
         });
       });
 
@@ -238,7 +228,7 @@ describe("NgtscEngine", () => {
     });
 
     // Unit: watch mode results reported to ResultCollector
-    it("reports build and dts results separately to ResultCollector", async () => {
+    it("reports build result to ResultCollector", async () => {
       const mockResultCollector = { add: vi.fn() };
 
       mockWorker.startWatch.mockImplementation(() => {
@@ -246,8 +236,7 @@ describe("NgtscEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true, errors: undefined },
-          dts: { success: false, errors: ["type error"] },
+          build: { success: false, errors: ["type error"] },
         });
       });
 
@@ -261,12 +250,9 @@ describe("NgtscEngine", () => {
 
       const addCalls = mockResultCollector.add.mock.calls;
       const buildResult = addCalls.find((c: any[]) => c[0].type === "build");
-      const dtsResult = addCalls.find((c: any[]) => c[0].type === "dts");
 
       expect(buildResult).toBeDefined();
-      expect(buildResult![0].status).toBe("success");
-      expect(dtsResult).toBeDefined();
-      expect(dtsResult![0].status).toBe("error");
+      expect(buildResult![0].status).toBe("error");
 
       await engine.stop();
     });