code-squad-cli 1.2.22 → 2.0.0

package/dist/index.js

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
 
 // dist/index.js
-import * as path12 from "path";
-import * as fs11 from "fs";
-import * as os5 from "os";
-import * as crypto from "crypto";
-import chalk2 from "chalk";
+import * as path11 from "path";
+import chalk from "chalk";
 
 // dist/adapters/GitAdapter.js
 import { exec as execCallback } from "child_process";
@@ -23,8 +20,17 @@ var GitAdapter = class {
     }
   }
   async getCurrentBranch(workspaceRoot) {
-    const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
-    return stdout.trim();
+    try {
+      const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+      return stdout.trim();
+    } catch {
+      try {
+        const { stdout } = await exec(`cd "${workspaceRoot}" && git symbolic-ref --short HEAD`, execOptions);
+        return stdout.trim();
+      } catch {
+        return "";
+      }
+    }
   }
   async listWorktrees(workspaceRoot) {
     try {
@@ -44,11 +50,11 @@ var GitAdapter = class {
         const headMatch = headLine.match(/^HEAD (.+)$/);
         const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
         if (pathMatch && headMatch) {
-          const path13 = pathMatch[1];
+          const path12 = pathMatch[1];
           const head = headMatch[1];
           const branch = branchMatch ? branchMatch[1] : "HEAD";
-          if (path13 !== workspaceRoot) {
-            worktrees.push({ path: path13, branch, head });
+          if (path12 !== workspaceRoot) {
+            worktrees.push({ path: path12, branch, head });
           }
         }
         i += 3;
@@ -59,9 +65,11 @@ var GitAdapter = class {
     }
   }
   async createWorktree(worktreePath, branch, workspaceRoot) {
+    await exec(`cd "${workspaceRoot}" && git worktree prune`, execOptions).catch(() => {
+    });
     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);
+    await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add -f "${worktreePath}" -b "${branch}"`, execOptions);
   }
   async removeWorktree(worktreePath, workspaceRoot, force = false) {
     const forceFlag = force ? " --force" : "";
@@ -79,19 +87,19 @@ var GitAdapter = class {
       throw new Error(`Failed to delete branch: ${error.message}`);
     }
   }
-  async isValidWorktree(path13, workspaceRoot) {
+  async isValidWorktree(path12, workspaceRoot) {
     try {
-      await fs.promises.access(path13, fs.constants.R_OK);
+      await fs.promises.access(path12, fs.constants.R_OK);
     } catch {
       return false;
     }
     try {
-      await exec(`cd "${path13}" && git rev-parse --git-dir`, execOptions);
+      await exec(`cd "${path12}" && git rev-parse --git-dir`, execOptions);
     } catch {
       return false;
     }
     const worktrees = await this.listWorktrees(workspaceRoot);
-    return worktrees.some((wt) => wt.path === path13);
+    return worktrees.some((wt) => wt.path === path12);
   }
   async getWorktreeBranch(worktreePath) {
     try {
@@ -141,277 +149,8 @@ var GitAdapter = class {
   }
 };
 
-// dist/ui/prompts.js
-import { createPrompt, useState, useKeypress, usePrefix, isEnterKey, isBackspaceKey } from "@inquirer/core";
-import { confirm } from "@inquirer/prompts";
-import chalk from "chalk";
-import * as path from "path";
-var cancelableInput = createPrompt((config, done) => {
-  const [value, setValue] = useState(config.default || "");
-  const [error, setError] = useState(null);
-  const prefix = usePrefix({ status: "idle" });
-  useKeypress((key, rl) => {
-    if (key.name === "escape") {
-      done(null);
-    } else if (isEnterKey(key)) {
-      if (config.validate) {
-        const result = config.validate(value);
-        if (result !== true) {
-          setError(typeof result === "string" ? result : "Invalid input");
-          return;
-        }
-      }
-      done(value);
-    } else if (isBackspaceKey(key)) {
-      setValue(value.slice(0, -1));
-      setError(null);
-    } else if (key.ctrl || key.name === "tab" || key.name === "up" || key.name === "down") {
-    } else {
-      const seq = key.sequence;
-      if (seq && seq.length === 1 && seq >= " ") {
-        setValue(value + seq);
-        setError(null);
-      }
-    }
-  });
-  const errorMsg = error ? chalk.red(`
-${error}`) : "";
-  return `${prefix} ${config.message} ${chalk.cyan(value)}${errorMsg}
-${chalk.dim("ESC:cancel Enter:confirm")}`;
-});
-function truncatePath(fullPath, maxLen) {
-  if (fullPath.length <= maxLen)
-    return fullPath;
-  const home = process.env.HOME || "";
-  let display = fullPath.startsWith(home) ? "~" + fullPath.slice(home.length) : fullPath;
-  if (display.length <= maxLen)
-    return display;
-  const parts = display.split(path.sep);
-  if (parts.length > 2) {
-    return "\u2026/" + parts.slice(-2).join("/");
-  }
-  return "\u2026" + display.slice(-maxLen + 1);
-}
-var vimSelect = createPrompt((config, done) => {
-  const { choices, pageSize = 15, shortcuts = [] } = config;
-  const enabledChoices = choices.filter((c) => !c.disabled);
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const prefix = usePrefix({ status: "idle" });
-  useKeypress((key) => {
-    if (key.name === "j" || key.name === "down") {
-      const nextIndex = (selectedIndex + 1) % enabledChoices.length;
-      setSelectedIndex(nextIndex);
-    } else if (key.name === "k" || key.name === "up") {
-      const prevIndex = (selectedIndex - 1 + enabledChoices.length) % enabledChoices.length;
-      setSelectedIndex(prevIndex);
-    } else if (isEnterKey(key)) {
-      done(enabledChoices[selectedIndex].value);
-    } else if (key.name === "escape" || key.name === "b") {
-      const backShortcut = shortcuts.find((s) => s.key === "back");
-      if (backShortcut) {
-        done(backShortcut.value);
-      }
-    } else {
-      const shortcut = shortcuts.find((s) => s.key === key.name);
-      if (shortcut) {
-        done(shortcut.value);
-      }
-    }
-  });
-  const totalItems = enabledChoices.length;
-  const halfPage = Math.floor(pageSize / 2);
-  let startIndex = 0;
-  if (totalItems > pageSize) {
-    if (selectedIndex <= halfPage) {
-      startIndex = 0;
-    } else if (selectedIndex >= totalItems - halfPage) {
-      startIndex = totalItems - pageSize;
-    } else {
-      startIndex = selectedIndex - halfPage;
-    }
-  }
-  const visibleChoices = enabledChoices.slice(startIndex, startIndex + pageSize);
-  const lines = visibleChoices.map((choice, i) => {
-    const actualIndex = startIndex + i;
-    const isSelected = actualIndex === selectedIndex;
-    const cursor = isSelected ? chalk.cyan("\u276F") : " ";
-    const name = isSelected ? chalk.cyan(choice.name) : choice.name;
-    return `${cursor} ${name}`;
-  });
-  if (startIndex > 0) {
-    lines.unshift(chalk.dim("  \u2191 more"));
-  }
-  if (startIndex + pageSize < totalItems) {
-    lines.push(chalk.dim("  \u2193 more"));
-  }
-  const shortcutHints = shortcuts.filter((s) => s.description).map((s) => chalk.dim(`${s.key}:${s.description}`)).join(" ");
-  const hint = chalk.dim("j/k:navigate enter:select") + (shortcutHints ? " " + shortcutHints : "");
-  return `${prefix} ${chalk.bold(config.message)}
-${lines.join("\n")}
-${hint}`;
-});
-async function selectThread(threads, repoName) {
-  const cols = process.stdout.columns || 80;
-  const nameWidth = 18;
-  const prefixWidth = 6;
-  const pathMaxLen = Math.max(20, cols - nameWidth - prefixWidth - 5);
-  const threadChoices = threads.map((t) => {
-    const typeIcon = t.type === "worktree" ? chalk.cyan("[W]") : chalk.yellow("[L]");
-    const displayPath = truncatePath(t.path, pathMaxLen);
-    return {
-      name: `${typeIcon} ${t.name.padEnd(nameWidth)} ${chalk.dim(displayPath)}`,
-      value: { type: "existing", thread: t },
-      thread: t
-    };
-  });
-  const newChoice = {
-    name: chalk.green("+ \uC0C8 \uC791\uC5C5"),
-    value: { type: "new" },
-    thread: null
-  };
-  const allChoices = [...threadChoices, newChoice];
-  const threadSelect = createPrompt((config, done) => {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const prefix = usePrefix({ status: "idle" });
-    const pageSize = 15;
-    useKeypress((key) => {
-      if (key.name === "j" || key.name === "down") {
-        setSelectedIndex((selectedIndex + 1) % allChoices.length);
-      } else if (key.name === "k" || key.name === "up") {
-        setSelectedIndex((selectedIndex - 1 + allChoices.length) % allChoices.length);
-      } else if (isEnterKey(key)) {
-        done(allChoices[selectedIndex].value);
-      } else if (key.name === "n") {
-        done({ type: "new" });
-      } else if (key.name === "q") {
-        done({ type: "exit" });
-      } else if (key.name === "d") {
-        const current = allChoices[selectedIndex];
-        if (current.thread) {
-          done({ type: "delete-selected", thread: current.thread });
-        }
-      }
-    });
-    const totalItems = allChoices.length;
-    const halfPage = Math.floor(pageSize / 2);
-    let startIndex = 0;
-    if (totalItems > pageSize) {
-      if (selectedIndex <= halfPage) {
-        startIndex = 0;
-      } else if (selectedIndex >= totalItems - halfPage) {
-        startIndex = totalItems - pageSize;
-      } else {
-        startIndex = selectedIndex - halfPage;
-      }
-    }
-    const visibleChoices = allChoices.slice(startIndex, startIndex + pageSize);
-    const lines = visibleChoices.map((choice, i) => {
-      const actualIndex = startIndex + i;
-      const isSelected = actualIndex === selectedIndex;
-      const cursor = isSelected ? chalk.cyan("\u276F") : " ";
-      const name = isSelected ? chalk.cyan(choice.name) : choice.name;
-      return `${cursor} ${name}`;
-    });
-    if (startIndex > 0) {
-      lines.unshift(chalk.dim("  \u2191 more"));
-    }
-    if (startIndex + pageSize < totalItems) {
-      lines.push(chalk.dim("  \u2193 more"));
-    }
-    const hint = chalk.dim("j/k:nav n:new d:delete q:quit");
-    return `${prefix} ${config.message}
-${lines.join("\n")}
-${hint}`;
-  });
-  return threadSelect({ message: chalk.bold(repoName) });
-}
-async function selectThreadAction(threadName) {
-  const choices = [
-    { name: "\uD130\uBBF8\uB110 \uC5F4\uAE30", value: "open" },
-    { name: chalk.red("\uC0AD\uC81C\uD558\uAE30"), value: "delete" },
-    { name: chalk.dim("\u2190 \uB4A4\uB85C"), value: "back" }
-  ];
-  return vimSelect({
-    message: `'${threadName}'`,
-    choices,
-    shortcuts: [{ key: "back", value: "back" }]
-  });
-}
-async function selectNewThreadType() {
-  const choices = [
-    {
-      name: chalk.cyan("\uC6CC\uD06C\uD2B8\uB9AC") + chalk.dim(" - \uC0C8 \uBE0C\uB79C\uCE58\uC640 \uB514\uB809\uD1A0\uB9AC \uC0DD\uC131"),
-      value: "worktree"
-    },
-    {
-      name: chalk.yellow("\uB85C\uCEEC") + chalk.dim(" - \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uC791\uC5C5"),
-      value: "local"
-    },
-    { name: chalk.dim("\u2190 \uB4A4\uB85C"), value: "back" }
-  ];
-  return vimSelect({
-    message: "\uC0C8 \uC791\uC5C5 \uD0C0\uC785",
-    choices,
-    shortcuts: [{ key: "back", value: "back" }]
-  });
-}
-async function newWorktreeForm(defaultBasePath) {
-  const name = await cancelableInput({
-    message: "\uC6CC\uD06C\uD2B8\uB9AC \uC774\uB984:",
-    validate: (value) => {
-      if (!value.trim())
-        return "\uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
-      if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
-        return "\uC601\uBB38, \uC22B\uC790, -, _ \uB9CC \uC0AC\uC6A9 \uAC00\uB2A5";
-      }
-      return true;
-    }
-  });
-  if (!name)
-    return null;
-  const defaultPath = `${defaultBasePath}/${name}`;
-  const pathInput = await cancelableInput({
-    message: "\uACBD\uB85C:",
-    default: defaultPath
-  });
-  if (!pathInput)
-    return null;
-  return { name, path: pathInput };
-}
-async function newLocalForm() {
-  const name = await cancelableInput({
-    message: "\uB85C\uCEEC \uC2A4\uB808\uB4DC \uC774\uB984:",
-    validate: (value) => {
-      if (!value.trim())
-        return "\uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
-      return true;
-    }
-  });
-  return name || null;
-}
-async function confirmDeleteWorktree(threadName) {
-  const confirmed = await confirm({
-    message: `'${threadName}' \uC6CC\uD06C\uD2B8\uB9AC\uB97C \uC0AD\uC81C\uD560\uAE4C\uC694?`,
-    default: true
-  });
-  if (!confirmed) {
-    return { confirmed: false, removeGitWorktree: false };
-  }
-  const removeGitWorktree = await confirm({
-    message: "Git worktree\uC640 \uBE0C\uB79C\uCE58\uB3C4 \uD568\uAED8 \uC0AD\uC81C\uD560\uAE4C\uC694?",
-    default: true
-  });
-  return { confirmed, removeGitWorktree };
-}
-async function confirmDeleteLocal(threadName) {
-  return await confirm({
-    message: `'${threadName}' \uB85C\uCEEC \uC2A4\uB808\uB4DC\uB97C \uC0AD\uC81C\uD560\uAE4C\uC694?`,
-    default: true
-  });
-}
-
 // dist/index.js
-import { confirm as confirm2 } from "@inquirer/prompts";
+import { confirm } from "@inquirer/prompts";
 
 // dist/flip/server/Server.js
 import express2 from "express";
@@ -422,7 +161,7 @@ import net from "net";
 // dist/flip/routes/files.js
 import { Router } from "express";
 import fs2 from "fs";
-import path2 from "path";
+import path from "path";
 
 // dist/flip/constants/filters.js
 var FILTERED_PATTERNS = /* @__PURE__ */ new Set([
@@ -489,8 +228,8 @@ function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
     return a.name.localeCompare(b.name);
   });
   for (const entry of entries) {
-    const fullPath = path2.join(currentPath, entry.name);
-    const relativePath = path2.relative(rootPath, fullPath);
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath);
     const filtered = isFiltered(entry.name);
     const node = {
       path: relativePath,
@@ -510,8 +249,8 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
     return result;
   const entries = fs2.readdirSync(currentPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path2.join(currentPath, entry.name);
-    const relativePath = path2.relative(rootPath, fullPath);
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath);
     if (isFiltered(entry.name)) {
       if (entry.isDirectory()) {
         result.filteredDirs.push(relativePath);
@@ -581,7 +320,7 @@ router.get("/flat", (req, res) => {
 // dist/flip/routes/file.js
 import { Router as Router2 } from "express";
 import fs3 from "fs";
-import path3 from "path";
+import path2 from "path";
 var router2 = Router2();
 var extensionMap = {
   // JavaScript/TypeScript
@@ -694,11 +433,11 @@ var filenameMap = {
   "CODEOWNERS": "gitignore"
 };
 function detectLanguage(filePath) {
-  const basename2 = path3.basename(filePath);
+  const basename2 = path2.basename(filePath);
   if (filenameMap[basename2]) {
     return filenameMap[basename2];
   }
-  const ext = path3.extname(filePath).slice(1).toLowerCase();
+  const ext = path2.extname(filePath).slice(1).toLowerCase();
   if (extensionMap[ext]) {
     return extensionMap[ext];
   }
@@ -727,9 +466,9 @@ router2.get("/", (req, res) => {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const filePath = path3.join(cwd, relativePath);
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedCwd = path3.resolve(cwd);
+  const filePath = path2.join(cwd, relativePath);
+  const resolvedPath = path2.resolve(filePath);
+  const resolvedCwd = path2.resolve(cwd);
   if (!resolvedPath.startsWith(resolvedCwd)) {
     res.status(403).json({ error: "Access denied" });
     return;
@@ -756,7 +495,7 @@ router2.get("/", (req, res) => {
 import { Router as Router3 } from "express";
 import { execSync } from "child_process";
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path3 from "path";
 var router3 = Router3();
 function parseGitStatus(output) {
   const files = [];
@@ -916,7 +655,7 @@ router3.get("/diff", (req, res) => {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const fullPath = path4.join(cwd, relativePath);
+  const fullPath = path3.join(cwd, relativePath);
   let fileStatus = "modified";
   try {
     const statusOutput = execSync(`git status --porcelain -- "${relativePath}"`, {
@@ -992,10 +731,10 @@ function formatComments(comments) {
 // dist/flip/output/clipboard.js
 import { spawn } from "child_process";
 import fs5 from "fs";
-import path5 from "path";
+import path4 from "path";
 import os from "os";
 async function copyToClipboard(text) {
-  const tmpFile = path5.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+  const tmpFile = path4.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
   const cleanupTmpFile = () => {
     try {
       fs5.unlinkSync(tmpFile);
@@ -1041,7 +780,7 @@ async function copyToClipboard(text) {
 // dist/flip/output/autopaste.js
 import { spawn as spawn2 } from "child_process";
 import fs6 from "fs";
-import path6 from "path";
+import path5 from "path";
 import os2 from "os";
 async function schedulePaste(sessionId) {
   if (process.platform !== "darwin") {
@@ -1051,7 +790,7 @@ async function schedulePaste(sessionId) {
   await pasteToOriginalSession(sessionId);
 }
 async function pasteToOriginalSession(sessionId) {
-  const sessionFile = path6.join(os2.tmpdir(), `flip-view-session-${sessionId}`);
+  const sessionFile = path5.join(os2.tmpdir(), `flip-view-session-${sessionId}`);
   let itermSessionId;
   try {
     itermSessionId = fs6.readFileSync(sessionFile, "utf-8").trim();
@@ -1098,7 +837,7 @@ async function pasteToOriginalSession(sessionId) {
         `;
   }
   try {
-    const tmpScript = path6.join(os2.tmpdir(), `flip-paste-${Date.now()}.scpt`);
+    const tmpScript = path5.join(os2.tmpdir(), `flip-paste-${Date.now()}.scpt`);
     fs6.writeFileSync(tmpScript, script);
     const cleanupScript = () => {
       try {
@@ -1177,21 +916,21 @@ router5.post("/", async (req, res) => {
 // dist/flip/routes/static.js
 import { Router as Router6 } from "express";
 import express from "express";
-import path7 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
 import fs7 from "fs";
 function createStaticRouter() {
   const router6 = Router6();
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path7.dirname(__filename);
-  let distPath = path7.resolve(__dirname, "flip-ui/dist");
+  const __dirname = path6.dirname(__filename);
+  let distPath = path6.resolve(__dirname, "flip-ui/dist");
   if (!fs7.existsSync(distPath)) {
-    distPath = path7.resolve(__dirname, "../../../flip-ui/dist");
+    distPath = path6.resolve(__dirname, "../../../flip-ui/dist");
   }
   if (fs7.existsSync(distPath)) {
     router6.use(express.static(distPath));
     router6.get("*", (req, res) => {
-      const indexPath = path7.join(distPath, "index.html");
+      const indexPath = path6.join(distPath, "index.html");
       if (fs7.existsSync(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -1299,7 +1038,7 @@ function createChangesRouter(sessionManager) {
 
 // dist/flip/watcher/FileWatcher.js
 import chokidar from "chokidar";
-import * as path8 from "path";
+import * as path7 from "path";
 var FileWatcher = class {
   watcher = null;
   cwd;
@@ -1316,8 +1055,8 @@ var FileWatcher = class {
   }
   start() {
     const shouldIgnore = (filePath) => {
-      const relativePath = path8.relative(this.cwd, filePath);
-      const segments = relativePath.split(path8.sep);
+      const relativePath = path7.relative(this.cwd, filePath);
+      const segments = relativePath.split(path7.sep);
       return segments.some((segment) => segment !== ".git" && FILTERED_PATTERNS.has(segment));
     };
     this.watcher = chokidar.watch(this.cwd, {
@@ -1365,7 +1104,7 @@ var FileWatcher = class {
     this.gitChangedCallbacks.push(callback);
   }
   handleFileEvent(filePath, event) {
-    const relativePath = path8.relative(this.cwd, filePath);
+    const relativePath = path7.relative(this.cwd, filePath);
     if (relativePath.startsWith(".git")) {
       this.emitGitChanged();
       return;
@@ -1379,7 +1118,7 @@ var FileWatcher = class {
     this.emitGitChanged();
   }
   handleDirEvent(dirPath, event) {
-    const relativePath = path8.relative(this.cwd, dirPath);
+    const relativePath = path7.relative(this.cwd, dirPath);
     if (relativePath.startsWith(".git")) {
       return;
     }
@@ -1739,7 +1478,7 @@ async function findExistingServer(startPort, endPort) {
 
 // dist/flip/index.js
 import open from "open";
-import path9 from "path";
+import path8 from "path";
 import fs8 from "fs";
 import os3 from "os";
 import http2 from "http";
@@ -1838,7 +1577,7 @@ async function runFlip(args) {
   } else {
     command = "oneshot";
   }
-  const cwd = pathArg ? path9.resolve(pathArg) : process.cwd();
+  const cwd = pathArg ? path8.resolve(pathArg) : process.cwd();
   const finalSessionId = sessionId || getSessionId();
   switch (command) {
     case "setup": {
@@ -1952,7 +1691,7 @@ async function setupHotkey() {
   } catch {
     csqPath = new URL(import.meta.url).pathname;
   }
-  const nodeDir = path9.dirname(nodePath);
+  const nodeDir = path8.dirname(nodePath);
   const wrapperScript = `#!/bin/bash
 # Add node to PATH (coprocess doesn't inherit shell PATH)
 export PATH="${nodeDir}:$PATH"
@@ -1978,8 +1717,8 @@ else
     exec ${csqPath} flip
 fi
 `;
-  const scriptDir = path9.join(os3.homedir(), ".config", "csq");
-  const scriptPath = path9.join(scriptDir, "flip-hotkey.sh");
+  const scriptDir = path8.join(os3.homedir(), ".config", "csq");
+  const scriptPath = path8.join(scriptDir, "flip-hotkey.sh");
   if (!fs8.existsSync(scriptDir)) {
     fs8.mkdirSync(scriptDir, { recursive: true });
   }
@@ -2008,8 +1747,8 @@ fi
 // dist/config.js
 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");
+import * as path9 from "path";
+var GLOBAL_CONFIG_PATH = path9.join(os4.homedir(), ".code-squad", "config.json");
 async function loadGlobalConfig() {
   try {
     const content = await fs9.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
@@ -2024,7 +1763,7 @@ async function loadGlobalConfig() {
 }
 async function loadConfig(workspaceRoot) {
   const globalConfig = await loadGlobalConfig();
-  const normalizedPath = path10.resolve(workspaceRoot);
+  const normalizedPath = path9.resolve(workspaceRoot);
   const projectConfig = globalConfig.projects?.[normalizedPath] ?? {};
   const defaults = globalConfig.defaults ?? {};
   return {
@@ -2044,7 +1783,7 @@ function getWorktreeCopyPatterns(config) {
 
 // dist/fileUtils.js
 import * as fs10 from "fs";
-import * as path11 from "path";
+import * as path10 from "path";
 import fg from "fast-glob";
 async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
   const copied = [];
@@ -2064,10 +1803,10 @@ async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
       for (const absolutePath of files) {
         try {
           await copySingleFile(absolutePath, sourceRoot, destRoot);
-          const relativePath = path11.relative(sourceRoot, absolutePath);
+          const relativePath = path10.relative(sourceRoot, absolutePath);
           copied.push(relativePath);
         } catch {
-          const relativePath = path11.relative(sourceRoot, absolutePath);
+          const relativePath = path10.relative(sourceRoot, absolutePath);
           failed.push(relativePath);
         }
       }
@@ -2077,9 +1816,9 @@ async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
   return { copied, failed };
 }
 async function copySingleFile(absolutePath, sourceRoot, destRoot) {
-  const relativePath = path11.relative(sourceRoot, absolutePath);
-  const destPath = path11.join(destRoot, relativePath);
-  const destDir = path11.dirname(destPath);
+  const relativePath = path10.relative(sourceRoot, absolutePath);
+  const destPath = path10.join(destRoot, relativePath);
+  const destDir = path10.dirname(destPath);
   await fs10.promises.mkdir(destDir, { recursive: true });
   await fs10.promises.copyFile(absolutePath, destPath);
 }
@@ -2091,38 +1830,30 @@ process.on("SIGINT", () => {
 var gitAdapter = new GitAdapter();
 async function main() {
   const args = process.argv.slice(2);
-  const persistentMode = args.includes("-p") || args.includes("--persistent");
-  const filteredArgs = args.filter((a) => a !== "-p" && a !== "--persistent");
-  const command = filteredArgs[0];
+  const command = args[0];
   if (command === "--init" || command === "init") {
     printShellInit();
     return;
   }
   if (command === "flip") {
-    await runFlip(filteredArgs.slice(1));
+    await runFlip(args.slice(1));
     return;
   }
   const workspaceRoot = await findGitRoot(process.cwd());
   if (!workspaceRoot) {
-    console.error(chalk2.red("Error: Not a git repository"));
+    console.error(chalk.red("Error: Not a git repository"));
     process.exit(1);
   }
   switch (command) {
-    case "list":
-      await listThreads(workspaceRoot);
-      break;
     case "new":
-      await createWorktreeCommand(workspaceRoot, filteredArgs.slice(1));
+      await createWorktreeCommand(workspaceRoot, args.slice(1));
       break;
     case "quit":
       await quitWorktreeCommand();
       break;
+    case "list":
     default:
-      if (persistentMode) {
-        await persistentInteractiveMode(workspaceRoot);
-      } else {
-        await interactiveMode(workspaceRoot);
-      }
+      await listWorktrees(workspaceRoot);
   }
 }
 async function findGitRoot(cwd) {
@@ -2131,66 +1862,6 @@ async function findGitRoot(cwd) {
   }
   return cwd;
 }
-function getProjectHash(workspaceRoot) {
-  return crypto.createHash("sha256").update(workspaceRoot).digest("hex").slice(0, 8);
-}
-function getSessionsPath(workspaceRoot) {
-  const projectHash = getProjectHash(workspaceRoot);
-  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 fs11.promises.readFile(sessionsPath, "utf-8");
-    const data = JSON.parse(content);
-    return data.localThreads || [];
-  } catch {
-    return [];
-  }
-}
-async function saveLocalThreads(workspaceRoot, threads) {
-  const sessionsPath = getSessionsPath(workspaceRoot);
-  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);
-  const newThread = {
-    id: Date.now().toString(),
-    name,
-    path: workspaceRoot,
-    createdAt: Date.now()
-  };
-  threads.push(newThread);
-  await saveLocalThreads(workspaceRoot, threads);
-  return newThread;
-}
-async function removeLocalThread(workspaceRoot, id) {
-  const threads = await loadLocalThreads(workspaceRoot);
-  const filtered = threads.filter((t) => t.id !== id);
-  await saveLocalThreads(workspaceRoot, filtered);
-}
-async function getAllThreads(workspaceRoot) {
-  const worktrees = await gitAdapter.listWorktrees(workspaceRoot);
-  const localThreads = await loadLocalThreads(workspaceRoot);
-  const threads = [
-    ...worktrees.map((wt) => ({
-      type: "worktree",
-      name: wt.branch,
-      path: wt.path,
-      branch: wt.branch
-    })),
-    ...localThreads.map((lt) => ({
-      type: "local",
-      name: lt.name,
-      path: lt.path,
-      id: lt.id
-    }))
-  ];
-  return threads;
-}
 function printShellInit() {
   const script = `
 csq() {
@@ -2221,56 +1892,33 @@ csq() {
 `.trim();
   console.log(script);
 }
-async function listThreads(workspaceRoot) {
-  const threads = await getAllThreads(workspaceRoot);
-  if (threads.length === 0) {
-    console.log(chalk2.dim("No threads found."));
+async function listWorktrees(workspaceRoot) {
+  const worktrees = await gitAdapter.listWorktrees(workspaceRoot);
+  if (worktrees.length === 0) {
+    console.log(chalk.dim("No worktrees found."));
     return;
   }
-  for (const t of threads) {
-    const typeLabel = t.type === "worktree" ? chalk2.cyan("[W]") : chalk2.yellow("[L]");
-    console.log(`${typeLabel} ${t.name.padEnd(20)} ${chalk2.dim(t.path)}`);
-  }
-}
-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;
-    }
+  for (const wt of worktrees) {
+    console.log(`${chalk.cyan("[W]")} ${wt.branch.padEnd(20)} ${chalk.dim(wt.path)}`);
   }
-  return { name, split };
 }
 async function createWorktreeCommand(workspaceRoot, args) {
-  const { name, split } = parseNewArgs(args);
+  const name = args.find((a) => !a.startsWith("-"));
   if (!name) {
-    console.error(chalk2.red("Error: Name is required"));
-    console.error(chalk2.dim("Usage: csq new <name> [-s|--split]"));
+    console.error(chalk.red("Error: Name is required"));
+    console.error(chalk.dim("Usage: csq new <name>"));
     process.exit(1);
   }
-  const repoName = path12.basename(workspaceRoot);
-  const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
-  const worktreePath = path12.join(defaultBasePath, name);
+  const repoName = path11.basename(workspaceRoot);
+  const defaultBasePath = path11.join(path11.dirname(workspaceRoot), `${repoName}.worktree`);
+  const worktreePath = path11.join(defaultBasePath, name);
   try {
     await gitAdapter.createWorktree(worktreePath, name, workspaceRoot);
-    console.log(chalk2.green(`\u2713 Created worktree: ${name}`));
+    console.log(chalk.green(`\u2713 Created worktree: ${name}`));
     await copyWorktreeFiles(workspaceRoot, worktreePath);
-    if (split) {
-      await openNewTerminal(worktreePath);
-    } else if (process.platform === "darwin") {
-      const success = await cdInCurrentTerminal(worktreePath);
-      if (!success) {
-        console.log(chalk2.dim("\nNote: Auto-cd may require shell function setup."));
-        console.log(chalk2.dim('Run: eval "$(csq --init)"'));
-      }
-    } else {
-      console.log(worktreePath);
-    }
+    console.log(worktreePath);
   } catch (error) {
-    console.error(chalk2.red(`Failed to create worktree: ${error.message}`));
+    console.error(chalk.red(`Failed to create worktree: ${error.message}`));
     process.exit(1);
   }
 }
@@ -2278,35 +1926,31 @@ 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"));
+    console.error(chalk.red("Error: Not in a worktree"));
     process.exit(1);
   }
   if (!context.mainRoot || !context.branch) {
-    console.error(chalk2.red("Error: Could not determine worktree context"));
+    console.error(chalk.red("Error: Could not determine worktree context"));
     process.exit(1);
   }
   const isDirty = await gitAdapter.hasDirtyState(cwd);
   if (isDirty) {
-    const confirmed = await confirm2({
+    const confirmed = await confirm({
       message: "Uncommitted changes detected. Delete anyway?",
       default: false
     });
     if (!confirmed) {
-      console.log(chalk2.dim("Cancelled."));
+      console.log(chalk.dim("Cancelled."));
       process.exit(0);
     }
   }
   try {
     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}`));
-    if (process.platform === "darwin") {
-      await cdInCurrentTerminal(context.mainRoot);
-    } else {
-      console.log(context.mainRoot);
-    }
+    console.log(chalk.green(`\u2713 Deleted worktree and branch: ${context.branch}`));
+    console.log(context.mainRoot);
   } catch (error) {
-    console.error(chalk2.red(`Failed to quit: ${error.message}`));
+    console.error(chalk.red(`Failed to quit: ${error.message}`));
     process.exit(1);
   }
 }
@@ -2318,224 +1962,16 @@ async function copyWorktreeFiles(sourceRoot, destRoot) {
   }
   const { copied, failed } = await copyFilesWithPatterns(sourceRoot, destRoot, patterns);
   if (copied.length > 0) {
-    console.log(chalk2.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
+    console.log(chalk.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 cdInCurrentTerminal(targetPath) {
-  const { exec: exec2 } = await import("child_process");
-  const escapedPath = targetPath.replace(/'/g, "'\\''");
-  const termProgram = process.env.TERM_PROGRAM;
-  if (termProgram === "vscode" || termProgram?.includes("cursor")) {
-    console.log(targetPath);
-    return true;
-  }
-  if (termProgram === "iTerm.app") {
-    const script = `
-tell application "iTerm"
-    tell current session of current window
-        write text "cd '${escapedPath}'"
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec2(`osascript -e '${script}'`, (error, stdout, stderr) => {
-        if (error) {
-          console.log(targetPath);
-          resolve2(true);
-          return;
-        }
-        resolve2(true);
-      });
-    });
-  }
-  if (termProgram === "Apple_Terminal") {
-    const terminalScript = `
-tell application "Terminal"
-    do script "cd '${escapedPath}'" in front window
-end tell`;
-    return new Promise((resolve2) => {
-      exec2(`osascript -e '${terminalScript}'`, (error, stdout, stderr) => {
-        if (error) {
-          console.log(targetPath);
-          resolve2(true);
-          return;
-        }
-        resolve2(true);
-      });
-    });
-  }
-  const hasIterm = await new Promise((resolve2) => {
-    exec2('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
-      resolve2(!error && stdout.trim().length > 0);
-    });
-  });
-  if (hasIterm) {
-    const script = `
-tell application "iTerm2"
-    tell current session of current window
-        write text "cd '${escapedPath}'"
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec2(`osascript -e '${script}'`, (error) => {
-        if (error) {
-          console.log(targetPath);
-        }
-        resolve2(true);
-      });
-    });
-  }
-  console.log(targetPath);
-  return true;
-}
-async function openNewTerminal(targetPath) {
-  const { exec: exec2 } = await import("child_process");
-  const escapedPath = targetPath.replace(/'/g, "'\\''");
-  const hasIterm = await new Promise((resolve2) => {
-    exec2('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
-      resolve2(!error && stdout.trim().length > 0);
-    });
-  });
-  if (hasIterm) {
-    const script = `
-tell application "iTerm2"
-    tell current session of current window
-        set newSession to (split vertically with default profile)
-        tell newSession
-            write text "cd '${escapedPath}'"
-        end tell
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec2(`osascript -e '${script}'`, (error) => {
-        resolve2(!error);
-      });
-    });
-  }
-  const terminalScript = `
-tell application "Terminal"
-    activate
-    do script "cd '${escapedPath}'"
-end tell`;
-  return new Promise((resolve2) => {
-    exec2(`osascript -e '${terminalScript}'`, (error) => {
-      resolve2(!error);
-    });
-  });
-}
-async function interactiveMode(workspaceRoot) {
-  const result = await runInteraction(workspaceRoot);
-  if (result?.cdPath) {
-    await cdInCurrentTerminal(result.cdPath);
-  }
-}
-async function persistentInteractiveMode(workspaceRoot) {
-  while (true) {
-    console.clear();
-    const result = await runInteraction(workspaceRoot, true);
-    if (result?.exit) {
-      break;
-    }
-    if (result?.cdPath) {
-      await openNewTerminal(result.cdPath);
-    }
+    console.log(chalk.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
   }
 }
-async function executeDelete(thread, workspaceRoot) {
-  if (thread.type === "local") {
-    const confirmed = await confirmDeleteLocal(thread.name);
-    if (confirmed) {
-      await removeLocalThread(workspaceRoot, thread.id);
-      console.log(chalk2.green(`\u2713 Deleted local thread: ${thread.name}`));
-    } else {
-      console.log(chalk2.dim("Cancelled."));
-    }
-  } else {
-    const { confirmed, removeGitWorktree } = await confirmDeleteWorktree(thread.name);
-    if (confirmed && removeGitWorktree) {
-      try {
-        await gitAdapter.removeWorktree(thread.path, workspaceRoot, true);
-        await gitAdapter.deleteBranch(thread.branch, workspaceRoot, true);
-        console.log(chalk2.green(`\u2713 Deleted worktree and branch: ${thread.name}`));
-      } catch (error) {
-        console.error(chalk2.red(`Failed to delete: ${error.message}`));
-      }
-    } else if (confirmed) {
-      console.log(chalk2.yellow("Worktree kept."));
-    } else {
-      console.log(chalk2.dim("Cancelled."));
-    }
-  }
-}
-async function runInteraction(workspaceRoot, _persistent = false) {
-  const threads = await getAllThreads(workspaceRoot);
-  const repoName = path12.basename(workspaceRoot);
-  const choice = await selectThread(threads, repoName);
-  if (choice.type === "exit") {
-    return { exit: true };
-  }
-  let targetPath;
-  switch (choice.type) {
-    case "existing": {
-      const thread = choice.thread;
-      const action = await selectThreadAction(thread.name);
-      if (action === "open") {
-        targetPath = thread.path;
-      } else if (action === "delete") {
-        await executeDelete(thread, workspaceRoot);
-        return null;
-      } else {
-        return null;
-      }
-      break;
-    }
-    case "delete-selected": {
-      const thread = choice.thread;
-      await executeDelete(thread, workspaceRoot);
-      return null;
-    }
-    case "new": {
-      const newType = await selectNewThreadType();
-      if (newType === "back") {
-        return null;
-      }
-      if (newType === "worktree") {
-        const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
-        const form = await newWorktreeForm(defaultBasePath);
-        if (!form) {
-          return null;
-        }
-        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}`));
-        }
-      } else {
-        const name = await newLocalForm();
-        if (!name) {
-          return null;
-        }
-        await addLocalThread(workspaceRoot, name);
-        console.log(chalk2.green(`\u2713 Created local thread: ${name}`));
-        targetPath = workspaceRoot;
-      }
-      break;
-    }
-  }
-  if (targetPath) {
-    return { cdPath: targetPath };
-  }
-  return null;
-}
 main().catch((error) => {
   if (error.message?.includes("SIGINT") || error.message?.includes("force closed")) {
     process.exit(130);
   }
-  console.error(chalk2.red(`Error: ${error.message}`));
+  console.error(chalk.red(`Error: ${error.message}`));
   process.exit(1);
 });