sync-worktrees 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as path8 from "path";
+import * as path10 from "path";
 import { confirm as confirm2 } from "@inquirer/prompts";
 import * as cron2 from "node-cron";
 import pLimit2 from "p-limit";
@@ -163,6 +163,9 @@ var ConfigLoaderService = class {
       if (repoObj.runOnce !== void 0 && typeof repoObj.runOnce !== "boolean") {
         throw new Error(`Repository '${repoObj.name}' has invalid 'runOnce' property`);
       }
+      if (repoObj.filesToCopyOnBranchCreate !== void 0) {
+        this.validateFilesToCopyConfig(repoObj.filesToCopyOnBranchCreate, `Repository '${repoObj.name}'`);
+      }
     });
     if (configObj.defaults) {
       if (typeof configObj.defaults !== "object") {
@@ -178,6 +181,9 @@ var ConfigLoaderService = class {
       if (defaults.retry !== void 0 && typeof defaults.retry !== "object") {
         throw new Error("Invalid 'retry' in defaults");
       }
+      if (defaults.filesToCopyOnBranchCreate !== void 0) {
+        this.validateFilesToCopyConfig(defaults.filesToCopyOnBranchCreate, "defaults");
+      }
     }
     if (configObj.retry !== void 0) {
       if (typeof configObj.retry !== "object") {
@@ -258,6 +264,19 @@ var ConfigLoaderService = class {
       );
     }
   }
+  validateFilesToCopyConfig(filesToCopy, context) {
+    if (!Array.isArray(filesToCopy)) {
+      throw new Error(`'filesToCopyOnBranchCreate' in ${context} must be an array`);
+    }
+    for (let i = 0; i < filesToCopy.length; i++) {
+      const pattern = filesToCopy[i];
+      if (typeof pattern !== "string" || pattern.trim() === "") {
+        throw new Error(
+          `'filesToCopyOnBranchCreate' in ${context} must contain only non-empty strings (invalid at index ${i})`
+        );
+      }
+    }
+  }
   resolveRepositoryConfig(repo, defaults, configDir, globalRetry) {
     const resolved = {
       name: repo.name,
@@ -291,6 +310,9 @@ var ConfigLoaderService = class {
     if (repo.updateExistingWorktrees !== void 0 || defaults?.updateExistingWorktrees !== void 0) {
       resolved.updateExistingWorktrees = repo.updateExistingWorktrees ?? defaults?.updateExistingWorktrees ?? true;
     }
+    if (repo.filesToCopyOnBranchCreate || defaults?.filesToCopyOnBranchCreate) {
+      resolved.filesToCopyOnBranchCreate = repo.filesToCopyOnBranchCreate ?? defaults?.filesToCopyOnBranchCreate;
+    }
     return resolved;
   }
   resolvePath(inputPath, baseDir) {
@@ -317,13 +339,15 @@ var ConfigLoaderService = class {
 };
 
 // src/services/InteractiveUIService.tsx
-import React4 from "react";
+import React7 from "react";
+import * as path7 from "path";
 import { render } from "ink";
 import * as cron from "node-cron";
+import { spawn } from "child_process";
 
 // src/components/App.tsx
-import React3, { useState as useState2, useEffect as useEffect2, useCallback } from "react";
-import { Box as Box3, useInput as useInput2 } from "ink";
+import React6, { useState as useState5, useEffect as useEffect5, useCallback as useCallback3, useRef as useRef3 } from "react";
+import { Box as Box6, useInput as useInput5, useStdout } from "ink";
 
 // src/components/StatusBar.tsx
 import React, { useState, useEffect } from "react";
@@ -359,7 +383,7 @@ var StatusBar = ({ status, repositoryCount, lastSyncTime, cronSchedule, diskSpac
   const getStatusIcon = () => {
     return status === "syncing" ? "\u27F3" : "\u2713";
   };
-  return /* @__PURE__ */ React.createElement(Box, { borderStyle: "single", paddingX: 1 }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, getStatusIcon(), " Status:", " ", /* @__PURE__ */ React.createElement(Text, { color: getStatusColor() }, status === "syncing" ? "Syncing..." : "Running")), /* @__PURE__ */ React.createElement(Text, null, "Repositories: ", /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, repositoryCount))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Last Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(lastSyncTime))), cronSchedule && /* @__PURE__ */ React.createElement(Text, null, "Next Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(nextSyncTime)))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Disk Space: ", /* @__PURE__ */ React.createElement(Text, { color: "magenta" }, diskSpaceUsed || "Calculating...")))));
+  return /* @__PURE__ */ React.createElement(Box, { borderStyle: "single", paddingX: 1 }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, getStatusIcon(), " Status:", " ", /* @__PURE__ */ React.createElement(Text, { color: getStatusColor() }, status === "syncing" ? "Syncing..." : "Running")), /* @__PURE__ */ React.createElement(Text, null, "Repositories: ", /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, repositoryCount))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Last Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(lastSyncTime))), cronSchedule && /* @__PURE__ */ React.createElement(Text, null, "Next Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(nextSyncTime)))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Disk Space: ", /* @__PURE__ */ React.createElement(Text, { color: "magenta" }, diskSpaceUsed || "Calculating...")), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "s"), "ync", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "c"), "reate", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "o"), "pen", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "r"), "eload", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "?"), "help", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "q"), "uit"))));
 };
 var StatusBar_default = StatusBar;
 
@@ -370,27 +394,632 @@ var HelpModal = ({ onClose }) => {
   useInput(() => {
     onClose();
   });
-  return /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", alignItems: "center", flexDirection: "column", marginTop: 2, marginBottom: 2 }, /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u{1F333} sync-worktrees - Keyboard Shortcuts")), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 0 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "?"), /* @__PURE__ */ React2.createElement(Text2, null, " or "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "h")), /* @__PURE__ */ React2.createElement(Text2, null, "Toggle this help screen")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "s")), /* @__PURE__ */ React2.createElement(Text2, null, "Manually trigger sync for all repositories")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "r")), /* @__PURE__ */ React2.createElement(Text2, null, "Reload configuration and re-sync all repos")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "q"), /* @__PURE__ */ React2.createElement(Text2, null, " or "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "Esc")), /* @__PURE__ */ React2.createElement(Text2, null, "Gracefully quit"))), /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Press any key to close"))));
+  return /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", alignItems: "center", flexDirection: "column", marginTop: 2, marginBottom: 2 }, /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u{1F333} sync-worktrees - Keyboard Shortcuts")), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 0 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green", dimColor: true }, "Navigation"), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "j"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "\u2193")), /* @__PURE__ */ React2.createElement(Text2, null, "Scroll down one line")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "k"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "\u2191")), /* @__PURE__ */ React2.createElement(Text2, null, "Scroll up one line")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "gg")), /* @__PURE__ */ React2.createElement(Text2, null, "Jump to top")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "G")), /* @__PURE__ */ React2.createElement(Text2, null, "Jump to bottom (re-enables auto-scroll)")), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green", dimColor: true }, "Actions")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "s")), /* @__PURE__ */ React2.createElement(Text2, null, "Manually trigger sync for all repositories")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "c")), /* @__PURE__ */ React2.createElement(Text2, null, "Create a new branch")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "o")), /* @__PURE__ */ React2.createElement(Text2, null, "Open editor in worktree")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "r")), /* @__PURE__ */ React2.createElement(Text2, null, "Reload configuration and re-sync all repos")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "?"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "h")), /* @__PURE__ */ React2.createElement(Text2, null, "Toggle this help screen")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "q"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "Esc")), /* @__PURE__ */ React2.createElement(Text2, null, "Gracefully quit"))), /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Press any key to close"))));
 };
 var HelpModal_default = HelpModal;
 
