code-squad-cli 1.1.2 → 1.2.2

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // dist/index.js
-import * as path7 from "path";
-import * as fs7 from "fs";
-import * as os3 from "os";
+import * as path10 from "path";
+import * as fs10 from "fs";
+import * as os4 from "os";
 import * as crypto from "crypto";
 import chalk2 from "chalk";
 
@@ -12,28 +12,28 @@ import { exec } from "child_process";
 import * as fs from "fs";
 var GitAdapter = class {
   async isGitRepository(workspaceRoot) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-        resolve(!error);
+        resolve2(!error);
       });
     });
   }
   async getCurrentBranch(workspaceRoot) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
         if (error) {
           reject(error);
           return;
         }
-        resolve(stdout.trim());
+        resolve2(stdout.trim());
       });
     });
   }
   async listWorktrees(workspaceRoot) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
         if (error) {
-          resolve([]);
+          resolve2([]);
           return;
         }
         const worktrees = [];
@@ -51,21 +51,21 @@ var GitAdapter = class {
           const headMatch = headLine.match(/^HEAD (.+)$/);
           const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
           if (pathMatch && headMatch) {
-            const path8 = pathMatch[1];
+            const path11 = pathMatch[1];
             const head = headMatch[1];
             const branch = branchMatch ? branchMatch[1] : "HEAD";
-            if (path8 !== workspaceRoot) {
-              worktrees.push({ path: path8, branch, head });
+            if (path11 !== workspaceRoot) {
+              worktrees.push({ path: path11, branch, head });
             }
           }
           i += 3;
         }
-        resolve(worktrees);
+        resolve2(worktrees);
       });
     });
   }
   async createWorktree(worktreePath, branch, workspaceRoot) {
-    return new Promise((resolve, reject) => {
+    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) => {
@@ -73,60 +73,60 @@ var GitAdapter = class {
           reject(error);
           return;
         }
-        resolve();
+        resolve2();
       });
     });
   }
   async removeWorktree(worktreePath, workspaceRoot, force = false) {
-    return new Promise((resolve, reject) => {
+    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;
         }
-        resolve();
+        resolve2();
       });
     });
   }
   async deleteBranch(branchName, workspaceRoot, force = false) {
-    return new Promise((resolve, reject) => {
+    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;
         }
-        resolve();
+        resolve2();
       });
     });
   }
