@simplysm/sd-cli 14.0.42 → 14.0.44

package/tests/workers/client-worker-refactor.verify.md

@@ -0,0 +1,22 @@
+# client.worker.ts startWatch 서브함수 추출 — LLM 검증
+
+## 검증 항목
+
+- [x] createSourceFileCachePlugin이 모듈 스코프에 존재하고 esbuild.Plugin을 반환한다: lines 192-250, `function createSourceFileCachePlugin(): esbuild.Plugin` 반환 타입 명시, `name: "sd-build-start"` 유지
+- [x] createDevBuildEndHandler가 모듈 스코프에 존재하고 onEnd 콜백을 반환한다: lines 255-322, 반환 타입 `(result: esbuild.BuildResult) => Promise<void>`
+- [x] startWatch에서 추출 함수를 호출한다: line 385 `plugins: [createSourceFileCachePlugin()]`, line 386 `onEnd: createDevBuildEndHandler(basePath, actualPort, outdir, entryNames, info.pkgDir)`
+- [x] 파일 변경 감지 로직이 동일하다: createSourceFileCachePlugin onStart (lines 198-230) — watchFiles + typeScriptFileCache 순회, mtime 비교, invalidate 호출, buildStart 이벤트 전송 모두 원본과 동일
+- [x] mtime 기록 로직이 동일하다: createSourceFileCachePlugin onEnd (lines 232-247) — prevMtimes.clear() + mtime 기록 원본과 동일
+- [x] index.html 재생성 로직이 동일하다: createDevBuildEndHandler (lines 264-279) — lastMetafile 보관 + generateIndexHtml + writeFileSync 원본과 동일
+- [x] HMR 디스패치 로직이 동일하다: lines 281-284, `hmrService.onBuildEnd(result.metafile)` 조건부 호출 원본과 동일
+- [x] build 이벤트 전송 로직이 동일하다: lines 286-300, `sender.send("build", ...)` 조건부 호출 원본과 동일
+- [x] 초기 빌드 resolve 로직이 동일하다: lines 302-312, `isInitialBuild = false` + `initialBuildResolve?.()` 원본과 동일
+- [x] 에러 핸들링 로직이 동일하다: lines 313-320, catch 블록 원본과 동일
+- [x] 외부 인터페이스가 변경되지 않았다: export는 `export default sender`만 존재 (line 501), ClientBuildInfo/ClientBuildResult/ClientWorkerEvents 타입 변경 없음
+- [x] build 함수가 변경되지 않았다: lines 96-187, 원본과 동일
+- [x] stopWatch에 리셋 로직이 추가되었다: lines 472-475, `lastMetafile = undefined`, `isInitialBuild = true`, `initialBuildResolve = undefined`
+- [x] stopWatch 기존 정리 로직이 변경되지 않았다: lines 439-470, 5단계 정리(esbuild dispose, HMR 종료, HTTP 종료, public 감시 종료, index.html 감시 종료) 원본과 동일
+- [x] 모듈 스코프 변수가 올바르게 선언되었다: lines 67-69, 기존 변수(62-66) 바로 아래 배치
+- [x] startWatch가 ~110줄로 축소되었다: lines 327-434 = 107줄 (목표 ~110줄 달성)
+- [x] index.html watcher에서 lastMetafile 접근이 정상 동작한다: line 400, `if (lastMetafile == null) return;` — 모듈 스코프 변수로 접근
+- [x] 기존 테스트 6개 전부 통과: client-worker.spec.ts (3), client-worker.acc.spec.ts (3) — 회귀 없음

package/tests/workers/client-worker-ts-cache-invalidation.verify.md