-// src/components/App.tsx
-var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) => {
-  const [showHelp, setShowHelp] = useState2(false);
-  const [status, setStatus] = useState2("idle");
-  const [lastSyncTime, setLastSyncTime] = useState2(null);
-  const [diskSpaceUsed, setDiskSpaceUsed] = useState2(null);
+// src/components/BranchCreationWizard.tsx
+import React3, { useState as useState2, useEffect as useEffect2, useCallback } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+var isValidGitBranchName = (name) => {
+  if (!name.trim()) {
+    return { valid: false, error: "Branch name cannot be empty" };
+  }
+  if (name.startsWith("-")) {
+    return { valid: false, error: "Branch name cannot start with '-'" };
+  }
+  if (name.endsWith(".lock")) {
+    return { valid: false, error: "Branch name cannot end with '.lock'" };
+  }
+  if (name.includes("..")) {
+    return { valid: false, error: "Branch name cannot contain '..'" };
+  }
+  if (name.includes("@{")) {
+    return { valid: false, error: "Branch name cannot contain '@{'" };
+  }
+  if (name.startsWith(".") || name.endsWith(".")) {
+    return { valid: false, error: "Branch name cannot start or end with '.'" };
+  }
+  if (name.includes("//")) {
+    return { valid: false, error: "Branch name cannot contain consecutive slashes" };
+  }
+  if (/[\x00-\x1f\x7f~^:?*\[\\]/.test(name)) {
+    return { valid: false, error: "Branch name contains invalid characters" };
+  }
+  return { valid: true };
+};
+var BranchCreationWizard = ({
+  repositories,
+  getBranchesForRepo,
+  getDefaultBranchForRepo,
+  createAndPushBranch,
+  onClose,
+  onComplete
+}) => {
+  const [step, setStep] = useState2(repositories.length > 1 ? "SELECT_PROJECT" : "SELECT_BRANCH");
+  const [selectedProjectIndex, setSelectedProjectIndex] = useState2(repositories.length === 1 ? 0 : 0);
+  const [branches, setBranches] = useState2([]);
+  const [defaultBranch, setDefaultBranch] = useState2("");
+  const [selectedBranchIndex, setSelectedBranchIndex] = useState2(0);
+  const [branchName, setBranchName] = useState2("");
+  const [existingSuffix, setExistingSuffix] = useState2(null);
+  const [validationError, setValidationError] = useState2(null);
+  const [result, setResult] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const loadBranches = useCallback(
+    async (repoIndex) => {
+      setLoading(true);
+      try {
+        const branchList = await getBranchesForRepo(repoIndex);
+        const defaultBr = getDefaultBranchForRepo(repoIndex);
+        setBranches(branchList);
+        setDefaultBranch(defaultBr);
+        const defaultIndex = branchList.indexOf(defaultBr);
+        setSelectedBranchIndex(defaultIndex >= 0 ? defaultIndex : 0);
+      } catch {
+        setBranches([]);
+      }
+      setLoading(false);
+    },
+    [getBranchesForRepo, getDefaultBranchForRepo]
+  );
+  const checkBranchExists = useCallback(
+    (name) => {
+      if (!name.trim()) {
+        setExistingSuffix(null);
+        setValidationError(null);
+        return;
+      }
+      const validation = isValidGitBranchName(name);
+      if (!validation.valid) {
+        setValidationError(validation.error ?? null);
+        setExistingSuffix(null);
+        return;
+      }
+      setValidationError(null);
+      let suffix = 0;
+      let testName = name;
+      while (branches.includes(testName)) {
+        suffix++;
+        testName = `${name}-${suffix}`;
+      }
+      setExistingSuffix(suffix > 0 ? suffix : null);
+    },
+    [branches]
+  );
+  useEffect2(() => {
+    if (step === "SELECT_BRANCH" && branches.length === 0 && !loading) {
+      loadBranches(selectedProjectIndex);
+    }
+  }, [step, selectedProjectIndex, branches.length, loading, loadBranches]);
+  useEffect2(() => {
+    if (step === "ENTER_NAME") {
+      checkBranchExists(branchName);
+    }
+  }, [branchName, step, checkBranchExists]);
+  const handleCreateBranch = async () => {
+    const trimmedName = branchName.trim();
+    if (!trimmedName) return;
+    const validation = isValidGitBranchName(trimmedName);
+    if (!validation.valid) {
+      setValidationError(validation.error ?? null);
+      return;
+    }
+    setStep("CREATING");
+    const baseBranch = branches[selectedBranchIndex];
+    const createResult = await createAndPushBranch(selectedProjectIndex, baseBranch, trimmedName);
+    setResult(createResult);
+    setStep("RESULT");
+  };
   useInput2((input2, key) => {
+    if (step === "CREATING") return;
+    if (key.escape) {
+      if (step === "SELECT_PROJECT") {
+        onClose();
+      } else if (step === "SELECT_BRANCH") {
+        if (repositories.length > 1) {
+          setBranches([]);
+          setStep("SELECT_PROJECT");
+        } else {
+          onClose();
+        }
+      } else if (step === "ENTER_NAME") {
+        setBranchName("");
+        setExistingSuffix(null);
+        setStep("SELECT_BRANCH");
+      } else if (step === "RESULT") {
+        const context = result?.success ? {
+          repoIndex: selectedProjectIndex,
+          baseBranch: branches[selectedBranchIndex],
+          newBranch: result.finalName
+        } : void 0;
+        onComplete(result?.success ?? false, context);
+      }
+      return;
+    }
+    if (step === "SELECT_PROJECT") {
+      if (key.upArrow) {
+        setSelectedProjectIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedProjectIndex((prev) => Math.min(repositories.length - 1, prev + 1));
+      } else if (key.return) {
+        loadBranches(selectedProjectIndex);
+        setStep("SELECT_BRANCH");
+      }
+    } else if (step === "SELECT_BRANCH") {
+      if (key.upArrow) {
+        setSelectedBranchIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedBranchIndex((prev) => Math.min(branches.length - 1, prev + 1));
+      } else if (key.return && branches.length > 0) {
+        setStep("ENTER_NAME");
+      }
+    } else if (step === "ENTER_NAME") {
+      if (key.return && branchName.trim()) {
+        void handleCreateBranch();
+      } else if (key.backspace || key.delete) {
+        setBranchName((prev) => prev.slice(0, -1));
+      } else if (input2 && !key.ctrl && !key.meta) {
+        const validChar = /^[a-zA-Z0-9/_-]$/.test(input2);
+        if (validChar) {
+          setBranchName((prev) => prev + input2);
+        }
+      }
+    } else if (step === "RESULT") {
+      const context = result?.success ? {
+        repoIndex: selectedProjectIndex,
+        baseBranch: branches[selectedBranchIndex],
+        newBranch: result.finalName
+      } : void 0;
+      onComplete(result?.success ?? false, context);
+    }
+  });
+  const getStepNumber = () => {
+    if (repositories.length === 1) {
+      if (step === "SELECT_BRANCH") return 1;
+      if (step === "ENTER_NAME") return 2;
+      return 2;
+    }
+    if (step === "SELECT_PROJECT") return 1;
+    if (step === "SELECT_BRANCH") return 2;
+    if (step === "ENTER_NAME") return 3;
+    return 3;
+  };
+  const getTotalSteps = () => repositories.length === 1 ? 2 : 3;
+  const renderProjectSelection = () => /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Select repository:"), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, repositories.map((repo, idx) => /* @__PURE__ */ React3.createElement(Box3, { key: repo.index }, /* @__PURE__ */ React3.createElement(Text3, { color: idx === selectedProjectIndex ? "cyan" : void 0 }, idx === selectedProjectIndex ? "> " : "  ", repo.name)))));
+  const renderBranchSelection = () => {
+    if (loading) {
+      return /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Loading branches...");
+    }
+    if (branches.length === 0) {
+      return /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, "No branches found");
+    }
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedBranchIndex - halfVisible);
+    const endIdx = Math.min(branches.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleBranches = branches.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Select base branch:"), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, startIdx > 0 && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "  ..."), visibleBranches.map((branch, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedBranchIndex;
+      const isDefault = branch === defaultBranch;
+      return /* @__PURE__ */ React3.createElement(Box3, { key: branch }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", branch, isDefault && /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, " (default)")));
+    }), endIdx < branches.length && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "  ...")));
+  };
+  const renderNameInput = () => {
+    const baseBranch = branches[selectedBranchIndex] || "";
+    const finalName = existingSuffix !== null ? `${branchName}-${existingSuffix}` : branchName;
+    const endsWithSlash = branchName.endsWith("/");
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Base branch: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, baseBranch)), /* @__PURE__ */ React3.createElement(Text3, null, "Enter new branch name:"), /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, "> "), /* @__PURE__ */ React3.createElement(Text3, null, branchName), /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, "|")), validationError && /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, validationError), !validationError && endsWithSlash && /* @__PURE__ */ React3.createElement(Text3, { color: "yellow", dimColor: true }, "Hint: consecutive slashes (//) are not allowed"), !validationError && !endsWithSlash && existingSuffix !== null && branchName && /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Name exists, will create: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, finalName)));
+  };
+  const renderCreating = () => /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Creating branch..."), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Please wait while the branch is created and pushed to remote."));
+  const renderResult = () => {
+    if (!result) return null;
+    if (result.success) {
+      return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, "Branch created successfully!"), /* @__PURE__ */ React3.createElement(Text3, null, "Created: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, result.finalName)), /* @__PURE__ */ React3.createElement(Text3, null, "From: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, branches[selectedBranchIndex])), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Syncing now to create the worktree..."));
+    }
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, "Failed to create branch"), /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, result.error));
+  };
+  const renderContent = () => {
+    switch (step) {
+      case "SELECT_PROJECT":
+        return renderProjectSelection();
+      case "SELECT_BRANCH":
+        return renderBranchSelection();
+      case "ENTER_NAME":
+        return renderNameInput();
+      case "CREATING":
+        return renderCreating();
+      case "RESULT":
+        return renderResult();
+    }
+  };
+  const renderFooter = () => {
+    if (step === "CREATING") return null;
+    if (step === "RESULT") {
+      return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Press any key to continue");
+    }
+    if (step === "ENTER_NAME") {
+      return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Enter to create \u2022 ESC to go back");
+    }
+    return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "\u2191/\u2193 to navigate \u2022 Enter to select \u2022 ESC to cancel");
+  };
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Box3, { borderStyle: "round", borderColor: "green", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "green" }, "\u{1F33F} Create New Branch", " ", step !== "CREATING" && step !== "RESULT" && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "(Step ", getStepNumber(), "/", getTotalSteps(), ")"))), repositories.length > 1 && step !== "SELECT_PROJECT" && step !== "CREATING" && step !== "RESULT" && /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Repository: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, repositories[selectedProjectIndex].name))), renderContent(), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, renderFooter())));
+};
+var BranchCreationWizard_default = BranchCreationWizard;
+
+// src/components/OpenEditorWizard.tsx
+import React4, { useState as useState3, useEffect as useEffect3, useMemo, useCallback as useCallback2, useRef } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+var OpenEditorWizard = ({
+  repositories,
+  getWorktreesForRepo,
+  openEditorInWorktree,
+  onClose
+}) => {
+  const [step, setStep] = useState3(repositories.length > 1 ? "SELECT_PROJECT" : "SELECT_WORKTREE");
+  const [selectedProjectIndex, setSelectedProjectIndex] = useState3(0);
+  const [projectFilter, setProjectFilter] = useState3("");
+  const selectedRepoIndexRef = useRef(repositories.length === 1 ? 0 : -1);
+  const [worktrees, setWorktrees] = useState3([]);
+  const [selectedWorktreeIndex, setSelectedWorktreeIndex] = useState3(0);
+  const [worktreeFilter, setWorktreeFilter] = useState3("");
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const filteredProjects = useMemo(() => {
+    if (!projectFilter) return repositories;
+    const lowerFilter = projectFilter.toLowerCase();
+    return repositories.filter((repo) => repo.name.toLowerCase().includes(lowerFilter));
+  }, [repositories, projectFilter]);
+  const filteredWorktrees = useMemo(() => {
+    if (!worktreeFilter) return worktrees;
+    const lowerFilter = worktreeFilter.toLowerCase();
+    return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerFilter));
+  }, [worktrees, worktreeFilter]);
+  const loadWorktrees = useCallback2(
+    async (repoIndex) => {
+      setLoading(true);
+      try {
+        const wts = await getWorktreesForRepo(repoIndex);
+        setWorktrees(wts);
+        setSelectedWorktreeIndex(0);
+      } catch (err) {
+        setError(`Failed to load worktrees: ${err}`);
+        setStep("ERROR");
+      }
+      setLoading(false);
+    },
+    [getWorktreesForRepo]
+  );
+  useEffect3(() => {
+    if (step === "SELECT_WORKTREE" && worktrees.length === 0 && !loading && selectedRepoIndexRef.current >= 0) {
+      loadWorktrees(selectedRepoIndexRef.current);
+    }
+  }, [step, worktrees.length, loading, loadWorktrees]);
+  const handleOpenEditor = () => {
+    const worktree = filteredWorktrees[selectedWorktreeIndex];
+    if (!worktree) return;
+    setStep("OPENING");
+    const result = openEditorInWorktree(worktree.path);
+    if (result.success) {
+      onClose();
+    } else {
+      setError(result.error || "Failed to open editor");
+      setStep("ERROR");
+    }
+  };
+  useInput3((input2, key) => {
+    if (step === "OPENING") return;
+    if (key.escape) {
+      if (step === "SELECT_PROJECT") {
+        onClose();
+      } else if (step === "SELECT_WORKTREE") {
+        if (repositories.length > 1) {
+          setWorktrees([]);
+          setWorktreeFilter("");
+          selectedRepoIndexRef.current = -1;
+          setStep("SELECT_PROJECT");
+        } else {
+          onClose();
+        }
+      } else if (step === "ERROR") {
+        onClose();
+      }
+      return;
+    }
+    if (step === "SELECT_PROJECT") {
+      if (key.upArrow) {
+        setSelectedProjectIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedProjectIndex((prev) => Math.min(filteredProjects.length - 1, prev + 1));
+      } else if (key.return && filteredProjects.length > 0) {
+        const selectedRepo = filteredProjects[selectedProjectIndex];
+        if (selectedRepo) {
+          selectedRepoIndexRef.current = selectedRepo.index;
+          setStep("SELECT_WORKTREE");
+          loadWorktrees(selectedRepo.index);
+        }
+      } else if (key.backspace || key.delete) {
+        setProjectFilter((prev) => prev.slice(0, -1));
+        setSelectedProjectIndex(0);
+      } else if (input2 && !key.ctrl && !key.meta) {
+        setProjectFilter((prev) => prev + input2);
+        setSelectedProjectIndex(0);
+      }
+    } else if (step === "SELECT_WORKTREE") {
+      if (key.upArrow) {
+        setSelectedWorktreeIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedWorktreeIndex((prev) => Math.min(filteredWorktrees.length - 1, prev + 1));
+      } else if (key.return && filteredWorktrees.length > 0) {
+        handleOpenEditor();
+      } else if (key.backspace || key.delete) {
+        setWorktreeFilter((prev) => prev.slice(0, -1));
+        setSelectedWorktreeIndex(0);
+      } else if (input2 && !key.ctrl && !key.meta) {
+        setWorktreeFilter((prev) => prev + input2);
+        setSelectedWorktreeIndex(0);
+      }
+    } else if (step === "ERROR") {
+      onClose();
+    }
+  });
+  const getStepNumber = () => {
+    if (repositories.length === 1) {
+      return 1;
+    }
+    return step === "SELECT_PROJECT" ? 1 : 2;
+  };
+  const getTotalSteps = () => repositories.length === 1 ? 1 : 2;
+  const renderProjectSelection = () => {
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedProjectIndex - halfVisible);
+    const endIdx = Math.min(filteredProjects.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleProjects = filteredProjects.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Select repository:"), /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, null, "Filter: "), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, projectFilter || "_"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ", "(", filteredProjects.length, "/", repositories.length, " matches)")), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, filteredProjects.length === 0 ? /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "No matches") : /* @__PURE__ */ React4.createElement(React4.Fragment, null, startIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."), visibleProjects.map((repo, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedProjectIndex;
+      return /* @__PURE__ */ React4.createElement(Box4, { key: repo.index }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", repo.name));
+    }), endIdx < filteredProjects.length && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."))));
+  };
+  const renderWorktreeSelection = () => {
+    if (loading) {
+      return /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "Loading worktrees...");
+    }
+    if (worktrees.length === 0) {
+      return /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, "No worktrees found");
+    }
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedWorktreeIndex - halfVisible);
+    const endIdx = Math.min(filteredWorktrees.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleWorktrees = filteredWorktrees.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Select worktree:"), /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, null, "Filter: "), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, worktreeFilter || "_"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ", "(", filteredWorktrees.length, "/", worktrees.length, " matches)")), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, filteredWorktrees.length === 0 ? /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "No matches") : /* @__PURE__ */ React4.createElement(React4.Fragment, null, startIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."), visibleWorktrees.map((wt, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedWorktreeIndex;
+      return /* @__PURE__ */ React4.createElement(Box4, { key: wt.path }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", wt.branch));
+    }), endIdx < filteredWorktrees.length && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."))));
+  };
+  const renderOpening = () => /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "Opening editor..."));
+  const renderError = () => /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, "Error: ", error), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Press any key to close"));
+  const renderContent = () => {
+    switch (step) {
+      case "SELECT_PROJECT":
+        return renderProjectSelection();
+      case "SELECT_WORKTREE":
+        return renderWorktreeSelection();
+      case "OPENING":
+        return renderOpening();
+      case "ERROR":
+        return renderError();
+    }
+  };
+  const renderFooter = () => {
+    if (step === "OPENING") return null;
+    if (step === "ERROR") return null;
+    return /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "\u2191/\u2193 navigate \u2022 Type to filter \u2022 Enter to select \u2022 ESC to cancel");
+  };
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: "blue", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React4.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "blue" }, "\u{1F4C2} Open in Editor", " ", step !== "OPENING" && step !== "ERROR" && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "(Step ", getStepNumber(), "/", getTotalSteps(), ")"))), repositories.length > 1 && step === "SELECT_WORKTREE" && !loading && selectedRepoIndexRef.current >= 0 && /* @__PURE__ */ React4.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Repository: ", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, repositories.find((r) => r.index === selectedRepoIndexRef.current)?.name))), renderContent(), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1 }, renderFooter())));
+};
+var OpenEditorWizard_default = OpenEditorWizard;
+
+// src/components/LogPanel.tsx
+import React5, { useState as useState4, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput4 } from "ink";
+var LogPanel = ({ logs, height, isActive }) => {
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  const [autoScroll, setAutoScroll] = useState4(true);
+  const [pendingG, setPendingG] = useState4(false);
+  const gTimeoutRef = useRef2(null);
+  const borderLines = 2;
+  const headerLine = 1;
+  const visibleLines = Math.max(1, height - borderLines - headerLine);
+  const maxOffset = Math.max(0, logs.length - visibleLines);
+  useEffect4(() => {
+    if (autoScroll) {
+      setScrollOffset(maxOffset);
+    }
+  }, [logs.length, maxOffset, autoScroll]);
+  useEffect4(() => {
+    return () => {
+      if (gTimeoutRef.current) {
+        clearTimeout(gTimeoutRef.current);
+      }
+    };
+  }, []);
+  useInput4(
+    (input2, key) => {
+      if (!isActive) return;
+      if (key.upArrow || input2 === "k") {
+        setScrollOffset((prev) => Math.max(0, prev - 1));
+        setAutoScroll(false);
+        setPendingG(false);
+      } else if (key.downArrow || input2 === "j") {
+        setScrollOffset((prev) => {
+          const newOffset = Math.min(maxOffset, prev + 1);
+          if (newOffset >= maxOffset) {
+            setAutoScroll(true);
+          }
+          return newOffset;
+        });
+        setPendingG(false);
+      } else if (key.pageUp) {
+        setScrollOffset((prev) => Math.max(0, prev - visibleLines));
+        setAutoScroll(false);
+        setPendingG(false);
+      } else if (key.pageDown) {
+        setScrollOffset((prev) => {
+          const newOffset = Math.min(maxOffset, prev + visibleLines);
+          if (newOffset >= maxOffset) {
+            setAutoScroll(true);
+          }
+          return newOffset;
+        });
+        setPendingG(false);
+      } else if (input2 === "g") {
+        if (pendingG) {
+          setScrollOffset(0);
+          setAutoScroll(false);
+          setPendingG(false);
+          if (gTimeoutRef.current) {
+            clearTimeout(gTimeoutRef.current);
+            gTimeoutRef.current = null;
+          }
+        } else {
+          setPendingG(true);
+          gTimeoutRef.current = setTimeout(() => {
+            setPendingG(false);
+          }, 500);
+        }
+      } else if (input2 === "G") {
+        setScrollOffset(maxOffset);
+        setAutoScroll(true);
+        setPendingG(false);
+      }
+    },
+    { isActive }
+  );
+  const getLogColor = (level) => {
+    switch (level) {
+      case "error":
+        return "red";
+      case "warn":
+        return "yellow";
+      default:
+        return void 0;
+    }
+  };
+  const visibleLogs = logs.slice(scrollOffset, scrollOffset + visibleLines);
+  const hasMoreAbove = scrollOffset > 0;
+  const hasMoreBelow = scrollOffset + visibleLines < logs.length;
+  const aboveCount = scrollOffset;
+  const belowCount = logs.length - scrollOffset - visibleLines;
+  const emptyLines = Math.max(0, visibleLines - visibleLogs.length);
+  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "single", flexDirection: "column", flexGrow: 1, paddingX: 1 }, /* @__PURE__ */ React5.createElement(Box5, { justifyContent: "space-between" }, /* @__PURE__ */ React5.createElement(Text5, { bold: true }, "\u{1F4CB} Logs ", logs.length > 0 && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(", logs.length, " entries)")), isActive && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, hasMoreAbove || hasMoreBelow ? "\u2191/\u2193 scroll" : "", " ", autoScroll ? "(auto)" : "")), hasMoreAbove && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2191 ", aboveCount, " more above"), visibleLogs.map((log) => /* @__PURE__ */ React5.createElement(Text5, { key: log.id, color: getLogColor(log.level), wrap: "truncate" }, log.message)), Array.from({ length: emptyLines }).map((_, i) => /* @__PURE__ */ React5.createElement(Text5, { key: `empty-${i}` }, " ")), hasMoreBelow && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2193 ", belowCount, " more below"));
+};
+var LogPanel_default = LogPanel;
+
+// src/utils/app-events.ts
+var AppEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => {
+      this.listeners.get(event)?.delete(callback);
+    };
+  }
+  emit(event, ...args) {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      for (const callback of callbacks) {
+        try {
+          callback(args[0]);
+        } catch {
+        }
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+var appEvents = new AppEventEmitter();
+
+// src/components/App.tsx
+var MAX_LOG_ENTRIES = 5e3;
+var App = ({
+  repositoryCount,
+  cronSchedule,
+  onManualSync,
+  onReload,
+  onQuit,
+  getRepositoryList,
+  getBranchesForRepo,
+  getDefaultBranchForRepo,
+  createAndPushBranch,
+  getWorktreesForRepo,
+  openEditorInWorktree,
+  copyBranchFiles,
+  createWorktreeForBranch
+}) => {
+  const [showHelp, setShowHelp] = useState5(false);
+  const [showBranchWizard, setShowBranchWizard] = useState5(false);
+  const [showOpenEditorWizard, setShowOpenEditorWizard] = useState5(false);
+  const [status, setStatus] = useState5("idle");
+  const [lastSyncTime, setLastSyncTime] = useState5(null);
+  const [diskSpaceUsed, setDiskSpaceUsed] = useState5(null);
+  const [logs, setLogs] = useState5([]);
+  const { stdout } = useStdout();
+  const addLog = useCallback3((message, level = "info") => {
+    setLogs((prev) => {
+      const newLogs = [
+        ...prev,
+        {
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          message,
+          level,
+          timestamp: /* @__PURE__ */ new Date()
+        }
+      ];
+      if (newLogs.length > MAX_LOG_ENTRIES) {
+        return newLogs.slice(-MAX_LOG_ENTRIES);
+      }
+      return newLogs;
+    });
+  }, []);
+  const addLogRef = useRef3(addLog);
+  addLogRef.current = addLog;
+  useInput5((input2) => {
     if (showHelp) {
       if (input2 === "?" || input2 === "h") {
         setShowHelp(false);
       }
       return;
     }
-    if (key.escape || input2 === "q") {
+    if (showBranchWizard || showOpenEditorWizard) {
+      return;
+    }
+    if (input2 === "q") {
       void onQuit();
     } else if (input2 === "?" || input2 === "h") {
       setShowHelp(true);
+    } else if (input2 === "c" && status === "idle") {
+      setShowBranchWizard(true);
+    } else if (input2 === "o" && status === "idle") {
+      setShowOpenEditorWizard(true);
     } else if (input2 === "s" && status !== "syncing") {
       setStatus("syncing");
       void (async () => {
@@ -413,21 +1042,71 @@ var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) =>
       })();
     }
   });
-  const updateLastSyncTime = useCallback(() => {
+  const updateLastSyncTime = useCallback3(() => {
     setLastSyncTime(/* @__PURE__ */ new Date());
     setStatus("idle");
   }, []);
-  useEffect2(() => {
-    globalThis.__inkAppMethods = {
-      updateLastSyncTime,
-      setStatus,
-      setDiskSpace: setDiskSpaceUsed
-    };
+  useEffect5(() => {
+    const unsubscribers = [
+      appEvents.on("updateLastSyncTime", () => {
+        setLastSyncTime(/* @__PURE__ */ new Date());
+        setStatus("idle");
+      }),
+      appEvents.on("setStatus", (newStatus) => {
+        setStatus(newStatus);
+      }),
+      appEvents.on("setDiskSpace", (diskSpace) => {
+        setDiskSpaceUsed(diskSpace);
+      }),
+      appEvents.on("addLog", ({ message, level }) => {
+        addLogRef.current(message, level);
+      })
+    ];
+    appEvents.emit("uiReady");
     return () => {
-      delete globalThis.__inkAppMethods;
+      unsubscribers.forEach((unsub) => unsub());
     };
-  }, [updateLastSyncTime, setStatus]);
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(
+  }, []);
+  const statusBarHeight = 5;
+  const terminalRows = stdout.rows ?? 24;
+  const logPanelHeight = Math.max(5, terminalRows - statusBarHeight);
+  const showModal = showHelp || showBranchWizard || showOpenEditorWizard;
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", minHeight: terminalRows }, !showModal && /* @__PURE__ */ React6.createElement(LogPanel_default, { logs, height: logPanelHeight, isActive: !showModal }), showHelp && /* @__PURE__ */ React6.createElement(HelpModal_default, { onClose: () => setShowHelp(false) }), showBranchWizard && /* @__PURE__ */ React6.createElement(
+    BranchCreationWizard_default,
+    {
+      repositories: getRepositoryList(),
+      getBranchesForRepo,
+      getDefaultBranchForRepo,
+      createAndPushBranch,
+      onClose: () => setShowBranchWizard(false),
+      onComplete: (success, context) => {
+        setShowBranchWizard(false);
+        if (success && context) {
+          setStatus("syncing");
+          void (async () => {
+            try {
+              await createWorktreeForBranch(context.repoIndex, context.newBranch);
+              if (copyBranchFiles) {
+                await copyBranchFiles(context.repoIndex, context.baseBranch, context.newBranch);
+              }
+            } catch (error) {
+              console.error("Failed to create worktree:", error);
+            } finally {
+              setStatus("idle");
+            }
+          })();
+        }
+      }
+    }
+  ), showOpenEditorWizard && /* @__PURE__ */ React6.createElement(
+    OpenEditorWizard_default,
+    {
+      repositories: getRepositoryList(),
+      getWorktreesForRepo,
+      openEditorInWorktree,
+      onClose: () => setShowOpenEditorWizard(false)
+    }
+  ), /* @__PURE__ */ React6.createElement(
     StatusBar_default,
     {
       status,
@@ -436,7 +1115,7 @@ var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) =>
       cronSchedule,
       diskSpaceUsed: diskSpaceUsed ?? void 0
     }
-  ), showHelp && /* @__PURE__ */ React3.createElement(HelpModal_default, { onClose: () => setShowHelp(false) }));
+  ));
 };
 var App_default = App;
 
