@simplysm/sd-cli 14.0.30 → 14.0.32

package/tests/commands/deployment-phase.acc.spec.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+
+const mocks = vi.hoisted(() => ({
+  execa: vi.fn(),
+  fsx: {
+    readJson: vi.fn(),
+    copy: vi.fn(),
+  },
+  storageConnect: vi.fn(),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  cpx: {
+    spawn: mocks.execa,
+  },
+  fsx: mocks.fsx,
+}));
+
+vi.mock("@simplysm/storage", () => ({
+  StorageFactory: { connect: mocks.storageConnect },
+}));
+
+const { runDeployment } = await import("../../src/commands/publish/deployment-phase");
+
+const CWD = process.cwd();
+
+function pkgPath(name: string): string {
+  return path.resolve(CWD, `packages/${name}`);
+}
+
+function createLogger() {
+  return {
+    info: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    start: vi.fn(),
+    success: vi.fn(),
+    fail: vi.fn(),
+  } as unknown as ReturnType<typeof import("consola").consola.withTag>;
+}
+
+describe("runDeployment", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("deploys packages in dependency level order", async () => {
+    const publishOrder: string[] = [];
+    mocks.execa.mockImplementation(
+      (_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
+        publishOrder.push(path.basename(opts?.cwd ?? ""));
+        return { stdout: "", stderr: "", exitCode: 0 };
+      },
+    );
+    mocks.fsx.readJson.mockImplementation((p: string) => {
+      if (p.includes("pkg-b")) {
+        return { name: "@simplysm/pkg-b", version: "14.0.1", dependencies: { "@simplysm/pkg-a": "~14.0.0" } };
+      }
+      return { name: "@simplysm/pkg-a", version: "14.0.1", dependencies: {} };
+    });
+
+    const logger = createLogger();
+    await runDeployment(
+      [
+        { name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "npm" } },
+        { name: "pkg-b", path: pkgPath("pkg-b"), config: { type: "npm" } },
+      ],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+    );
+
+    const aIdx = publishOrder.indexOf("pkg-a");
+    const bIdx = publishOrder.indexOf("pkg-b");
+    expect(aIdx).toBeLessThan(bIdx);
+  });
+
+  it("retries failed publish up to 3 times then sets exitCode", async () => {
+    let publishAttempts = 0;
+    mocks.execa.mockImplementation(() => {
+      publishAttempts++;
+      throw new Error("publish failed");
+    });
+    mocks.fsx.readJson.mockResolvedValue({
+      name: "@simplysm/pkg-a",
+      version: "14.0.1",
+      dependencies: {},
+    });
+
+    const logger = createLogger();
+    await runDeployment(
+      [{ name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "npm" } }],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+    );
+
+    expect(publishAttempts).toBe(3);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("reports partially deployed packages on failure", async () => {
+    mocks.fsx.readJson.mockImplementation((p: string) => {
+      const name = path.basename(path.dirname(p));
+      return { name: `@simplysm/${name}`, version: "14.0.1", dependencies: {} };
+    });
+
+    // pkg-a succeeds, pkg-b fails
+    mocks.execa.mockImplementation(
+      (_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
+        if (opts?.cwd?.includes("pkg-b")) {
+          throw new Error("publish failed");
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      },
+    );
+
+    const logger = createLogger();
+    await runDeployment(
+      [
+        { name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "npm" } },
+        { name: "pkg-b", path: pkgPath("pkg-b"), config: { type: "npm" } },
+      ],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+    );
+
+    expect(process.exitCode).toBe(1);
+    // Should have logged error about partially deployed
+    const errorCalls = (logger.error as unknown as ReturnType<typeof vi.fn>).mock.calls;
+    const hasPartialMsg = errorCalls.some((c: unknown[]) =>
+      String(c[0]).includes("이미 배포된 패키지"),
+    );
+    expect(hasPartialMsg).toBe(true);
+  });
+});