@@ -0,0 +1,12 @@
+# sd-build-start 플러그인 TypeScript 파일 감시 — LLM 검증
+
+## 검증 항목
+
+- [x] onStart에서 `typeScriptFileCache.keys()`가 watchTargets에 포함: `client.worker.ts:266` — `...typeScriptFileCache.keys()`가 `watchTargets` 배열에 spread되어 포함됨
+- [x] onStart에서 `loadResultCache.watchFiles`도 여전히 watchTargets에 포함: `client.worker.ts:265` — `...loadResultCache.watchFiles`가 첫 번째로 spread됨 (기존 JS 동작 보존)
+- [x] onStart에서 watchTargets의 각 파일에 대해 mtime 비교 수행: `client.worker.ts:268-279` — `for (const file of watchTargets)` 루프에서 `fs.statSync(file).mtimeMs`와 `prevMtimes.get(file)` 비교
+- [x] 초기 빌드 직후 prevMtimes가 비어있으면 mtime 비교 스킵: `client.worker.ts:271-273` — `prev != null` 조건에 의해 `prevMtimes`에 없는 파일은 `changedFiles`에 추가되지 않음
+- [x] onEnd에서 `typeScriptFileCache.keys()`가 prevMtimes 기록 대상에 포함: `client.worker.ts:297` — `...esbuildResult.sourceFileCache.typeScriptFileCache.keys()`가 watchTargets에 spread됨
+- [x] onEnd에서 `loadResultCache.watchFiles`도 여전히 prevMtimes 기록 대상에 포함: `client.worker.ts:296` — `...esbuildResult.sourceFileCache.loadResultCache.watchFiles`가 첫 번째로 spread됨
+- [x] `typeScriptFileCache`가 `sourceFileCache`에서 destructuring으로 접근: `client.worker.ts:260` — `const { loadResultCache, typeScriptFileCache } = esbuildResult.sourceFileCache;` SourceFileCache의 public 속성 (`source-file-cache.js:52`)
+- [x] 삭제된 TS 파일에 대한 catch 처리: `client.worker.ts:275-279` — `catch` 블록에서 `prevMtimes.has(file)`인 경우 `changedFiles`에 추가 (기존 로직 동일)

package/tests/workers/client-worker.acc.spec.ts

@@ -122,10 +122,12 @@ describe("client.worker build() — Acceptance", () => {
     const result = await workerFns["build"](baseBuildInfo);
 
     expect(result.success).toBe(false);
-    expect(result.errors).toContain("Could not resolve 'missing-module'");
-    expect(result.errors).toContain("Syntax error in file.ts");
+    // formatEsbuildMessages가 ANSI 색상 코드를 포함하므로 부분 문자열 매칭
+    const errorsJoined = result.errors!.join("\n");
+    expect(errorsJoined).toContain("Could not resolve 'missing-module'");
+    expect(errorsJoined).toContain("Syntax error in file.ts");
     // 요약 메시지("Build failed with 2 errors")가 아닌 상세 에러만 포함
-    expect(result.errors).not.toContain("Build failed with 2 errors");
+    expect(errorsJoined).not.toContain("Build failed with 2 errors");
   });
 
   // Scenario: 일반 Error 발생 시 기존 폴백이 동작한다
@@ -183,3 +185,4 @@ describe("client.worker build() — browserSupport 전달", () => {
     );
   });
 });
+

package/tests/workers/incremental-mtime-tracker.acc.spec.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { IncrementalMtimeTracker } from "../../src/workers/incremental-mtime-tracker";
+
+describe("IncrementalMtimeTracker — Acceptance", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mtime-acc-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createFile(name: string): string {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(filePath, `content-${name}`, "utf-8");
+    return filePath;
+  }
+
+  function touchFile(filePath: string): void {
+    const stat = fs.statSync(filePath);
+    const newTime = stat.mtimeMs / 1000 + 2;
+    fs.utimesSync(filePath, newTime, newTime);
+  }
+
+  // Scenario: 변경된 파일만 mtime 갱신
+  it("onEnd에서 변경된 파일만 stat 호출한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+    const fileC = createFile("c.ts");
+    const targets = [fileA, fileB, fileC];
+
+    // 초기 빌드: prevMtimes 채우기
+    tracker.updateMtimes(targets);
+
+    // 파일 A 변경
+    touchFile(fileA);
+
+    // onStart: 변경 감지
+    const changed = tracker.detectChanges(targets);
+    expect(changed.size).toBe(1);
+    expect(changed.has(fileA)).toBe(true);
+
+    // onEnd: 증분 갱신 — 변경된 A만 stat
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes(targets);
+    const statPaths = spy.mock.calls.map((c) => c[0]);
+    expect(statPaths).toContain(fileA);
+    expect(statPaths).not.toContain(fileB);
+    expect(statPaths).not.toContain(fileC);
+    spy.mockRestore();
+  });
+
+  // Scenario: 새로 추가된 파일만 stat 호출
+  it("onEnd에서 새로 추가된 파일만 stat 호출한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    const fileC = createFile("c.ts");
+    tracker.detectChanges([fileA, fileB, fileC]);
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA, fileB, fileC]);
+    const statPaths = spy.mock.calls.map((c) => c[0]);
+    expect(statPaths).toEqual([fileC]);
+    spy.mockRestore();
+  });
+
+  // Scenario: 변경도 신규도 없으면 stat 호출 0회
+  it("변경도 신규도 없으면 onEnd에서 stat 호출이 0회이다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+    tracker.detectChanges([fileA, fileB]);
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA, fileB]);
+    expect(spy.mock.calls).toHaveLength(0);
+    spy.mockRestore();
+  });
+
+  // Scenario: 삭제된 파일이 prevMtimes에서 제거된다
+  it("삭제된 파일은 이후 빌드에서 변경으로 감지되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    // fileB를 watchTargets에서 제거
+    tracker.detectChanges([fileA]);
+    tracker.updateMtimes([fileA]);
+
+    // fileB를 다시 추가 — "신규" 파일이므로 changedFiles에 포함되지 않음
+    const changed = tracker.detectChanges([fileA, fileB]);
+    expect(changed.has(fileB)).toBe(false);
+  });
+
+  // Scenario: mtime 변경된 파일이 changedFiles에 포함된다
+  it("mtime이 변경된 파일이 changedFiles에 포함된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+    touchFile(fileA);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(true);
+  });
+
+  // Scenario: 삭제된 파일이 changedFiles에 포함된다
+  it("삭제된 파일이 changedFiles에 포함된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+    fs.unlinkSync(fileA);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(true);
+  });
+
+  // Scenario: 신규 파일은 changedFiles에 포함되지 않는다
+  it("신규 파일은 changedFiles에 포함되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+
+    const fileB = createFile("b.ts");
+    const changed = tracker.detectChanges([fileA, fileB]);
+    expect(changed.has(fileB)).toBe(false);
+  });
+});

