code-squad-cli 1.2.7 → 1.2.9

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // dist/index.js
-import * as path10 from "path";
-import * as fs10 from "fs";
-import * as os4 from "os";
+import * as path12 from "path";
+import * as fs11 from "fs";
+import * as os5 from "os";
 import * as crypto from "crypto";
 import chalk2 from "chalk";
 
@@ -44,11 +44,11 @@ var GitAdapter = class {
         const headMatch = headLine.match(/^HEAD (.+)$/);
         const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
         if (pathMatch && headMatch) {
-          const path11 = pathMatch[1];
+          const path13 = pathMatch[1];
           const head = headMatch[1];
           const branch = branchMatch ? branchMatch[1] : "HEAD";
-          if (path11 !== workspaceRoot) {
-            worktrees.push({ path: path11, branch, head });
+          if (path13 !== workspaceRoot) {
+            worktrees.push({ path: path13, branch, head });
           }
         }
         i += 3;
@@ -79,19 +79,19 @@ var GitAdapter = class {
       throw new Error(`Failed to delete branch: ${error.message}`);
     }
   }
-  async isValidWorktree(path11, workspaceRoot) {
+  async isValidWorktree(path13, workspaceRoot) {
     try {
-      await fs.promises.access(path11, fs.constants.R_OK);
+      await fs.promises.access(path13, fs.constants.R_OK);
     } catch {
       return false;
     }
     try {
-      await exec(`cd "${path11}" && git rev-parse --git-dir`, execOptions);
+      await exec(`cd "${path13}" && git rev-parse --git-dir`, execOptions);
     } catch {
       return false;
     }
     const worktrees = await this.listWorktrees(workspaceRoot);
-    return worktrees.some((wt) => wt.path === path11);
+    return worktrees.some((wt) => wt.path === path13);
   }
   async getWorktreeBranch(worktreePath) {
     try {
@@ -423,6 +423,8 @@ import net from "net";
 import { Router } from "express";
 import fs2 from "fs";
 import path2 from "path";
+
+// dist/flip/constants/filters.js
 var FILTERED_PATTERNS = /* @__PURE__ */ new Set([
   // Package managers
   "node_modules",
@@ -451,6 +453,8 @@ var FILTERED_PATTERNS = /* @__PURE__ */ new Set([
 function isFiltered(name) {
   return FILTERED_PATTERNS.has(name);
 }
+
+// dist/flip/routes/files.js
 var router = Router();
 function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
   if (depth > maxDepth)
@@ -495,7 +499,14 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
       continue;
     }
     if (entry.isFile()) {
-      result.files.push(relativePath);
+      try {
+        const stat = fs2.statSync(fullPath);
+        result.files.push({
+          path: relativePath,
+          mtime: stat.mtimeMs
+        });
+      } catch {
+      }
     } else if (entry.isDirectory()) {
       collectFlatFiles(rootPath, fullPath, maxDepth, depth + 1, result);
     }
@@ -514,11 +525,17 @@ router.get("/", (req, res) => {
 router.get("/flat", (req, res) => {
   const state = req.app.locals.state;
   const result = collectFlatFiles(state.cwd, state.cwd, 10);
-  result.files.sort();
+  result.files.sort((a, b) => a.path.localeCompare(b.path));
   result.filteredDirs.sort();
+  let recentFile = null;
+  if (result.files.length > 0) {
+    const mostRecent = result.files.reduce((prev, curr) => curr.mtime > prev.mtime ? curr : prev);
+    recentFile = mostRecent.path;
+  }
   const response = {
     files: result.files,
-    filteredDirs: result.filteredDirs
+    filteredDirs: result.filteredDirs,
+    recentFile
   };
   res.json(response);
 });
@@ -901,16 +918,61 @@ function formatComments(comments) {
 }
 
 // dist/flip/output/clipboard.js
-import clipboardy from "clipboardy";
+import { spawn } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+import os from "os";
 async function copyToClipboard(text) {
-  await clipboardy.write(text);
+  if (process.platform === "darwin") {
+    const tmpFile = path5.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+    try {
+      fs5.writeFileSync(tmpFile, text);
+      const child = spawn("sh", ["-c", `cat "${tmpFile}" | pbcopy && rm "${tmpFile}"`], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+    } catch (e) {
+      console.log(`Output saved to: ${tmpFile}`);
+      throw e;
+    }
+  } else if (process.platform === "linux") {
+    const tmpFile = path5.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+    fs5.writeFileSync(tmpFile, text);
+    try {
+      const child = spawn("sh", ["-c", `cat "${tmpFile}" | xclip -selection clipboard && rm "${tmpFile}"`], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+    } catch {
+      try {
+        const child = spawn("sh", ["-c", `cat "${tmpFile}" | xsel --clipboard --input && rm "${tmpFile}"`], {
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+      } catch (e) {
+        console.log(`Output saved to: ${tmpFile}`);
+        throw e;
+      }
+    }
+  } else if (process.platform === "win32") {
+    const tmpFile = path5.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+    fs5.writeFileSync(tmpFile, text);
+    const child = spawn("cmd", ["/c", `type "${tmpFile}" | clip && del "${tmpFile}"`], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  }
 }
 
 // dist/flip/output/autopaste.js
-import { execSync as execSync2 } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
-import os from "os";
+import { spawn as spawn2 } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
 async function schedulePaste(sessionId) {
   if (process.platform !== "darwin") {
     console.error("Auto-paste not supported on this platform. Please paste manually (Ctrl+V).");
@@ -919,10 +981,10 @@ async function schedulePaste(sessionId) {
   await pasteToOriginalSession(sessionId);
 }
 async function pasteToOriginalSession(sessionId) {
-  const sessionFile = path5.join(os.tmpdir(), `flip-view-session-${sessionId}`);
+  const sessionFile = path6.join(os2.tmpdir(), `flip-view-session-${sessionId}`);
   let itermSessionId;
   try {
-    itermSessionId = fs5.readFileSync(sessionFile, "utf-8").trim();
+    itermSessionId = fs6.readFileSync(sessionFile, "utf-8").trim();
   } catch {
   }
   let script;
@@ -950,7 +1012,7 @@ async function pasteToOriginalSession(sessionId) {
             end tell
         `;
     try {
-      fs5.unlinkSync(sessionFile);
+      fs6.unlinkSync(sessionFile);
     } catch {
     }
   } else {
@@ -966,9 +1028,19 @@ async function pasteToOriginalSession(sessionId) {
         `;
   }
   try {
-    execSync2(`osascript -e '${script.replace(/'/g, `'"'"'`)}'`, {
-      stdio: "pipe"
+    const tmpScript = path6.join(os2.tmpdir(), `flip-paste-${Date.now()}.scpt`);
+    fs6.writeFileSync(tmpScript, script);
+    const child = spawn2("osascript", [tmpScript], {
+      detached: true,
+      stdio: "ignore"
     });
+    child.unref();
+    setTimeout(() => {
+      try {
+        fs6.unlinkSync(tmpScript);
+      } catch {
+      }
+    }, 5e3);
   } catch (e) {
     console.error("Failed to paste to iTerm:", e);
   }
@@ -990,15 +1062,22 @@ router4.post("/", async (req, res) => {
     text: item.comment
   }));
   const formatted = formatComments(comments);
+  let clipboardSuccess = false;
   try {
     await copyToClipboard(formatted);
+    clipboardSuccess = true;
   } catch (e) {
     console.error("Failed to copy to clipboard:", e);
+    console.log("\n--- Output (copy manually) ---");
+    console.log(formatted);
+    console.log("--- End of output ---\n");
   }
-  try {
-    await schedulePaste(body.session_id);
-  } catch (e) {
-    console.error("Failed to schedule paste:", e);
+  if (clipboardSuccess) {
+    try {
+      await schedulePaste(body.session_id);
+    } catch (e) {
+      console.error("Failed to schedule paste:", e);
+    }
   }
   res.json({ status: "ok" });
   if (state.resolve) {
@@ -1020,19 +1099,19 @@ router5.post("/", (req, res) => {
 // dist/flip/routes/static.js
 import { Router as Router6 } from "express";
 import express from "express";
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
-import fs6 from "fs";
+import fs7 from "fs";
 function createStaticRouter() {
   const router6 = Router6();
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path6.dirname(__filename);
-  const distPath = path6.resolve(__dirname, "flip-ui/dist");
-  if (fs6.existsSync(distPath)) {
+  const __dirname = path7.dirname(__filename);
+  const distPath = path7.resolve(__dirname, "../../../flip-ui/dist");
+  if (fs7.existsSync(distPath)) {
     router6.use(express.static(distPath));
     router6.get("*", (req, res) => {
-      const indexPath = path6.join(distPath, "index.html");
-      if (fs6.existsSync(indexPath)) {
+      const indexPath = path7.join(distPath, "index.html");
+      if (fs7.existsSync(indexPath)) {
         res.sendFile(indexPath);
       } else {
         res.status(404).send("Not Found");
@@ -1046,6 +1125,175 @@ function createStaticRouter() {
   return router6;
 }
 
+// dist/flip/routes/events.js
+import { Router as Router7 } from "express";
+function createEventsRouter(sseManager) {
+  const router6 = Router7();
+  router6.get("/", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.write('data: {"type":"connected"}\n\n');
+    sseManager.addClient(res);
+    const heartbeat = setInterval(() => {
+      res.write(":heartbeat\n\n");
+    }, 3e4);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+    });
+  });
+  return router6;
+}
+
+// dist/flip/watcher/FileWatcher.js
+import chokidar from "chokidar";
+import * as path8 from "path";
+var FileWatcher = class {
+  watcher = null;
+  cwd;
+  debounceMs;
+  filesChangedCallbacks = [];
+  fileChangedCallbacks = [];
+  gitChangedCallbacks = [];
+  filesDebounceTimer = null;
+  gitDebounceTimer = null;
+  fileDebounceTimers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.debounceMs = options.debounceMs ?? 300;
+  }
+  start() {
+    const ignoredPatterns = Array.from(FILTERED_PATTERNS).map((pattern) => {
+      if (pattern === ".git") {
+        return void 0;
+      }
+      return `**/${pattern}/**`;
+    }).filter(Boolean);
+    this.watcher = chokidar.watch(this.cwd, {
+      ignored: ignoredPatterns,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("add", (filePath) => this.handleFileEvent(filePath, "add")).on("unlink", (filePath) => this.handleFileEvent(filePath, "unlink")).on("change", (filePath) => this.handleFileEvent(filePath, "change")).on("addDir", (filePath) => this.handleDirEvent(filePath, "addDir")).on("unlinkDir", (filePath) => this.handleDirEvent(filePath, "unlinkDir")).on("error", (error) => console.error("Watcher error:", error));
+  }
+  async stop() {
+    if (this.filesDebounceTimer) {
+      clearTimeout(this.filesDebounceTimer);
+    }
+    if (this.gitDebounceTimer) {
+      clearTimeout(this.gitDebounceTimer);
+    }
+    Array.from(this.fileDebounceTimers.values()).forEach((timer) => {
+      clearTimeout(timer);
+    });
+    this.fileDebounceTimers.clear();
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  onFilesChanged(callback) {
+    this.filesChangedCallbacks.push(callback);
+  }
+  onFileChanged(callback) {
+    this.fileChangedCallbacks.push(callback);
+  }
+  onGitChanged(callback) {
+    this.gitChangedCallbacks.push(callback);
+  }
+  handleFileEvent(filePath, event) {
+    const relativePath = path8.relative(this.cwd, filePath);
+    if (relativePath.startsWith(".git")) {
+      this.emitGitChanged();
+      return;
+    }
+    if (event === "add" || event === "unlink") {
+      this.emitFilesChanged();
+    }
+    if (event === "change" || event === "add") {
+      this.emitFileChanged(relativePath);
+    }
+    this.emitGitChanged();
+  }
+  handleDirEvent(dirPath, event) {
+    const relativePath = path8.relative(this.cwd, dirPath);
+    if (relativePath.startsWith(".git")) {
+      return;
+    }
+    this.emitFilesChanged();
+  }
+  emitFilesChanged() {
+    if (this.filesDebounceTimer) {
+      clearTimeout(this.filesDebounceTimer);
+    }
+    this.filesDebounceTimer = setTimeout(() => {
+      for (const callback of this.filesChangedCallbacks) {
+        callback();
+      }
+    }, this.debounceMs);
+  }
+  emitFileChanged(relativePath) {
+    const existingTimer = this.fileDebounceTimers.get(relativePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.fileDebounceTimers.delete(relativePath);
+      for (const callback of this.fileChangedCallbacks) {
+        callback(relativePath);
+      }
+    }, this.debounceMs);
+    this.fileDebounceTimers.set(relativePath, timer);
+  }
+  emitGitChanged() {
+    if (this.gitDebounceTimer) {
+      clearTimeout(this.gitDebounceTimer);
+    }
+    this.gitDebounceTimer = setTimeout(() => {
+      for (const callback of this.gitChangedCallbacks) {
+        callback();
+      }
+    }, this.debounceMs);
+  }
+};
+
+// dist/flip/events/SSEManager.js
+var SSEManager = class {
+  clients = /* @__PURE__ */ new Set();
+  addClient(res) {
+    this.clients.add(res);
+    res.on("close", () => {
+      this.clients.delete(res);
+    });
+  }
+  removeClient(res) {
+    this.clients.delete(res);
+  }
+  broadcast(event) {
+    const data = JSON.stringify(event);
+    const message = `data: ${data}
+
+`;
+    this.clients.forEach((client) => {
+      client.write(message);
+    });
+  }
+  closeAll() {
+    this.clients.forEach((client) => {
+      client.end();
+    });
+    this.clients.clear();
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+};
+
 // dist/flip/server/Server.js
 var Server = class {
   cwd;
@@ -1064,15 +1312,30 @@ var Server = class {
       app.use(cors());
       app.use(express2.json());
       app.locals.state = state;
+      const sseManager = new SSEManager();
+      const fileWatcher = new FileWatcher({ cwd: this.cwd });
+      fileWatcher.onFilesChanged(() => {
+        sseManager.broadcast({ type: "files-changed" });
+      });
+      fileWatcher.onFileChanged((path13) => {
+        sseManager.broadcast({ type: "file-changed", path: path13 });
+      });
+      fileWatcher.onGitChanged(() => {
+        sseManager.broadcast({ type: "git-changed" });
+      });
+      fileWatcher.start();
       app.use("/api/files", router);
       app.use("/api/file", router2);
       app.use("/api/git", router3);
       app.use("/api/submit", router4);
       app.use("/api/cancel", router5);
+      app.use("/api/events", createEventsRouter(sseManager));
       app.use(createStaticRouter());
       const server = http.createServer(app);
-      state.resolve = (output) => {
-        server.close();
+      state.resolve = async (output) => {
+        await fileWatcher.stop();
+        sseManager.closeAll();
+        await new Promise((res) => server.close(() => res()));
         resolve2(output);
       };
       server.listen(this.port, "127.0.0.1", () => {
@@ -1097,12 +1360,11 @@ async function findFreePort(preferred) {
 
 // dist/flip/index.js
 import open from "open";
-import path7 from "path";
-import fs7 from "fs";
-import os2 from "os";
-import { execSync as execSync3 } from "child_process";
+import path9 from "path";
+import fs8 from "fs";
+import os3 from "os";
+import { execSync as execSync2 } from "child_process";
 import { confirm as confirm2 } from "@inquirer/prompts";
-import clipboardy2 from "clipboardy";
 var DEFAULT_PORT = 51234;
 function formatTime() {
   const now = /* @__PURE__ */ new Date();
@@ -1150,7 +1412,7 @@ async function runFlip(args) {
   } else {
     command = "oneshot";
   }
-  const cwd = pathArg ? path7.resolve(pathArg) : process.cwd();
+  const cwd = pathArg ? path9.resolve(pathArg) : process.cwd();
   switch (command) {
     case "setup": {
       await setupHotkey();
@@ -1222,17 +1484,17 @@ function printUsage() {
   console.error("  --session <uuid>   Session ID for paste-back tracking");
 }
 async function setupHotkey() {
-  const configDir = path7.join(os2.homedir(), ".config", "flip");
-  const applescriptPath = path7.join(configDir, "flip.applescript");
-  const shPath = path7.join(configDir, "flip.sh");
+  const configDir = path9.join(os3.homedir(), ".config", "flip");
+  const applescriptPath = path9.join(configDir, "flip.applescript");
+  const shPath = path9.join(configDir, "flip.sh");
   let nodePath;
   try {
-    nodePath = execSync3("which node", { encoding: "utf-8" }).trim();
+    nodePath = execSync2("which node", { encoding: "utf-8" }).trim();
   } catch {
     nodePath = "/usr/local/bin/node";
   }
   const csqPath = new URL(import.meta.url).pathname;
-  fs7.mkdirSync(configDir, { recursive: true });
+  fs8.mkdirSync(configDir, { recursive: true });
   const applescriptContent = `#!/usr/bin/osascript
 
 -- flip hotkey script
@@ -1249,13 +1511,13 @@ tell application "iTerm2"
 end tell
 
 return ""`;
-  fs7.writeFileSync(applescriptPath, applescriptContent);
-  fs7.chmodSync(applescriptPath, "755");
+  fs8.writeFileSync(applescriptPath, applescriptContent);
+  fs8.chmodSync(applescriptPath, "755");
   const shContent = `#!/bin/bash
 osascript ${applescriptPath} > /dev/null 2>&1
 `;
-  fs7.writeFileSync(shPath, shContent);
-  fs7.chmodSync(shPath, "755");
+  fs8.writeFileSync(shPath, shContent);
+  fs8.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");
@@ -1270,7 +1532,7 @@ osascript ${applescriptPath} > /dev/null 2>&1
   });
   if (openSettings) {
     try {
-      execSync3(`osascript -e 'tell application "iTerm2" to activate' -e 'tell application "System Events" to keystroke "," using command down'`);
+      execSync2(`osascript -e 'tell application "iTerm2" to activate' -e 'tell application "System Events" to keystroke "," using command down'`);
       console.log("");
       console.log("  \u2192 iTerm2 Settings opened. Navigate to: Keys \u2192 Key Bindings");
     } catch {
@@ -1299,7 +1561,7 @@ osascript ${applescriptPath} > /dev/null 2>&1
   console.log("\u2502  3. Command: Paste the path (copied below)      \u2502");
   console.log("\u2514\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\u2518");
   console.log("");
-  await clipboardy2.write(shPath);
+  await copyToClipboard(shPath);
   console.log(`\u2713 Copied to clipboard: ${shPath}`);
   console.log("");
   await confirm2({
@@ -1320,13 +1582,13 @@ osascript ${applescriptPath} > /dev/null 2>&1
 }
 
 // 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");
+import * as fs9 from "fs";
+import * as os4 from "os";
+import * as path10 from "path";
+var GLOBAL_CONFIG_PATH = path10.join(os4.homedir(), ".code-squad", "config.json");
 async function loadGlobalConfig() {
   try {
-    const content = await fs8.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
+    const content = await fs9.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -1338,7 +1600,7 @@ async function loadGlobalConfig() {
 }
 async function loadConfig(workspaceRoot) {
   const globalConfig = await loadGlobalConfig();
-  const normalizedPath = path8.resolve(workspaceRoot);
+  const normalizedPath = path10.resolve(workspaceRoot);
   const projectConfig = globalConfig.projects?.[normalizedPath] ?? {};
   const defaults = globalConfig.defaults ?? {};
   return {
@@ -1357,8 +1619,8 @@ function getWorktreeCopyPatterns(config) {
 }
 
 // dist/fileUtils.js
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import fg from "fast-glob";
 async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
   const copied = [];
@@ -1378,10 +1640,10 @@ async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
       for (const absolutePath of files) {
         try {
           await copySingleFile(absolutePath, sourceRoot, destRoot);
-          const relativePath = path9.relative(sourceRoot, absolutePath);
+          const relativePath = path11.relative(sourceRoot, absolutePath);
           copied.push(relativePath);
         } catch {
-          const relativePath = path9.relative(sourceRoot, absolutePath);
+          const relativePath = path11.relative(sourceRoot, absolutePath);
           failed.push(relativePath);
         }
       }
@@ -1391,11 +1653,11 @@ async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
   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);
+  const relativePath = path11.relative(sourceRoot, absolutePath);
+  const destPath = path11.join(destRoot, relativePath);
+  const destDir = path11.dirname(destPath);
+  await fs10.promises.mkdir(destDir, { recursive: true });
+  await fs10.promises.copyFile(absolutePath, destPath);
 }
 
 // dist/index.js
@@ -1450,13 +1712,13 @@ function getProjectHash(workspaceRoot) {
 }
 function getSessionsPath(workspaceRoot) {
   const projectHash = getProjectHash(workspaceRoot);
-  const projectName = path10.basename(workspaceRoot);
-  return path10.join(os4.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
+  const projectName = path12.basename(workspaceRoot);
+  return path12.join(os5.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
 }
 async function loadLocalThreads(workspaceRoot) {
   const sessionsPath = getSessionsPath(workspaceRoot);
   try {
-    const content = await fs10.promises.readFile(sessionsPath, "utf-8");
+    const content = await fs11.promises.readFile(sessionsPath, "utf-8");
     const data = JSON.parse(content);
     return data.localThreads || [];
   } catch {
@@ -1465,9 +1727,9 @@ async function loadLocalThreads(workspaceRoot) {
 }
 async function saveLocalThreads(workspaceRoot, threads) {
   const sessionsPath = getSessionsPath(workspaceRoot);
-  const dir = path10.dirname(sessionsPath);
-  await fs10.promises.mkdir(dir, { recursive: true });
-  await fs10.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
+  const dir = path12.dirname(sessionsPath);
+  await fs11.promises.mkdir(dir, { recursive: true });
+  await fs11.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
 }
 async function addLocalThread(workspaceRoot, name) {
   const threads = await loadLocalThreads(workspaceRoot);
@@ -1565,9 +1827,9 @@ async function createWorktreeCommand(workspaceRoot, args) {
     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`);
-  const worktreePath = path10.join(defaultBasePath, name);
+  const repoName = path12.basename(workspaceRoot);
+  const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
+  const worktreePath = path12.join(defaultBasePath, name);
   try {
     await gitAdapter.createWorktree(worktreePath, name, workspaceRoot);
     console.log(chalk2.green(`\u2713 Created worktree: ${name}`));
@@ -1746,7 +2008,7 @@ async function executeDelete(thread, workspaceRoot) {
 }
 async function runInteraction(workspaceRoot, _persistent = false) {
   const threads = await getAllThreads(workspaceRoot);
-  const repoName = path10.basename(workspaceRoot);
+  const repoName = path12.basename(workspaceRoot);
   const choice = await selectThread(threads, repoName);
   if (choice.type === "exit") {
     return { exit: true };
@@ -1777,7 +2039,7 @@ async function runInteraction(workspaceRoot, _persistent = false) {
         return null;
       }
       if (newType === "worktree") {
-        const defaultBasePath = path10.join(path10.dirname(workspaceRoot), `${repoName}.worktree`);
+        const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
         const form = await newWorktreeForm(defaultBasePath);
         if (!form) {
           return null;