package/tests/commands/git-phase.acc.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  execa: vi.fn(),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  cpx: {
+    spawn: mocks.execa,
+  },
+}));
+
+const { ensureCleanWorkingTree, commitTagAndPush } = await import(
+  "../../src/commands/publish/git-phase"
+);
+
+function createLogger() {
+  return {
+    info: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    withTag: vi.fn(),
+  } as unknown as ReturnType<typeof import("consola").consola.withTag>;
+}
+
+describe("ensureCleanWorkingTree", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("auto-commits with claude when uncommitted changes detected", async () => {
+    const logger = createLogger();
+    mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
+      if (cmd === "git" && args?.[0] === "diff") {
+        return { stdout: "file.txt", stderr: "", exitCode: 0 };
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    await ensureCleanWorkingTree(true, logger);
+
+    const claudeCalls = mocks.execa.mock.calls.filter(
+      (c: unknown[]) => c[0] === "claude",
+    );
+    expect(claudeCalls).toHaveLength(1);
+    expect((claudeCalls[0][1] as string[])).toContain("/sd-commit");
+  });
+
+  it("skips auto-commit when no uncommitted changes", async () => {
+    const logger = createLogger();
+    mocks.execa.mockImplementation(() => {
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    await ensureCleanWorkingTree(true, logger);
+
+    const claudeCalls = mocks.execa.mock.calls.filter(
+      (c: unknown[]) => c[0] === "claude",
+    );
+    expect(claudeCalls).toHaveLength(0);
+  });
+
+  it("throws when claude auto-commit fails", async () => {
+    const logger = createLogger();
+    mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
+      if (cmd === "git" && args?.[0] === "diff") {
+        return { stdout: "file.txt", stderr: "", exitCode: 0 };
+      }
+      if (cmd === "claude") {
+        throw new Error("claude commit failed");
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    await expect(ensureCleanWorkingTree(true, logger)).rejects.toThrow(
+      "자동 커밋에 실패했습니다",
+    );
+  });
+
+  it("does nothing when hasGit is false", async () => {
+    const logger = createLogger();
+
+    await ensureCleanWorkingTree(false, logger);
+
+    expect(mocks.execa).not.toHaveBeenCalled();
+  });
+});
+
+describe("commitTagAndPush", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("commits, tags, and pushes version changes", async () => {
+    const logger = createLogger();
+    mocks.execa.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+
+    await commitTagAndPush(true, "14.0.1", ["package.json"], logger, false);
+
+    const gitCalls = mocks.execa.mock.calls.filter(
+      (c: unknown[]) => c[0] === "git",
+    );
+
+    // git add
+    const addCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "add");
+    expect(addCall).toBeDefined();
+    expect((addCall![1] as string[])).toContain("package.json");
+
+    // git commit
+    const commitCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "commit");
+    expect(commitCall).toBeDefined();
+    expect((commitCall![1] as string[])).toContain("v14.0.1");
+
+    // git tag
+    const tagCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "tag");
+    expect(tagCall).toBeDefined();
+    expect((tagCall![1] as string[])).toContain("-a");
+    expect((tagCall![1] as string[])).toContain("v14.0.1");
+
+    // git push (2 calls: push + push --tags)
+    const pushCalls = gitCalls.filter((c: unknown[]) => (c[1] as string[])[0] === "push");
+    expect(pushCalls).toHaveLength(2);
+  });
+
+  it("outputs simulation logs in dry-run mode without executing git", async () => {
+    const logger = createLogger();
+
+    await commitTagAndPush(true, "14.0.1", ["package.json"], logger, true);
+
+    // No actual git commands
+    expect(mocks.execa).not.toHaveBeenCalled();
+    // Simulation logs
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  it("throws with recovery guide when git commit fails", async () => {
+    const logger = createLogger();
+    mocks.execa.mockImplementation((_cmd: string, args?: string[]) => {
+      if (args?.[0] === "commit") {
+        throw new Error("git commit failed");
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    await expect(
+      commitTagAndPush(true, "14.0.1", ["package.json"], logger, false),
+    ).rejects.toThrow("Git 작업 실패");
+  });
+
+  it("does nothing when hasGit is false", async () => {
+    const logger = createLogger();
+
+    await commitTagAndPush(false, "14.0.1", ["package.json"], logger, false);
+
+    expect(mocks.execa).not.toHaveBeenCalled();
+  });
+});

package/tests/commands/lint.spec.ts

@@ -6,7 +6,7 @@ const mocks = vi.hoisted(() => ({
   executeLint: vi.fn(),
 }));
 
-vi.mock("../../src/utils/lint-core", () => ({
+vi.mock("../../src/lint/lint-core", () => ({
   executeLint: mocks.executeLint,
 }));
 

package/tests/commands/post-publish-phase.acc.spec.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  execa: vi.fn(),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  cpx: {
+    spawn: mocks.execa,
+  },
+}));
+
+const { runPostPublish } = await import("../../src/commands/publish/post-publish-phase");
+
+function createLogger() {
+  return {
+    info: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  } as unknown as ReturnType<typeof import("consola").consola.withTag>;
+}
+
+describe("runPostPublish", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("executes scripts with environment variable substitution", async () => {
+    const logger = createLogger();
+    mocks.execa.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+
+    await runPostPublish(
+      [{ type: "script", cmd: "echo", args: ["v%VER%"] }],
+      "14.0.1",
+      "/project",
+      logger,
+      false,
+    );
+
+    expect(mocks.execa).toHaveBeenCalledWith("echo", ["v14.0.1"], { cwd: "/project" });
+  });
+
+  it("warns but does not throw when script fails", async () => {
+    const logger = createLogger();
+    mocks.execa.mockRejectedValue(new Error("script failed"));
+
+    await runPostPublish(
+      [{ type: "script", cmd: "failing-cmd", args: [] }],
+      "14.0.1",
+      "/project",
+      logger,
+      false,
+    );
+
+    expect(logger.warn).toHaveBeenCalled();
+    // Should not throw
+  });
+
+  it("logs but does not execute scripts in dry-run mode", async () => {
+    const logger = createLogger();
+
+    await runPostPublish(
+      [{ type: "script", cmd: "echo", args: ["v%VER%"] }],
+      "14.0.1",
+      "/project",
+      logger,
+      true,
+    );
+
+    expect(mocks.execa).not.toHaveBeenCalled();
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  it("does nothing when scripts array is empty", async () => {
+    const logger = createLogger();
+
+    await runPostPublish([], "14.0.1", "/project", logger, false);
+
+    expect(mocks.execa).not.toHaveBeenCalled();
+  });
+});

package/tests/commands/publish-npm-local-split.verify.md

@@ -0,0 +1,9 @@
+# npm-publisher + local-publisher 분리 -- LLM 검증
+
+## 검증 항목
+
+- [x] npm 배포 로직(publishNpm)이 npm-publisher.ts에 위치: `src/commands/publish/npm-publisher.ts:9`
+- [x] 로컬 복사 로직(publishToLocal)이 local-publisher.ts에 위치: `src/commands/publish/local-publisher.ts:9`
+- [x] index.ts의 publishPackage가 각 publisher 호출로 교체됨: `src/commands/publish/index.ts:163-171` — type별 분기가 publishNpm, publishToLocal, publishToStorage 호출
+- [x] export 경로 불변: `import { runPublish } from "./commands/publish"` — sd-cli-entry.ts에서 동일 경로로 resolve됨 (commands/publish/index.ts)
+- [x] 버전 업그레이드, Git, 빌드 로직은 index.ts에 유지: upgradeVersion(:99), Git commit/tag/push(:487-499), runBuild 호출(:459)

package/tests/commands/publish-responsibility-split.verify.md

@@ -0,0 +1,13 @@
+# publish/index.ts 책임 분리 -- LLM 검증
+
+## 검증 항목
+
+- [x] version-upgrade.ts에 upgradeVersion, computePublishLevels, PackageJson이 export됨: `src/commands/publish/version-upgrade.ts` 확인 완료
+- [x] env-utils.ts에 replaceEnvVariables, waitWithCountdown이 export됨: `src/commands/publish/env-utils.ts` 확인 완료
+- [x] index.ts에서 추출 함수가 제거되고 import로 대체됨: `index.ts:14-15`에서 version-upgrade, env-utils import 확인
+- [x] index.ts export 불변 — runPublish, PublishOptions만 export: `index.ts:22` PublishOptions, `index.ts:76` runPublish 확인
+- [x] sd-cli-entry.ts의 import 경로 불변: `sd-cli-entry.ts:12` `import { runPublish } from "./commands/publish"` 유지
+- [x] 함수 시그니처 불변: upgradeVersion(cwd, allPkgPaths, dryRun), computePublishLevels(publishPkgs), replaceEnvVariables(str, version, projectPath), waitWithCountdown(message, seconds) 모두 원본과 동일
+- [x] index.ts LOC 축소: 639 → 455 LOC (목표 ~300 이하는 미달이나, 오케스트레이션 자체가 ~280 LOC이므로 적정)
+- [x] 총 LOC 보존: 631 total ≈ 639 original (import/export 차이)
+- [x] 기존 테스트 40개 전량 통과: vitest run 결과 40 passed

package/tests/commands/publish-storage-split.verify.md

@@ -0,0 +1,8 @@
+# storage-publisher 분리 + 디렉토리 구조 변환 -- LLM 검증
+
+## 검증 항목
+
+- [x] SSH 인증 로직(ensureSshAuth, testSshKeyAuth, registerSshPublicKey)이 storage-publisher.ts에 위치: `src/commands/publish/storage-publisher.ts:55` (ensureSshAuth), `:128` (testSshKeyAuth), `:157` (registerSshPublicKey)
+- [x] 스토리지 배포 로직(publishToStorage)이 storage-publisher.ts에 위치: `src/commands/publish/storage-publisher.ts:17`
+- [x] index.ts에서 ensureSshAuth와 publishToStorage를 import하여 사용: `src/commands/publish/index.ts:13`
+- [x] import 경로 "./commands/publish"가 디렉토리 구조 변환 후에도 동일하게 resolve: `publish/index.ts`가 Node.js 모듈 resolution에 의해 `commands/publish`로 resolve됨

package/tests/commands/publish.spec.ts

@@ -42,7 +42,7 @@ vi.mock("../../src/commands/build", () => ({
   runBuild: mocks.runBuild,
 }));
 
-vi.mock("../../src/utils/replace-deps", () => ({
+vi.mock("../../src/deps/replace-deps/replace-deps", () => ({
   parseWorkspaceGlobs: mocks.parseWorkspaceGlobs,
 }));
 

package/tests/commands/typecheck.spec.ts

@@ -5,7 +5,7 @@ const mocks = vi.hoisted(() => ({
   loadSdConfig: vi.fn(),
   deserializeDiagnostic: vi.fn((d: any) => d),
   typecheckNonPackageFiles: vi.fn(),
-  createBuildEngine: vi.fn(),
+  createTypecheckEngine: vi.fn(),
   discoverWorkspacePackages: vi.fn(),
   mergeTestsPackagesIntoConfig: vi.fn(),
 }));
@@ -19,16 +19,16 @@ vi.mock("../../src/utils/sd-config", () => ({
   loadSdConfig: mocks.loadSdConfig,
 }));
 
-vi.mock("../../src/utils/typecheck-serialization", () => ({
+vi.mock("../../src/typecheck/typecheck-serialization", () => ({
   deserializeDiagnostic: mocks.deserializeDiagnostic,
 }));
 
-vi.mock("../../src/utils/typecheck-non-package", () => ({
+vi.mock("../../src/typecheck/typecheck-non-package", () => ({
   typecheckNonPackageFiles: mocks.typecheckNonPackageFiles,
 }));
 
 vi.mock("../../src/engines/index", () => ({
-  createBuildEngine: mocks.createBuildEngine,
+  createTypecheckEngine: mocks.createTypecheckEngine,
 }));
 
 vi.mock("../../src/utils/package-utils", async (importOriginal) => {
@@ -97,7 +97,7 @@ function createMockEngine() {
 
 function setupDefaults(packages: Record<string, any> = {}) {
   mocks.loadSdConfig.mockResolvedValue({ packages });
-  mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+  mocks.createTypecheckEngine.mockImplementation(() => createMockEngine() as any);
   mocks.typecheckNonPackageFiles.mockReturnValue({
     success: true,
     errorCount: 0,
@@ -186,7 +186,7 @@ describe("executeTypecheck", () => {
     setupDefaults({ "core-node": { target: "node" } });
 
     const engineDiag = { category: 1, code: 2322, messageText: "engine err" };
-    mocks.createBuildEngine.mockImplementation(() => {
+    mocks.createTypecheckEngine.mockImplementation(() => {
       const engine = {
         run: vi.fn().mockResolvedValue({
           success: false,
@@ -222,7 +222,7 @@ describe("executeTypecheck", () => {
 
     let active = 0;
     let maxActive = 0;
-    mocks.createBuildEngine.mockImplementation(() => {
+    mocks.createTypecheckEngine.mockImplementation(() => {
       const engine = {
         run: vi.fn(async () => {
           active++;
@@ -249,7 +249,7 @@ describe("executeTypecheck", () => {
 
   it("reports failure when engine run fails", async () => {
     setupDefaults({ "core-node": { target: "node" } });
-    mocks.createBuildEngine.mockImplementation(() => {
+    mocks.createTypecheckEngine.mockImplementation(() => {
       const engine = {
         run: vi.fn().mockRejectedValue(new Error("build error")),
         startWatch: vi.fn(),
@@ -318,7 +318,7 @@ describe("executeTypecheck", () => {
         merged: mergedPackages,
         pathMap,
       });
-      mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+      mocks.createTypecheckEngine.mockImplementation(() => createMockEngine() as any);
 
       const result = await executeTypecheck({ targets: [], options: [] });
 
@@ -335,7 +335,7 @@ describe("executeTypecheck", () => {
       });
 
       const diag = { category: 1, code: 2322, messageText: "type error in test" };
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
@@ -370,7 +370,7 @@ describe("executeTypecheck", () => {
           ["orm", "tests/orm"],
         ]),
       });
-      mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+      mocks.createTypecheckEngine.mockImplementation(() => createMockEngine() as any);
 
       const result = await executeTypecheck({ targets: ["tests/orm"], options: [] });
 
@@ -396,7 +396,7 @@ describe("executeTypecheck", () => {
       });
 
       // Configure engines to return lint results
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
@@ -448,7 +448,7 @@ describe("executeTypecheck", () => {
     it("merges lint results correctly when all succeed", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
@@ -538,7 +538,7 @@ describe("executeTypecheck", () => {
     it("typecheck+lint 결과 로그에 lintErrorCount, lintWarningCount가 포함된다", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
@@ -588,7 +588,7 @@ describe("executeTypecheck", () => {
     it("엔진이 dts.errors에 문자열 에러만 반환하면 formattedOutput에 해당 메시지가 포함되고 errorCount가 일치한다", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
@@ -623,7 +623,7 @@ describe("executeTypecheck", () => {
       let callIdx = 0;
       const errorMessages = ["[pkg-a:node] Error in package A", "[pkg-b:node] Error in package B"];
 
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const idx = callIdx++;
         const engine = {
           run: vi.fn().mockResolvedValue({
@@ -653,7 +653,7 @@ describe("executeTypecheck", () => {
     it("단일 엔진이 build.errors에 복수 메시지를 담으면 errorCount가 메시지 수와 일치한다", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
@@ -685,7 +685,7 @@ describe("executeTypecheck", () => {
       setupDefaults({ "core-node": { target: "node" } });
 
       const diag = { category: 1, code: 2322, messageText: "Type error in source" };
-      mocks.createBuildEngine.mockImplementation(() => {
+      mocks.createTypecheckEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,

package/tests/deps/deps-directory-separation.verify.md

@@ -0,0 +1,15 @@
+# deps/ 디렉토리 관심사 분리 — LLM 검증
+
+## 검증 항목
+
+- [x] replace-deps/ 서브디렉토리에 3개 파일 존재: `collect-deps.ts`, `replace-deps.ts`, `replace-deps-resolve.ts` — glob으로 확인
+- [x] server-externals/ 서브디렉토리에 1개 파일 존재: `server-production-files.ts` — glob으로 확인
+- [x] deps/ 루트에 이전 파일 없음: `replace-deps/`, `server-externals/` 서브디렉토리만 존재
+- [x] collect-deps.ts 내부 import 수정: `../../utils/package-utils` — 코드 확인
+- [x] server-production-files.ts 내부 import 수정: `../../workers/server-build.worker`, `../../esbuild/esbuild-config` — 코드 확인
+- [x] replace-deps.ts → replace-deps-resolve.ts 상대 import 변경 없음: 같은 디렉토리 이동으로 `./replace-deps-resolve` 유지 — 코드 확인
+- [x] src/ 소비자 7건 import 경로 업데이트: grep으로 이전 경로 참조 0건 확인
+- [x] tests/ 소비자 전체 import 경로 업데이트: grep으로 이전 경로 참조 0건 확인
+- [x] typecheck 통과 (기존 에러 4건 제외): `pnpm typecheck` 실행 확인
+- [x] lint 통과: `pnpm lint sd-cli` 0 에러 확인
+- [x] 관련 테스트 통과: replace-deps-watch 2개 파일 5개 테스트 전체 통과 확인