package/tests/workers/incremental-mtime-tracker.spec.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { IncrementalMtimeTracker } from "../../src/workers/incremental-mtime-tracker";
+
+describe("IncrementalMtimeTracker", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mtime-unit-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createFile(name: string): string {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(filePath, name, "utf-8");
+    return filePath;
+  }
+
+  it("빈 watchTargets로 detectChanges하면 빈 Set을 반환한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const changed = tracker.detectChanges([]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("빈 watchTargets로 updateMtimes하면 stat 호출이 없다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([]);
+    expect(spy.mock.calls).toHaveLength(0);
+    spy.mockRestore();
+  });
+
+  it("모든 파일이 watchTargets에서 제거되면 이후 detectChanges에서 감지되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    // 모든 파일 제거
+    tracker.detectChanges([]);
+    tracker.updateMtimes([]);
+
+    // 다시 추가 — "신규"로 취급
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(false);
+  });
+
+  it("동일 파일이 watchTargets에 중복되어도 정상 동작한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA, fileA]);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("detectChanges 없이 연속 updateMtimes를 호출하면 모두 신규로 처리된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA]);
+    expect(spy.mock.calls).toHaveLength(1);
+    spy.mockRestore();
+  });
+
+  it("존재하지 않는 파일은 detectChanges에서 prevMtimes에 없으면 무시된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const nonExistent = path.join(tmpDir, "ghost.ts");
+
+    const changed = tracker.detectChanges([nonExistent]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("updateMtimes 중 stat이 실패하는 변경 파일은 prevMtimes에서 제거된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+
+    // 파일 삭제 후 detectChanges — changedFiles에 포함
+    fs.unlinkSync(fileA);
+    tracker.detectChanges([fileA]);
+
+    // updateMtimes — stat 실패 → prevMtimes에서 제거
+    tracker.updateMtimes([fileA]);
+
+    // 파일 재생성
+    const fileANew = createFile("a.ts");
+
+    // 다음 detectChanges — "신규"로 취급 (prevMtimes에 없으므로)
+    const changed = tracker.detectChanges([fileANew]);
+    expect(changed.has(fileANew)).toBe(false);
+  });
+});

package/tests/workers/library-build-lint.spec.ts

@@ -1,41 +1,24 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import * as tscBuildModule from "../../src/utils/tsc-build";
 
 // --- Mocks ---
 
