@simplysm/sd-cli 14.0.38 → 14.0.39

package/tests/workers/server-build-worker.spec.ts

@@ -29,8 +29,8 @@ let mockMetafileInputs: Record<string, unknown> = {};
 // tsc build mock
 const mockRunTscPackageBuild = vi.fn(() => ({
   success: true,
-  errors: undefined,
-  diagnostics: [],
+  errors: undefined as string[] | undefined,
+  diagnostics: [] as unknown[],
   errorCount: 0,
   warningCount: 0,
 }));
@@ -116,6 +116,20 @@ vi.mock("../../src/utils/tsc-build", () => ({
   runTscPackageBuild: mockRunTscPackageBuild,
 }));
 
+// tsc plugin mock (build() js=true path uses createTscPlugin)
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn((): string[] | undefined => undefined),
+  resetBuilderProgram: vi.fn(),
+};
+
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 vi.mock("../../src/workers/shared-worker-lifecycle", () => {
   let guardCalled = false;
   resetGuard = () => { guardCalled = false; };
@@ -175,7 +189,14 @@ describe("server-build.worker build()", () => {
       diagnostics: [],
       errorCount: 0,
       warningCount: 0,
-      });
+    });
+
+    // Reset tsc plugin mock (used for js=true path)
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+    mockTscPlugin.resetBuilderProgram.mockReset();
 
     // Reset lockfile content and cache
     mockLockfileContent = "";
@@ -212,21 +233,65 @@ describe("server-build.worker build()", () => {
     expect(result.mainJsPath).toBe(path.resolve(baseBuildInfo.pkgDir, "dist", "main.js").replace(/\\/g, "/"));
   });
 
-  // Acceptance: type error detected
+  // Acceptance: type error detected via tsc plugin (js=true)
   it("reports typecheck error in build field", async () => {
+    mockTscPlugin.getErrors.mockReturnValue(["TS2345: type error"]);
+    mockTscPlugin.getDiagnostics.mockReturnValue([{ code: 2345, category: 1 }]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("TS2345: type error");
+    expect(result.build.diagnostics).toHaveLength(1);
+  });
+
+  // Acceptance: esbuild + tsc both error — merged
+  it("merges esbuild and tsc errors when both fail", async () => {
+    vi.mocked(esbuild.build).mockResolvedValueOnce({
+      errors: [{ text: "esbuild syntax error" }],
+      warnings: [],
+      outputFiles: [],
+    } as any);
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("esbuild syntax error");
+    expect(result.build.errors).toContain("TS2322: type mismatch");
+  });
+
+  // Acceptance: diagnostics from tsc plugin (js=true)
+  it("includes diagnostics from tsc plugin in build result", async () => {
+    mockTscPlugin.getDiagnostics.mockReturnValue([
+      { code: 2322, category: 1, messageText: "Type mismatch" },
+    ]);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.build.diagnostics).toHaveLength(1);
+    expect(result.build.diagnostics[0]).toEqual(
+      expect.objectContaining({ code: 2322 }),
+    );
+  });
+
+  // Acceptance: js=false uses runTscPackageBuild directly
+  it("uses runTscPackageBuild directly when output.js=false", async () => {
     mockRunTscPackageBuild.mockReturnValueOnce({
       success: false,
-      errors: ["TS2345: type error"] as any,
+      errors: ["TS2345: type error"],
       diagnostics: [{ code: 2345, category: 1 }] as any,
       errorCount: 1,
       warningCount: 0,
-      });
+    });
 
-    const result = await workerFns["build"](baseBuildInfo);
+    const result = await workerFns["build"]({
+      ...baseBuildInfo,
+      output: { js: false, dts: true },
+    });
 
     expect(result.build.success).toBe(false);
     expect(result.build.errors).toContain("TS2345: type error");
-    expect(result.build.diagnostics).toHaveLength(1);
   });
 
   // Acceptance: esbuild error detected
