@simplysm/sd-cli 14.0.42 → 14.0.44

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

@@ -0,0 +1,148 @@
+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-vu-unit-"));
+}
+
+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 — unit", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("prerelease 버전은 prerelease로 증가한다", async () => {
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0-beta.3",
+    });
+    fs.mkdirSync(path.join(tmpDir, "packages", "sd-cli", "templates"), {
+      recursive: true,
+    });
+
+    const result = await upgradeVersion(tmpDir, [], false);
+    expect(result.version).toBe("14.0.0-beta.4");
+  });
+
+  it("dryRun이면 파일을 수정하지 않고 새 버전만 반환한다", async () => {
+    writeJson(path.join(tmpDir, "package.json"), {
+      name: "@simplysm/root",
+      version: "14.0.0",
+    });
+
+    const pkgDir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgDir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+    });
+
+    const result = await upgradeVersion(tmpDir, [pkgDir], true);
+    expect(result.version).toBe("14.0.1");
+    expect(result.changedFiles).toHaveLength(0);
+
+    // 파일이 수정되지 않았는지 확인
+    const rootPkg = readJson<{ version: string }>(path.join(tmpDir, "package.json"));
+    expect(rootPkg.version).toBe("14.0.0");
+  });
+
+  it("템플릿 파일에서 @simplysm 버전이 없으면 수정하지 않는다", async () => {
+    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 });
+    fs.writeFileSync(path.join(templatesDir, "no-version.hbs"), "plain template content", "utf-8");
+
+    const result = await upgradeVersion(tmpDir, [], false);
+    const templateChanges = result.changedFiles.filter((f) => f.endsWith(".hbs"));
+    expect(templateChanges).toHaveLength(0);
+
+    // 파일이 수정되지 않았는지 확인
+    expect(fs.readFileSync(path.join(templatesDir, "no-version.hbs"), "utf-8")).toBe(
+      "plain template content",
+    );
+  });
+});
+
+describe("computePublishLevels — unit", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("의존성 없는 패키지들은 모두 Level 0이다", async () => {
+    const publishPkgs = ["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",
+        dependencies: {},
+      });
+      return { name, path: pkgDir };
+    });
+
+    const levels = await computePublishLevels(publishPkgs);
+    expect(levels).toHaveLength(1);
+    expect(levels[0].map((p) => p.name).sort()).toEqual(["pkg-a", "pkg-b", "pkg-c"]);
+  });
+
+  it("외부 의존성(@simplysm/ 아닌)은 레벨 계산에 영향 없다", async () => {
+    const pkgDir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgDir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+      dependencies: { lodash: "^4.0.0", express: "^5.0.0" },
+    });
+
+    const levels = await computePublishLevels([{ name: "pkg-a", path: pkgDir }]);
+    expect(levels).toHaveLength(1);
+    expect(levels[0][0].name).toBe("pkg-a");
+  });
+
+  it("peerDependencies와 optionalDependencies도 레벨에 반영된다", async () => {
+    const pkgADir = path.join(tmpDir, "packages", "pkg-a");
+    writeJson(path.join(pkgADir, "package.json"), {
+      name: "@simplysm/pkg-a",
+      version: "14.0.0",
+    });
+
+    const pkgBDir = path.join(tmpDir, "packages", "pkg-b");
+    writeJson(path.join(pkgBDir, "package.json"), {
+      name: "@simplysm/pkg-b",
+      version: "14.0.0",
+      peerDependencies: { "@simplysm/pkg-a": "~14.0.0" },
+    });
+
+    const levels = await computePublishLevels([
+      { name: "pkg-a", path: pkgADir },
+      { name: "pkg-b", path: pkgBDir },
+    ]);
+    expect(levels).toHaveLength(2);
+    expect(levels[0][0].name).toBe("pkg-a");
+    expect(levels[1][0].name).toBe("pkg-b");
+  });
+});

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");
+  });
+});

package/tests/deps/replace-deps/collect-deps.spec.ts

@@ -0,0 +1,49 @@
+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", () => {
+  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 }),
+    );
+  }
+
+  it("tests/ 패키지만 의존하면 workspaceDeps가 빈 배열이다", () => {
+    createPkg("tests/orm", "@test/orm");
+    createPkg("tests/service", "@test/service");
+    createPkg("packages/my-lib", "@test/my-lib", {
+      "@test/orm": "workspace:*",
+      "@test/service": "workspace:*",
+    });
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toEqual([]);
+  });
+
+  it("의존성이 없는 패키지는 빈 결과를 반환한다", () => {
+    createPkg("packages/my-lib", "@test/my-lib");
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toEqual([]);
+    expect(result.replaceDeps).toEqual([]);
+  });
+});