-  async isValidWorktree(path8, workspaceRoot) {
+  async isValidWorktree(path11, workspaceRoot) {
     try {
-      await fs.promises.access(path8, fs.constants.R_OK);
+      await fs.promises.access(path11, fs.constants.R_OK);
     } catch {
       return false;
     }
-    const isGitRepo = await new Promise((resolve) => {
-      exec(`cd "${path8}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
-        resolve(!error);
+    const isGitRepo = await new Promise((resolve2) => {
+      exec(`cd "${path11}" && git rev-parse --git-dir`, { maxBuffer: 1024 * 1024 }, (error) => {
+        resolve2(!error);
       });
     });
     if (!isGitRepo) {
       return false;
     }
     const worktrees = await this.listWorktrees(workspaceRoot);
-    return worktrees.some((wt) => wt.path === path8);
+    return worktrees.some((wt) => wt.path === path11);
   }
   async getWorktreeBranch(worktreePath) {
-    return new Promise((resolve, reject) => {
+    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();
-        resolve(branch);
+        resolve2(branch);
       });
     });
   }
@@ -157,12 +157,12 @@ var cancelableInput = createPrompt((config, done) => {
       setValue(value.slice(0, -1));
       setError(null);
     } else if (key.ctrl || key.name === "tab" || key.name === "up" || key.name === "down") {
-    } else if (key.name && key.name.length === 1) {
-      setValue(value + key.name);
-      setError(null);
-    } else if (key.name === "space") {
-      setValue(value + " ");
-      setError(null);
+    } else {
+      const seq = key.sequence;
+      if (seq && seq.length === 1 && seq >= " ") {
+        setValue(value + seq);
+        setError(null);
+      }
     }
   });
   const errorMsg = error ? chalk.red(`
@@ -582,6 +582,8 @@ router2.get("/", (req, res) => {
 // dist/flip/routes/git.js
 import { Router as Router3 } from "express";
 import { execSync } from "child_process";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var router3 = Router3();
 function parseGitStatus(output) {
   const files = [];
@@ -613,6 +615,75 @@ function parseGitStatus(output) {
   }
   return files;
 }
+function parseUnifiedDiff(diffOutput) {
+  const hunks = [];
+  const lines = diffOutput.split("\n");
+  let currentHunk = null;
+  let oldLineNum = 0;
+  let newLineNum = 0;
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldLines: parseInt(hunkMatch[2] || "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newLines: parseInt(hunkMatch[4] || "1", 10),
+        lines: []
+      };
+      oldLineNum = currentHunk.oldStart;
+      newLineNum = currentHunk.newStart;
+      continue;
+    }
+    if (!currentHunk)
+      continue;
+    if (line.startsWith("diff ") || line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("\\")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      currentHunk.lines.push({
+        type: "add",
+        content: line.substring(1),
+        newLineNumber: newLineNum++
+      });
+    } else if (line.startsWith("-")) {
+      currentHunk.lines.push({
+        type: "delete",
+        content: line.substring(1),
+        oldLineNumber: oldLineNum++
+      });
+    } else if (line.startsWith(" ") || line === "") {
+      currentHunk.lines.push({
+        type: "context",
+        content: line.startsWith(" ") ? line.substring(1) : line,
+        oldLineNumber: oldLineNum++,
+        newLineNumber: newLineNum++
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function createAddedFileDiff(content) {
+  const lines = content.split("\n");
+  const diffLines = lines.map((line, idx) => ({
+    type: "add",
+    content: line,
+    newLineNumber: idx + 1
+  }));
+  return [{
+    oldStart: 0,
+    oldLines: 0,
+    newStart: 1,
+    newLines: lines.length,
+    lines: diffLines
+  }];
+}
 router3.get("/status", (req, res) => {
   const state = req.app.locals.state;
   let isGitRepo = false;
@@ -647,6 +718,66 @@ router3.get("/status", (req, res) => {
   };
   res.json(response);
 });
+router3.get("/diff", (req, res) => {
+  const state = req.app.locals.state;
+  const relativePath = req.query.path;
+  if (!relativePath) {
+    res.status(400).json({ error: "Missing path parameter" });
+    return;
+  }
+  const fullPath = path4.join(state.cwd, relativePath);
+  let fileStatus = "modified";
+  try {
+    const statusOutput = execSync(`git status --porcelain -- "${relativePath}"`, {
+      cwd: state.cwd,
+      encoding: "utf-8"
+    });
+    if (statusOutput.startsWith("??")) {
+      fileStatus = "untracked";
+    } else if (statusOutput.includes("A")) {
+      fileStatus = "added";
+    } else if (statusOutput.includes("D")) {
+      fileStatus = "deleted";
+    }
+  } catch {
+  }
+  if (fileStatus === "untracked") {
+    try {
+      const content = fs4.readFileSync(fullPath, "utf-8");
+      const diff = {
+        hunks: createAddedFileDiff(content),
+        status: "untracked"
+      };
+      res.json(diff);
+      return;
+    } catch {
+      res.status(404).json({ error: "File not found" });
+      return;
+    }
+  }
+  try {
+    const diffOutput = execSync(`git diff --no-color -- "${relativePath}"`, {
+      cwd: state.cwd,
+      encoding: "utf-8"
+    });
+    if (!diffOutput.trim()) {
+      const diff2 = {
+        hunks: [],
+        status: fileStatus
+      };
+      res.json(diff2);
+      return;
+    }
+    const hunks = parseUnifiedDiff(diffOutput);
+    const diff = {
+      hunks,
+      status: fileStatus
+    };
+    res.json(diff);
+  } catch (err) {
+    res.status(500).json({ error: "Failed to get diff" });
+  }
+});
 
 // dist/flip/routes/submit.js
 import { Router as Router4 } from "express";
@@ -675,8 +806,8 @@ async function copyToClipboard(text) {
 
 // dist/flip/output/autopaste.js
 import { execSync as execSync2 } from "child_process";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import os from "os";
 async function schedulePaste(sessionId) {
   if (process.platform !== "darwin") {
@@ -686,10 +817,10 @@ async function schedulePaste(sessionId) {
   await pasteToOriginalSession(sessionId);
 }
 async function pasteToOriginalSession(sessionId) {
-  const sessionFile = path4.join(os.tmpdir(), `flip-view-session-${sessionId}`);
+  const sessionFile = path5.join(os.tmpdir(), `flip-view-session-${sessionId}`);
   let itermSessionId;
   try {
-    itermSessionId = fs4.readFileSync(sessionFile, "utf-8").trim();
+    itermSessionId = fs5.readFileSync(sessionFile, "utf-8").trim();
   } catch {
   }
   let script;
@@ -717,7 +848,7 @@ async function pasteToOriginalSession(sessionId) {
             end tell
         `;
     try {
-      fs4.unlinkSync(sessionFile);
+      fs5.unlinkSync(sessionFile);
     } catch {
     }
   } else {
@@ -787,19 +918,19 @@ router5.post("/", (req, res) => {
 // dist/flip/routes/static.js
 import { Router as Router6 } from "express";
 import express from "express";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
-import fs5 from "fs";
+import fs6 from "fs";
 function createStaticRouter() {
   const router6 = Router6();
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path5.dirname(__filename);
-  const distPath = path5.resolve(__dirname, "flip-ui/dist");
-  if (fs5.existsSync(distPath)) {
+  const __dirname = path6.dirname(__filename);
+  const distPath = path6.resolve(__dirname, "flip-ui/dist");
+  if (fs6.existsSync(distPath)) {
     router6.use(express.static(distPath));
     router6.get("*", (req, res) => {
-      const indexPath = path5.join(distPath, "index.html");
-      if (fs5.existsSync(indexPath)) {
+      const indexPath = path6.join(distPath, "index.html");
+      if (fs6.existsSync(indexPath)) {
         res.sendFile(indexPath);
       } else {
         res.status(404).send("Not Found");
@@ -822,7 +953,7 @@ var Server = class {
     this.port = port;
   }
   async run() {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const state = {
         cwd: this.cwd,
         resolve: null
@@ -840,7 +971,7 @@ var Server = class {
       const server = http.createServer(app);
       state.resolve = (output) => {
         server.close();
-        resolve(output);
+        resolve2(output);
       };
       server.listen(this.port, "127.0.0.1", () => {
         console.log(`Server running at http://localhost:${this.port}`);
@@ -849,23 +980,23 @@ var Server = class {
   }
 };
 async function findFreePort(preferred) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const server = net.createServer();
     server.listen(preferred, "127.0.0.1", () => {
       server.close(() => {
-        resolve(preferred);
+        resolve2(preferred);
       });
     });
     server.on("error", () => {
-      findFreePort(preferred + 1).then(resolve);
+      findFreePort(preferred + 1).then(resolve2);
     });
   });
 }
 
 // dist/flip/index.js
 import open from "open";
-import path6 from "path";
-import fs6 from "fs";
+import path7 from "path";
+import fs7 from "fs";
 import os2 from "os";
 import { execSync as execSync3 } from "child_process";
 import { confirm as confirm2 } from "@inquirer/prompts";
@@ -917,7 +1048,7 @@ async function runFlip(args) {
   } else {
     command = "oneshot";
   }
-  const cwd = pathArg ? path6.resolve(pathArg) : process.cwd();
+  const cwd = pathArg ? path7.resolve(pathArg) : process.cwd();
   switch (command) {
     case "setup": {
       await setupHotkey();
@@ -989,9 +1120,9 @@ function printUsage() {
   console.error("  --session <uuid>   Session ID for paste-back tracking");
 }
 async function setupHotkey() {
-  const configDir = path6.join(os2.homedir(), ".config", "flip");
-  const applescriptPath = path6.join(configDir, "flip.applescript");
-  const shPath = path6.join(configDir, "flip.sh");
+  const configDir = path7.join(os2.homedir(), ".config", "flip");
+  const applescriptPath = path7.join(configDir, "flip.applescript");
+  const shPath = path7.join(configDir, "flip.sh");
   let nodePath;
   try {
     nodePath = execSync3("which node", { encoding: "utf-8" }).trim();
@@ -999,7 +1130,7 @@ async function setupHotkey() {
     nodePath = "/usr/local/bin/node";
   }
   const csqPath = new URL(import.meta.url).pathname;
-  fs6.mkdirSync(configDir, { recursive: true });
+  fs7.mkdirSync(configDir, { recursive: true });
   const applescriptContent = `#!/usr/bin/osascript
 
 -- flip hotkey script
@@ -1016,13 +1147,13 @@ tell application "iTerm2"
 end tell
 
 return ""`;
-  fs6.writeFileSync(applescriptPath, applescriptContent);
-  fs6.chmodSync(applescriptPath, "755");
+  fs7.writeFileSync(applescriptPath, applescriptContent);
+  fs7.chmodSync(applescriptPath, "755");
   const shContent = `#!/bin/bash
 osascript ${applescriptPath} > /dev/null 2>&1
 `;
-  fs6.writeFileSync(shPath, shContent);
-  fs6.chmodSync(shPath, "755");
+  fs7.writeFileSync(shPath, shContent);
+  fs7.chmodSync(shPath, "755");
   console.log("");
   console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
   console.log("\u2502           Flip Hotkey Setup Wizard              \u2502");
@@ -1086,6 +1217,85 @@ osascript ${applescriptPath} > /dev/null 2>&1
   console.log("");
 }
 
+// dist/config.js
+import * as fs8 from "fs";
+import * as os3 from "os";
+import * as path8 from "path";
+var GLOBAL_CONFIG_PATH = path8.join(os3.homedir(), ".code-squad", "config.json");
+async function loadGlobalConfig() {
+  try {
+    const content = await fs8.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    console.warn(`[Code Squad] Warning: Could not load global config at ${GLOBAL_CONFIG_PATH}.`, error);
+    return {};
+  }
+}
+async function loadConfig(workspaceRoot) {
+  const globalConfig = await loadGlobalConfig();
+  const normalizedPath = path8.resolve(workspaceRoot);
+  const projectConfig = globalConfig.projects?.[normalizedPath] ?? {};
+  const defaults = globalConfig.defaults ?? {};
+  return {
+    ...defaults,
+    ...projectConfig,
+    worktreeCopyPatterns: [
+      .../* @__PURE__ */ new Set([
+        ...defaults.worktreeCopyPatterns ?? [],
+        ...projectConfig.worktreeCopyPatterns ?? []
+      ])
+    ]
+  };
+}
+function getWorktreeCopyPatterns(config) {
+  return config.worktreeCopyPatterns ?? [];
+}
+
+// dist/fileUtils.js
+import * as fs9 from "fs";
+import * as path9 from "path";
+import fg from "fast-glob";
+async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
+  const copied = [];
+  const failed = [];
+  if (patterns.length === 0) {
+    return { copied, failed };
+  }
+  for (const pattern of patterns) {
+    try {
+      const files = await fg(pattern, {
+        cwd: sourceRoot,
+        absolute: true,
+        onlyFiles: true,
+        dot: true
+        // .env 같은 dotfile도 매칭
+      });
+      for (const absolutePath of files) {
+        try {
+          await copySingleFile(absolutePath, sourceRoot, destRoot);
+          const relativePath = path9.relative(sourceRoot, absolutePath);
+          copied.push(relativePath);
+        } catch {
+          const relativePath = path9.relative(sourceRoot, absolutePath);
+          failed.push(relativePath);
+        }
+      }
+    } catch {
+    }
+  }
+  return { copied, failed };
+}
+async function copySingleFile(absolutePath, sourceRoot, destRoot) {
+  const relativePath = path9.relative(sourceRoot, absolutePath);
+  const destPath = path9.join(destRoot, relativePath);
+  const destDir = path9.dirname(destPath);
+  await fs9.promises.mkdir(destDir, { recursive: true });
+  await fs9.promises.copyFile(absolutePath, destPath);
+}
+
 // dist/index.js
 process.on("SIGINT", () => {
   process.exit(130);
@@ -1135,13 +1345,13 @@ function getProjectHash(workspaceRoot) {
 }
 function getSessionsPath(workspaceRoot) {
   const projectHash = getProjectHash(workspaceRoot);
-  const projectName = path7.basename(workspaceRoot);
-  return path7.join(os3.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
+  const projectName = path10.basename(workspaceRoot);
+  return path10.join(os4.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
 }
 async function loadLocalThreads(workspaceRoot) {
   const sessionsPath = getSessionsPath(workspaceRoot);
   try {
-    const content = await fs7.promises.readFile(sessionsPath, "utf-8");
+    const content = await fs10.promises.readFile(sessionsPath, "utf-8");
     const data = JSON.parse(content);
     return data.localThreads || [];
   } catch {
@@ -1150,9 +1360,9 @@ async function loadLocalThreads(workspaceRoot) {
 }
 async function saveLocalThreads(workspaceRoot, threads) {
   const sessionsPath = getSessionsPath(workspaceRoot);
-  const dir = path7.dirname(sessionsPath);
-  await fs7.promises.mkdir(dir, { recursive: true });
-  await fs7.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
+  const dir = path10.dirname(sessionsPath);
+  await fs10.promises.mkdir(dir, { recursive: true });
+  await fs10.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
 }
 async function addLocalThread(workspaceRoot, name) {
   const threads = await loadLocalThreads(workspaceRoot);
@@ -1232,13 +1442,13 @@ async function listThreads(workspaceRoot) {
   }
 }
 async function createWorktree(workspaceRoot, name) {
-  const repoName = path7.basename(workspaceRoot);
-  const defaultBasePath = path7.join(path7.dirname(workspaceRoot), `${repoName}.worktree`);
+  const repoName = path10.basename(workspaceRoot);
+  const defaultBasePath = path10.join(path10.dirname(workspaceRoot), `${repoName}.worktree`);
   let worktreeName;
   let worktreePath;
   if (name) {
     worktreeName = name;
-    worktreePath = path7.join(defaultBasePath, name);
+    worktreePath = path10.join(defaultBasePath, name);
   } else {
     const form = await newWorktreeForm(defaultBasePath);
     if (!form) {
@@ -1251,24 +1461,39 @@ async function createWorktree(workspaceRoot, name) {
   try {
     await gitAdapter.createWorktree(worktreePath, worktreeName, workspaceRoot);
     console.log(chalk2.green(`\u2713 Created worktree: ${worktreeName}`));
+    await copyWorktreeFiles(workspaceRoot, worktreePath);
     await writeCdFile(worktreePath);
   } catch (error) {
     console.error(chalk2.red(`Failed to create worktree: ${error.message}`));
     process.exit(1);
   }
 }
+async function copyWorktreeFiles(sourceRoot, destRoot) {
+  const config = await loadConfig(sourceRoot);
+  const patterns = getWorktreeCopyPatterns(config);
+  if (patterns.length === 0) {
+    return;
+  }
+  const { copied, failed } = await copyFilesWithPatterns(sourceRoot, destRoot, patterns);
+  if (copied.length > 0) {
+    console.log(chalk2.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
+  }
+  if (failed.length > 0) {
+    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 fs7.promises.writeFile(cdFile, targetPath);
+    await fs10.promises.writeFile(cdFile, targetPath);
   }
 }
 async function openNewTerminal(targetPath) {
   const { exec: exec2 } = await import("child_process");
   const escapedPath = targetPath.replace(/'/g, "'\\''");
-  const hasIterm = await new Promise((resolve) => {
+  const hasIterm = await new Promise((resolve2) => {
     exec2('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
-      resolve(!error && stdout.trim().length > 0);
+      resolve2(!error && stdout.trim().length > 0);
     });
   });
   if (hasIterm) {
@@ -1281,13 +1506,13 @@ tell application "iTerm2"
         end tell
     end tell
 end tell`;
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       exec2(`osascript -e '${script}'`, (error) => {
         if (error) {
           console.error(chalk2.red("Failed to open iTerm2 split pane"));
-          resolve(false);
+          resolve2(false);
         } else {
-          resolve(true);
+          resolve2(true);
         }
       });
     });
@@ -1297,13 +1522,13 @@ tell application "Terminal"
     activate
     do script "cd '${escapedPath}'"
 end tell`;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     exec2(`osascript -e '${terminalScript}'`, (error) => {
       if (error) {
         console.error(chalk2.red("Failed to open Terminal"));
-        resolve(false);
+        resolve2(false);
       } else {
-        resolve(true);
+        resolve2(true);
       }
     });
   });
@@ -1311,7 +1536,14 @@ end tell`;
 async function interactiveMode(workspaceRoot) {
   const result = await runInteraction(workspaceRoot);
   if (result?.cdPath) {
-    await openNewTerminal(result.cdPath);
+    if (process.env.CSQ_CD_FILE) {
+      console.log(result.cdPath);
+    } else {
+      console.log(chalk2.dim("\nRun this to switch:"));
+      console.log(chalk2.cyan(`  cd "${result.cdPath}"`));
+      console.log(chalk2.dim("\nTip: Add to ~/.zshrc for auto-cd:"));
+      console.log(chalk2.dim('  eval "$(csq --init)"'));
+    }
   }
 }
 async function persistentInteractiveMode(workspaceRoot) {
@@ -1354,7 +1586,7 @@ async function executeDelete(thread, workspaceRoot) {
 }
 async function runInteraction(workspaceRoot, _persistent = false) {
   const threads = await getAllThreads(workspaceRoot);
-  const repoName = path7.basename(workspaceRoot);
+  const repoName = path10.basename(workspaceRoot);
   const choice = await selectThread(threads, repoName);
   if (choice.type === "exit") {
     return { exit: true };
@@ -1385,7 +1617,7 @@ async function runInteraction(workspaceRoot, _persistent = false) {
         return null;
       }
       if (newType === "worktree") {
-        const defaultBasePath = path7.join(path7.dirname(workspaceRoot), `${repoName}.worktree`);
+        const defaultBasePath = path10.join(path10.dirname(workspaceRoot), `${repoName}.worktree`);
         const form = await newWorktreeForm(defaultBasePath);
         if (!form) {
           return null;
@@ -1393,6 +1625,7 @@ async function runInteraction(workspaceRoot, _persistent = false) {
         try {
           await gitAdapter.createWorktree(form.path, form.name, workspaceRoot);
           console.log(chalk2.green(`\u2713 Created worktree: ${form.name}`));
+          await copyWorktreeFiles(workspaceRoot, form.path);
           targetPath = form.path;
         } catch (error) {
           console.error(chalk2.red(`Failed to create worktree: ${error.message}`));