@@ -466,7 +531,14 @@ describe("server-build.worker startWatch()", () => {
       diagnostics: [],
       errorCount: 0,
       warningCount: 0,
-      });
+    });
+
+    // Reset tsc plugin mock (used for watch mode rebuild)
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+    mockTscPlugin.resetBuilderProgram.mockReset();
 
     mockReadFileSync.mockImplementation((filePath: string) => {
       if (String(filePath).endsWith("package.json")) {
@@ -567,6 +639,47 @@ describe("server-build.worker startWatch()", () => {
     const buildCalls = mockSend.mock.calls.filter((c) => c[0] === "build");
     expect(buildCalls.length).toBeGreaterThanOrEqual(1);
   });
+
+  // Acceptance: rebuildAll js=true — single esbuildCtx.rebuild() call, tsc not called directly
+  it("uses esbuildCtx.rebuild() without direct tsc call in watch mode rebuild", async () => {
+    mockMetafileInputs = { "packages/my-server/src/main.ts": {} };
+
+    await workerFns["startWatch"](watchInfo);
+
+    const onChangeHandler = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    mockRebuild.mockClear();
+    mockRunTscPackageBuild.mockClear();
+    mockSend.mockClear();
+
+    const absPath = path.resolve("/workspace", "packages/my-server/src/main.ts").replace(/\\/g, "/");
+    await onChangeHandler([{ event: "change", path: absPath }]);
+
+    // esbuild rebuild should have been called (tsc triggered by plugin inside)
+    expect(mockRebuild).toHaveBeenCalled();
+    // runTscPackageBuild should NOT be called directly for js=true
+    expect(mockRunTscPackageBuild).not.toHaveBeenCalled();
+    // Build event should be sent
+    expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
+      build: expect.objectContaining({ success: true }),
+    }));
+  });
+
+  // Acceptance: startWatch passes tsc options to createContext
+  it("passes tsc options to esbuildCtx.createContext", async () => {
+    await workerFns["startWatch"]({
+      ...watchInfo,
+      output: { js: true, dts: true, env: "node" as any, includeTests: true },
+    });
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
 });
 
 describe("server-build.worker stopWatch()", () => {

package/tests/workers/server-esbuild-context-tsc.verify.md

@@ -0,0 +1,7 @@
+# server-esbuild-context tsc 통합 — LLM 검증
+
+## 검증 항목
+
+- [x] `EsbuildContextOptions.tsc`가 optional이므로 `server-watch-manager.ts:66-71`의 기존 `recreateContext()` 호출이 타입 에러 없이 동작: 확인 — `tsc` 미전달 시 기존 플러그인 재사용 로직 정상
+- [x] `server-watch-manager.spec.ts` 8개 테스트 전부 통과: 확인 — 회귀 없음
+- [x] `server-watch-manager.ts`에 코드 변경 없음: 확인 — 파일 미수정

package/tests/workers/server-esbuild-context.acc.spec.ts

@@ -5,6 +5,15 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 const mockRebuild = vi.fn();
 const mockDispose = vi.fn();
 
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn(),
+  resetBuilderProgram: vi.fn(),
+};
+
 vi.mock("esbuild", () => ({
   default: {
     context: vi.fn(() =>
@@ -21,11 +30,18 @@ vi.mock("../../src/esbuild/esbuild-config", async (importOriginal) => {
   };
 });
 
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 //#endregion
 
 const esbuild = (await import("esbuild")).default;
-const { createContext, rebuild, recreateContext, dispose, getMetafile, hasContext } =
-  await import("../../src/workers/server-esbuild-context");
+const {
+  createContext, rebuild, recreateContext, dispose, getMetafile, hasContext,
+  getTscProgram, getTscAffectedFiles, getTscDiagnostics,
+} = await import("../../src/workers/server-esbuild-context");
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
 
 const baseOptions = {
   pkgDir: "/workspace/packages/my-server",
@@ -33,11 +49,22 @@ const baseOptions = {
   external: [],
 };
 
+const baseTscOptions = {
+  cwd: "/workspace",
+  output: { dts: true },
+};
+
 describe("server-esbuild-context lifecycle", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -96,3 +123,130 @@ describe("server-esbuild-context lifecycle", () => {
     expect(result).toBeNull();
   });
 });
+
+describe("server-esbuild-context tsc integration lifecycle", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  // Acceptance: create with tsc → delegation works → dispose clears all
+  it("manages tsc plugin lifecycle: create with tsc → delegation returns plugin values → dispose clears", async () => {
+    const fakeProgram = { id: "fake-program" };
+    const fakeAffectedFiles = new Set(["/src/main.ts"]);
+    const fakeDiagnostics = [{ category: 1, code: 2322, messageText: "Type error" }];
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+    mockTscPlugin.getAffectedFiles.mockReturnValue(fakeAffectedFiles);
+    mockTscPlugin.getDiagnostics.mockReturnValue(fakeDiagnostics);
+
+    // Create with tsc options
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    expect(hasContext()).toBe(true);
+
+    // Delegation methods return plugin values
+    expect(getTscProgram()).toBe(fakeProgram);
+    expect(getTscAffectedFiles()).toBe(fakeAffectedFiles);
+    expect(getTscDiagnostics()).toEqual(fakeDiagnostics);
+
+    // Dispose clears everything
+    await dispose();
+    expect(hasContext()).toBe(false);
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+
+  // Acceptance: create with tsc → recreate without tsc → plugin persists
+  it("persists tsc plugin across context recreation when tsc options omitted", async () => {
+    const fakeProgram = { id: "persisted-program" };
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+
+    // Initial create with tsc
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    expect(getTscProgram()).toBe(fakeProgram);
+
+    // Recreate without tsc options — plugin persists
+    await recreateContext(baseOptions);
+    expect(hasContext()).toBe(true);
+    expect(getTscProgram()).toBe(fakeProgram);
+  });
+
+  // Acceptance: create without tsc → no plugin → delegation returns defaults
+  it("returns default values from delegation methods when no tsc plugin exists", async () => {
+    await createContext(baseOptions);
+
+    expect(hasContext()).toBe(true);
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+
+  // Acceptance: rebuild merges esbuild + tsc errors
+  it("merges esbuild and tsc errors in rebuild result", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "esbuild syntax error" }],
+      warnings: [{ text: "deprecation" }],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["esbuild syntax error", "TS2322: type mismatch"],
+      warnings: ["deprecation"],
+    });
+  });
+
+  // Acceptance: recreateContext resets tsc and persists plugin
+  it("resets tsc builderProgram on recreateContext and persists plugin for next rebuild", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+
+    // recreateContext — resets tsc + creates new esbuild context
+    await recreateContext(baseOptions);
+
+    expect(mockTscPlugin.resetBuilderProgram).toHaveBeenCalled();
+    expect(hasContext()).toBe(true);
+
+    // rebuild still works with merged result
+    const result = await rebuild();
+    expect(result).toEqual({
+      success: true,
+      errors: undefined,
+      warnings: undefined,
+    });
+  });
+
+  // Acceptance: LOGIC-001 — recreateContext failure preserves tsc plugin reset
+  it("resets tsc and disposes old context even when recreateContext fails (LOGIC-001)", async () => {
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+
+    // New context creation fails
+    vi.mocked(esbuild.context).mockRejectedValueOnce(new Error("creation failed"));
+
+    await expect(recreateContext(baseOptions)).rejects.toThrow("creation failed");
+
+    expect(mockTscPlugin.resetBuilderProgram).toHaveBeenCalled();
+    expect(mockDispose).toHaveBeenCalled();
+    expect(hasContext()).toBe(false);
+  });
+});