@simplysm/sd-cli 14.0.42 → 14.0.43

package/tests/angular/web-worker-transformer.spec.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi } from "vitest";
+import ts from "typescript";
+
+const { createWorkerTransformer } = await import(
+  "../../src/angular/web-worker-transformer.js"
+);
+
+//#region 헬퍼
+
+/**
+ * TypeScript 소스 코드에 transformer를 적용하고 결과 코드를 반환한다.
+ */
+function transformCode(
+  code: string,
+  fileProcessor: (workerFile: string, containingFile: string) => string,
+  fileName = "test.ts",
+): string {
+  const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ES2022, true);
+  const transformer = createWorkerTransformer(fileProcessor);
+  const result = ts.transform(sourceFile, [transformer]);
+  const printer = ts.createPrinter();
+  const output = printer.printFile(result.transformed[0]);
+  result.dispose();
+  return output;
+}
+
+//#endregion
+
+describe("createWorkerTransformer", () => {
+  // Acceptance: Worker 표준 패턴을 감지하여 번들된 경로로 치환한다
+  it("Worker 표준 패턴 — URL 치환 + { type: 'module' } 자동 추가", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-ABCD1234.js");
+    const code = `const w = new Worker(new URL('./my-worker.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./my-worker.ts", "test.ts");
+    expect(output).toContain('"worker-ABCD1234.js"');
+    expect(output).toContain('type');
+    expect(output).toContain('"module"');
+    expect(output).not.toContain("./my-worker.ts");
+  });
+
+  // Acceptance: SharedWorker도 동일하게 처리한다
+  it("SharedWorker도 동일하게 변환한다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-SHARED01.js");
+    const code = `const sw = new SharedWorker(new URL('./shared.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./shared.ts", "test.ts");
+    expect(output).toContain('"worker-SHARED01.js"');
+  });
+
+  // Acceptance: Worker의 기존 options 인자가 있으면 유지한다
+  it("기존 options 인자가 있으면 유지한다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-OPT00001.js");
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url), { name: 'test' });`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(output).toContain('"worker-OPT00001.js"');
+    expect(output).toContain("name");
+    // { type: 'module' } 자동 추가 없이 기존 options가 유지됨
+    expect(output).not.toMatch(/type.*module.*name/);
+  });
+});
+
+describe("createWorkerTransformer — 변환하지 않는 케이스", () => {
+  const noopProcessor = vi.fn().mockReturnValue("should-not-appear.js");
+
+  // URL 패턴이 아닌 Worker 생성
+  it("URL 패턴 없이 문자열 인자만 있으면 변환하지 않는다", () => {
+    const code = `const w = new Worker('./my-worker.ts');`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("./my-worker.ts");
+  });
+
+  // import.meta.url이 아닌 URL
+  it("import.meta.url이 아닌 URL은 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', 'http://example.com'));`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("./w.ts");
+  });
+
+  // Worker 인자 없음
+  it("Worker 인자가 없으면 변환하지 않는다", () => {
+    const code = `const w = new Worker();`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // Worker 인자 3개 이상
+  it("Worker 인자가 3개 이상이면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url), {}, 'extra');`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // URL 인자가 1개
+  it("URL 인자가 1개면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts'));`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // URL 인자가 3개
+  it("URL 인자가 3개면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url, 'extra'));`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // 'Worker' 문자열 없으면 skip
+  it("소스에 'Worker' 문자열이 없으면 변환을 건너뛴다", () => {
+    const code = `const x = 1 + 2;`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("1 + 2");
+  });
+});
+
+describe("createWorkerTransformer — 추가 경계 케이스", () => {
+  // fileProcessor가 원본과 동일한 경로를 반환하면 변환하지 않는다
+  it("fileProcessor가 원본 경로를 그대로 반환하면 AST를 변경하지 않는다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("./my-worker.ts");
+    const code = `const w = new Worker(new URL('./my-worker.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./my-worker.ts", "test.ts");
+    // 원본 경로가 그대로 유지 (변환 없음)
+    expect(output).toContain("./my-worker.ts");
+  });
+
+  // 소스에 Worker 문자열은 있지만 new 표현이 아닌 경우
+  it("Worker 문자열이 있지만 new 표현이 아니면 변환하지 않는다", () => {
+    const fileProcessor = vi.fn();
+    const code = `const WorkerName = "test";`;
+
+    transformCode(code, fileProcessor);
+
+    expect(fileProcessor).not.toHaveBeenCalled();
+  });
+});

package/tests/capacitor/capacitor-build.spec.ts

@@ -66,7 +66,7 @@ vi.mock("sharp", () => ({
 
 // consola mock (logger assertion 필요)
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion
 

package/tests/capacitor/capacitor-icon.spec.ts

@@ -66,7 +66,7 @@ vi.mock("sharp", () => ({ default: mockSharp }));
 
 // consola mock (logger assertion 필요)
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion
 

package/tests/capacitor/capacitor-init.spec.ts

@@ -62,7 +62,7 @@ vi.mock("sharp", () => ({
 }));
 
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion
 

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/deps/replace-deps/collect-deps.acc.spec.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { collectDeps } from "../../../src/deps/replace-deps/collect-deps";
+import { pathx } from "@simplysm/core-node";
+
+describe("collectDeps — tests/ 패키지 제외", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = pathx.posix(fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-test-")));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createPkg(relDir: string, name: string, deps: Record<string, string> = {}): void {
+    const dir = pathx.posix(path.join(tmpDir, relDir));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      pathx.posix(path.join(dir, "package.json")),
+      JSON.stringify({ name, dependencies: deps }),
+    );
+  }
+
+  // Scenario: packages/ 패키지는 워크스페이스 맵에 포함된다
+  it("packages/ 패키지를 workspaceDeps에 포함한다", () => {
+    createPkg("packages/core-common", "@test/core-common");
+    createPkg("packages/my-lib", "@test/my-lib", { "@test/core-common": "workspace:*" });
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toContain("core-common");
+  });
+
+  // Scenario: tests/ 패키지는 워크스페이스 맵에서 제외된다
+  it("tests/ 패키지를 workspaceDeps에 포함하지 않는다", () => {
+    createPkg("packages/my-lib", "@test/my-lib", { "@test/orm": "workspace:*" });
+    createPkg("tests/orm", "@test/orm");
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).not.toContain("orm");
+  });
+
+  // Scenario: 패키지의 dependency에 tests/ 패키지가 있으면 workspaceDeps에서 무시된다
+  it("dependency에 tests/ 패키지가 있어도 workspaceDeps에서 무시한다", () => {
+    createPkg("packages/core-common", "@test/core-common");
+    createPkg("tests/orm", "@test/orm");
+    createPkg("packages/my-lib", "@test/my-lib", {
+      "@test/core-common": "workspace:*",
+      "@test/orm": "workspace:*",
+    });
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toContain("core-common");
+    expect(result.workspaceDeps).not.toContain("orm");
+  });
+});