code-squad-cli 1.2.4 → 1.2.5

package/dist/adapters/GitAdapter.d.ts

@@ -9,5 +9,18 @@ export declare class GitAdapter implements PartialGitPort {
     deleteBranch(branchName: string, workspaceRoot: string, force?: boolean): Promise<void>;
     isValidWorktree(path: string, workspaceRoot: string): Promise<boolean>;
     getWorktreeBranch(worktreePath: string): Promise<string>;
+    /**
+     * 현재 디렉토리가 워크트리인지 확인하고 컨텍스트 반환
+     */
+    getWorktreeContext(cwd: string): Promise<{
+        isWorktree: boolean;
+        mainRoot: string | null;
+        currentPath: string;
+        branch: string | null;
+    }>;
+    /**
+     * staged 또는 unstaged 변경사항이 있는지 확인 (untracked 제외)
+     */
+    hasDirtyState(workspacePath: string): Promise<boolean>;
 }
 export {};

package/dist/adapters/GitAdapter.js

@@ -1,102 +1,84 @@
-import { exec } from 'child_process';
+import { exec as execCallback } from 'child_process';
+import { promisify } from 'util';
 import * as fs from 'fs';
+const exec = promisify(execCallback);
+const execOptions = { maxBuffer: 1024 * 1024 };
 export class GitAdapter {
     async isGitRepository(workspaceRoot) {
-        return new Promise((resolve) => {
-            exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-                resolve(!error);
-            });
-        });
+        try {
+            await exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, execOptions);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     async getCurrentBranch(workspaceRoot) {
-        return new Promise((resolve, reject) => {
-            exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve(stdout.trim());
-            });
-        });
+        const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+        return stdout.trim();
     }
     async listWorktrees(workspaceRoot) {
-        return new Promise((resolve) => {
-            exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    resolve([]);
-                    return;
+        try {
+            const { stdout } = await exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, execOptions);
+            const worktrees = [];
+            const lines = stdout.split('\n').filter((line) => line.trim());
+            // Parse porcelain format: groups of 3 lines
+            // worktree /path
+            // HEAD sha
+            // branch refs/heads/name
+            let i = 0;
+            while (i < lines.length) {
+                const worktreeLine = lines[i];
+                const headLine = lines[i + 1];
+                const branchLine = lines[i + 2];
+                if (!worktreeLine || !headLine) {
+                    i++;
+                    continue;
                 }
-                const worktrees = [];
-                const lines = stdout.split('\n').filter((line) => line.trim());
-                // Parse porcelain format: groups of 3 lines
-                // worktree /path
-                // HEAD sha
-                // branch refs/heads/name
-                let i = 0;
-                while (i < lines.length) {
-                    const worktreeLine = lines[i];
-                    const headLine = lines[i + 1];
-                    const branchLine = lines[i + 2];
-                    if (!worktreeLine || !headLine) {
-                        i++;
-                        continue;
-                    }
-                    const pathMatch = worktreeLine.match(/^worktree (.+)$/);
-                    const headMatch = headLine.match(/^HEAD (.+)$/);
-                    const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
-                    if (pathMatch && headMatch) {
-                        const path = pathMatch[1];
-                        const head = headMatch[1];
-                        const branch = branchMatch ? branchMatch[1] : 'HEAD';
-                        // Skip main repository root (first entry)
-                        if (path !== workspaceRoot) {
-                            worktrees.push({ path, branch, head });
-                        }
+                const pathMatch = worktreeLine.match(/^worktree (.+)$/);
+                const headMatch = headLine.match(/^HEAD (.+)$/);
+                const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
+                if (pathMatch && headMatch) {
+                    const path = pathMatch[1];
+                    const head = headMatch[1];
+                    const branch = branchMatch ? branchMatch[1] : 'HEAD';
+                    // Skip main repository root (first entry)
+                    if (path !== workspaceRoot) {
+                        worktrees.push({ path, branch, head });
                     }
-                    // Move to next worktree entry
-                    i += 3;
                 }
-                resolve(worktrees);
-            });
-        });
+                // Move to next worktree entry
+                i += 3;
+            }
+            return worktrees;
+        }
+        catch {
+            return [];
+        }
     }
     async createWorktree(worktreePath, branch, workspaceRoot) {
-        return new Promise((resolve, reject) => {
-            // Extract parent directory and create it if needed
-            const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf('/'));
-            const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : '';
-            exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add "${worktreePath}" -b "${branch}"`, { maxBuffer: 1024 * 1024 }, (error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
+        // Extract parent directory and create it if needed
+        const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf('/'));
+        const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : '';
+        await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add "${worktreePath}" -b "${branch}"`, execOptions);
     }
     async removeWorktree(worktreePath, workspaceRoot, force = false) {
-        return new Promise((resolve, reject) => {
-            const forceFlag = force ? ' --force' : '';
-            exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, { maxBuffer: 1024 * 1024 }, (error) => {
-                if (error) {
-                    reject(new Error(`Failed to remove worktree: ${error.message}`));
-                    return;
-                }
-                resolve();
-            });
-        });
+        const forceFlag = force ? ' --force' : '';
+        try {
+            await exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, execOptions);
+        }
+        catch (error) {
+            throw new Error(`Failed to remove worktree: ${error.message}`);
+        }
     }
     async deleteBranch(branchName, workspaceRoot, force = false) {
-        return new Promise((resolve, reject) => {
-            const deleteFlag = force ? '-D' : '-d';
-            exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, { maxBuffer: 1024 * 1024 }, (error) => {
-                if (error) {
-                    reject(new Error(`Failed to delete branch: ${error.message}`));
-                    return;
-                }
-                resolve();
-            });
-        });
+        const deleteFlag = force ? '-D' : '-d';
+        try {
+            await exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, execOptions);
+        }
+        catch (error) {
+            throw new Error(`Failed to delete branch: ${error.message}`);
+        }
     }
     async isValidWorktree(path, workspaceRoot) {
         // Step 1: Check if path exists and is accessible
@@ -107,12 +89,10 @@ export class GitAdapter {
             return false;
         }
         // Step 2: Check if path is a valid git repository
-        const isGitRepo = await new Promise((resolve) => {
-            exec(`cd "${path}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-                resolve(!error);
-            });
-        });
-        if (!isGitRepo) {
+        try {
+            await exec(`cd "${path}" && git rev-parse --git-dir`, execOptions);
+        }
+        catch {
             return false;
         }
         // Step 3: Verify path is listed in main repo's worktree list
@@ -120,15 +100,60 @@ export class GitAdapter {
         return worktrees.some((wt) => wt.path === path);
     }
     async getWorktreeBranch(worktreePath) {
-        return new Promise((resolve, reject) => {
-            exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(new Error(`Failed to get branch name: ${error.message}`));
-                    return;
-                }
-                const branch = stdout.trim();
-                resolve(branch);
-            });
-        });
+        try {
+            const { stdout } = await exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`Failed to get branch name: ${error.message}`);
+        }
+    }
+    /**
+     * 현재 디렉토리가 워크트리인지 확인하고 컨텍스트 반환
+     */
+    async getWorktreeContext(cwd) {
+        // git-common-dir로 워크트리 여부 확인
+        let commonDir = null;
+        try {
+            const { stdout } = await exec(`cd "${cwd}" && git rev-parse --git-common-dir`, execOptions);
+            commonDir = stdout.trim();
+        }
+        catch {
+            return { isWorktree: false, mainRoot: null, currentPath: cwd, branch: null };
+        }
+        // .git 이면 메인 레포, 아니면 워크트리
+        const isWorktree = commonDir !== '.git';
+        if (!isWorktree) {
+            return { isWorktree: false, mainRoot: cwd, currentPath: cwd, branch: null };
+        }
+        // 메인 레포 루트 찾기 (worktree list의 첫 번째)
+        let mainRoot = null;
+        try {
+            const { stdout } = await exec(`cd "${cwd}" && git worktree list --porcelain`, execOptions);
+            const match = stdout.match(/^worktree (.+)$/m);
+            mainRoot = match ? match[1] : null;
+        }
+        catch {
+            // ignore
+        }
+        // 현재 브랜치
+        const branch = await this.getWorktreeBranch(cwd).catch(() => null);
+        return { isWorktree, mainRoot, currentPath: cwd, branch };
+    }
+    /**
+     * staged 또는 unstaged 변경사항이 있는지 확인 (untracked 제외)
+     */
+    async hasDirtyState(workspacePath) {
+        try {
+            const { stdout } = await exec(`cd "${workspacePath}" && git status --porcelain`, execOptions);
+            // ?? 로 시작하는 줄(untracked)을 제외한 변경사항이 있는지
+            const lines = stdout.split('\n').filter(line => line.trim());
+            const dirtyLines = lines.filter(line => !line.startsWith('??'));
+            return dirtyLines.length > 0;
+        }
+        catch {
+            // 에러 시 안전하게 dirty로 처리 (데이터 손실 방지)
+            return true;
+        }
     }
 }

package/dist/index.js

@@ -8,98 +8,76 @@ import * as crypto from "crypto";
 import chalk2 from "chalk";
 
 // dist/adapters/GitAdapter.js
-import { exec } from "child_process";
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
 import * as fs from "fs";
+var exec = promisify(execCallback);
+var execOptions = { maxBuffer: 1024 * 1024 };
 var GitAdapter = class {
   async isGitRepository(workspaceRoot) {
-    return new Promise((resolve2) => {
-      exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-        resolve2(!error);
-      });
-    });
+    try {
+      await exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, execOptions);
+      return true;
+    } catch {
+      return false;
+    }
   }
   async getCurrentBranch(workspaceRoot) {
-    return new Promise((resolve2, reject) => {
-      exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve2(stdout.trim());
-      });
-    });
+    const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+    return stdout.trim();
   }
   async listWorktrees(workspaceRoot) {
-    return new Promise((resolve2) => {
-      exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-        if (error) {
-          resolve2([]);
-          return;
+    try {
+      const { stdout } = await exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, execOptions);
+      const worktrees = [];
+      const lines = stdout.split("\n").filter((line) => line.trim());
+      let i = 0;
+      while (i < lines.length) {
+        const worktreeLine = lines[i];
+        const headLine = lines[i + 1];
+        const branchLine = lines[i + 2];
+        if (!worktreeLine || !headLine) {
+          i++;
+          continue;
         }
-        const worktrees = [];
-        const lines = stdout.split("\n").filter((line) => line.trim());
-        let i = 0;
-        while (i < lines.length) {
-          const worktreeLine = lines[i];
-          const headLine = lines[i + 1];
-          const branchLine = lines[i + 2];
-          if (!worktreeLine || !headLine) {
-            i++;
-            continue;
-          }
-          const pathMatch = worktreeLine.match(/^worktree (.+)$/);
-          const headMatch = headLine.match(/^HEAD (.+)$/);
-          const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
-          if (pathMatch && headMatch) {
-            const path11 = pathMatch[1];
-            const head = headMatch[1];
-            const branch = branchMatch ? branchMatch[1] : "HEAD";
-            if (path11 !== workspaceRoot) {
-              worktrees.push({ path: path11, branch, head });
-            }
+        const pathMatch = worktreeLine.match(/^worktree (.+)$/);
+        const headMatch = headLine.match(/^HEAD (.+)$/);
+        const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
+        if (pathMatch && headMatch) {
+          const path11 = pathMatch[1];
+          const head = headMatch[1];
+          const branch = branchMatch ? branchMatch[1] : "HEAD";
+          if (path11 !== workspaceRoot) {
+            worktrees.push({ path: path11, branch, head });
           }
-          i += 3;
         }
-        resolve2(worktrees);
-      });
-    });
+        i += 3;
+      }
+      return worktrees;
+    } catch {
+      return [];
+    }
   }
   async createWorktree(worktreePath, branch, workspaceRoot) {
-    return new Promise((resolve2, reject) => {
-      const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf("/"));
-      const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : "";
-      exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add "${worktreePath}" -b "${branch}"`, { maxBuffer: 1024 * 1024 }, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve2();
-      });
-    });
+    const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf("/"));
+    const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : "";
+    await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add "${worktreePath}" -b "${branch}"`, execOptions);
   }
   async removeWorktree(worktreePath, workspaceRoot, force = false) {
-    return new Promise((resolve2, reject) => {
-      const forceFlag = force ? " --force" : "";
-      exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, { maxBuffer: 1024 * 1024 }, (error) => {
-        if (error) {
-          reject(new Error(`Failed to remove worktree: ${error.message}`));
-          return;
-        }
-        resolve2();
-      });
-    });
+    const forceFlag = force ? " --force" : "";
+    try {
+      await exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, execOptions);
+    } catch (error) {
+      throw new Error(`Failed to remove worktree: ${error.message}`);
+    }
   }
   async deleteBranch(branchName, workspaceRoot, force = false) {
-    return new Promise((resolve2, reject) => {
-      const deleteFlag = force ? "-D" : "-d";
-      exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, { maxBuffer: 1024 * 1024 }, (error) => {
-        if (error) {
-          reject(new Error(`Failed to delete branch: ${error.message}`));
-          return;
-        }
-        resolve2();
-      });
-    });
+    const deleteFlag = force ? "-D" : "-d";
+    try {
+      await exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, execOptions);
+    } catch (error) {
+      throw new Error(`Failed to delete branch: ${error.message}`);
+    }
   }
   async isValidWorktree(path11, workspaceRoot) {
     try {
@@ -107,28 +85,59 @@ var GitAdapter = class {
     } catch {
       return false;
     }
-    const isGitRepo = await new Promise((resolve2) => {
-      exec(`cd "${path11}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-        resolve2(!error);
-      });
-    });
-    if (!isGitRepo) {
+    try {
+      await exec(`cd "${path11}" && git rev-parse --git-dir`, execOptions);
+    } catch {
       return false;
     }
     const worktrees = await this.listWorktrees(workspaceRoot);
     return worktrees.some((wt) => wt.path === path11);
   }
   async getWorktreeBranch(worktreePath) {
-    return new Promise((resolve2, reject) => {
-      exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
-        if (error) {
-          reject(new Error(`Failed to get branch name: ${error.message}`));
-          return;
-        }
-        const branch = stdout.trim();
-        resolve2(branch);
-      });
-    });
+    try {
+      const { stdout } = await exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+      return stdout.trim();
+    } catch (error) {
+      throw new Error(`Failed to get branch name: ${error.message}`);
+    }
+  }
+  /**
+   * 현재 디렉토리가 워크트리인지 확인하고 컨텍스트 반환
+   */
+  async getWorktreeContext(cwd) {
+    let commonDir = null;
+    try {
+      const { stdout } = await exec(`cd "${cwd}" && git rev-parse --git-common-dir`, execOptions);
+      commonDir = stdout.trim();
+    } catch {
+      return { isWorktree: false, mainRoot: null, currentPath: cwd, branch: null };
+    }
+    const isWorktree = commonDir !== ".git";
+    if (!isWorktree) {
+      return { isWorktree: false, mainRoot: cwd, currentPath: cwd, branch: null };
+    }
+    let mainRoot = null;
+    try {
+      const { stdout } = await exec(`cd "${cwd}" && git worktree list --porcelain`, execOptions);
+      const match = stdout.match(/^worktree (.+)$/m);
+      mainRoot = match ? match[1] : null;
+    } catch {
+    }
+    const branch = await this.getWorktreeBranch(cwd).catch(() => null);
+    return { isWorktree, mainRoot, currentPath: cwd, branch };
+  }
+  /**
+   * staged 또는 unstaged 변경사항이 있는지 확인 (untracked 제외)
+   */
+  async hasDirtyState(workspacePath) {
+    try {
+      const { stdout } = await exec(`cd "${workspacePath}" && git status --porcelain`, execOptions);
+      const lines = stdout.split("\n").filter((line) => line.trim());
+      const dirtyLines = lines.filter((line) => !line.startsWith("??"));
+      return dirtyLines.length > 0;
+    } catch {
+      return true;
+    }
   }
 };
 