@@ -726,34 +1405,66 @@ function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
 var Logger = class _Logger {
   repoName;
   debugEnabled;
+  outputFn;
   constructor(options = {}) {
     this.repoName = options.repoName;
     this.debugEnabled = options.debug ?? false;
+    this.outputFn = options.outputFn;
   }
   prefix() {
     return this.repoName ? `[${this.repoName}] ` : "";
   }
   debug(message, ...args) {
     if (!this.debugEnabled) return;
-    console.log(this.prefix() + this.formatMessage(message, args));
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "debug");
+    } else {
+      console.log(formattedMessage);
+    }
   }
   info(message, ...args) {
-    console.log(this.prefix() + this.formatMessage(message, args));
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "info");
+    } else {
+      console.log(formattedMessage);
+    }
   }
   warn(message, ...args) {
-    console.warn(this.prefix() + this.formatMessage(message, args));
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "warn");
+    } else {
+      console.warn(formattedMessage);
+    }
   }
   error(message, error) {
+    let formattedMessage = this.prefix() + message;
     if (error instanceof Error) {
-      console.error(this.prefix() + message, error);
+      formattedMessage += ` ${error.message}`;
     } else if (error) {
-      console.error(this.prefix() + message, error);
+      formattedMessage += ` ${String(error)}`;
+    }
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "error");
     } else {
-      console.error(this.prefix() + message);
+      if (error instanceof Error) {
+        console.error(this.prefix() + message, error);
+      } else if (error) {
+        console.error(this.prefix() + message, error);
+      } else {
+        console.error(this.prefix() + message);
+      }
     }
   }
   table(content) {
-    console.log("\n" + content + "\n");
+    const formattedMessage = "\n" + content + "\n";
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "info");
+    } else {
+      console.log(formattedMessage);
+    }
   }
   formatMessage(message, args) {
     if (args.length === 0) {
@@ -1024,9 +1735,9 @@ var WorktreeError = class extends SyncWorktreesError {
   }
 };
 var WorktreeNotCleanError = class extends WorktreeError {
-  constructor(path9, reasons) {
-    super(`Worktree at '${path9}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path9;
+  constructor(path11, reasons) {
+    super(`Worktree at '${path11}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path11;
     this.reasons = reasons;
   }
 };
@@ -1347,12 +2058,16 @@ var GitService = class {
   metadataService;
   statusService;
   logger;
+  updateLogger(logger) {
+    this.logger = logger;
+  }
   async initialize() {
     const { repoUrl } = this.config;
+    let needsClone = false;
     try {
       await fs4.access(path4.join(this.bareRepoPath, "HEAD"));
-      this.logger.info(`Bare repository at "${this.bareRepoPath}" already exists. Using it.`);
     } catch {
+      needsClone = true;
       this.logger.info(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
       await fs4.mkdir(path4.dirname(this.bareRepoPath), { recursive: true });
       const cloneGit = this.isLfsSkipEnabled() ? simpleGit3().env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3();
@@ -1369,11 +2084,12 @@ var GitService = class {
     } catch {
       await bareGit.addConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
     }
-    this.logger.info("Fetching remote branches...");
-    await bareGit.fetch(["--all"]);
+    if (needsClone) {
+      this.logger.info("Fetching remote branches...");
+      await bareGit.fetch(["--all"]);
+    }
     this.defaultBranch = await this.detectDefaultBranch(bareGit);
     this.mainWorktreePath = path4.join(this.config.worktreeDir, this.defaultBranch);
-    this.logger.info(`Detected default branch: ${this.defaultBranch}`);
     let needsMainWorktree = true;
     try {
       const worktrees = await this.getWorktreesFromBare(bareGit);
@@ -1443,6 +2159,9 @@ var GitService = class {
     }
     return this.git;
   }
+  isInitialized() {
+    return this.git !== null;
+  }
   getDefaultBranch() {
     return this.defaultBranch;
   }
@@ -1935,6 +2654,18 @@ var GitService = class {
       return false;
     }
   }
+  async isLocalAheadOfRemote(worktreePath, branch) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const mergeBase = await worktreeGit.raw(["merge-base", "HEAD", `origin/${branch}`]);
+      const mergeBaseSha = mergeBase.trim();
+      const remoteSha = await worktreeGit.revparse([`origin/${branch}`]);
+      const remoteShaTrimmed = remoteSha.trim();
+      return mergeBaseSha === remoteShaTrimmed;
+    } catch {
+      return false;
+    }
+  }
   async compareTreeContent(worktreePath, branch) {
     const worktreeGit = simpleGit3(worktreePath);
     try {
@@ -1972,6 +2703,29 @@ var GitService = class {
     const commit = await git.revparse([ref]);
     return commit.trim();
   }
+  async branchExists(branchName) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    const localBranches = await bareGit.branch();
+    const local = localBranches.all.includes(branchName);
+    const remoteBranches = await bareGit.branch(["-r"]);
+    const remote = remoteBranches.all.includes(`origin/${branchName}`);
+    return { local, remote };
+  }
+  async getLocalBranches() {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    const branches = await bareGit.branch();
+    return branches.all;
+  }
+  async createBranch(branchName, baseBranch) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.raw(["branch", branchName, `origin/${baseBranch}`]);
+    this.logger.info(`Created branch '${branchName}' from '${baseBranch}'`);
+  }
+  async pushBranch(branchName) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.push(["origin", `${branchName}:${branchName}`, "-u"]);
+    this.logger.info(`Pushed branch '${branchName}' to remote`);
+  }
   async getWorktreeMetadata(worktreePath) {
     return this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
   }
@@ -2026,9 +2780,19 @@ var WorktreeSyncService = class {
   async initialize() {
     await this.gitService.initialize();
   }
+  isInitialized() {
+    return this.gitService.isInitialized();
+  }
   isSyncInProgress() {
     return this.syncInProgress;
   }
+  getGitService() {
+    return this.gitService;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+    this.gitService.updateLogger(logger);
+  }
   async sync() {
     if (this.syncInProgress) {
       this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
@@ -2353,6 +3117,11 @@ var WorktreeSyncService = class {
           if (!isClean) return null;
           const canFastForward = await this.gitService.canFastForward(worktree.path, worktree.branch);
           if (!canFastForward) {
+            const isAhead = await this.gitService.isLocalAheadOfRemote(worktree.path, worktree.branch);
+            if (isAhead) {
+              this.logger.info(`\u23ED\uFE0F  Skipping '${worktree.branch}' - has unpushed commits`);
+              return null;
+            }
             await this.handleDivergedBranch(worktree);
             return null;
           }
@@ -2521,6 +3290,84 @@ var WorktreeSyncService = class {
   }
 };
 
+// src/services/file-copy.service.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+import { glob } from "glob";
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**"
+];
+var FileCopyService = class {
+  /**
+   * Copy files matching patterns from source to destination directory.
+   * Skips files that already exist at destination.
+   * Preserves directory structure relative to source.
+   */
+  async copyFiles(sourceDir, destDir, patterns) {
+    const result = {
+      copied: [],
+      skipped: [],
+      errors: []
+    };
+    if (!patterns || patterns.length === 0) {
+      return result;
+    }
+    const filesToCopy = await this.expandPatterns(sourceDir, patterns);
+    for (const relativePath of filesToCopy) {
+      const sourcePath = path6.join(sourceDir, relativePath);
+      const destPath = path6.join(destDir, relativePath);
+      try {
+        const copied = await this.copyFile(sourcePath, destPath);
+        if (copied) {
+          result.copied.push(relativePath);
+        } else {
+          result.skipped.push(relativePath);
+        }
+      } catch (error) {
+        result.errors.push({
+          file: relativePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async expandPatterns(sourceDir, patterns) {
+    const allFiles = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      try {
+        const matches = await glob(pattern, {
+          cwd: sourceDir,
+          nodir: true,
+          dot: true,
+          ignore: DEFAULT_IGNORE_PATTERNS
+        });
+        for (const match of matches) {
+          allFiles.add(match);
+        }
+      } catch {
+      }
+    }
+    return Array.from(allFiles);
+  }
+  async copyFile(sourcePath, destPath) {
+    try {
+      await fs6.access(destPath);
+      return false;
+    } catch {
+    }
+    const destDir = path6.dirname(destPath);
+    await fs6.mkdir(destDir, { recursive: true });
+    await fs6.copyFile(sourcePath, destPath);
+    return true;
+  }
+};
+
 // src/utils/disk-space.ts
 import fastFolderSize from "fast-folder-size";
 async function calculateDirectorySize(dirPath) {
@@ -2569,9 +3416,8 @@ var InteractiveUIService = class {
   cronSchedule;
   cronJobs = [];
   repositoryCount;
-  originalConsoleLog;
-  originalConsoleWarn;
-  originalConsoleError;
+  logBuffer = [];
+  uiReady = false;
   constructor(syncServices, configPath, cronSchedule) {
     if (syncServices.length === 0) {
       throw new Error("InteractiveUIService requires at least one WorktreeSyncService");
@@ -2580,31 +3426,52 @@ var InteractiveUIService = class {
     this.configPath = configPath;
     this.cronSchedule = cronSchedule;
     this.repositoryCount = syncServices.length;
-    this.originalConsoleLog = console.log.bind(console);
-    this.originalConsoleWarn = console.warn.bind(console);
-    this.originalConsoleError = console.error.bind(console);
-    this.redirectConsole();
     this.setupCronJobs();
+    this.startBufferFlushCheck();
     this.renderUI();
+    this.injectLoggersIntoServices();
+    setTimeout(() => {
+      this.addLog("\u{1F680} sync-worktrees UI initialized", "info");
+    }, 100);
+  }
+  startBufferFlushCheck() {
+    const unsubscribe = appEvents.on("uiReady", () => {
+      this.uiReady = true;
+      this.flushLogBuffer();
+      unsubscribe();
+    });
   }
-  redirectConsole() {
-    console.log = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleLog(message);
-    };
-    console.warn = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleWarn(message);
-    };
-    console.error = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleError(message);
+  createOutputFn() {
+    return (message, level) => {
+      const uiLevel = level === "debug" ? "info" : level;
+      this.addLog(message, uiLevel);
     };
   }
-  restoreConsole() {
-    console.log = this.originalConsoleLog;
-    console.warn = this.originalConsoleWarn;
-    console.error = this.originalConsoleError;
+  injectLoggersIntoServices() {
+    const outputFn = this.createOutputFn();
+    for (const service of this.syncServices) {
+      const config = service.config;
+      service.updateLogger(
+        new Logger({
+          repoName: config.name,
+          debug: config.debug,
+          outputFn
+        })
+      );
+    }
+  }
+  addLog(message, level = "info") {
+    if (this.uiReady) {
+      appEvents.emit("addLog", { message, level });
+    } else {
+      this.logBuffer.push({ message, level });
+    }
+  }
+  flushLogBuffer() {
+    for (const log of this.logBuffer) {
+      appEvents.emit("addLog", { message: log.message, level: log.level });
+    }
+    this.logBuffer = [];
   }
   setupCronJobs() {
     if (!this.cronSchedule) {
@@ -2618,6 +3485,9 @@ var InteractiveUIService = class {
       const task = cron.schedule(schedule3, async () => {
         this.setStatus("syncing");
         try {
+          if (!service.isInitialized()) {
+            await service.initialize();
+          }
           await service.sync();
         } catch (error) {
           console.error(`Error syncing: ${error.message}`);
@@ -2641,28 +3511,42 @@ var InteractiveUIService = class {
       this.app.unmount();
     }
     this.app = render(
-      /* @__PURE__ */ React4.createElement(
+      /* @__PURE__ */ React7.createElement(
         App_default,
         {
           repositoryCount: this.repositoryCount,
           cronSchedule: this.cronSchedule,
           onManualSync: () => this.handleManualSync(),
           onReload: () => this.handleReload(),
-          onQuit: () => this.handleQuit()
+          onQuit: () => this.handleQuit(),
+          getRepositoryList: () => this.getRepositoryList(),
+          getBranchesForRepo: (index) => this.getBranchesForRepo(index),
+          getDefaultBranchForRepo: (index) => this.getDefaultBranchForRepo(index),
+          createAndPushBranch: (repoIndex, baseBranch, branchName) => this.createAndPushBranch(repoIndex, baseBranch, branchName),
+          getWorktreesForRepo: (index) => this.getWorktreesForRepo(index),
+          openEditorInWorktree: (path11) => this.openEditorInWorktree(path11),
+          copyBranchFiles: (repoIndex, baseBranch, targetBranch) => this.copyBranchFiles(repoIndex, baseBranch, targetBranch),
+          createWorktreeForBranch: (repoIndex, branchName) => this.createWorktreeForBranch(repoIndex, branchName)
         }
       )
     );
   }
   async handleManualSync() {
+    await this.triggerInitialSync();
+  }
+  async triggerInitialSync() {
     this.setStatus("syncing");
     try {
       for (const service of this.syncServices) {
+        if (!service.isInitialized()) {
+          await service.initialize();
+        }
         await service.sync();
       }
       this.updateLastSyncTime();
       await this.calculateAndUpdateDiskSpace();
     } catch (error) {
-      console.error("Manual sync failed:", error);
+      console.error("Sync failed:", error);
     } finally {
       this.setStatus("idle");
     }
@@ -2746,22 +3630,13 @@ var InteractiveUIService = class {
     }
   }
   updateLastSyncTime() {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.updateLastSyncTime) {
-      methods.updateLastSyncTime();
-    }
+    appEvents.emit("updateLastSyncTime");
   }
   setStatus(status) {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.setStatus) {
-      methods.setStatus(status);
-    }
+    appEvents.emit("setStatus", status);
   }
   setDiskSpace(diskSpace) {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.setDiskSpace) {
-      methods.setDiskSpace(diskSpace);
-    }
+    appEvents.emit("setDiskSpace", diskSpace);
   }
   async calculateAndUpdateDiskSpace() {
     try {
@@ -2776,14 +3651,137 @@ var InteractiveUIService = class {
       this.setDiskSpace("N/A");
     }
   }
+  getRepositoryList() {
+    return this.syncServices.map((service, index) => ({
+      index,
+      name: service.config.name || `repo-${index}`,
+      repoUrl: service.config.repoUrl
+    }));
+  }
+  async getBranchesForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getRemoteBranches();
+  }
+  getDefaultBranchForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getDefaultBranch();
+  }
+  async createAndPushBranch(repoIndex, baseBranch, branchName) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      return { success: false, finalName: branchName, error: `Invalid repository index: ${repoIndex}` };
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    try {
+      let finalName = branchName;
+      let suffix = 0;
+      while (true) {
+        const exists = await gitService.branchExists(finalName);
+        if (!exists.local && !exists.remote) {
+          break;
+        }
+        suffix++;
+        finalName = `${branchName}-${suffix}`;
+      }
+      await gitService.createBranch(finalName, baseBranch);
+      await gitService.pushBranch(finalName);
+      return { success: true, finalName };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, finalName: branchName, error: errorMessage };
+    }
+  }
+  async getWorktreesForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getWorktrees();
+  }
+  async createWorktreeForBranch(repoIndex, branchName) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    const worktreeDir = service.config.worktreeDir;
+    const worktreePath = path7.join(worktreeDir, branchName);
+    await gitService.addWorktree(branchName, worktreePath);
+  }
+  openEditorInWorktree(worktreePath) {
+    const editor = process.env.EDITOR || process.env.VISUAL || "code";
+    try {
+      const child = spawn(editor, [worktreePath], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.on("error", (err) => {
+        this.addLog(`Failed to open editor '${editor}': ${err.message}`, "error");
+        this.addLog("Set EDITOR or VISUAL environment variable to your preferred editor", "warn");
+      });
+      child.unref();
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.addLog(`Failed to open editor '${editor}': ${errorMessage}`, "error");
+      return { success: false, error: errorMessage };
+    }
+  }
+  async copyBranchFiles(repoIndex, baseBranch, targetBranch) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      return;
+    }
+    const service = this.syncServices[repoIndex];
+    const config = service.config;
+    if (!config.filesToCopyOnBranchCreate?.length) {
+      return;
+    }
+    const gitService = service.getGitService();
+    const worktrees = await gitService.getWorktrees();
+    const sourceWorktree = worktrees.find((w) => w.branch === baseBranch);
+    const targetWorktree = worktrees.find((w) => w.branch === targetBranch);
+    if (!sourceWorktree || !targetWorktree) {
+      console.warn(`Could not find worktrees for file copy: source=${baseBranch}, target=${targetBranch}`);
+      return;
+    }
+    const fileCopyService = new FileCopyService();
+    try {
+      const result = await fileCopyService.copyFiles(
+        sourceWorktree.path,
+        targetWorktree.path,
+        config.filesToCopyOnBranchCreate
+      );
+      if (result.copied.length > 0) {
+        console.log(`\u{1F4CB} Copied ${result.copied.length} file(s) to new branch: ${result.copied.join(", ")}`);
+      }
+      if (result.errors.length > 0) {
+        console.warn(`\u26A0\uFE0F Failed to copy ${result.errors.length} file(s):`);
+        for (const err of result.errors) {
+          console.warn(`  - ${err.file}: ${err.error}`);
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to copy files to new branch: ${error}`);
+    }
+  }
   destroy() {
     this.cancelCronJobs();
-    this.restoreConsole();
     if (this.app) {
       this.app.unmount();
       this.app = null;
     }
-    delete globalThis.__inkAppMethods;
+    appEvents.removeAllListeners();
+    this.uiReady = false;
+    this.logBuffer = [];
   }
 };
 
@@ -2842,6 +3840,10 @@ function parseArguments() {
     type: "boolean",
     description: "Enable debug mode to show detailed reasons why worktrees are not cleaned up.",
     default: false
+  }).option("sync-on-start", {
+    type: "boolean",
+    description: "Run sync immediately when starting the interactive UI (config mode only).",
+    default: false
   }).help().alias("help", "h").parseSync();
   return {
     config: argv.config,
@@ -2855,7 +3857,8 @@ function parseArguments() {
     branchMaxAge: argv.branchMaxAge,
     skipLfs: argv.skipLfs,
     noUpdateExisting: argv["no-update-existing"],
-    debug: argv.debug
+    debug: argv.debug,
+    syncOnStart: argv["sync-on-start"]
   };
 }
 function isInteractiveMode(config) {
@@ -2893,12 +3896,12 @@ function reconstructCliCommand(config) {
 }
 
 // src/utils/interactive.ts
-import * as path7 from "path";
+import * as path9 from "path";
 import { confirm, input, select } from "@inquirer/prompts";
 
 // src/utils/config-generator.ts
-import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
 function serializeToESM(obj, indent = 0) {
   const spaces = " ".repeat(indent);
   const innerSpaces = " ".repeat(indent + 2);
@@ -2928,9 +3931,9 @@ ${spaces}}`;
   return String(obj);
 }
 async function generateConfigFile(config, configPath) {
-  const configDir = path6.dirname(configPath);
-  await fs6.mkdir(configDir, { recursive: true });
-  const worktreeDirRelative = path6.relative(configDir, config.worktreeDir);
+  const configDir = path8.dirname(configPath);
+  await fs7.mkdir(configDir, { recursive: true });
+  const worktreeDirRelative = path8.relative(configDir, config.worktreeDir);
   const useRelativeWorktree = !worktreeDirRelative.startsWith("../../../");
   const repoName = extractRepoNameFromUrl(config.repoUrl);
   const repository = {
@@ -2939,7 +3942,7 @@ async function generateConfigFile(config, configPath) {
     worktreeDir: useRelativeWorktree ? `./${worktreeDirRelative}` : config.worktreeDir
   };
   if (config.bareRepoDir) {
-    const bareRepoDirRelative = path6.relative(configDir, config.bareRepoDir);
+    const bareRepoDirRelative = path8.relative(configDir, config.bareRepoDir);
     const useRelativeBare = !bareRepoDirRelative.startsWith("../../../");
     repository.bareRepoDir = useRelativeBare ? `./${bareRepoDirRelative}` : config.bareRepoDir;
   }
@@ -2957,10 +3960,10 @@ async function generateConfigFile(config, configPath) {
 
 export default ${serializeToESM(configObject)};
 `;
-  await fs6.writeFile(configPath, configContent, "utf-8");
+  await fs7.writeFile(configPath, configContent, "utf-8");
 }
 function getDefaultConfigPath() {
-  return path6.join(process.cwd(), "sync-worktrees.config.js");
+  return path8.join(process.cwd(), "sync-worktrees.config.js");
 }
 
 // src/utils/interactive.ts
@@ -3002,8 +4005,8 @@ async function promptForConfig(partialConfig) {
     if (!worktreeDir.trim() && defaultWorktreeDir) {
       worktreeDir = defaultWorktreeDir;
     }
-    if (!path7.isAbsolute(worktreeDir)) {
-      worktreeDir = path7.resolve(worktreeDir);
+    if (!path9.isAbsolute(worktreeDir)) {
+      worktreeDir = path9.resolve(worktreeDir);
     }
   }
   let bareRepoDir = partialConfig.bareRepoDir;
@@ -3022,8 +4025,8 @@ async function promptForConfig(partialConfig) {
         return true;
       }
     });
-    if (!path7.isAbsolute(bareRepoDir)) {
-      bareRepoDir = path7.resolve(bareRepoDir);
+    if (!path9.isAbsolute(bareRepoDir)) {
+      bareRepoDir = path9.resolve(bareRepoDir);
     }
   }
   let runOnce = partialConfig.runOnce;
@@ -3094,8 +4097,8 @@ async function promptForConfig(partialConfig) {
         return true;
       }
     });
-    if (!path7.isAbsolute(configPath)) {
-      configPath = path7.resolve(configPath);
+    if (!path9.isAbsolute(configPath)) {
+      configPath = path9.resolve(configPath);
     }
     try {
       await generateConfigFile(finalConfig, configPath);
@@ -3103,7 +4106,7 @@ async function promptForConfig(partialConfig) {
 \u2705 Configuration saved to: ${configPath}`);
       console.log(`
 \u{1F4A1} You can now use this config file with:`);
-      console.log(`   sync-worktrees --config ${path7.relative(process.cwd(), configPath)}`);
+      console.log(`   sync-worktrees --config ${path9.relative(process.cwd(), configPath)}`);
       console.log("");
     } catch (error) {
       console.error(`
@@ -3150,62 +4153,66 @@ async function runSingleRepository(config) {
     process.exit(1);
   }
 }
-async function runMultipleRepositories(repositories, runOnce, configPath, maxParallel) {
+async function runMultipleRepositories(repositories, runOnce, configPath, maxParallel, syncOnStart) {
   const services = /* @__PURE__ */ new Map();
   const globalLogger = Logger.createDefault();
-  globalLogger.info(`
-\u{1F504} Syncing ${repositories.length} repositories...`);
   const limit = pLimit2(maxParallel ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
-  const initResults = await Promise.allSettled(
-    repositories.map(
-      (repoConfig) => limit(async () => {
-        const repoLogger = Logger.createDefault(repoConfig.name, repoConfig.debug);
-        repoLogger.info(`
+  if (runOnce) {
+    globalLogger.info(`
+\u{1F504} Syncing ${repositories.length} repositories...`);
+    const initResults = await Promise.allSettled(
+      repositories.map(
+        (repoConfig) => limit(async () => {
+          const repoLogger = Logger.createDefault(repoConfig.name, repoConfig.debug);
+          repoLogger.info(`
 \u{1F4E6} Repository: ${repoConfig.name}`);
-        repoLogger.info(`   URL: ${repoConfig.repoUrl}`);
-        repoLogger.info(`   Worktrees: ${repoConfig.worktreeDir}`);
-        if (repoConfig.bareRepoDir) {
-          repoLogger.info(`   Bare repo: ${repoConfig.bareRepoDir}`);
-        }
-        if (!repoConfig.logger) {
-          repoConfig.logger = repoLogger;
-        }
-        const syncService = new WorktreeSyncService(repoConfig);
-        await syncService.initialize();
-        return { name: repoConfig.name, service: syncService };
-      })
-    )
-  );
-  const servicesToSync = [];
-  for (const result of initResults) {
-    if (result.status === "fulfilled") {
-      services.set(result.value.name, result.value.service);
-      servicesToSync.push(result.value);
-    } else {
-      globalLogger.error(`\u274C Failed to initialize repository:`, result.reason);
+          repoLogger.info(`   URL: ${repoConfig.repoUrl}`);
+          repoLogger.info(`   Worktrees: ${repoConfig.worktreeDir}`);
+          if (repoConfig.bareRepoDir) {
+            repoLogger.info(`   Bare repo: ${repoConfig.bareRepoDir}`);
+          }
+          if (!repoConfig.logger) {
+            repoConfig.logger = repoLogger;
+          }
+          const syncService = new WorktreeSyncService(repoConfig);
+          await syncService.initialize();
+          return { name: repoConfig.name, service: syncService };
+        })
+      )
+    );
+    const servicesToSync = [];
+    for (const result of initResults) {
+      if (result.status === "fulfilled") {
+        services.set(result.value.name, result.value.service);
+        servicesToSync.push(result.value);
+      } else {
+        globalLogger.error(`\u274C Failed to initialize repository:`, result.reason);
+      }
     }
-  }
-  const syncResults = await Promise.allSettled(
-    servicesToSync.map(
-      ({ name, service }) => limit(async () => {
-        try {
-          await service.sync();
-        } catch (error) {
-          globalLogger.error(`\u274C Error syncing repository '${name}':`, error);
-          throw error;
-        }
-      })
-    )
-  );
-  const successCount = syncResults.filter((r) => r.status === "fulfilled").length;
-  globalLogger.info(`
+    const syncResults = await Promise.allSettled(
+      servicesToSync.map(
+        ({ name, service }) => limit(async () => {
+          try {
+            await service.sync();
+          } catch (error) {
+            globalLogger.error(`\u274C Error syncing repository '${name}':`, error);
+            throw error;
+          }
+        })
+      )
+    );
+    const successCount = syncResults.filter((r) => r.status === "fulfilled").length;
+    globalLogger.info(`
 \u2705 Successfully synced ${successCount}/${servicesToSync.length} repositories`);
-  if (!runOnce) {
+  } else {
+    for (const repoConfig of repositories) {
+      const syncService = new WorktreeSyncService(repoConfig);
+      services.set(repoConfig.name, syncService);
+    }
     const uniqueSchedules = [...new Set(repositories.map((r) => r.cronSchedule))];
     const displaySchedule = uniqueSchedules.length === 1 ? uniqueSchedules[0] : void 0;
     const allServices = Array.from(services.values());
     const uiService = new InteractiveUIService(allServices, configPath, displaySchedule);
-    uiService.updateLastSyncTime();
     void uiService.calculateAndUpdateDiskSpace();
     const cronJobs = /* @__PURE__ */ new Map();
     for (const repoConfig of repositories) {
@@ -3221,11 +4228,14 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
               (repo) => limit(async () => {
                 const service = services.get(repo.name);
                 if (!service) return;
-                globalLogger.info(`Running scheduled sync for: ${repo.name}`);
+                uiService.addLog(`Running scheduled sync for: ${repo.name}`);
                 try {
+                  if (!service.isInitialized()) {
+                    await service.initialize();
+                  }
                   await service.sync();
                 } catch (error) {
-                  globalLogger.error(`Error syncing '${repo.name}':`, error);
+                  uiService.addLog(`Error syncing '${repo.name}': ${error}`, "error");
                 }
               })
             )
@@ -3235,10 +4245,13 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
         });
       }
     }
-    globalLogger.info(`All ${repositories.length} repositories scheduled`);
+    uiService.addLog(`\u{1F4CB} ${repositories.length} repositories configured`);
     for (const [schedule3] of cronJobs) {
       const repoCount = repositories.filter((r) => r.cronSchedule === schedule3).length;
-      globalLogger.info(`${schedule3}: ${repoCount} repository(ies)`);
+      uiService.addLog(`\u23F0 ${schedule3}: ${repoCount} repository(ies)`);
+    }
+    if (syncOnStart) {
+      await uiService.triggerInitialSync();
     }
   }
 }
@@ -3246,7 +4259,7 @@ async function listRepositories(configPath, filter) {
   const configLoader = new ConfigLoaderService();
   try {
     const configFile = await configLoader.loadConfigFile(configPath);
-    const configDir = path8.dirname(path8.resolve(configPath));
+    const configDir = path10.dirname(path10.resolve(configPath));
     let repositories = configFile.repositories.map(
       (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
     );
@@ -3287,7 +4300,7 @@ async function main() {
     }
     try {
       const configFile = await configLoader.loadConfigFile(options.config);
-      const configDir = path8.dirname(path8.resolve(options.config));
+      const configDir = path10.dirname(path10.resolve(options.config));
       let repositories = configFile.repositories.map(
         (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
       );
@@ -3312,7 +4325,7 @@ async function main() {
         }));
       }
       const maxParallel = configFile.parallelism?.maxRepositories ?? configFile.defaults?.parallelism?.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
-      await runMultipleRepositories(repositories, globalRunOnce, options.config, maxParallel);
+      await runMultipleRepositories(repositories, globalRunOnce, options.config, maxParallel, options.syncOnStart);
     } catch (error) {
       if (error instanceof Error && error.message.includes("Config file not found")) {
         console.error(`