@simplysm/sd-cli 14.0.53 → 14.0.55

package/tests/commands/check.spec.ts

@@ -264,6 +264,27 @@ describe("runCheck", () => {
       expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
       expect(process.exitCode).toBeUndefined();
     });
+
+    it("runs scripts lint when typecheck has no engine lint result", async () => {
+      mocks.executeTypecheck.mockResolvedValue({
+        success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+        scriptsPackagePaths: ["packages/sd-codex"],
+      });
+      mocks.runLintInWorker.mockResolvedValue({
+        success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+      });
+
+      await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
+
+      expect(mocks.runLintInWorker).toHaveBeenCalledWith({
+        targets: ["packages/sd-codex"],
+        fix: false,
+        timing: false,
+      });
+      const successArgs = collectArgs(mockLogger.success);
+      expect(successArgs.some((a) => a.includes("LINT"))).toBe(true);
+      expect(process.exitCode).toBeUndefined();
+    });
   });
 
   describe("lint-only path", () => {

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

@@ -29,7 +29,7 @@ describe("ensureCleanWorkingTree", () => {
     vi.clearAllMocks();
   });
 
-  it("auto-commits with claude when uncommitted changes detected", async () => {
+  it("auto-commits with codex when uncommitted changes detected", async () => {
     const logger = createLogger();
     mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
       if (cmd === "git" && args?.[0] === "diff") {
@@ -40,11 +40,14 @@ describe("ensureCleanWorkingTree", () => {
 
     await ensureCleanWorkingTree(true, logger);
 
-    const claudeCalls = mocks.execa.mock.calls.filter(
-      (c: unknown[]) => c[0] === "claude",
+    const codexCalls = mocks.execa.mock.calls.filter(
+      (c: unknown[]) => c[0] === "codex",
     );
-    expect(claudeCalls).toHaveLength(1);
-    expect((claudeCalls[0][1] as string[])).toContain("/sd-commit");
+    expect(codexCalls).toHaveLength(1);
+    expect((codexCalls[0][1] as string[])).toContain("exec");
+    expect((codexCalls[0][1] as string[])).toContain("gpt-5.3-codex-spark");
+    expect((codexCalls[0][1] as string[])).toContain('model_reasoning_effort="low"');
+    expect((codexCalls[0][1] as string[])).toContain("$sd-commit");
   });
 
   it("skips auto-commit when no uncommitted changes", async () => {
@@ -55,20 +58,20 @@ describe("ensureCleanWorkingTree", () => {
 
     await ensureCleanWorkingTree(true, logger);
 
-    const claudeCalls = mocks.execa.mock.calls.filter(
-      (c: unknown[]) => c[0] === "claude",
+    const codexCalls = mocks.execa.mock.calls.filter(
+      (c: unknown[]) => c[0] === "codex",
     );
-    expect(claudeCalls).toHaveLength(0);
+    expect(codexCalls).toHaveLength(0);
   });
 
-  it("throws when claude auto-commit fails", async () => {
+  it("throws when codex 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");
+      if (cmd === "codex") {
+        throw new Error("codex commit failed");
       }
       return { stdout: "", stderr: "", exitCode: 0 };
     });

package/tests/commands/publish.spec.ts

@@ -256,6 +256,7 @@ describe("runPublish", () => {
         (c: unknown[]) => c[0] === "pnpm" && (c[1] as string[] | undefined)?.[0] === "publish",
       );
       expect(call?.[2]).toHaveProperty("cwd", pkgPath("pkg-a"));
+      expect(call?.[2]).toHaveProperty("shell", true);
     });
 
     it("publishes all packages with publish config when targets empty", async () => {
@@ -334,6 +335,11 @@ describe("runPublish", () => {
 
       expect(process.exitCode).toBeUndefined();
       expect(getExecaCalls("npm", "whoami")).toHaveLength(1);
+      expect(mocks.execa).toHaveBeenCalledWith(
+        "npm",
+        ["whoami"],
+        expect.objectContaining({ shell: true }),
+      );
     });
 
     it("aborts when npm whoami fails", async () => {
@@ -379,7 +385,7 @@ describe("runPublish", () => {
       expect(getExecaCalls("npm", "whoami")).toHaveLength(0);
     });
 
-    it("auto-commits with claude when uncommitted changes detected", async () => {
+    it("auto-commits with codex when uncommitted changes detected", async () => {
       setupHappyPath();
       mocks.execa.mockImplementation(
         (cmd: string, args?: string[], _opts?: unknown) => {
@@ -398,23 +404,26 @@ describe("runPublish", () => {
         options: [],
       });
 
-      // claude CLI should have been called for auto-commit
-      const claudeCalls = mocks.execa.mock.calls.filter(
-        (c: unknown[]) => c[0] === "claude",
+      // codex CLI should have been called for auto-commit
+      const codexCalls = mocks.execa.mock.calls.filter(
+        (c: unknown[]) => c[0] === "codex",
       );
-      expect(claudeCalls).toHaveLength(1);
-      expect((claudeCalls[0][1] as string[])).toContain("/sd-commit");
+      expect(codexCalls).toHaveLength(1);
+      expect((codexCalls[0][1] as string[])).toContain("exec");
+      expect((codexCalls[0][1] as string[])).toContain("gpt-5.3-codex-spark");
+      expect((codexCalls[0][1] as string[])).toContain('model_reasoning_effort="low"');
+      expect((codexCalls[0][1] as string[])).toContain("$sd-commit");
     });
 
-    it("aborts when auto-commit claude command fails", async () => {
+    it("aborts when auto-commit codex command fails", async () => {
       setupHappyPath();
       mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
         if (cmd === "npm") return { stdout: "testuser", stderr: "", exitCode: 0 };
         if (cmd === "git" && args?.[0] === "diff") {
           return { stdout: "file.txt", stderr: "", exitCode: 0 };
         }
-        if (cmd === "claude") {
-          throw new Error("claude commit failed");
+        if (cmd === "codex") {
+          throw new Error("codex commit failed");
         }
         return { stdout: "", stderr: "", exitCode: 0 };
       });
@@ -439,11 +448,11 @@ describe("runPublish", () => {
         options: [],
       });
 
-      // No claude CLI calls
-      const claudeCalls = mocks.execa.mock.calls.filter(
-        (c: unknown[]) => c[0] === "claude",
+      // No codex CLI calls
+      const codexCalls = mocks.execa.mock.calls.filter(
+        (c: unknown[]) => c[0] === "codex",
       );
-      expect(claudeCalls).toHaveLength(0);
+      expect(codexCalls).toHaveLength(0);
     });
   });
 

package/tests/electron/electron.spec.ts

@@ -182,9 +182,11 @@ describe("Electron", () => {
       expect(findElectronPackageJson()).toBeDefined();
 
       const spawnCalls = mockCpxSpawn.mock.calls;
-      expect(
-        spawnCalls.find((c) => c[0] === "pnpm" && (c[1] as string[]).includes("install")),
-      ).toBeDefined();
+      const installCall = spawnCalls.find(
+        (c) => c[0] === "pnpm" && (c[1] as string[]).includes("install"),
+      );
+      expect(installCall).toBeDefined();
+      expect(installCall?.[2]).toEqual(expect.objectContaining({ shell: true }));
       expect(
         spawnCalls.find(
           (c) => c[0] === "pnpm" && (c[1] as string[]).includes("electron-rebuild"),
@@ -520,6 +522,10 @@ describe("Electron", () => {
       expect(callArgs.format).toBe("esm");
       expect(callArgs.bundle).toBe(true);
       expect(callArgs.external).toContain("electron");
+      const electronCall = mockCpxSpawn.mock.calls.find(
+        (c) => c[0] === "pnpm" && (c[1] as string[]).includes("electron"),
+      );
+      expect(electronCall?.[2]).toEqual(expect.objectContaining({ shell: true, reject: false }));
 
       // ESM 배너에 createRequire shim 포함
       expect(banner).toContain("createRequire");