package/tests/deps/replace-deps/replace-deps-filter.spec.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { pathx } from "@simplysm/core-node";
+import {
+  createCopyFilter,
+  loadFilesField,
+  NPM_DEFAULT_FILE_PATTERN,
+} from "../../../src/deps/replace-deps/replace-deps";
+
+describe("NPM_DEFAULT_FILE_PATTERN", () => {
+  it("README 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("README")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("README.md")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("readme.txt")).toBe(true);
+  });
+
+  it("LICENSE/LICENCE 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("LICENSE")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("LICENCE")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("license.md")).toBe(true);
+  });
+
+  it("CHANGELOG/HISTORY 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CHANGELOG")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CHANGELOG.md")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("HISTORY.md")).toBe(true);
+  });
+
+  it("관련없는 파일명은 매칭하지 않는다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("tsconfig.json")).toBe(false);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CLAUDE.md")).toBe(false);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("package.json")).toBe(false);
+  });
+});
+
+describe("createCopyFilter", () => {
+  const sourcePath = "/source/pkg";
+
+  it("allowedNames에 포함된 첫 번째 세그먼트는 허용한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "dist"))).toBe(true);
+    expect(filter(path.join(sourcePath, "src"))).toBe(true);
+    expect(filter(path.join(sourcePath, "dist", "index.js"))).toBe(true);
+    expect(filter(path.join(sourcePath, "src", "utils", "helper.ts"))).toBe(true);
+  });
+
+  it("allowedNames에 없는 항목은 거부한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "tsconfig.json"))).toBe(false);
+    expect(filter(path.join(sourcePath, "CLAUDE.md"))).toBe(false);
+    expect(filter(path.join(sourcePath, "node_modules"))).toBe(false);
+  });
+
+  it("package.json은 항상 거부한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "package.json"))).toBe(false);
+  });
+
+  it("npm 기본 파일 패턴은 allowedNames에 없어도 허용한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist"]));
+
+    expect(filter(path.join(sourcePath, "README.md"))).toBe(true);
+    expect(filter(path.join(sourcePath, "LICENSE"))).toBe(true);
+    expect(filter(path.join(sourcePath, "CHANGELOG.md"))).toBe(true);
+  });
+});
+
+describe("loadFilesField", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-load-files-")));
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("files 필드가 있으면 문자열 배열을 반환한다", async () => {
+    await fs.promises.writeFile(
+      pathx.posix(path.join(tmpDir, "package.json")),
+      JSON.stringify({ name: "test", files: ["dist", "src"] }),
+    );
+
+    const result = await loadFilesField(tmpDir);
+    expect(result).toEqual(["dist", "src"]);
+  });
+
+  it("files 필드가 없으면 undefined를 반환한다", async () => {
+    await fs.promises.writeFile(
+      pathx.posix(path.join(tmpDir, "package.json")),
+      JSON.stringify({ name: "test" }),
+    );
+
+    const result = await loadFilesField(tmpDir);
+    expect(result).toBeUndefined();
+  });
+});

package/tests/deps/replace-deps/replace-deps-perf.verify.md

@@ -0,0 +1,15 @@
+# replace-deps 성능 최적화 — LLM 검증
+
+## 검증 항목
+
+### Slice 1: Set 중복 검사 + glob 병렬화
+
+- [x] `resolveAllReplaceDepEntries`에서 `entries.some()` 대신 `Set<string>` 사용 확인: `replace-deps-resolve.ts:143`에 `seenTargetPaths = new Set<string>()` 선언, `:205`에서 `seenTargetPaths.has(actualTargetPath)` + `seenTargetPaths.add(actualTargetPath)` 사용. 기존 `entries.some()` 제거됨.
+- [x] glob 병렬화 확인: `replace-deps-resolve.ts:167-171`에서 `Promise.all(Object.keys(replaceDeps).map(...))` 사용. 기존 순차 `for` 루프 제거됨. `:172-174`에서 `flatMap`으로 결과를 합침.
+- [x] `seenTargetPaths`가 while 루프 바깥에 선언되어 재귀 탐색 전체에 걸쳐 중복 방지가 유지됨 확인.
+
+### Slice 2: watch onChange entries 사전 필터링
+
+- [x] `watchReplaceDeps`에서 사전 필터링 확인: `replace-deps.ts:240-242`에 `sourceEntries = entries.filter(e => e.resolvedSourcePath === entry.resolvedSourcePath)` 선언. watcher 생성 전에 필터링되어 클로저에 캡처됨.
+- [x] onChange 내부에서 `sourceEntries`만 순회 확인: `replace-deps.ts:252`에서 `for (const e of sourceEntries)` 사용. 기존 `for (const e of entries)` + `if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;` 패턴이 제거됨.
+- [x] `entries` 배열은 `resolveAllReplaceDepEntries` 호출 후 불변이므로, 필터링 결과가 watcher 생명주기 동안 유효함 확인 (`replace-deps.ts:202`에서 `entries` 할당 후 수정 없음).

