@simplysm/sd-cli 14.0.42 → 14.0.44

package/tests/commands/check.spec.ts

@@ -1,10 +1,21 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { consola } from "consola";
+
+const mockLogger = {
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  start: vi.fn(),
+  success: vi.fn(),
+};
+
+vi.spyOn(consola, "withTag").mockReturnValue(mockLogger as any);
 
 const mocks = vi.hoisted(() => ({
   executeTypecheck: vi.fn(),
   executeLint: vi.fn(),
   runLintInWorker: vi.fn(),
-  execa: vi.fn(),
   loadSdConfig: vi.fn(),
   discoverWorkspacePackages: vi.fn(),
 }));
@@ -25,13 +36,6 @@ vi.mock("../../src/utils/sd-config", () => ({
   loadSdConfig: mocks.loadSdConfig,
 }));
 
-vi.mock("@simplysm/core-node", () => ({
-  cpx: {
-    spawn: mocks.execa,
-    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
-  },
-}));
-
 vi.mock("../../src/utils/package-utils", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../src/utils/package-utils")>();
   return {
@@ -42,20 +46,21 @@ vi.mock("../../src/utils/package-utils", async (importOriginal) => {
 
 const { runCheck } = await import("../../src/commands/check");
 
+/**
+ * Collects all calls to the given mock function's first argument into an array,
+ * preserving call order for sequential assertions.
+ */
+function collectArgs(fn: ReturnType<typeof vi.fn>): string[] {
+  return fn.mock.calls.map((call) => String(call[0]));
+}
+
 describe("runCheck", () => {
   let savedExitCode: typeof process.exitCode;
-  let writeSpy: ReturnType<typeof vi.spyOn>;
-  let stdoutOutput: string;
 
   beforeEach(() => {
     vi.clearAllMocks();
     savedExitCode = process.exitCode;
     process.exitCode = undefined;
-    stdoutOutput = "";
-    writeSpy = vi.spyOn(process.stdout, "write").mockImplementation((chunk: unknown) => {
-      stdoutOutput += String(chunk);
-      return true;
-    });
 
     // Default: workspace packages
     mocks.discoverWorkspacePackages.mockReturnValue(
@@ -89,41 +94,22 @@ describe("runCheck", () => {
     mocks.runLintInWorker.mockResolvedValue({
       success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
     });
-    mocks.execa.mockResolvedValue({
-      stdout: "Tests  1 passed", stderr: "", exitCode: 0,
-    });
   });
 
   afterEach(() => {
     process.exitCode = savedExitCode;
-    writeSpy.mockRestore();
   });
 
-  it("runs typecheck+lint and test", async () => {
-    await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
-
-    expect(stdoutOutput).toContain("TYPECHECK");
-    expect(stdoutOutput).toContain("TEST");
-  });
+  it("outputs success sections in TYPECHECK → LINT order via logger.success", async () => {
+    await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-  it("outputs results in TYPECHECK → LINT → TEST → 요약 order", async () => {
-    await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
-
-    const tcIdx = stdoutOutput.indexOf("TYPECHECK");
-    const lintIdx = stdoutOutput.indexOf("LINT");
-    const testIdx = stdoutOutput.indexOf("TEST");
-    const summaryIdx = stdoutOutput.indexOf("요약");
+    const successArgs = collectArgs(mockLogger.success);
+    const tcIdx = successArgs.findIndex((a) => a.includes("TYPECHECK"));
+    const lintIdx = successArgs.findIndex((a) => a.includes("LINT"));
 
+    expect(tcIdx).toBeGreaterThanOrEqual(0);
+    expect(lintIdx).toBeGreaterThanOrEqual(0);
     expect(tcIdx).toBeLessThan(lintIdx);
-    expect(lintIdx).toBeLessThan(testIdx);
-    expect(testIdx).toBeLessThan(summaryIdx);
-  });
-
-  it("runs only specified check types", async () => {
-    await runCheck({ targets: [], types: ["test"], fix: false });
-
-    expect(stdoutOutput).not.toContain("TYPECHECK");
-    expect(stdoutOutput).toContain("TEST");
   });
 
   it("sets exitCode 1 when typecheck fails", async () => {
@@ -133,35 +119,52 @@ describe("runCheck", () => {
       scriptsPackagePaths: [],
     });
 
-    await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
+    await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
     expect(process.exitCode).toBe(1);
   });
 
-  it("sets exitCode to 1 when lint fails", async () => {
-    mocks.executeLint.mockResolvedValue({
-      success: false, errorCount: 1, warningCount: 0, formattedOutput: "lint errors",
+  it("outputs failed section via logger.error with formattedOutput", async () => {
+    mocks.executeTypecheck.mockResolvedValue({
+      success: false, errorCount: 2, warningCount: 0, formattedOutput: "type errors",
+      lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
+      scriptsPackagePaths: [],
     });
 
-    await runCheck({ targets: [], types: ["lint"], fix: false });
+    await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-    expect(process.exitCode).toBe(1);
+    const errorArgs = collectArgs(mockLogger.error);
+    expect(errorArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
+    expect(errorArgs.some((a) => a.includes("type errors"))).toBe(true);
+  });
+
+  it("outputs success summary via logger.success when all pass", async () => {
+    await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
+
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("전체 통과"))).toBe(true);
   });
 
-  it("sets exitCode 1 when test fails", async () => {
-    mocks.execa.mockResolvedValue({
-      stdout: "3 tests failed", stderr: "", exitCode: 1,
+  it("outputs failure summary via logger.error when any fails", async () => {
+    mocks.executeTypecheck.mockResolvedValue({
+      success: false, errorCount: 1, warningCount: 0, formattedOutput: "err",
+      lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
+      scriptsPackagePaths: [],
     });
 
-    await runCheck({ targets: [], types: ["test"], fix: false });
+    await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-    expect(process.exitCode).toBe(1);
+    const errorArgs = collectArgs(mockLogger.error);
+    expect(errorArgs.some((a) => a.includes("실패"))).toBe(true);
+    expect(errorArgs.some((a) => a.includes("합계"))).toBe(true);
   });
 
-  it("handles vitest execution error gracefully", async () => {
-    mocks.execa.mockRejectedValue(new Error("vitest not found"));
+  it("sets exitCode to 1 when lint fails", async () => {
+    mocks.executeLint.mockResolvedValue({
+      success: false, errorCount: 1, warningCount: 0, formattedOutput: "lint errors",
+    });
 
-    await runCheck({ targets: [], types: ["test"], fix: false });
+    await runCheck({ targets: [], types: ["lint"], fix: false });
 
     expect(process.exitCode).toBe(1);
   });
@@ -179,51 +182,45 @@ describe("runCheck", () => {
   it("resolves package target to packages/ path", async () => {
     await runCheck({ targets: ["core-node"], types: ["typecheck"], fix: false });
 
-    expect(stdoutOutput).toContain("TYPECHECK");
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
     expect(process.exitCode).toBeUndefined();
   });
 
   it("resolves test directory target to tests/ path", async () => {
     await runCheck({ targets: ["orm"], types: ["typecheck"], fix: false });
 
-    expect(stdoutOutput).toContain("TYPECHECK");
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
     expect(process.exitCode).toBeUndefined();
   });
 
   it("resolves mixed targets to correct paths", async () => {
     await runCheck({ targets: ["core-node", "orm"], types: ["typecheck"], fix: false });
 
-    expect(stdoutOutput).toContain("TYPECHECK");
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
     expect(process.exitCode).toBeUndefined();
   });
 
   it("resolves lint target to correct path", async () => {
     await runCheck({ targets: ["orm"], types: ["lint"], fix: false });
 
-    expect(stdoutOutput).toContain("LINT");
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
     expect(process.exitCode).toBeUndefined();
   });
 
-  it("passes resolved paths to vitest", async () => {
-    await runCheck({ targets: ["orm"], types: ["test"], fix: false });
-
-    expect(mocks.execa).toHaveBeenCalledWith(
-      "pnpm",
-      ["vitest", "tests/orm", "--run"],
-      expect.any(Object),
-    );
-  });
-
   it("passes empty targets for all when no targets specified", async () => {
     await runCheck({ targets: [], types: ["typecheck"], fix: false });
 
-    expect(stdoutOutput).toContain("TYPECHECK");
+    const successArgs = collectArgs(mockLogger.success);
+    expect(successArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
     expect(process.exitCode).toBeUndefined();
   });
 
   describe("lint via engine integration", () => {
     beforeEach(() => {
-      // Default: executeTypecheck returns lint result and scriptsPackagePaths
       mocks.executeTypecheck.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
         lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
@@ -231,15 +228,14 @@ describe("runCheck", () => {
       });
     });
 
-    // Scenario: typecheck+lint 요청 시 TYPECHECK과 LINT 섹션이 출력된다
     it("outputs TYPECHECK and LINT sections when both are requested", async () => {
       await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-      expect(stdoutOutput).toContain("TYPECHECK");
-      expect(stdoutOutput).toContain("LINT");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("TYPECHECK"))).toBe(true);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
     });
 
-    // Scenario: lint 실패 시 exitCode 설정
     it("sets exitCode 1 when engine lint fails", async () => {
       mocks.executeTypecheck.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
@@ -252,7 +248,6 @@ describe("runCheck", () => {
       expect(process.exitCode).toBe(1);
     });
 
-    // Scenario: scripts 패키지 포함 시 lint가 성공한다
     it("succeeds when scriptsPackagePaths is non-empty", async () => {
       mocks.executeTypecheck.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
@@ -265,69 +260,62 @@ describe("runCheck", () => {
 
       await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
       expect(process.exitCode).toBeUndefined();
     });
   });
 
   describe("lint-only path", () => {
-    // Scenario: lint만 요청 시 LINT 섹션만 출력된다
     it("outputs LINT section when only lint type is requested", async () => {
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).not.toContain("TYPECHECK");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
+      const allArgs = [...collectArgs(mockLogger.success), ...collectArgs(mockLogger.error)];
+      expect(allArgs.some((a) => a.includes("TYPECHECK"))).toBe(false);
     });
 
-    // Scenario: lint,test 요청 시 LINT과 TEST 섹션 출력 (TYPECHECK 없음)
-    it("outputs LINT and TEST sections when lint,test are requested", async () => {
-      await runCheck({ targets: [], types: ["lint", "test"], fix: false });
-
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).toContain("TEST");
-      expect(stdoutOutput).not.toContain("TYPECHECK");
-    });
-
-    // Scenario: scripts 패키지 포함 전체 lint
     it("handles all packages via lint including scripts", async () => {
       mocks.discoverWorkspacePackages.mockReturnValue(
         new Map([
           ["core-common", "packages/core-common"],
-          ["sd-claude", "packages/sd-claude"], // scripts package
+          ["sd-claude", "packages/sd-claude"],
         ]),
       );
 
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).not.toContain("TYPECHECK");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
+      const allArgs = [...collectArgs(mockLogger.success), ...collectArgs(mockLogger.error)];
+      expect(allArgs.some((a) => a.includes("TYPECHECK"))).toBe(false);
     });
 
-    // Scenario: 특정 타겟 지정 lint
     it("succeeds with normalized target paths for lint", async () => {
       await runCheck({ targets: ["core-common"], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
       expect(process.exitCode).toBeUndefined();
     });
 
-    // Scenario: --fix 옵션으로 자동 수정
     it("succeeds when --fix is specified", async () => {
       await runCheck({ targets: [], types: ["lint"], fix: true });
 
-      expect(stdoutOutput).toContain("LINT");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
       expect(process.exitCode).toBeUndefined();
     });
 
-    // Scenario: --fix 없이 실행
     it("succeeds when --fix is not specified", async () => {
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
       expect(process.exitCode).toBeUndefined();
     });
 
-    // Scenario: lint 에러 없음
     it("does not set exitCode when lint passes", async () => {
       mocks.executeLint.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
@@ -338,7 +326,6 @@ describe("runCheck", () => {
       expect(process.exitCode).toBeUndefined();
     });
 
-    // Scenario: lint 에러 발생
     it("sets exitCode 1 when lint has errors", async () => {
       mocks.executeLint.mockResolvedValue({
         success: false, errorCount: 3, warningCount: 2, formattedOutput: "lint errors",
@@ -349,12 +336,11 @@ describe("runCheck", () => {
       expect(process.exitCode).toBe(1);
     });
 
-    // typecheck 관련 로그 메시지가 출력되지 않는다
     it("does not output typecheck-related sections when only lint is requested", async () => {
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).not.toContain("TYPECHECK");
+      const allArgs = [...collectArgs(mockLogger.success), ...collectArgs(mockLogger.error)];
+      expect(allArgs.some((a) => a.includes("TYPECHECK"))).toBe(false);
     });
   });
-
 });

package/tests/commands/publish.spec.ts

@@ -298,8 +298,16 @@ describe("runPublish", () => {
         },
       });
 
-      const writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true);
+      const { consola } = await import("consola");
+      const infoSpy = vi.fn();
+      const origWithTag = consola.withTag.bind(consola);
+      const withTagSpy = vi.spyOn(consola, "withTag").mockImplementation((tag: string) => {
+        const logger = origWithTag(tag);
+        logger.info = infoSpy as any;
+        return logger;
+      });
 
+      // Re-import to pick up the spy (module already loaded, but logger is created at call time)
       await runPublish({
         targets: [],
         noBuild: false,
@@ -307,9 +315,9 @@ describe("runPublish", () => {
         options: [],
       });
 
-      const output = writeSpy.mock.calls.map((c) => String(c[0])).join("");
-      expect(output).toContain("배포할 패키지가 없습니다");
-      writeSpy.mockRestore();
+      const infoArgs = infoSpy.mock.calls.map((c: unknown[]) => String(c[0]));
+      expect(infoArgs.some((a: string) => a.includes("배포할 패키지가 없습니다"))).toBe(true);
+      withTagSpy.mockRestore();
     });
   });
 

package/tests/commands/slice3-severity-cleanup.verify.md

@@ -0,0 +1,12 @@
+# Slice 3: severity 정리 — LLM 검증
+
+## 검증 항목
+
+- [x] replace-deps.ts:5 — `const logger = consola.withTag("sd:cli:replace-deps")` 모듈-레벨 로거 추가 확인
+- [x] replace-deps.ts:24 — `consola.warn(...)` → `logger.warn(...)` 변경 확인
+- [x] deployment-phase.ts:66-70 — DRY-RUN 성공 메시지 `debug` → `info` 전환 확인: `dryRun ? logger.info("[DRY-RUN] ...") : logger.debug(...)`
+- [x] deployment-phase.ts:76-80 — DRY-RUN 재시도 메시지 `debug` → `info` 전환 확인: 동일 패턴
+- [x] deployment-phase.ts:102 — `logger.fail(...)` → `logger.error(...)` 전환 확인
+- [x] BuildOrchestrator.ts:251 — `this._logger.success("빌드 실행 완료")` 행 제거 확인: 250행 뒤에 바로 `return` 문
+- [x] BuildOrchestrator.ts:477 — `this._logger.info("빌드 완료")` → `this._logger.success("빌드 완료")` 전환 확인
+- [x] BuildOrchestrator.ts:232-233 — `this._logger.start("빌드 실행 중...")` 유지 확인: start(232)/success(477) 쌍 정상화

package/tests/commands/version-upgrade.acc.spec.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { upgradeVersion, computePublishLevels } from "../../src/commands/publish/version-upgrade";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-version-upgrade-"));
+}
+
+function writeJson(filePath: string, data: unknown): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+function readJson<T>(filePath: string): T {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8")) as T;
+}
+
+describe("upgradeVersion", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("복수 패키지의 package.json을 병렬 업데이트한다", async () => {
+    // Given: allPkgPaths에 5개 패키지 경로가 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const pkgNames = ["pkg-a", "pkg-b", "pkg-c", "pkg-d", "pkg-e"];
+    const allPkgPaths = pkgNames.map((name) => {
+      const pkgDir = path.join(tmpDir, "packages", name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${name}`,
+        version: "14.0.0",
+      });
+      return pkgDir;
+    });
+
+    // sd-cli/templates 디렉토리 생성 (glob 대상이 없도록)
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, allPkgPaths, false);
+
+    // Then: 5개 패키지의 package.json이 모두 newVersion으로 업데이트된다
+    expect(result.version).toBe("14.0.1");
+    for (const pkgDir of allPkgPaths) {
+      const pkg = readJson<{ version: string }>(path.join(pkgDir, "package.json"));
+      expect(pkg.version).toBe("14.0.1");
+    }
+
+    // And: changedFiles에 5개 패키지 경로가 모두 포함된다
+    for (const pkgDir of allPkgPaths) {
+      expect(result.changedFiles).toContain(path.resolve(pkgDir, "package.json"));
+    }
+  });
+
+  it("패키지가 없으면 루트 package.json만 changedFiles에 포함된다", async () => {
+    // Given: allPkgPaths가 빈 배열이다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then: 루트 package.json만 changedFiles에 포함된다
+    expect(result.changedFiles).toHaveLength(1);
+    expect(result.changedFiles[0]).toBe(path.resolve(tmpDir, "package.json"));
+  });
+
+  it("복수 템플릿 파일을 병렬 업데이트한다", async () => {
+    // Given: 템플릿 3개 중 2개에 @simplysm 버전이 포함되어 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const templatesDir = path.join(tmpDir, "packages", "sd-cli", "templates");
+    fs.mkdirSync(templatesDir, { recursive: true });
+
+    // 템플릿 1: @simplysm 버전 포함
+    fs.writeFileSync(
+      path.join(templatesDir, "a.hbs"),
+      `"@simplysm/core-common": "~14.0.0"`,
+      "utf-8",
+    );
+    // 템플릿 2: @simplysm 버전 포함
+    fs.writeFileSync(
+      path.join(templatesDir, "b.hbs"),
+      `"@simplysm/angular": "~14.0.0"`,
+      "utf-8",
+    );
+    // 템플릿 3: @simplysm 버전 미포함
+    fs.writeFileSync(path.join(templatesDir, "c.hbs"), `no version here`, "utf-8");
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then: 2개 파일만 수정되고 changedFiles에 추가된다
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(2);
+
+    // 수정된 파일들의 내용 확인
+    expect(fs.readFileSync(path.join(templatesDir, "a.hbs"), "utf-8")).toContain("~14.0.1");
+    expect(fs.readFileSync(path.join(templatesDir, "b.hbs"), "utf-8")).toContain("~14.0.1");
+    // 수정되지 않은 파일
+    expect(fs.readFileSync(path.join(templatesDir, "c.hbs"), "utf-8")).toBe("no version here");
+  });
+
+  it("템플릿이 없으면 템플릿 관련 쓰기 없이 완료된다", async () => {
+    // Given: glob 결과가 빈 배열이다 (templates 디렉토리에 .hbs 파일 없음)
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, [], false);
+
+    // Then
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(0);
+  });
+
+  it("changedFiles[0]이 프로젝트 루트 package.json 경로이다", async () => {
+    // Given: allPkgPaths에 3개 패키지가 있다
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const allPkgPaths = ["pkg-a", "pkg-b", "pkg-c"].map((name) => {
+      const pkgDir = path.join(tmpDir, "packages", name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${name}`,
+        version: "14.0.0",
+      });
+      return pkgDir;
+    });
+
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    // When
+    const result = await upgradeVersion(tmpDir, allPkgPaths, false);
+
+    // Then: changedFiles[0]이 프로젝트 루트 package.json 경로이다
+    expect(result.changedFiles[0]).toBe(path.resolve(tmpDir, "package.json"));
+  });
+});
+
+describe("computePublishLevels", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("의존 관계가 있는 패키지들의 레벨을 올바르게 계산한다", async () => {
+    // Given: A(의존 없음), B(A 의존), C(B 의존)
+    const pkgs = [
+      { name: "pkg-a", deps: {} },
+      { name: "pkg-b", deps: { "@simplysm/pkg-a": "~14.0.0" } },
+      { name: "pkg-c", deps: { "@simplysm/pkg-b": "~14.0.0" } },
+    ];
+
+    const publishPkgs = pkgs.map((p) => {
+      const pkgDir = path.join(tmpDir, "packages", p.name);
+      writeJson(path.join(pkgDir, "package.json"), {
+        name: `@simplysm/${p.name}`,
+        version: "14.0.0",
+        dependencies: p.deps,
+      });
+      return { name: p.name, path: pkgDir };
+    });
+
+    // When
+    const levels = await computePublishLevels(publishPkgs);
+
+    // Then: 레벨은 [[A], [B], [C]]
+    expect(levels).toHaveLength(3);
+    expect(levels[0].map((p) => p.name)).toEqual(["pkg-a"]);
+    expect(levels[1].map((p) => p.name)).toEqual(["pkg-b"]);
+    expect(levels[2].map((p) => p.name)).toEqual(["pkg-c"]);
+  });
+});