@@ -401,6 +410,9 @@ async function confirmDeleteLocal(threadName) {
   });
 }
 
+// dist/index.js
+import { confirm as confirm3 } from "@inquirer/prompts";
+
 // dist/flip/server/Server.js
 import express2 from "express";
 import cors from "cors";
@@ -1433,7 +1445,10 @@ async function main() {
       await listThreads(workspaceRoot);
       break;
     case "new":
-      await createWorktree(workspaceRoot, filteredArgs[1]);
+      await createWorktreeCommand(workspaceRoot, filteredArgs.slice(1));
+      break;
+    case "quit":
+      await quitWorktreeCommand();
       break;
     default:
       if (persistentMode) {
@@ -1550,30 +1565,71 @@ async function listThreads(workspaceRoot) {
     console.log(`${typeLabel} ${t.name.padEnd(20)} ${chalk2.dim(t.path)}`);
   }
 }
-async function createWorktree(workspaceRoot, name) {
+function parseNewArgs(args) {
+  let name;
+  let split = false;
+  for (const arg of args) {
+    if (arg === "-s" || arg === "--split") {
+      split = true;
+    } else if (!arg.startsWith("-") && !name) {
+      name = arg;
+    }
+  }
+  return { name, split };
+}
+async function createWorktreeCommand(workspaceRoot, args) {
+  const { name, split } = parseNewArgs(args);
+  if (!name) {
+    console.error(chalk2.red("Error: Name is required"));
+    console.error(chalk2.dim("Usage: csq new <name> [-s|--split]"));
+    process.exit(1);
+  }
   const repoName = path10.basename(workspaceRoot);
   const defaultBasePath = path10.join(path10.dirname(workspaceRoot), `${repoName}.worktree`);
-  let worktreeName;
-  let worktreePath;
-  if (name) {
-    worktreeName = name;
-    worktreePath = path10.join(defaultBasePath, name);
-  } else {
-    const form = await newWorktreeForm(defaultBasePath);
-    if (!form) {
+  const worktreePath = path10.join(defaultBasePath, name);
+  try {
+    await gitAdapter.createWorktree(worktreePath, name, workspaceRoot);
+    console.log(chalk2.green(`\u2713 Created worktree: ${name}`));
+    await copyWorktreeFiles(workspaceRoot, worktreePath);
+    if (split) {
+      await openNewTerminal(worktreePath);
+    } else {
+      console.log(worktreePath);
+    }
+  } catch (error) {
+    console.error(chalk2.red(`Failed to create worktree: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function quitWorktreeCommand() {
+  const cwd = process.cwd();
+  const context = await gitAdapter.getWorktreeContext(cwd);
+  if (!context.isWorktree) {
+    console.error(chalk2.red("Error: Not in a worktree"));
+    process.exit(1);
+  }
+  if (!context.mainRoot || !context.branch) {
+    console.error(chalk2.red("Error: Could not determine worktree context"));
+    process.exit(1);
+  }
+  const isDirty = await gitAdapter.hasDirtyState(cwd);
+  if (isDirty) {
+    const confirmed = await confirm3({
+      message: "Uncommitted changes detected. Delete anyway?",
+      default: false
+    });
+    if (!confirmed) {
       console.log(chalk2.dim("Cancelled."));
-      return;
+      process.exit(0);
     }
-    worktreeName = form.name;
-    worktreePath = form.path;
   }
   try {
-    await gitAdapter.createWorktree(worktreePath, worktreeName, workspaceRoot);
-    console.log(chalk2.green(`\u2713 Created worktree: ${worktreeName}`));
-    await copyWorktreeFiles(workspaceRoot, worktreePath);
-    await writeCdFile(worktreePath);
+    await gitAdapter.removeWorktree(context.currentPath, context.mainRoot, true);
+    await gitAdapter.deleteBranch(context.branch, context.mainRoot, true);
+    console.log(chalk2.green(`\u2713 Deleted worktree and branch: ${context.branch}`));
+    console.log(context.mainRoot);
   } catch (error) {
-    console.error(chalk2.red(`Failed to create worktree: ${error.message}`));
+    console.error(chalk2.red(`Failed to quit: ${error.message}`));
     process.exit(1);
   }
 }
@@ -1591,12 +1647,6 @@ async function copyWorktreeFiles(sourceRoot, destRoot) {
     console.log(chalk2.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
   }
 }
-async function writeCdFile(targetPath) {
-  const cdFile = process.env.CSQ_CD_FILE;
-  if (cdFile) {
-    await fs10.promises.writeFile(cdFile, targetPath);
-  }
-}
 async function cdInCurrentTerminal(targetPath) {
   const { exec: exec2 } = await import("child_process");
   const escapedPath = targetPath.replace(/'/g, "'\\''");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-squad-cli",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "type": "module",
   "bin": {
     "csq": "./dist/index.js"