package/tests/deps/replace-deps/replace-deps-resolve.acc.spec.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { pathx } from "@simplysm/core-node";
+import { resolveAllReplaceDepEntries } from "../../../src/deps/replace-deps/replace-deps-resolve";
+import { consola } from "consola";
+
+describe("resolveAllReplaceDepEntries", () => {
+  let tmpDir: string;
+  let projectRoot: string;
+  const logger = consola.withTag("test");
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-resolve-deps-")));
+    projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    await fs.promises.mkdir(projectRoot, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n",
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * node_modules에 패키지 디렉토리를 생성하는 헬퍼
+   */
+  async function createNodeModulesPkg(
+    nodeModulesDir: string,
+    pkgName: string,
+  ): Promise<string> {
+    const pkgDir = pathx.posix(path.join(nodeModulesDir, pkgName));
+    await fs.promises.mkdir(pkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(pkgDir, "package.json")),
+      JSON.stringify({ name: pkgName }),
+    );
+    return pkgDir;
+  }
+
+  /**
+   * 소스 패키지를 생성하는 헬퍼
+   */
+  async function createSourcePkg(name: string): Promise<string> {
+    const sourcePath = pathx.posix(path.join(tmpDir, name));
+    await fs.promises.mkdir(sourcePath, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "package.json")),
+      JSON.stringify({ name, files: ["dist"] }),
+    );
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "dist")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "dist", "index.js")),
+      "module.exports = {};",
+    );
+    return sourcePath;
+  }
+
+  it("동일 actualTargetPath를 가진 항목은 중복 등록되지 않는다", async () => {
+    // Given: 루트 node_modules와 workspace pkg의 node_modules에 동일 패키지가 존재하고
+    //        둘 다 같은 실제 경로(symlink 해석 후)를 가리킨다
+    const sourcePath = await createSourcePkg("@test/pkg");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg");
+
+    // workspace 패키지 설정 (pnpm-workspace.yaml에 추가)
+    const workspacePkgDir = pathx.posix(path.join(projectRoot, "packages", "my-app"));
+    await fs.promises.mkdir(workspacePkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n  - packages/*\n",
+    );
+
+    // workspace 패키지의 node_modules에도 동일 패키지 생성
+    const wsPkgNodeModules = pathx.posix(path.join(workspacePkgDir, "node_modules"));
+    await createNodeModulesPkg(wsPkgNodeModules, "@test/pkg");
+
+    // When
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      { "@test/pkg": sourcePath },
+      logger,
+    );
+
+    // Then: actualTargetPath가 다르므로 2개가 반환되어야 한다
+    //       (symlink가 아닌 실제 디렉토리이므로 actualTargetPath가 각각 다름)
+    //       중복 방지 로직은 동일 actualTargetPath일 때만 작동한다
+    const actualTargetPaths = entries.map((e) => e.actualTargetPath);
+    const uniqueActualTargetPaths = new Set(actualTargetPaths);
+    expect(actualTargetPaths.length).toBe(uniqueActualTargetPaths.size);
+  });
+
+  it("여러 replaceDeps 패턴이 올바르게 매칭되어 결과를 반환한다", async () => {
+    // Given: 2개의 다른 패턴과 각각의 소스 패키지
+    const sourceA = await createSourcePkg("@test/pkg-a");
+    const sourceB = await createSourcePkg("@other/lib");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg-a");
+    await createNodeModulesPkg(nodeModulesDir, "@other/lib");
+
+    // When: 2개 패턴으로 호출 (glob이 병렬 실행되어야 함)
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      {
+        "@test/pkg-a": sourceA,
+        "@other/lib": sourceB,
+      },
+      logger,
+    );
+
+    // Then: 두 패턴 모두 매칭되어 2개 entries 반환
+    expect(entries).toHaveLength(2);
+    const targetNames = entries.map((e) => e.targetName).sort();
+    expect(targetNames).toEqual(["@other/lib", "@test/pkg-a"]);
+  });
+
+  it("빈 replaceDeps 설정이면 빈 배열을 반환한다", async () => {
+    const entries = await resolveAllReplaceDepEntries(projectRoot, {}, logger);
+    expect(entries).toEqual([]);
+  });
+});

package/tests/deps/replace-deps/replace-deps-setup.acc.spec.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { setupReplaceDeps } from "../../../src/deps/replace-deps/replace-deps";
+import { pathx } from "@simplysm/core-node";
+
+describe("setupReplaceDeps 화이트리스트 복사", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-replace-deps-")));
+
+    // pnpm-workspace.yaml
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    await fs.promises.mkdir(projectRoot, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n",
+    );
+
+    // 타겟 (node_modules에 기존 패키지)
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+    await fs.promises.mkdir(targetPkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(targetPkgDir, "package.json")),
+      JSON.stringify({ name: "@test/pkg", version: "2.0.0" }),
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * 소스 패키지를 생성하는 헬퍼
+   */
+  async function createSourcePkg(opts: {
+    files?: string[];
+    extraFiles?: Record<string, string>;
+  }): Promise<string> {
+    const sourcePath = pathx.posix(path.join(tmpDir, "source-pkg"));
+    await fs.promises.mkdir(sourcePath, { recursive: true });
+
+    // package.json
+    const pkgJson: Record<string, unknown> = { name: "@test/pkg", version: "1.0.0" };
+    if (opts.files != null) {
+      pkgJson["files"] = opts.files;
+    }
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "package.json")),
+      JSON.stringify(pkgJson),
+    );
+
+    // 기본 디렉토리/파일 생성
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "dist")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "dist", "index.js")),
+      "module.exports = {};",
+    );
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "src")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "src", "index.ts")),
+      "export const v = 1;",
+    );
+    // files에 없는 파일들
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "tsconfig.json")),
+      "{}",
+    );
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "CLAUDE.md")),
+      "# CLAUDE",
+    );
+
+    // 추가 파일
+    if (opts.extraFiles != null) {
+      for (const [relPath, content] of Object.entries(opts.extraFiles)) {
+        const fullPath = pathx.posix(path.join(sourcePath, relPath));
+        await fs.promises.mkdir(pathx.posix(path.dirname(fullPath)), { recursive: true });
+        await fs.promises.writeFile(fullPath, content);
+      }
+    }
+
+    return sourcePath;
+  }
+
+  it("files에 포함된 디렉토리가 복사되고, files에 없는 파일은 복사되지 않는다", async () => {
+    const sourcePath = await createSourcePkg({ files: ["dist", "src"] });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // files에 포함된 디렉토리가 복사됨
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "dist", "index.js")))).toBe(true);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "src", "index.ts")))).toBe(true);
+
+    // files에 없는 파일은 복사되지 않음
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "tsconfig.json")))).toBe(false);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "CLAUDE.md")))).toBe(false);
+  });
+
+  it("npm 기본 포함 파일(README, LICENSE)은 files에 없어도 복사된다", async () => {
+    const sourcePath = await createSourcePkg({
+      files: ["dist", "src"],
+      extraFiles: {
+        "README.md": "# README",
+        "LICENSE": "MIT License",
+      },
+    });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "README.md")))).toBe(true);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "LICENSE")))).toBe(true);
+  });
+
+  it("package.json은 복사되지 않고 대상의 기존 package.json이 보존된다", async () => {
+    const sourcePath = await createSourcePkg({ files: ["dist", "src"] });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // 대상의 기존 package.json이 보존됨 (소스의 것으로 덮어씌워지지 않음)
+    const targetPkgJson = JSON.parse(
+      fs.readFileSync(pathx.posix(path.join(targetPkgDir, "package.json")), "utf-8"),
+    );
+    expect(targetPkgJson.version).toBe("2.0.0");
+  });
+
+  it("files 필드가 없는 패키지는 건너뛰고 복사하지 않는다", async () => {
+    const sourcePath = await createSourcePkg({ files: undefined });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // 복사가 수행되지 않음
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "dist")))).toBe(false);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "src")))).toBe(false);
+  });
+});

package/tests/electron/electron.spec.ts

@@ -70,7 +70,10 @@ vi.mock("esbuild", () => ({
 const mockLoggerDebug = vi.fn();
 const mockLoggerWarn = vi.fn();
 const mockLoggerInfo = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: mockLoggerDebug, warn: mockLoggerWarn, info: mockLoggerInfo } as any);
+const mockLoggerStart = vi.fn();
+const mockLoggerSuccess = vi.fn();
+const mockLoggerError = vi.fn();
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: mockLoggerDebug, warn: mockLoggerWarn, info: mockLoggerInfo, start: mockLoggerStart, success: mockLoggerSuccess, error: mockLoggerError } as any);
 
 //#endregion