-const { mockLintFn, MockLintWithProgramRunner } = vi.hoisted(() => {
-  const lintFn = vi.fn().mockResolvedValue({
-    success: true,
-    errorCount: 0,
-    warningCount: 0,
-    formattedOutput: "",
+const { mockCompileAsync, MockSdTsCompiler } = vi.hoisted(() => {
+  const compileAsync = vi.fn();
+  const Compiler = vi.fn().mockImplementation(function () {
+    return { compileAsync };
   });
-  const RunnerCls = vi.fn().mockImplementation(function () {
-    return { lint: lintFn };
-  });
-  return { mockLintFn: lintFn, MockLintWithProgramRunner: RunnerCls };
+  return { mockCompileAsync: compileAsync, MockSdTsCompiler: Compiler };
 });
 
-vi.mock("../../src/lint/lint-with-program", () => ({
-  LintWithProgramRunner: MockLintWithProgramRunner,
+vi.mock("../../src/ts-compiler/SdTsCompiler", () => ({
+  SdTsCompiler: MockSdTsCompiler,
 }));
 
-const mockTscResult = {
-  success: true,
-  errors: undefined,
-  diagnostics: [],
-  errorCount: 0,
-  warningCount: 0,
-  program: { getSourceFiles: () => [] },
-};
-
-const runTscSpy = vi.spyOn(tscBuildModule, "runTscPackageBuild")
-  .mockReturnValue(mockTscResult as any);
-
-vi.mock("../../src/runtime/worker-utils", () => ({
-  registerCleanupHandlers: vi.fn(),
-  createOnceGuard: vi.fn(() => vi.fn()),
-  setupWorkerConsola: vi.fn(),
+vi.mock("../../src/workers/shared-worker-lifecycle", () => ({
+  setupWorkerLifecycle: vi.fn(() => ({
+    logger: { debug: vi.fn(), warn: vi.fn() },
+    guardStartWatch: vi.fn(),
+  })),
 }));
 
 vi.mock("@simplysm/core-node", () => ({
@@ -52,6 +35,21 @@ vi.mock("../../src/deps/replace-deps/collect-deps", () => ({
   collectDeps: vi.fn(() => ({ workspaceDeps: [], replaceDeps: [] })),
 }));
 
+const defaultCompileResult = {
+  program: { getSourceFiles: () => [] },
+  builderProgram: {},
+  isForAngular: false,
+  affectedFiles: new Set<string>(),
+  diagnostics: [] as any[],
+  errorCount: 0,
+  warningCount: 0,
+  errors: undefined as string[] | undefined,
+  emitResults: undefined,
+  lint: undefined as any,
+  scssErrors: [] as string[],
+  scssDependencies: new Map<string, Set<string>>(),
+};
+
 const workerMethods: Record<string, Function> = {};
 
 await import("../../src/workers/library-build.worker");
@@ -60,33 +58,31 @@ await import("../../src/workers/library-build.worker");
 
 beforeEach(() => {
   vi.clearAllMocks();
-  runTscSpy.mockReturnValue(mockTscResult as any);
-  mockLintFn.mockResolvedValue({
-    success: true,
-    errorCount: 0,
-    warningCount: 0,
-    formattedOutput: "",
-  });
-  mockTscResult.program = { getSourceFiles: () => [] } as any;
+  mockCompileAsync.mockResolvedValue({ ...defaultCompileResult });
 });
 
 describe("library-build.worker lint integration (Slice 3)", () => {
   describe("Scenario: library-build.worker runs lint after typecheck", () => {
     it("returns lint result in build output when lint is enabled", async () => {
+      const lintResult = {
+        success: true,
+        errorCount: 0,
+        warningCount: 0,
+        formattedOutput: "",
+      };
+      mockCompileAsync.mockResolvedValueOnce({
+        ...defaultCompileResult,
+        lint: lintResult,
+      });
+
       const result = await workerMethods["build"]({
         name: "my-lib",
-        config: { target: "node" },
         cwd: "/workspace",
         pkgDir: "/workspace/packages/my-lib",
         output: { js: true, dts: true, lint: true },
       });
 
-      expect(result.lint).toEqual({
-        success: true,
-        errorCount: 0,
-        warningCount: 0,
-        formattedOutput: "",
-      });
+      expect(result.lint).toEqual(lintResult);
     });
   });
 
@@ -94,7 +90,6 @@ describe("library-build.worker lint integration (Slice 3)", () => {
     it("does not run lint when output.lint is false", async () => {
       const result = await workerMethods["build"]({
         name: "my-lib",
-        config: { target: "node" },
         cwd: "/workspace",
         pkgDir: "/workspace/packages/my-lib",
         output: { js: true, dts: true },